@jarenjs/refs 0.8.2 → 0.9.2

package/dist/types/json-schema-2020-12/index.import.no-lint.d.ts

@@ -0,0 +1,421 @@
+declare const _default: {
+    metaSchema: {
+        $schema: string;
+        $id: string;
+        $vocabulary: {
+            "https://json-schema.org/draft/2020-12/vocab/core": boolean;
+            "https://json-schema.org/draft/2020-12/vocab/applicator": boolean;
+            "https://json-schema.org/draft/2020-12/vocab/unevaluated": boolean;
+            "https://json-schema.org/draft/2020-12/vocab/validation": boolean;
+            "https://json-schema.org/draft/2020-12/vocab/meta-data": boolean;
+            "https://json-schema.org/draft/2020-12/vocab/format-annotation": boolean;
+            "https://json-schema.org/draft/2020-12/vocab/content": boolean;
+        };
+        $dynamicAnchor: string;
+        title: string;
+        allOf: {
+            $ref: string;
+        }[];
+        type: string[];
+        $comment: string;
+        properties: {
+            definitions: {
+                $comment: string;
+                type: string;
+                additionalProperties: {
+                    $dynamicRef: string;
+                };
+                deprecated: boolean;
+                default: {};
+            };
+            dependencies: {
+                $comment: string;
+                type: string;
+                additionalProperties: {
+                    anyOf: ({
+                        $dynamicRef: string;
+                        $ref?: undefined;
+                    } | {
+                        $dynamicRef?: undefined;
+                        $ref: string;
+                    })[];
+                };
+                deprecated: boolean;
+                default: {};
+            };
+            $recursiveAnchor: {
+                $comment: string;
+                $ref: string;
+                deprecated: boolean;
+            };
+            $recursiveRef: {
+                $comment: string;
+                $ref: string;
+                deprecated: boolean;
+            };
+        };
+    };
+    applicator: {
+        $schema: string;
+        $id: string;
+        $vocabulary: {
+            "https://json-schema.org/draft/2020-12/vocab/applicator": boolean;
+        };
+        $dynamicAnchor: string;
+        title: string;
+        type: string[];
+        properties: {
+            prefixItems: {
+                $ref: string;
+            };
+            items: {
+                $dynamicRef: string;
+            };
+            contains: {
+                $dynamicRef: string;
+            };
+            additionalProperties: {
+                $dynamicRef: string;
+            };
+            properties: {
+                type: string;
+                additionalProperties: {
+                    $dynamicRef: string;
+                };
+                default: {};
+            };
+            patternProperties: {
+                type: string;
+                additionalProperties: {
+                    $dynamicRef: string;
+                };
+                propertyNames: {
+                    format: string;
+                };
+                default: {};
+            };
+            dependentSchemas: {
+                type: string;
+                additionalProperties: {
+                    $dynamicRef: string;
+                };
+                default: {};
+            };
+            propertyNames: {
+                $dynamicRef: string;
+            };
+            if: {
+                $dynamicRef: string;
+            };
+            then: {
+                $dynamicRef: string;
+            };
+            else: {
+                $dynamicRef: string;
+            };
+            allOf: {
+                $ref: string;
+            };
+            anyOf: {
+                $ref: string;
+            };
+            oneOf: {
+                $ref: string;
+            };
+            not: {
+                $dynamicRef: string;
+            };
+        };
+        $defs: {
+            schemaArray: {
+                type: string;
+                minItems: number;
+                items: {
+                    $dynamicRef: string;
+                };
+            };
+        };
+    };
+    unevaluated: {
+        $schema: string;
+        $id: string;
+        $vocabulary: {
+            "https://json-schema.org/draft/2020-12/vocab/unevaluated": boolean;
+        };
+        $dynamicAnchor: string;
+        title: string;
+        type: string[];
+        properties: {
+            unevaluatedItems: {
+                $dynamicRef: string;
+            };
+            unevaluatedProperties: {
+                $dynamicRef: string;
+            };
+        };
+    };
+    content: {
+        $schema: string;
+        $id: string;
+        $vocabulary: {
+            "https://json-schema.org/draft/2020-12/vocab/content": boolean;
+        };
+        $dynamicAnchor: string;
+        title: string;
+        type: string[];
+        properties: {
+            contentEncoding: {
+                type: string;
+            };
+            contentMediaType: {
+                type: string;
+            };
+            contentSchema: {
+                $dynamicRef: string;
+            };
+        };
+    };
+    core: {
+        $schema: string;
+        $id: string;
+        $vocabulary: {
+            "https://json-schema.org/draft/2020-12/vocab/core": boolean;
+        };
+        $dynamicAnchor: string;
+        title: string;
+        type: string[];
+        properties: {
+            $id: {
+                $ref: string;
+                $comment: string;
+                pattern: string;
+            };
+            $schema: {
+                $ref: string;
+            };
+            $ref: {
+                $ref: string;
+            };
+            $anchor: {
+                $ref: string;
+            };
+            $dynamicRef: {
+                $ref: string;
+            };
+            $dynamicAnchor: {
+                $ref: string;
+            };
+            $vocabulary: {
+                type: string;
+                propertyNames: {
+                    $ref: string;
+                };
+                additionalProperties: {
+                    type: string;
+                };
+            };
+            $comment: {
+                type: string;
+            };
+            $defs: {
+                type: string;
+                additionalProperties: {
+                    $dynamicRef: string;
+                };
+            };
+        };
+        $defs: {
+            anchorString: {
+                type: string;
+                pattern: string;
+            };
+            uriString: {
+                type: string;
+                format: string;
+            };
+            uriReferenceString: {
+                type: string;
+                format: string;
+            };
+        };
+    };
+    formatAnnotation: {
+        $schema: string;
+        $id: string;
+        $vocabulary: {
+            "https://json-schema.org/draft/2020-12/vocab/format-annotation": boolean;
+        };
+        $dynamicAnchor: string;
+        title: string;
+        type: string[];
+        properties: {
+            format: {
+                type: string;
+            };
+        };
+    };
+    formatAssertion: {
+        $schema: string;
+        $id: string;
+        $vocabulary: {
+            "https://json-schema.org/draft/2020-12/vocab/format-assertion": boolean;
+        };
+        $dynamicAnchor: string;
+        title: string;
+        type: string[];
+        properties: {
+            format: {
+                type: string;
+            };
+        };
+    };
+    metadata: {
+        $schema: string;
+        $id: string;
+        $vocabulary: {
+            "https://json-schema.org/draft/2020-12/vocab/meta-data": boolean;
+        };
+        $dynamicAnchor: string;
+        title: string;
+        type: string[];
+        properties: {
+            title: {
+                type: string;
+            };
+            description: {
+                type: string;
+            };
+            default: boolean;
+            deprecated: {
+                type: string;
+                default: boolean;
+            };
+            readOnly: {
+                type: string;
+                default: boolean;
+            };
+            writeOnly: {
+                type: string;
+                default: boolean;
+            };
+            examples: {
+                type: string;
+                items: boolean;
+            };
+        };
+    };
+    validation: {
+        $schema: string;
+        $id: string;
+        $vocabulary: {
+            "https://json-schema.org/draft/2020-12/vocab/validation": boolean;
+        };
+        $dynamicAnchor: string;
+        title: string;
+        type: string[];
+        properties: {
+            type: {
+                anyOf: ({
+                    $ref: string;
+                    type?: undefined;
+                    items?: undefined;
+                    minItems?: undefined;
+                    uniqueItems?: undefined;
+                } | {
+                    $ref?: undefined;
+                    type: string;
+                    items: {
+                        $ref: string;
+                    };
+                    minItems: number;
+                    uniqueItems: boolean;
+                })[];
+            };
+            const: boolean;
+            enum: {
+                type: string;
+                items: boolean;
+            };
+            multipleOf: {
+                type: string;
+                exclusiveMinimum: number;
+            };
+            maximum: {
+                type: string;
+            };
+            exclusiveMaximum: {
+                type: string;
+            };
+            minimum: {
+                type: string;
+            };
+            exclusiveMinimum: {
+                type: string;
+            };
+            maxLength: {
+                $ref: string;
+            };
+            minLength: {
+                $ref: string;
+            };
+            pattern: {
+                type: string;
+                format: string;
+            };
+            maxItems: {
+                $ref: string;
+            };
+            minItems: {
+                $ref: string;
+            };
+            uniqueItems: {
+                type: string;
+                default: boolean;
+            };
+            maxContains: {
+                $ref: string;
+            };
+            minContains: {
+                $ref: string;
+                default: number;
+            };
+            maxProperties: {
+                $ref: string;
+            };
+            minProperties: {
+                $ref: string;
+            };
+            required: {
+                $ref: string;
+            };
+            dependentRequired: {
+                type: string;
+                additionalProperties: {
+                    $ref: string;
+                };
+            };
+        };
+        $defs: {
+            nonNegativeInteger: {
+                type: string;
+                minimum: number;
+            };
+            nonNegativeIntegerDefault0: {
+                $ref: string;
+                default: number;
+            };
+            simpleTypes: {
+                enum: string[];
+            };
+            stringArray: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                uniqueItems: boolean;
+                default: never[];
+            };
+        };
+    };
+};
+export default _default;

