add support for $ref

Author: DetachHead

src/lib/SchemaForm.svelte

@@ -12,7 +12,7 @@
 	import { FileNone, type CommonComponentParameters, type ValidationErrors } from './types/CommonComponentParameters';
 	import Enum from './editors/Enum.svelte';
 	import Array from './editors/Array.svelte';
-	import { incr, nullOptionalsAllowed } from './utilities.js';
+	import { incr, nullOptionalsAllowed, resolveRefs } from './utilities.js';
 	import Boolean from './editors/Boolean.svelte';
 	import Number from './editors/Number.svelte';
 	import { errorMapper } from "./errorMapper";
@@ -34,15 +34,17 @@
 	export let components: Record<string, new (...args: any[]) => any> = {};
 	export let componentContext: Record<string, unknown> = {};
 
+	let resolvedSchema: any = resolveRefs(schema, schema)
+
 	const dispatch = createEventDispatcher();
 
 	let validationErrors = {} as ValidationErrors;
 
 	const revalidate = (newValue?: any) => {
-		const validate = validator(nullOptionalsAllowed(schema), { includeErrors: true, allErrors: true, allowUnusedKeywords: true });
+		const validate = validator(nullOptionalsAllowed(resolvedSchema), { includeErrors: true, allErrors: true, allowUnusedKeywords: true });
 		const validatorResult = validate(newValue || value);
 		validationErrors = Object.fromEntries(
-			(validate.errors || []).map(ve => errorMapper(schema, value, ve.keywordLocation, ve.instanceLocation))
+			(validate.errors || []).map(ve => errorMapper(resolvedSchema, value, ve.keywordLocation, ve.instanceLocation))
 		);
 	}
 
@@ -87,7 +89,7 @@
 		pathChanged,
 		validationErrors,
 		containerParent: "none",
-		containerReadOnly: schema.readOnly || false,
+		containerReadOnly: resolvedSchema.readOnly || false,
 		showErrors,
 		collapsible,
 		idx: incr()
@@ -140,4 +142,4 @@
 	};
 </script>
 
-<SubSchemaForm {params} {value} bind:schema />
+<SubSchemaForm {params} {value} root={schema} bind:schema={resolvedSchema} /> 

src/lib/SubSchemaForm.svelte

@@ -1,18 +1,21 @@
 <script lang="ts">
 	import type { CommonComponentParameters } from "./types/CommonComponentParameters";
 	import { editorForSchema } from "./types/schema";
+  	import { resolveRefs } from "./utilities";
 	export let params: CommonComponentParameters;
 	export let schema: any;
+	export let root: any;
 	export let value: any;
 	let { components } = params;
+	$: resolvedSchema = resolveRefs(root, schema);
 
 	let typeComponent: any;
 	
 	let component: new (...args: any[]) => any;
-	$: component = components[editorForSchema(schema)];
+	$: component = components[editorForSchema(resolvedSchema)];
 </script>
 
-<svelte:component this={component} {params} {value} bind:schema />
+<svelte:component this={component} {params} {value} {root} bind:schema={resolvedSchema} />
 
 
 

src/lib/editors/ListDetail.svelte

@@ -8,6 +8,7 @@
     import { tick } from "svelte";
 	export let params: CommonComponentParameters;
 	export let schema: any;
+	export let root: any;
 	export let value: any[];
 
 	interface SortSpec {
@@ -188,6 +189,7 @@
 						}}
 						value={selectedValue}
 						bind:schema={schema.items}
+						{root}
 					/>
 				</div>
 			{/if}

src/lib/editors/Object.svelte

@@ -6,6 +6,7 @@
     import { stringToHtml } from "../utilities.js";
 	export let params: CommonComponentParameters;
 	export let schema: any;
+	export let root: any;
 	export let value: any;
 
 	let propnames: string[];
@@ -50,6 +51,7 @@
 		}}
 		value={value?.[propName]}
 		bind:schema={schema.properties[propName]}
+		{root}
 	/>
 	{/each}
 	{/if}

src/lib/schemasafe-extended.d.ts

@@ -1,4 +1,13 @@
 declare module "@exodus/schemasafe/src/pointer" {
-	let get: (obj: any, pointer: string, objpath?: string) => any;
-	export { get };
-};
+  export let get: (obj: any, pointer: string, objpath?: string) => any;
+  export function resolveReference(
+    root: Record<string, unknown>,
+    schemas: Set<string>,
+    ref: string,
+    base?: string
+  ): [
+    schema: Record<string, unknown>,
+    root: Record<string, unknown>,
+    basePath: string
+  ][];
+}

