@hyperjump/json-schema 0.23.4 → 1.0.0

package/draft-04/additionalItems.js

@@ -0,0 +1,29 @@
+import * as Instance from "../lib/instance.js";
+import * as Schema from "../lib/schema.js";
+import Validation from "../lib/keywords/validation.js";
+import { getKeywordName } from "../lib/keywords.js";
+
+
+const id = "https://json-schema.org/keyword/draft-04/additionalItems";
+
+const compile = async (schema, ast, parentSchema) => {
+  const itemsKeywordName = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/draft-04/items");
+  const items = await Schema.step(itemsKeywordName, parentSchema);
+  const numberOfItems = Schema.typeOf(items, "array") ? Schema.length(items) : Number.MAX_SAFE_INTEGER;
+
+  return [numberOfItems, await Validation.compile(schema, ast)];
+};
+
+const interpret = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  return Instance.every((item, ndx) => ndx < numberOfItems || Validation.interpret(additionalItems, item, ast, dynamicAnchors), instance);
+};
+
+const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
+  return interpret(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance.map((item, ndx) => ndx, instance));
+};
+
+export default { id, compile, interpret, collectEvaluatedItems };

package/{lib/keywords → draft-04}/dependencies.js

@@ -1,11 +1,15 @@
-const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
-const Pact = require("@hyperjump/pact");
+import * as Instance from "../lib/instance.js";
+import * as Schema from "../lib/schema.js";
+import Validation from "../lib/keywords/validation.js";
+import * as Pact from "@hyperjump/pact";
 
 
+const id = "https://json-schema.org/keyword/draft-04/dependencies";
+
 const compile = (schema, ast) => Pact.pipeline([
   Schema.entries,
   Pact.map(async ([key, dependency]) => {
-    return [key, Schema.typeOf(dependency, "array") ? Schema.value(dependency) : await Core.compileSchema(dependency, ast)];
+    return [key, Schema.typeOf(dependency, "array") ? Schema.value(dependency) : await Validation.compile(dependency, ast)];
   }),
   Pact.all
 ], schema);
@@ -21,9 +25,9 @@ const interpret = (dependencies, instance, ast, dynamicAnchors) => {
     if (Array.isArray(dependency)) {
       return dependency.every((key) => key in value);
     } else {
-      return Core.interpretSchema(dependency, instance, ast, dynamicAnchors);
+      return Validation.interpret(dependency, instance, ast, dynamicAnchors);
     }
   });
 };
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/draft-04/exclusiveMaximum.js

@@ -0,0 +1,5 @@
+const id = "https://json-schema.org/keyword/draft-04/exclusiveMaximum";
+const compile = (schema) => schema.value;
+const interpret = () => true;
+
+export default { id, compile, interpret };

package/draft-04/exclusiveMinimum.js

@@ -0,0 +1,5 @@
+const id = "https://json-schema.org/keyword/draft-04/exclusiveMinimum";
+const compile = (schema) => schema.value;
+const interpret = () => true;
+
+export default { id, compile, interpret };

package/draft-04/id.js

@@ -0,0 +1 @@
+export default { id: "https://json-schema.org/keyword/draft-04/id" };

package/draft-04/index.d.ts

@@ -0,0 +1,43 @@
+import type { Json } from "@hyperjump/json-pointer";
+import type { JsonSchemaType } from "../lib/common.js";
+
+
+export type JsonSchemaDraft04 = {
+  $ref: string;
+} | {
+  $schema?: "http://json-schema.org/draft-04/schema#";
+  id?: string;
+  title?: string;
+  description?: string;
+  default?: Json;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: boolean;
+  minimum?: number;
+  exclusiveMinimum?: boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  additionalItems?: boolean | JsonSchemaDraft04;
+  items?: JsonSchemaDraft04 | JsonSchemaDraft04[];
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  additionalProperties?: boolean | JsonSchemaDraft04;
+  definitions?: Record<string, JsonSchemaDraft04>;
+  properties?: Record<string, JsonSchemaDraft04>;
+  patternProperties?: Record<string, JsonSchemaDraft04>;
+  dependencies?: Record<string, JsonSchemaDraft04 | string[]>;
+  enum?: Json[];
+  type?: JsonSchemaType | JsonSchemaType[];
+  format?: "date-time" | "email" | "hostname" | "ipv4" | "ipv6" | "uri";
+  allOf?: JsonSchemaDraft04[];
+  anyOf?: JsonSchemaDraft04[];
+  oneOf?: JsonSchemaDraft04[];
+  not?: JsonSchemaDraft04;
+};
+
+export * from "../lib/index.js";

