feat: support propertyDependencies from draft/next

For now, causes an uncertainty from removeAdditional / useDefaults, but
that could be resolved/optimized in some certain situations later.

Refs: json-schema-org/json-schema-spec#1082
Refs: json-schema-org/json-schema-spec#1143

Author: ChALkeR

doc/samples/draft-next/README.md

@@ -58,7 +58,7 @@ Based on JSON Schema Test Suite for `draft-next`.
 | [patternProperties](./patternProperties.md)                                     | 5     | -                 | -        | -             |
 | [prefixItems](./prefixItems.md)                                                 | 4     | -                 | -        | -             |
 | [properties](./properties.md)                                                   | 6     | -                 | -        | -             |
-| [propertyDependencies](./propertyDependencies.md)                               | 3     | -                 | 3        | 1             |
+| [propertyDependencies](./propertyDependencies.md)                               | 3     | -                 | -        | -             |
 | [propertyNames](./propertyNames.md)                                             | 3     | -                 | -        | -             |
 | [ref](./ref.md)                                                                 | 29    | -                 | -        | -             |
 | [refRemote](./refRemote.md)                                                     | 13    | -                 | -        | -             |

doc/samples/draft-next/propertyDependencies.md

@@ -12,15 +12,21 @@
 
 ```js
 'use strict'
+const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
 const ref0 = function validate(data) {
+  if (typeof data === "object" && data && !Array.isArray(data)) {
+    if (data.foo !== undefined && hasOwn(data, "foo")) {
+      if (data.foo === "bar") return false
+    }
+  }
   return true
 };
 return ref0
 ```
 
-### Warnings
+##### Strong mode notices
 
- * `Keyword not supported: "propertyDependencies" at #`
+ * `[requireValidation] type should be specified at #`
 
 
 ## propertyDependencies doesn't act on non-string property values
@@ -35,15 +41,21 @@ return ref0
 
 ```js
 'use strict'
+const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
 const ref0 = function validate(data) {
+  if (typeof data === "object" && data && !Array.isArray(data)) {
+    if (data.foo !== undefined && hasOwn(data, "foo")) {
+      if (data.foo === "bar") return false
+    }
+  }
   return true
 };
 return ref0
 ```
 
-### Warnings
+##### Strong mode notices
 
- * `Keyword not supported: "propertyDependencies" at #`
+ * `[requireValidation] type should be specified at #`
 
 
 ## multiple options selects the right one
@@ -67,17 +79,30 @@ return ref0
 
 ```js
 'use strict'
+const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
 const ref0 = function validate(data) {
+  if (typeof data === "object" && data && !Array.isArray(data)) {
+    if (data.foo !== undefined && hasOwn(data, "foo")) {
+      if (data.foo === "bar") {
+        if (typeof data === "object" && data && !Array.isArray(data)) {
+          if (Object.keys(data).length > 2) return false
+          if (Object.keys(data).length < 2) return false
+        }
+      }
+      if (data.foo === "baz") {
+        if (typeof data === "object" && data && !Array.isArray(data)) {
+          if (Object.keys(data).length > 1) return false
+        }
+      }
+      if (data.foo === "quux") return false
+    }
+  }
   return true
 };
 return ref0
 ```
 
-### Warnings
-
- * `Keyword not supported: "propertyDependencies" at #`
-
-### Misclassified!
+##### Strong mode notices
 
-**This schema caused 4 misclassifications!**
+ * `[requireValidation] schema = true is not allowed at #/propertyDependencies/foo/qux`
 

src/compile.js

@@ -764,7 +764,7 @@ const compileSchema = (schema, root, opts, scope, basePathRoot = '') => {
                 errorIf(safeand(present(item), condition), errorArgs)
               }
             } else if (isSchemaish(deps) && dependencies !== 'dependentRequired') {
-              uncertain(dependencies)
+              uncertain(dependencies) // TODO: we don't always need this, remove when no uncertainity?
               fun.if(item.checked ? true : present(item), () => {
                 const delta = rule(current, deps, subPath(dependencies, key), dyn)
                 evaluateDelta(orDelta({}, delta))
@@ -776,6 +776,27 @@ const compileSchema = (schema, root, opts, scope, basePathRoot = '') => {
         })
       }
 
+      handle('propertyDependencies', ['object'], (propertyDependencies) => {
+        for (const [key, variants] of Object.entries(propertyDependencies)) {
+          enforce(isPlainObject(variants), 'propertyDependencies must be an object')
+          uncertain('propertyDependencies') // TODO: we don't always need this, remove when no uncertainity?
+          const item = currPropImm(key, checked(key))
+          // NOTE: would it be useful to also check if it's a string?
+          fun.if(item.checked ? true : present(item), () => {
+            for (const [val, deps] of Object.entries(variants)) {
+              enforce(isSchemaish(deps), 'propertyDependencies must contain schemas')
+              fun.if(compare(buildName(item), val), () => {
+                // TODO: we already know that we have an object here, optimize?
+                const delta = rule(current, deps, subPath('propertyDependencies', key, val), dyn)
+                evaluateDelta(orDelta({}, delta))
+                evaluateDeltaDynamic(delta)
+              })
+            }
+          })
+        }
+        return null
+      })
+
       handle('properties', ['object'], (properties) => {
         for (const p of Object.keys(properties)) {
           if (constProp === p) continue // checked in discriminator, avoid double-check
@@ -1181,8 +1202,9 @@ const compileSchema = (schema, root, opts, scope, basePathRoot = '') => {
       const logicalOp = ['not', 'if', 'then', 'else'].includes(schemaPath[schemaPath.length - 1])
       const branchOp = ['oneOf', 'anyOf', 'allOf'].includes(schemaPath[schemaPath.length - 2])
       const depOp = ['dependencies', 'dependentSchemas'].includes(schemaPath[schemaPath.length - 2])
+      const propDepOp = ['propertyDependencies'].includes(schemaPath[schemaPath.length - 3])
       // Coherence check, unreachable, double-check that we came from expected path
-      enforce(logicalOp || branchOp || depOp, 'Unexpected')
+      enforce(logicalOp || branchOp || depOp || propDepOp, 'Unexpected logical path')
     } else if (!schemaPath.includes('not')) {
       // 'not' does not mark anything as evaluated (unlike even if/then/else), so it's safe to exclude from these
       // checks, as we are sure that everything will be checked without it. It can be viewed as a pure add-on.

src/known-keywords.js

@@ -13,7 +13,8 @@ const knownKeywords = [
   ...['maxLength', 'minLength', 'format', 'pattern'], // strings
   ...['contentEncoding', 'contentMediaType', 'contentSchema'], // strings content
   ...['properties', 'maxProperties', 'minProperties', 'additionalProperties', 'patternProperties'], // objects
-  ...['propertyNames', 'dependencies', 'dependentRequired', 'dependentSchemas'], // objects
+  ...['propertyNames'], // objects
+  ...['dependencies', 'dependentRequired', 'dependentSchemas', 'propertyDependencies'], // objects (dependencies)
   ...['unevaluatedProperties', 'unevaluatedItems'], // see-through
   // Unused meta keywords not affecting validation (annotations and comments)
   // https://json-schema.org/understanding-json-schema/reference/generic.html

test/json-schema.js

@@ -119,9 +119,6 @@ const unsupported = new Set([
 
   // draft-next changes to bookending requirement in dynamicRef
   'draft-next/dynamicRef.json',
-
-  // draft-next only, new features
-  'draft-next/propertyDependencies.json',
 ])
 const unsupportedMask = []