src/lib/utilities.ts

@@ -1,5 +1,6 @@
-import { get } from "lodash-es";
-
+import { get, cloneDeep } from "lodash-es";
+import { resolveReference } from "@exodus/schemasafe/src/pointer";
+ 
 export const upTo = (str: string, match: string, start?: number) => {
     const pos = str.indexOf(match, start);
     return pos < 0 ? str.substring(start || 0) : str.substring(start || 0, pos);
@@ -39,30 +40,34 @@ export function camelToTitle(camel: string): string {
     return camelToWords(camel).replace(/[a-z]/i, (ltr) => ltr.toUpperCase())
 }
 
+export function resolveRefs(root: Record<string, unknown>, schema: Record<string, unknown>): Record<string, unknown> {
+    return schema['$ref']
+        ? resolveReference(root, new Set(Object.keys(root.definitions as Record<string, unknown>[])), schema['$ref'] as string)[0][0]
+        : cloneDeep(schema)
+}
+
 /** manipulate the schema to allow any optional property to have a null value
  * which is appropriate for form input */
- export function nullOptionalsAllowed(schema: object): object {
+ export function nullOptionalsAllowed(schema: Record<string, unknown>): object {
     if (schema === null || schema === undefined) schema = {};
-    let newSchema = deepCopy(schema);
-    nullOptionalsAllowedApply(newSchema as Record<string, unknown>);
-    return newSchema;
+    return nullOptionalsAllowedApply(schema, schema);
 }
 
-function nullOptionalsAllowedApply(schema: Record<string, unknown>) {
+function nullOptionalsAllowedApply(root: Record<string, unknown>, unresolvedSchema: Record<string, unknown>): Record<string, unknown> {
+    const schema = resolveRefs(root, unresolvedSchema)
     let req = (schema['required'] || []) as Array<string>;
-    if (schema['$ref']) return;
     switch (schema['type']) {
         case 'object':
             const properties = (schema['properties'] || {}) as Record<string, unknown>;
             for (let prop in properties) {
                 if (req.indexOf(prop) < 0) {
-                    nullOptionalsAllowedApply(properties[prop] as Record<string, unknown>);
+                    properties[prop] = nullOptionalsAllowedApply(root, properties[prop] as Record<string, unknown>);
                 }
             }
             break;
         case 'array':
             const items = (schema['items'] || {}) as Record<string, unknown>;
-            nullOptionalsAllowedApply(items);
+            schema['items'] = nullOptionalsAllowedApply(root, items);
             if (items['oneOf'] && !(items['oneOf'] as any[]).some(subschema => subschema["type"] == "null")) {
                 (items['oneOf'] as any[]).push({ type: 'null' });
             }
@@ -80,44 +85,10 @@ function nullOptionalsAllowedApply(schema: Record<string, unknown>) {
     const defns = schema['definitions'] as Record<string, unknown>;
     if (defns) {
         for (let defn in defns) {
-            nullOptionalsAllowedApply(defns[defn] as Record<string, unknown>);
+            defns[defn] = nullOptionalsAllowedApply(root, defns[defn] as Record<string, unknown>);
         }
     }
-}
-
-export function deepCopy(obj: object): object {
-    var copy;
-
-    // Handle the 3 simple types, and null or undefined
-    if (null == obj || "object" != typeof obj) return obj;
-
-    // Handle Date
-    if (obj instanceof Date) {
-        copy = new Date();
-        copy.setTime(obj.getTime());
-        return copy;
-    }
-
-    // Handle Array
-    if (obj instanceof Array) {
-        copy = [];
-        for (var i = 0, len = obj.length; i < len; i++) {
-            copy[i] = deepCopy(obj[i]);
-        }
-        return copy;
-    }
-
-    // Handle Object
-    if (obj instanceof Object) {
-        copy = {} as Record<string, unknown>;
-        const recObj = obj as Record<string, unknown>;
-        for (var attr in recObj) {
-            if (recObj.hasOwnProperty(attr)) copy[attr] = deepCopy(recObj[attr] as object);
-        }
-        return copy;
-    }
-
-    throw new Error("Unable to copy obj! Its type isn't supported.");
+    return schema;
 }
 
 let incrVal = 0;