package/draft-04/index.js

@@ -0,0 +1,69 @@
+import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
+import { addSchema } from "../lib/core.js";
+import metaSchema from "./schema.js";
+import additionalItems from "./additionalItems.js";
+import dependencies from "./dependencies.js";
+import exclusiveMaximum from "./exclusiveMaximum.js";
+import exclusiveMinimum from "./exclusiveMinimum.js";
+import id from "./id.js";
+import items from "./items.js";
+import maximum from "./maximum.js";
+import minimum from "./minimum.js";
+import ref from "./ref.js";
+
+
+addKeyword(additionalItems);
+addKeyword(dependencies);
+addKeyword(exclusiveMaximum);
+addKeyword(exclusiveMinimum);
+addKeyword(maximum);
+addKeyword(minimum);
+addKeyword(id);
+addKeyword(items);
+addKeyword(ref);
+
+const jsonSchemaVersion = "http://json-schema.org/draft-04/schema";
+
+defineVocabulary(jsonSchemaVersion, {
+  "id": "https://json-schema.org/keyword/draft-04/id",
+  "$ref": "https://json-schema.org/keyword/draft-04/ref",
+  "additionalItems": "https://json-schema.org/keyword/draft-04/additionalItems",
+  "additionalProperties": "https://json-schema.org/keyword/additionalProperties",
+  "allOf": "https://json-schema.org/keyword/allOf",
+  "anyOf": "https://json-schema.org/keyword/anyOf",
+  "default": "https://json-schema.org/keyword/default",
+  "definitions": "https://json-schema.org/keyword/definitions",
+  "dependencies": "https://json-schema.org/keyword/draft-04/dependencies",
+  "description": "https://json-schema.org/keyword/description",
+  "enum": "https://json-schema.org/keyword/enum",
+  "exclusiveMaximum": "https://json-schema.org/keyword/draft-04/exclusiveMaximum",
+  "exclusiveMinimum": "https://json-schema.org/keyword/draft-04/exclusiveMinimum",
+  "format": "https://json-schema.org/keyword/format",
+  "items": "https://json-schema.org/keyword/draft-04/items",
+  "maxItems": "https://json-schema.org/keyword/maxItems",
+  "maxLength": "https://json-schema.org/keyword/maxLength",
+  "maxProperties": "https://json-schema.org/keyword/maxProperties",
+  "maximum": "https://json-schema.org/keyword/draft-04/maximum",
+  "minItems": "https://json-schema.org/keyword/minItems",
+  "minLength": "https://json-schema.org/keyword/minLength",
+  "minProperties": "https://json-schema.org/keyword/minProperties",
+  "minimum": "https://json-schema.org/keyword/draft-04/minimum",
+  "multipleOf": "https://json-schema.org/keyword/multipleOf",
+  "not": "https://json-schema.org/keyword/not",
+  "oneOf": "https://json-schema.org/keyword/oneOf",
+  "pattern": "https://json-schema.org/keyword/pattern",
+  "patternProperties": "https://json-schema.org/keyword/patternProperties",
+  "properties": "https://json-schema.org/keyword/properties",
+  "required": "https://json-schema.org/keyword/required",
+  "title": "https://json-schema.org/keyword/title",
+  "type": "https://json-schema.org/keyword/type",
+  "uniqueItems": "https://json-schema.org/keyword/uniqueItems"
+});
+
+loadDialect(jsonSchemaVersion, {
+  [jsonSchemaVersion]: true
+}, true);
+
+addSchema(metaSchema);
+
+export * from "../lib/index.js";