package/package.json

@@ -1,20 +1,30 @@
 {
   "name": "@jarenjs/refs",
   "private": false,
-  "version": "0.8.2",
+  "version": "0.9.2",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./src/index.js",
+  "types": "./dist/types/index.d.ts",
+  "sideEffects": false,
   "files": [
-    "dist"
+    "dist/types/",
+    "src/"
   ],
   "description": "Jaren JSON Schema Draft Specifications",
   "author": "joham",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jklarenbeek/jarenjs.git",
+    "url": "git+https://github.com/jklarenbeek/jarenjs.git",
     "directory": "packages/refs"
   },
   "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "keywords": [
     "jaren",
     "draft-06",
@@ -26,16 +36,28 @@
     "json"
   ],
   "exports": {
-    ".": "./src/index.js",
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./src/index.js"
+    },
     "./draft-06": "./src/json-schema-draft-06.json",
     "./draft-07": "./src/json-schema-draft-07.json",
-    "./draft-2019-09": "./src/json-schema-draft-2019-09/index.js",
-    "./draft-2020-12": "./src/json-schema-draft-2020-12/index.js"
+    "./draft-2019-09": {
+      "types": "./dist/types/json-schema-2019-09/index.d.ts",
+      "default": "./src/json-schema-2019-09/index.js"
+    },
+    "./draft-2020-12": {
+      "types": "./dist/types/json-schema-2020-12/index.d.ts",
+      "default": "./src/json-schema-2020-12/index.js"
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "node esbuild.config.js"
+    "build": "node esbuild.config.js && npm run build:types",
+    "build:types": "tsc -p tsconfig.json",
+    "prepack": "npm run build:types"
   },
