json-schema-library 11.0.2 → 11.0.3

package/index.ts

@@ -3,7 +3,7 @@ export type { CompileOptions } from "./src/compileSchema";
 export type { Context, SchemaNode, GetNodeOptions, ValidateReturnType } from "./src/SchemaNode";
 export type { DataNode } from "./src/methods/toDataNodes";
 export type { Draft, DraftVersion } from "./src/Draft";
-export type { JsonError, JsonAnnotation, JsonPointer, JsonSchema, OptionalNodeOrError, NodeOrError } from "./src/types";
+export type { JsonError, JsonAnnotation, JsonPointer, JsonSchema, BooleanSchema, OptionalNodeOrError, NodeOrError } from "./src/types";
 export type {
     Keyword,
     Maybe,
@@ -37,7 +37,7 @@ export type { Annotation, AnnotationData, ErrorConfig } from "./src/types";
 // utilities
 export { getTypeOf } from "./src/utils/getTypeOf";
 export { isReduceable } from "./src/SchemaNode";
-export { isJsonError, isJsonAnnotation, isAnnotation, isSchemaNode } from "./src/types";
+export { isJsonError, isJsonAnnotation, isAnnotation, isSchemaNode, isJsonSchema, isBooleanSchema } from "./src/types";
 export { extendDraft, addKeywords } from "./src/Draft";
 export { mergeNode } from "./src/mergeNode";
 export { mergeSchema } from "./src/utils/mergeSchema";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.0.2",
+  "version": "11.0.3",
   "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -12,7 +12,12 @@
     },
     "./package.json": "./package.json"
   },
+  "engines": {
+    "yarn": ">=1.22.0",
+    "npm": "use yarn instead"
+  },
   "scripts": {
+    "preinstall": "npx only-allow yarn",
     "coverage": "nyc npm run test --reporter=lcov",
     "dist": "tsdown -f esm -f cjs --minify; yarn dist:iife",
     "dist:iife": "tsdown --config tsdown.iife.config.ts --no-clean --minify; mv dist/index.iife.js dist/jlib.js",

package/src/SchemaNode.ts

@@ -15,7 +15,9 @@ import { Draft } from "./Draft";
 import { toSchemaNodes } from "./methods/toSchemaNodes";
 import {
     isJsonError,
+    isJsonSchema,
     JsonSchema,
+    BooleanSchema,
     JsonError,
     AnnotationData,
     DefaultErrors,
@@ -189,7 +191,7 @@ export interface SchemaNode extends SchemaNodeMethodsType {
  * Fixed SchemaNode mixin methods
  */
 interface SchemaNodeMethodsType {
-    compileSchema(schema: JsonSchema, evaluationPath?: string, schemaLocation?: string, dynamicId?: string): SchemaNode;
+    compileSchema(schema: JsonSchema | BooleanSchema, evaluationPath?: string, schemaLocation?: string, dynamicId?: string): SchemaNode;
     createError<T extends string = DefaultErrors>(code: T, data: AnnotationData, message?: string): JsonError;
     createAnnotation<T extends string = DefaultErrors>(code: T, data: AnnotationData, message?: string): JsonAnnotation;
     createSchema(data?: unknown): JsonSchema;
@@ -241,7 +243,7 @@ interface SchemaNodeMethodsType {
     ): OptionalNodeOrError;
     resolveRef: (args?: { pointer?: string; path?: ValidationPath }) => SchemaNode;
     validate(data: unknown, pointer?: string, path?: ValidationPath): ValidateReturnType;
-    addRemoteSchema(url: string, schema: JsonSchema): SchemaNode;
+    addRemoteSchema(url: string, schema: JsonSchema | BooleanSchema): SchemaNode;
     toSchemaNodes(): SchemaNode[];
     toDataNodes(data: unknown, pointer?: string): DataNode[];
     toJSON(): unknown;
@@ -494,12 +496,16 @@ export const SchemaNodeMethods = {
      * Register a JSON Schema as a remote-schema to be resolved by $ref, $anchor, etc
      * @returns the current node (not the remote schema-node)
      */
-    addRemoteSchema(url: string, schema: JsonSchema): SchemaNode {
-        // @draft >= 6
+    addRemoteSchema(url: string, schema: JsonSchema | BooleanSchema): SchemaNode {
+    // @draft >= 6
+    if (isJsonSchema(schema)) {
         schema.$id = resolveUri(schema.$id || url);
+    }
+        
         const node = this as SchemaNode;
         const { context } = node;
-        const draft = getDraft(context.drafts, schema?.$schema ?? context.rootNode.schema?.$schema);
+        const schemaId = isJsonSchema(schema) ? schema.$schema : undefined;
+const draft = getDraft(context.drafts, schemaId ?? context.rootNode.schema?.$schema);
 
         const remoteNode: SchemaNode = {
             evaluationPath: "#",

package/src/compileSchema.ts

@@ -6,7 +6,7 @@ import { draft07 } from "./draft07";
 import { draft2019 } from "./draft2019";
 import { draft2020 } from "./draft2020";
 import { pick } from "./utils/pick";
-import { JsonSchema, Draft } from "./types";
+import { JsonSchema, BooleanSchema, Draft, isJsonSchema } from "./types";
 import { TemplateOptions } from "./methods/getData";
 import { SchemaNode, SchemaNodeMethods, addKeywords, isSchemaNode } from "./SchemaNode";
 import settings from "./settings";
@@ -31,10 +31,10 @@ function getDraft(drafts: Draft[], $schema: string) {
  * wrapping each schema with utilities and as much preevaluation as possible. Each
  * node will be reused for each task, but will create a compiledNode for bound data.
  */
-export function compileSchema(schema: JsonSchema, options: CompileOptions = {}) {
+export function compileSchema(schema: JsonSchema | BooleanSchema, options: CompileOptions = {}) {
     let formatAssertion = options.formatAssertion ?? true;
     const drafts = options.drafts ?? defaultDrafts;
-    const draft = getDraft(drafts, schema?.$schema);
+    const draft = getDraft(drafts, isJsonSchema(schema) ? schema.$schema : undefined);
 
     const node: SchemaNode = {
         evaluationPath: "#",
@@ -44,7 +44,7 @@ export function compileSchema(schema: JsonSchema, options: CompileOptions = {})
         reducers: [],
         resolvers: [],
         validators: [],
-        schema,
+        schema: schema as JsonSchema,
         // @ts-expect-error self-reference added later
         context: {
             remotes: {},
@@ -60,7 +60,7 @@ export function compileSchema(schema: JsonSchema, options: CompileOptions = {})
     };
 
     node.context.rootNode = node;
-    node.context.remotes[schema?.$id ?? "#"] = node;
+    node.context.remotes[(isJsonSchema(schema) ? schema.$id : undefined) ?? "#"] = node;
 
     if (options.remote) {
         const metaSchema = getRef(node, node.schema.$schema);

package/src/types.ts

@@ -9,6 +9,13 @@ export type BooleanSchema = boolean;
 export interface JsonSchema {
     [keyword: string]: any;
 }
+export function isJsonSchema(value: unknown): value is JsonSchema {
+    return isObject(value);
+}
+
+export function isBooleanSchema(value: unknown): value is BooleanSchema {
+    return typeof value === "boolean";
+}
 
 export type JsonPointer = string;