package/draft-04/items.js

@@ -0,0 +1,35 @@
+import * as Instance from "../lib/instance.js";
+import * as Schema from "../lib/schema.js";
+import Validation from "../lib/keywords/validation.js";
+
+
+const id = "https://json-schema.org/keyword/draft-04/items";
+
+const compile = async (schema, ast) => {
+  if (Schema.typeOf(schema, "array")) {
+    const tupleItems = await Schema.map((itemSchema) => Validation.compile(itemSchema, ast), schema);
+    return Promise.all(tupleItems);
+  } else {
+    return Validation.compile(schema, ast);
+  }
+};
+
+const interpret = (items, instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  if (typeof items === "string") {
+    return Instance.every((itemValue) => Validation.interpret(items, itemValue, ast, dynamicAnchors), instance);
+  } else {
+    return Instance.every((item, ndx) => !(ndx in items) || Validation.interpret(items[ndx], item, ast, dynamicAnchors), instance);
+  }
+};
+
+const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {
+  return interpret(items, instance, ast, dynamicAnchors) && (typeof items === "string"
+    ? new Set(Instance.map((item, itemIndex) => itemIndex, instance))
+    : new Set(items.map((item, itemIndex) => itemIndex)));
+};
+
+export default { id, compile, interpret, collectEvaluatedItems };

package/draft-04/maximum.js

@@ -0,0 +1,26 @@
+import * as Instance from "../lib/instance.js";
+import * as Schema from "../lib/schema.js";
+import { getKeywordName } from "../lib/keywords.js";
+
+
+const id = "https://json-schema.org/keyword/draft-04/maximum";
+
+const compile = async (schema, ast, parentSchema) => {
+  const exclusiveMaximumKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/draft-04/exclusiveMaximum");
+  console.log(exclusiveMaximumKeyword);
+  const exclusiveMaximum = await Schema.step(exclusiveMaximumKeyword, parentSchema);
+  const isExclusive = Schema.value(exclusiveMaximum);
+
+  return [Schema.value(schema), isExclusive];
+};
+
+const interpret = ([maximum, isExclusive], instance) => {
+  if (!Instance.typeOf(instance, "number")) {
+    return true;
+  }
+
+  const value = Instance.value(instance);
+  return isExclusive ? value < maximum : value <= maximum;
+};
+
+export default { id, compile, interpret };

package/draft-04/minimum.js

@@ -0,0 +1,25 @@
+import * as Instance from "../lib/instance.js";
+import * as Schema from "../lib/schema.js";
+import { getKeywordName } from "../lib/keywords.js";
+
+
+const id = "https://json-schema.org/keyword/draft-04/minimum";
+
+const compile = async (schema, ast, parentSchema) => {
+  const exclusiveMinimumKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/draft-04/exclusiveMinimum");
+  const exclusiveMinimum = await Schema.step(exclusiveMinimumKeyword, parentSchema);
+  const isExclusive = Schema.value(exclusiveMinimum);
+
+  return [Schema.value(schema), isExclusive];
+};
+
+const interpret = ([minimum, isExclusive], instance) => {
+  if (!Instance.typeOf(instance, "number")) {
+    return true;
+  }
+
+  const value = Instance.value(instance);
+  return isExclusive ? value > minimum : value >= minimum;
+};
+
+export default { id, compile, interpret };

package/draft-04/ref.js

@@ -0,0 +1 @@
+export default { id: "https://json-schema.org/keyword/draft-04/ref" };

package/draft-04/schema.js

