json-schema-library 5.3.0 → 7.0.0

package/lib/getTemplate.ts

@@ -4,9 +4,8 @@ import getTypeOf from "./getTypeOf";
 import merge from "./utils/merge";
 import copy from "./utils/copy";
 import settings from "./config/settings";
-import { JSONSchema, JSONPointer } from "./types";
-import Core from "./cores/CoreInterface";
-
+import { JSONSchema, JSONPointer, isJSONError } from "./types";
+import { Draft as Core } from "./draft";
 
 interface TemplateOptions {
     /** Add all properties (required and optional) to the generated data */
@@ -17,24 +16,32 @@ const defaultOptions: TemplateOptions = {
     addOptionalProps: true
 };
 
-let cache;
+let cache: Record<string, JSONSchema>;
 function shouldResolveRef(schema: JSONSchema, pointer: JSONPointer) {
     // ensure we refactored consistently
-    if (pointer == null) { throw new Error("Missing pointer"); }
+    if (pointer == null) {
+        throw new Error("Missing pointer");
+    }
 
     const { $ref } = schema;
-    if ($ref == null) { return true; }
+    if ($ref == null) {
+        return true;
+    }
 
-    const value = (cache[pointer] == null || cache[pointer][$ref] == null) ? 0 : cache[pointer][$ref];
+    const value = cache[pointer] == null || cache[pointer][$ref] == null ? 0 : cache[pointer][$ref];
     return value < settings.GET_TEMPLATE_RECURSION_LIMIT;
 }
 
 function resolveRef(core: Core, schema: JSONSchema, pointer: JSONPointer) {
     // ensure we refactored consistently
-    if (pointer == null) { throw new Error(`missing pointer ${pointer}`); }
+    if (pointer == null) {
+        throw new Error(`missing pointer ${pointer}`);
+    }
 
     const { $ref } = schema;
-    if ($ref == null) { return schema; }
+    if ($ref == null) {
+        return schema;
+    }
 
     // @todo pointer + ref is redundant?
     cache[pointer] = cache[pointer] || {};
@@ -43,7 +50,6 @@ function resolveRef(core: Core, schema: JSONSchema, pointer: JSONPointer) {
     return core.resolveRef(schema);
 }
 
-
 function convertValue(type: string, value: any) {
     if (type === "string") {
         return JSON.stringify(value);
@@ -68,13 +74,20 @@ function convertValue(type: string, value: any) {
  * @param pointer
  * @return resolved json-schema or input-schema
  */
-function createTemplateSchema(core: Core, schema: JSONSchema, data, pointer: JSONPointer): JSONSchema|false {
+function createTemplateSchema(
+    core: Core,
+    schema: JSONSchema,
+    data: unknown,
+    pointer: JSONPointer
+): JSONSchema | false {
     // invalid schema
     if (getTypeOf(schema) !== "object") {
         return Object.assign({ pointer }, schema);
     }
     // return if reached recursion limit
-    if (shouldResolveRef(schema, pointer) === false && data == null) { return false; }
+    if (shouldResolveRef(schema, pointer) === false && data == null) {
+        return false;
+    }
 
     // resolve $ref and copy schema
     let templateSchema = copy(resolveRef(core, schema, pointer));
@@ -95,7 +108,10 @@ function createTemplateSchema(core: Core, schema: JSONSchema, data, pointer: JSO
         for (let i = 0, l = schema.allOf.length; i < l; i += 1) {
             // test if we may resolve
             if (shouldResolveRef(schema.allOf[i], `${pointer}/allOf/${i}`)) {
-                templateSchema = merge(templateSchema, resolveRef(core, schema.allOf[i], `${pointer}/allOf/${i}`));
+                templateSchema = merge(
+                    templateSchema,
+                    resolveRef(core, schema.allOf[i], `${pointer}/allOf/${i}`)
+                );
                 // add pointer return-value, if any
                 templateSchema.pointer = schema.allOf[i].$ref || templateSchema.pointer;
             }
@@ -107,7 +123,8 @@ function createTemplateSchema(core: Core, schema: JSONSchema, data, pointer: JSO
     return templateSchema;
 }
 
-const isJSONSchema = (template): template is JSONSchema => template && typeof template === "object";
+const isJSONSchema = (template: unknown): template is JSONSchema =>
+    template && typeof template === "object";
 
 /**
  * Create data object matching the given schema
@@ -117,21 +134,37 @@ const isJSONSchema = (template): template is JSONSchema => template && typeof te
  * @param [schema] - json schema, defaults to rootSchema
  * @return created template data
  */
-function getTemplate(core, data, _schema: JSONSchema, pointer: JSONPointer, opts: TemplateOptions) {
-    if (_schema == null) { throw new Error(`getTemplate: missing schema for data: ${JSON.stringify(data)}`); }
-    if (pointer == null) { throw new Error("Missing pointer"); }
+function getTemplate(
+    core: Core,
+    data?: unknown,
+    _schema?: JSONSchema,
+    pointer?: JSONPointer,
+    opts?: TemplateOptions
+) {
+    if (_schema == null) {
+        throw new Error(`getTemplate: missing schema for data: ${JSON.stringify(data)}`);
+    }
+    if (pointer == null) {
+        throw new Error("Missing pointer");
+    }
 
     // resolve $ref references, allOf and first anyOf definitions
     let schema = createTemplateSchema(core, _schema, data, pointer);
-    if (!isJSONSchema(schema)) { return undefined; }
+    if (!isJSONSchema(schema)) {
+        return undefined;
+    }
     pointer = schema.pointer;
 
+    if (schema?.const) {
+        return schema.const;
+    }
+
     if (schema.oneOf) {
         // find correct schema for data
         const resolvedSchema = resolveOneOfFuzzy(core, data, schema);
-        if (data == null && resolvedSchema.type === "error") {
+        if (data == null && isJSONError(resolvedSchema)) {
             schema = schema.oneOf[0];
-        } else if (resolvedSchema.type === "error") {
+        } else if (isJSONError(resolvedSchema.type)) {
             // @todo - check: do not return schema, but either input-data or undefined (clearing wrong data)
             return data;
         } else {
@@ -139,6 +172,10 @@ function getTemplate(core, data, _schema: JSONSchema, pointer: JSONPointer, opts
         }
     }
 
+    // @todo Array.isArray(schema.type)
+    // -> hasDefault? return
+    // if not -> pick first type
+
     if (!isJSONSchema(schema) || schema.type == null) {
         return undefined;
     }
@@ -148,7 +185,8 @@ function getTemplate(core, data, _schema: JSONSchema, pointer: JSONPointer, opts
         data = convertValue(schema.type, data);
     }
 
-    if (TYPE[schema.type] == null) { // eslint-disable-line no-use-before-define
+    if (TYPE[schema.type] == null) {
+        // eslint-disable-line no-use-before-define
         throw new Error(`Unsupported type '${schema.type} in ${JSON.stringify(schema)}'`);
     }
 
@@ -156,42 +194,94 @@ function getTemplate(core, data, _schema: JSONSchema, pointer: JSONPointer, opts
     return templateData;
 }
 
-
-const TYPE = {
-    "string": (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, ""),
-    "number": (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, 0),
-    "integer": (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, 0),
-    "boolean": (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, false),
-    "object": (core: Core, schema: JSONSchema, data: any, pointer: JSONPointer, opts: TemplateOptions) => {
+const TYPE: Record<
+    string,
+    (
+        core: Core,
+        schema: JSONSchema,
+        data: unknown,
+        pointer: JSONPointer,
+        opts: TemplateOptions
+    ) => unknown
+> = {
+    null: (core, schema, data) => getDefault(schema, data, null),
+    string: (core, schema, data) => getDefault(schema, data, ""),
+    number: (core, schema, data) => getDefault(schema, data, 0),
+    integer: (core, schema, data) => getDefault(schema, data, 0),
+    boolean: (core, schema, data) => getDefault(schema, data, false),
+    object: (
+        core,
+        schema,
+        data: Record<string, unknown> | undefined,
+        pointer: JSONPointer,
+        opts: TemplateOptions
+    ) => {
         const template = schema.default === undefined ? {} : schema.default;
-        const d = {}; // do not assign data here, to keep ordering from json-schema
+        const d: Record<string, unknown> = {}; // do not assign data here, to keep ordering from json-schema
 
         if (schema.properties) {
-            Object.keys(schema.properties).forEach(key => {
-                const value = (data == null || data[key] == null) ? template[key] : data[key];
+            Object.keys(schema.properties).forEach((key) => {
+                const value = data == null || data[key] == null ? template[key] : data[key];
                 const isRequired = Array.isArray(schema.required) && schema.required.includes(key);
 
                 // Omit adding a property if it is not required or optional props should be added
                 if (value != null || isRequired || opts.addOptionalProps) {
-                    d[key] = getTemplate(core, value, schema.properties[key], `${pointer}/properties/${key}`, opts);
+                    d[key] = getTemplate(
+                        core,
+                        value,
+                        schema.properties[key],
+                        `${pointer}/properties/${key}`,
+                        opts
+                    );
+                }
+            });
+        }
+
+        if (schema.dependencies) {
+            Object.keys(schema.dependencies).forEach((key) => {
+                const dependency = schema.dependencies[key];
+                if (getTypeOf(dependency) !== "object") {
+                    return;
+                }
+                if (d[key] === undefined) {
+                    return;
+                }
+
+                const result = getTemplate(
+                    core,
+                    data,
+                    { ...dependency, type: "object" },
+                    `${pointer}/dependencies/${key}`,
+                    opts
+                );
+
+                if (result && !isJSONError(result)) {
+                    Object.assign(d, result);
                 }
             });
         }
 
         if (data) {
             // merge any missing data (additionals) to resulting object
-            Object.keys(data).forEach(key => (d[key] == null && (d[key] = data[key])));
+            Object.keys(data).forEach((key) => d[key] == null && (d[key] = data[key]));
         }
 
         // returns object, which is ordered by json-schema
         return d;
     },
     // build array type of items, ignores additionalItems
-    "array": (core: Core, schema: JSONSchema, data, pointer: JSONPointer, opts: TemplateOptions) => {
+    array: (
+        core: Core,
+        schema: JSONSchema,
+        data: unknown[],
+        pointer: JSONPointer,
+        opts: TemplateOptions
+    ) => {
         const template = schema.default === undefined ? [] : schema.default;
-        const d = data || [];
         schema.minItems = schema.minItems || 0;
 
+        const d: unknown[] = data || [];
+
         // items are undefined
         if (schema.items == null) {
             return d;
@@ -200,7 +290,13 @@ const TYPE = {
         // build defined set of items
         if (Array.isArray(schema.items)) {
             for (let i = 0, l = Math.min(schema.minItems, schema.items.length); i < l; i += 1) {
-                d[i] = getTemplate(core, d[i] == null ? template[i] : d[i], schema.items[i], `${pointer}/items/${i}`, opts);
+                d[i] = getTemplate(
+                    core,
+                    d[i] == null ? template[i] : d[i],
+                    schema.items[i],
+                    `${pointer}/items/${i}`,
+                    opts
+                );
             }
             return d;
         }
@@ -221,7 +317,13 @@ const TYPE = {
         if (templateSchema.oneOf && d.length === 0) {
             const oneOfSchema = templateSchema.oneOf[0];
             for (let i = 0; i < schema.minItems; i += 1) {
-                d[i] = getTemplate(core, d[i] == null ? template[i] : d[i], oneOfSchema, `${pointer}/oneOf/0`, opts);
+                d[i] = getTemplate(
+                    core,
+                    d[i] == null ? template[i] : d[i],
+                    oneOfSchema,
+                    `${pointer}/oneOf/0`,
+                    opts
+                );
             }
             return d;
         }
@@ -243,7 +345,13 @@ const TYPE = {
         // build items-definition
         if (templateSchema.type) {
             for (let i = 0, l = Math.max(schema.minItems, d.length); i < l; i += 1) {
-                d[i] = getTemplate(core, d[i] == null ? template[i] : d[i], templateSchema, `${pointer}/items`, opts);
+                d[i] = getTemplate(
+                    core,
+                    d[i] == null ? template[i] : d[i],
+                    templateSchema,
+                    `${pointer}/items`,
+                    opts
+                );
             }
             return d;
         }
@@ -252,10 +360,11 @@ const TYPE = {
     }
 };
 
-
 function getDefault(schema: JSONSchema, templateValue: any, initValue: any) {
     if (templateValue != null) {
         return templateValue;
+    } else if (schema.const) {
+        return schema.const;
     } else if (schema.default === undefined && Array.isArray(schema.enum)) {
         return schema.enum[0];
     } else if (schema.default === undefined) {
@@ -264,8 +373,12 @@ function getDefault(schema: JSONSchema, templateValue: any, initValue: any) {
     return schema.default;
 }
 
-
-export default (core: Core, data?: any, schema: JSONSchema = core.rootSchema, opts: TemplateOptions = defaultOptions) => {
-    cache = { "mi": ".." };
+export default (
+    core: Core,
+    data?: any,
+    schema: JSONSchema = core.rootSchema,
+    opts: TemplateOptions = defaultOptions
+) => {
+    cache = { mi: {} };
     return getTemplate(core, data, schema, "#", opts);
 };

package/lib/getTypeOf.ts

@@ -1,7 +1,8 @@
 const toString = Object.prototype.toString;
 
+export type JSType = "array"|"bigint"|"boolean"|"function"|"null"|"number"|"object"|"string"|"symbol"|"undefined";
 
-export default function getTypeOf(value: any) {
+export default function getTypeOf(value: unknown) : JSType {
     // eslint-disable-next-line newline-per-chained-call
     return toString.call(value).match(/\s([^\]]+)\]/).pop().toLowerCase();
 }

package/lib/isValid.ts

@@ -1,6 +1,5 @@
 import { JSONSchema, JSONPointer } from "./types";
-import Core from "./cores/CoreInterface";
-
+import { Draft as Core } from "./draft";
 
 /**
  * Test if the data is valid according to the given schema
@@ -11,6 +10,11 @@ import Core from "./cores/CoreInterface";
  * @param [pointer] - json pointer pointing to value
  * @return if schema does match given value
  */
-export default function isValid(core: Core, value: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): boolean {
+export default function isValid(
+    core: Core,
+    value: any,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+): boolean {
     return core.validate(value, schema, pointer).length === 0;
 }

package/lib/jsoneditor/index.ts

@@ -0,0 +1,20 @@
+import merge from "../utils/merge";
+import resolveOneOf from "../resolveOneOf.fuzzy";
+import resolveRef from "../resolveRef.merge";
+import { Draft, DraftConfig } from "../draft";
+import { draft07Config } from "../draft07";
+import { JSONSchema } from "../types";
+
+const draftJsonEditorConfig: DraftConfig = {
+    ...draft07Config,
+    resolveOneOf,
+    resolveRef
+};
+
+class JsonEditor extends Draft {
+    constructor(schema?: JSONSchema, config: Partial<DraftConfig> = {}) {
+        super(merge(draftJsonEditorConfig, config), schema);
+    }
+}
+
+export { JsonEditor, draftJsonEditorConfig };

package/lib/resolveAllOf.ts

@@ -2,16 +2,20 @@ import copy from "./utils/copy";
 import merge from "./utils/merge";
 import errors from "./validation/errors";
 import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 
-
-export default function resolveAllOf(core: Core, data: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): JSONSchema|JSONError {
+export default function resolveAllOf(
+    core: Core,
+    data: any,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+): JSONSchema | JSONError {
     let mergedSchema = copy(schema);
     for (let i = 0; i < schema.allOf.length; i += 1) {
         const allOfSchema = core.resolveRef(schema.allOf[i]);
-        if (core.isValid(data, allOfSchema, pointer) === false) {
-            return errors.allOfError({ value: data, pointer, allOf: JSON.stringify(schema.allOf) });
-        }
+        // if (core.isValid(data, allOfSchema, pointer) === false) {
+        //     return errors.allOfError({ value: data, pointer, allOf: JSON.stringify(schema.allOf) });
+        // }
         mergedSchema = merge(mergedSchema, allOfSchema);
     }
 

package/lib/resolveAnyOf.ts

@@ -2,10 +2,14 @@ import copy from "./utils/copy";
 import merge from "./utils/merge";
 import errors from "./validation/errors";
 import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 
-
-export default function resolveAnyOf(core: Core, data: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): JSONSchema|JSONError {
+export default function resolveAnyOf(
+    core: Core,
+    data: any,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+): JSONSchema | JSONError {
     let found = false;
     let mergedSchema = copy(schema);
     for (let i = 0; i < schema.anyOf.length; i += 1) {

package/lib/resolveOneOf.fuzzy.ts

@@ -2,9 +2,8 @@ import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
 import getTypeOf from "./getTypeOf";
 import settings from "./config/settings";
-import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
-
+import { JSONSchema, JSONPointer, JSONError, isJSONError } from "./types";
+import { Draft as Core } from "./draft";
 
 const { DECLARATOR_ONEOF } = settings;
 
@@ -17,7 +16,12 @@ const { DECLARATOR_ONEOF } = settings;
  * @param [pointer]
  * @return ranking value (higher is better)
  */
-function fuzzyObjectValue(core: Core, one: JSONSchema, data: { [p: string]: any }, pointer?: JSONPointer) {
+function fuzzyObjectValue(
+    core: Core,
+    one: JSONSchema,
+    data: { [p: string]: any },
+    pointer?: JSONPointer
+) {
     if (data == null || one.properties == null) {
         return -1;
     }
@@ -43,7 +47,12 @@ function fuzzyObjectValue(core: Core, one: JSONSchema, data: { [p: string]: any
  * @param [pointer] - json pointer to data
  * @return oneOf schema or an error
  */
-export default function resolveOneOf(core: Core, data: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): JSONSchema|JSONError {
+export default function resolveOneOf(
+    core: Core,
+    data: any,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+): JSONSchema | JSONError {
     // !keyword: oneOfProperty
     // an additional <DECLARATOR_ONEOF> (default `oneOfProperty`) on the schema will exactly determine the
     // oneOf value (if set in data)
@@ -52,7 +61,6 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
     // abort if no data is given an DECLARATOR_ONEOF is set (used by getChildSchemaSelection)
     // this case (data != null) should not be necessary
     if (data != null && schema[DECLARATOR_ONEOF]) {
-
         const errors = [];
         const oneOfProperty = schema[DECLARATOR_ONEOF];
         const oneOfValue = data[schema[DECLARATOR_ONEOF]];
@@ -65,7 +73,7 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
             const one = core.resolveRef(schema.oneOf[i]);
             const oneOfPropertySchema = core.step(oneOfProperty, one, data, pointer);
 
-            if (oneOfPropertySchema && oneOfPropertySchema.type === "error") {
+            if (isJSONError(oneOfPropertySchema)) {
                 return oneOfPropertySchema;
             }
 
@@ -79,7 +87,12 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
             }
         }
 
-        return core.errors.oneOfPropertyError({ property: oneOfProperty, value: oneOfValue, pointer, errors });
+        return core.errors.oneOfPropertyError({
+            property: oneOfProperty,
+            value: oneOfValue,
+            pointer,
+            errors
+        });
     }
 
     // keyword: oneOf
@@ -111,7 +124,11 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
         }
 
         if (schemaOfItem === undefined) {
-            return core.errors.oneOfError({ value: JSON.stringify(data), pointer, oneOf: schema.oneOf });
+            return core.errors.oneOfError({
+                value: JSON.stringify(data),
+                pointer,
+                oneOf: schema.oneOf
+            });
         }
 
         return schemaOfItem;

package/lib/resolveOneOf.strict.ts

@@ -1,8 +1,10 @@
 import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
-import Core from "./cores/CoreInterface";
-import { JSONSchema, JSONError, JSONPointer } from "./types";
+import settings from "./config/settings";
+import { JSONSchema, JSONPointer, JSONError, isJSONError } from "./types";
+import { Draft as Core } from "./draft";
 
+const { DECLARATOR_ONEOF } = settings;
 
 /**
  * Selects and returns a oneOf schema for the given data
@@ -13,7 +15,54 @@ import { JSONSchema, JSONError, JSONPointer } from "./types";
  * @param pointer - json pointer to data
  * @return oneOf schema or an error
  */
-export default function resolveOneOf(core: Core, data: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): JSONSchema|JSONError {
+export default function resolveOneOf(
+    core: Core,
+    data: any,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+): JSONSchema | JSONError {
+    // !keyword: oneOfProperty
+    // an additional <DECLARATOR_ONEOF> (default `oneOfProperty`) on the schema will exactly determine the
+    // oneOf value (if set in data)
+
+    // @fixme
+    // abort if no data is given an DECLARATOR_ONEOF is set (used by getChildSchemaSelection)
+    // this case (data != null) should not be necessary
+    if (data != null && schema[DECLARATOR_ONEOF]) {
+        const errors = [];
+        const oneOfProperty = schema[DECLARATOR_ONEOF];
+        const oneOfValue = data[schema[DECLARATOR_ONEOF]];
+
+        if (oneOfValue === undefined) {
+            return core.errors.missingOneOfPropertyError({ property: oneOfProperty, pointer });
+        }
+
+        for (let i = 0; i < schema.oneOf.length; i += 1) {
+            const one = core.resolveRef(schema.oneOf[i]);
+            const oneOfPropertySchema = core.step(oneOfProperty, one, data, pointer);
+
+            if (isJSONError(oneOfPropertySchema)) {
+                return oneOfPropertySchema;
+            }
+
+            let result = flattenArray(core.validate(oneOfValue, oneOfPropertySchema, pointer));
+            result = result.filter(errorOrPromise);
+
+            if (result.length > 0) {
+                errors.push(...result);
+            } else {
+                return one; // return resolved schema
+            }
+        }
+
+        return core.errors.oneOfPropertyError({
+            property: oneOfProperty,
+            value: oneOfValue,
+            pointer,
+            errors
+        });
+    }
+
     const matches = [];
     const errors = [];
     for (let i = 0; i < schema.oneOf.length; i += 1) {
@@ -33,8 +82,17 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
         return matches[0];
     }
     if (matches.length > 1) {
-        return core.errors.multipleOneOfError({ value: data, pointer, matches });
+        return core.errors.multipleOneOfError({
+            value: data,
+            pointer,
+            matches
+        });
     }
 
-    return core.errors.oneOfError({ value: JSON.stringify(data), pointer, oneOf: schema.oneOf, errors });
+    return core.errors.oneOfError({
+        value: JSON.stringify(data),
+        pointer,
+        oneOf: schema.oneOf,
+        errors
+    });
 }

package/lib/resolveRef.strict.ts

@@ -6,6 +6,15 @@ export default function resolveRef(schema: JSONSchema, rootSchema: JSONSchema):
         return schema;
     }
 
+    if (schema.getRoot) {
+        // we actually always need to resolve the schema like this, since returned subschemas
+        // must resolve relative from their schema
+        const resolvedSchema = schema.getRoot().getRef(schema);
+        // console.log(schema.$ref, "=>", resolvedSchema);
+        return resolvedSchema;
+    }
+
+    // tryout - this should never be called, except we missed something
     const resolvedSchema = rootSchema.getRef(schema);
     return resolvedSchema;
 }