-  "devDependencies": {
-    "esbuild": "^0.23.1"
+  "dependencies": {
+    "@jarenjs/core": "^0.9.2"
   }
 }

package/src/data.json

@@ -0,0 +1,13 @@
+{
+  "$id": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
+  "description": "Meta-schema for $data reference (JSON AnySchema extension proposal)",
+  "type": "object",
+  "required": ["$data"],
+  "properties": {
+    "$data": {
+      "type": "string",
+      "anyOf": [{"format": "relative-json-pointer"}, {"format": "json-pointer"}]
+    }
+  },
+  "additionalProperties": false
+}

package/src/index.import.no-lint.js

@@ -0,0 +1,5 @@
+import draft6 from './json-schema-draft-06.json' with { type: 'json' };
+import draft7 from './json-schema-draft-07.json' with { type: 'json' };
+
+export const _draft6 = draft6;
+export const _draft7 = draft7;

package/src/index.js

@@ -0,0 +1,86 @@
+//@ts-check
+import { isStringType } from '@jarenjs/core';
+
+import {
+  _draft6,
+  _draft7
+} from './index.import.no-lint.js';
+
+import _draft2019 from './json-schema-2019-09/index.js';
+import _draft2020 from './json-schema-2020-12/index.js';
+
+const schemaDrafts = {
+  6: { draft: 'http://json-schema.org/draft-06/schema', schema: [_draft6] },
+  7: { draft: 'http://json-schema.org/draft-07/schema', schema: [_draft7] },
+  2019: { draft: 'https://json-schema.org/draft/2019-09/schema', schema: _draft2019 },
+  2020: { draft: 'https://json-schema.org/draft/2020-12/schema', schema: _draft2020 },
+};
+
+/**
+ * A JSON Schema draft specification bundle: the draft's canonical URI and
+ * the meta-schema document(s) that define it. For draft 2019-09 and
+ * 2020-12 the `schema` array holds the main meta-schema followed by its
+ * vocabulary meta-schemas; for draft-06/07 it holds the single meta-schema.
+ * @typedef {Object} SchemaDraftInfo
+ * @property {string} draft - The draft's canonical URI (e.g. 'http://json-schema.org/draft-07/schema')
+ * @property {object[]} schema - The meta-schema document(s) of the draft
+ */
+
+/**
+ * Gets a schema draft bundle by version number.
+ * @param {6 | 7 | 2019 | 2020} version - The draft version
+ * @returns {SchemaDraftInfo} The draft URI and its meta-schema document(s)
+ * @throws {Error} When the version is unknown
+ */
+export function getSchemaDraftByVersion(version) {
+  if (version in schemaDrafts)
+    return schemaDrafts[version];
+  else
+    throw new Error('Unknown reference schema version');
+}
+
+/**
+ * Gets a schema draft bundle by name. Accepts the common spellings of
+ * each draft name (e.g. 'draft-07', '2019-09', 'draft2020-12').
+ * @param {'6'|'draft6'|'draft-6'|'draft06'|'draft-06'
+ *   |'7'|'draft7'|'draft-7'|'draft07'|'draft-07'
+ *   |'draft2019'|'draft-2019'|'draft2019-09'|'2019'|'2019-09'
+ *   |'draft2020'|'draft-2020'|'draft2020-12'|'2020'|'2020-12'} name - The draft name variant
+ * @returns {SchemaDraftInfo} The draft URI and its meta-schema document(s)
+ * @throws {Error} When the name is unknown
+ */
+export function getSchemaDraftByName(name) {
+  switch (name) {
+    case '6': case 'draft6': case 'draft-6': case 'draft06': case 'draft-06':
+      return getSchemaDraftByVersion(6);
+    case '7': case 'draft7': case 'draft-7': case 'draft07': case 'draft-07':
+      return getSchemaDraftByVersion(7);
+    case 'draft2019': case 'draft-2019': case 'draft2019-09': case '2019': case '2019-09':
+      return getSchemaDraftByVersion(2019);
+    case 'draft2020': case 'draft-2020': case 'draft2020-12': case '2020': case '2020-12':
+      return getSchemaDraftByVersion(2020);
+    default:
+      throw new Error(`Unknown reference schema name: '${name}'`);
+  }
+}
+
+/**
+ * Gets a schema draft bundle by its canonical $id URI (case-insensitive).
+ * @param {string} schemaId - The schema $id URI
+ * @returns {SchemaDraftInfo} The draft URI and its meta-schema document(s)
+ * @throws {Error} When the schema id is not a string or not found
+ */
+export function getSchemaDraftById(schemaId) {
+  if (!isStringType(schemaId))
+    throw new Error('The schema id must be of type string');
+
+  const $id = schemaId.toLowerCase();
+  // eslint-disable-next-line no-unused-vars
+  for (const [_, item] of Object.entries(schemaDrafts)) {
+    const draft = item.draft;
+    if (draft.toLowerCase() === $id)
+      return item;
+  }
+
+  throw new Error(`Schema draft with id '${schemaId}' does not exists`);
+}