@@ -0,0 +1,149 @@
+export default {
+  "id": "http://json-schema.org/draft-04/schema#",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "Core schema meta-schema",
+  "definitions": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#" }
+    },
+    "positiveInteger": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "positiveIntegerDefault0": {
+      "allOf": [{ "$ref": "#/definitions/positiveInteger" }, { "default": 0 }]
+    },
+    "simpleTypes": {
+      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    "stringArray": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1,
+      "uniqueItems": true
+    }
+  },
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string"
+    },
+    "$schema": {
+      "type": "string"
+    },
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "default": {},
+    "multipleOf": {
+      "type": "number",
+      "minimum": 0,
+      "exclusiveMinimum": true
+    },
+    "maximum": {
+      "type": "number"
+    },
+    "exclusiveMaximum": {
+      "type": "boolean",
+      "default": false
+    },
+    "minimum": {
+      "type": "number"
+    },
+    "exclusiveMinimum": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxLength": { "$ref": "#/definitions/positiveInteger" },
+    "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+    "pattern": {
+      "type": "string",
+      "format": "regex"
+    },
+    "additionalItems": {
+      "anyOf": [
+        { "type": "boolean" },
+        { "$ref": "#" }
+      ],
+      "default": {}
+    },
+    "items": {
+      "anyOf": [
+        { "$ref": "#" },
+        { "$ref": "#/definitions/schemaArray" }
+      ],
+      "default": {}
+    },
+    "maxItems": { "$ref": "#/definitions/positiveInteger" },
+    "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+    "uniqueItems": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+    "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+    "required": { "$ref": "#/definitions/stringArray" },
+    "additionalProperties": {
+      "anyOf": [
+        { "type": "boolean" },
+        { "$ref": "#" }
+      ],
+      "default": {}
+    },
+    "definitions": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#" },
+      "default": {}
+    },
+    "properties": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#" },
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#" },
+      "default": {}
+    },
+    "dependencies": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [
+          { "$ref": "#" },
+          { "$ref": "#/definitions/stringArray" }
+        ]
+      }
+    },
+    "enum": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "type": {
+      "anyOf": [
+        { "$ref": "#/definitions/simpleTypes" },
+        {
+          "type": "array",
+          "items": { "$ref": "#/definitions/simpleTypes" },
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      ]
+    },
+    "format": { "type": "string" },
+    "allOf": { "$ref": "#/definitions/schemaArray" },
+    "anyOf": { "$ref": "#/definitions/schemaArray" },
+    "oneOf": { "$ref": "#/definitions/schemaArray" },
+    "not": { "$ref": "#" }
+  },
+  "dependencies": {
+    "exclusiveMaximum": ["maximum"],
+    "exclusiveMinimum": ["minimum"]
+  },
+  "default": {}
+};

package/draft-06/contains.js

@@ -0,0 +1,13 @@
+import * as Instance from "../lib/instance.js";
+import Validation from "../lib/keywords/validation.js";
+
+
+const id = "https://json-schema.org/keyword/draft-06/contains";
+
+const compile = (schema, ast) => Validation.compile(schema, ast);
+
+const interpret = (contains, instance, ast, dynamicAnchors) => {
+  return !Instance.typeOf(instance, "array") || Instance.some((item) => Validation.interpret(contains, item, ast, dynamicAnchors), instance);
+};
+
+export default { id, compile, interpret };

package/draft-06/index.d.ts

@@ -0,0 +1,47 @@
+import type { Json } from "@hyperjump/json-pointer";
+import type { JsonSchemaType } from "../lib/common.js";
+
+
+export type JsonSchemaDraft06 = boolean | {
+  $ref: string;
+} | {
+  $schema?: "http://json-schema.org/draft-06/schema#";
+  $id?: string;
+  title?: string;
+  description?: string;
+  default?: Json;
+  examples?: Json[];
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number;
+  minimum?: number;
+  exclusiveMinimum?: number;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  additionalItems?: JsonSchemaDraft06;
+  items?: JsonSchemaDraft06 | JsonSchemaDraft06[];
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  contains?: JsonSchemaDraft06;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  additionalProperties?: JsonSchemaDraft06;
+  definitions?: Record<string, JsonSchemaDraft06>;
+  properties?: Record<string, JsonSchemaDraft06>;
+  patternProperties?: Record<string, JsonSchemaDraft06>;
+  dependencies?: Record<string, JsonSchemaDraft06 | string[]>;
+  propertyNames?: JsonSchemaDraft06;
+  const?: Json;
+  enum?: Json[];
+  type?: JsonSchemaType | JsonSchemaType[];
+  format?: "date-time" | "email" | "hostname" | "ipv4" | "ipv6" | "uri" | "uri-reference" | "uri-template" | "json-pointer";
+  allOf?: JsonSchemaDraft06[];
+  anyOf?: JsonSchemaDraft06[];
+  oneOf?: JsonSchemaDraft06[];
+  not?: JsonSchemaDraft06;
+};
+
+export * from "../lib/index.js";

package/draft-06/index.js

@@ -0,0 +1,66 @@
+import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
+import { addSchema } from "../lib/core.js";
+import metaSchema from "./schema.js";
+import additionalItems from "../draft-04/additionalItems.js";
+import contains from "./contains.js";
+import dependencies from "../draft-04/dependencies.js";
+import id from "../draft-04/id.js";
+import items from "../draft-04/items.js";
+import ref from "../draft-04/ref.js";
+
+
+addKeyword(additionalItems);
+addKeyword(dependencies);
+addKeyword(contains);
+addKeyword(id);
+addKeyword(items);
+addKeyword(ref);
+
+const jsonSchemaVersion = "http://json-schema.org/draft-06/schema";
+
+defineVocabulary(jsonSchemaVersion, {
+  "$id": "https://json-schema.org/keyword/draft-04/id",
+  "$ref": "https://json-schema.org/keyword/draft-04/ref",
+  "additionalItems": "https://json-schema.org/keyword/draft-04/additionalItems",
+  "additionalProperties": "https://json-schema.org/keyword/additionalProperties",
+  "allOf": "https://json-schema.org/keyword/allOf",
+  "anyOf": "https://json-schema.org/keyword/anyOf",
+  "const": "https://json-schema.org/keyword/const",
+  "contains": "https://json-schema.org/keyword/draft-06/contains",
+  "default": "https://json-schema.org/keyword/default",
+  "definitions": "https://json-schema.org/keyword/definitions",
+  "dependencies": "https://json-schema.org/keyword/draft-04/dependencies",
+  "description": "https://json-schema.org/keyword/description",
+  "enum": "https://json-schema.org/keyword/enum",
+  "exclusiveMaximum": "https://json-schema.org/keyword/exclusiveMaximum",
+  "exclusiveMinimum": "https://json-schema.org/keyword/exclusiveMinimum",
+  "format": "https://json-schema.org/keyword/format",
+  "items": "https://json-schema.org/keyword/draft-04/items",
+  "maxItems": "https://json-schema.org/keyword/maxItems",
+  "maxLength": "https://json-schema.org/keyword/maxLength",
+  "maxProperties": "https://json-schema.org/keyword/maxProperties",
+  "maximum": "https://json-schema.org/keyword/maximum",
+  "minItems": "https://json-schema.org/keyword/minItems",
+  "minLength": "https://json-schema.org/keyword/minLength",
+  "minProperties": "https://json-schema.org/keyword/minProperties",
+  "minimum": "https://json-schema.org/keyword/minimum",
+  "multipleOf": "https://json-schema.org/keyword/multipleOf",
+  "not": "https://json-schema.org/keyword/not",
+  "oneOf": "https://json-schema.org/keyword/oneOf",
+  "pattern": "https://json-schema.org/keyword/pattern",
+  "patternProperties": "https://json-schema.org/keyword/patternProperties",
+  "properties": "https://json-schema.org/keyword/properties",
+  "propertyNames": "https://json-schema.org/keyword/propertyNames",
+  "required": "https://json-schema.org/keyword/required",
+  "title": "https://json-schema.org/keyword/title",
+  "type": "https://json-schema.org/keyword/type",
+  "uniqueItems": "https://json-schema.org/keyword/uniqueItems"
+});
+
+loadDialect(jsonSchemaVersion, {
+  [jsonSchemaVersion]: true
+}, true);
+
+addSchema(metaSchema);
+
+export * from "../lib/index.js";