package/src/json-schema-2019-09/index.import.no-lint.js

@@ -0,0 +1,17 @@
+import metaSchema from './schema.json' with { type: 'json' };
+import applicator from './meta/applicator.json' with { type: 'json' };
+import content from './meta/content.json' with { type: 'json' };
+import core from './meta/core.json' with { type: 'json' };
+import format from './meta/format.json' with { type: 'json' };
+import metadata from './meta/meta-data.json' with { type: 'json' };
+import validation from './meta/validation.json' with { type: 'json' };
+
+export default {
+  metaSchema,
+  applicator,
+  content,
+  core,
+  format,
+  metadata,
+  validation,
+};

package/src/json-schema-2019-09/index.js

@@ -0,0 +1,12 @@
+import draft from './index.import.no-lint.js';
+
+const draft2019 = [
+  draft.metaSchema,
+  draft.applicator,
+  draft.content,
+  draft.core,
+  draft.format,
+  draft.metadata,
+  draft.validation];
+
+export default draft2019;

package/src/json-schema-2019-09/meta/applicator.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "https://json-schema.org/draft/2019-09/schema",
+  "$id": "https://json-schema.org/draft/2019-09/meta/applicator",
+  "$vocabulary": {
+    "https://json-schema.org/draft/2019-09/vocab/applicator": true
+  },
+  "$recursiveAnchor": true,
+
+  "title": "Applicator vocabulary meta-schema",
+  "type": ["object", "boolean"],
+  "properties": {
+    "additionalItems": {"$recursiveRef": "#"},
+    "unevaluatedItems": {"$recursiveRef": "#"},
+    "items": {
+      "anyOf": [{"$recursiveRef": "#"}, {"$ref": "#/$defs/schemaArray"}]
+    },
+    "contains": {"$recursiveRef": "#"},
+    "additionalProperties": {"$recursiveRef": "#"},
+    "unevaluatedProperties": {"$recursiveRef": "#"},
+    "properties": {
+      "type": "object",
+      "additionalProperties": {"$recursiveRef": "#"},
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": {"$recursiveRef": "#"},
+      "propertyNames": {"format": "regex"},
+      "default": {}
+    },
+    "dependentSchemas": {
+      "type": "object",
+      "additionalProperties": {
+        "$recursiveRef": "#"
+      }
+    },
+    "propertyNames": {"$recursiveRef": "#"},
+    "if": {"$recursiveRef": "#"},
+    "then": {"$recursiveRef": "#"},
+    "else": {"$recursiveRef": "#"},
+    "allOf": {"$ref": "#/$defs/schemaArray"},
+    "anyOf": {"$ref": "#/$defs/schemaArray"},
+    "oneOf": {"$ref": "#/$defs/schemaArray"},
+    "not": {"$recursiveRef": "#"}
+  },
+  "$defs": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": {"$recursiveRef": "#"}
+    }
+  }
+}

package/src/json-schema-2019-09/meta/content.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json-schema.org/draft/2019-09/schema",
+  "$id": "https://json-schema.org/draft/2019-09/meta/content",
+  "$vocabulary": {
+    "https://json-schema.org/draft/2019-09/vocab/content": true
+  },
+  "$recursiveAnchor": true,
+
+  "title": "Content vocabulary meta-schema",
+
+  "type": ["object", "boolean"],
+  "properties": {
+    "contentMediaType": {"type": "string"},
+    "contentEncoding": {"type": "string"},
+    "contentSchema": {"$recursiveRef": "#"}
+  }
+}