@microsoft/fast-html 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/dts/components/utilities.d.ts

@@ -1,9 +1,12 @@
+import { type JSONSchema, type JSONSchemaDefinition, Schema } from "./schema.js";
 type BehaviorType = "dataBinding" | "templateDirective";
-type TemplateDirective = "when" | "repeat" | "apply";
+type TemplateDirective = "when" | "repeat";
 export type AttributeDirective = "children" | "slotted" | "ref";
+type DataBindingBindingType = "client" | "default" | "unescaped";
 interface BehaviorConfig {
     type: BehaviorType;
 }
+export type PathType = "access" | "default" | "event" | "repeat";
 export interface ContentDataBindingBehaviorConfig extends BaseDataBindingBehaviorConfig {
     subtype: "content";
 }
@@ -18,6 +21,7 @@ export interface AttributeDirectiveBindingBehaviorConfig extends BaseDataBinding
 export type DataBindingBehaviorConfig = ContentDataBindingBehaviorConfig | AttributeDataBindingBehaviorConfig | AttributeDirectiveBindingBehaviorConfig;
 export interface BaseDataBindingBehaviorConfig extends BehaviorConfig {
     type: "dataBinding";
+    bindingType: DataBindingBindingType;
     openingStartIndex: number;
     openingEndIndex: number;
     closingStartIndex: number;
@@ -32,11 +36,30 @@ export interface TemplateDirectiveBehaviorConfig extends BehaviorConfig {
     closingTagStartIndex: number;
     closingTagEndIndex: number;
 }
-interface PartialTemplateConfig {
-    innerHTML: string;
-    startIndex: number;
-    endIndex: number;
+export interface ChildrenMap {
+    customElementName: string;
+    attributeName: string;
 }
+export declare const contextPrefix: string;
+export declare const contextPrefixDot: string;
+declare const LogicalOperator: {
+    AND: string;
+    OR: string;
+};
+type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
+declare const Operator: {
+    readonly ACCESS: "access";
+    readonly EQUALS: "==";
+    readonly GREATER_THAN: ">";
+    readonly GREATER_THAN_OR_EQUALS: ">=";
+    readonly LESS_THAN: "<";
+    readonly LESS_THAN_OR_EQUALS: "<=";
+    readonly NOT: "!";
+    readonly NOT_EQUALS: "!=";
+    readonly AND: string;
+    readonly OR: string;
+};
+type Operator = (typeof Operator)[keyof typeof Operator];
 /**
  * Get the index of the next matching tag
  * @param openingTagStartSlice - The slice starting from the opening tag
@@ -51,19 +74,7 @@ export declare function getIndexOfNextMatchingTag(openingTagStartSlice: string,
  * @param innerHTML - The innerHTML string to evaluate
  * @returns DataBindingBehaviorConfig | DirectiveBehaviorConfig | null - A configuration object or null
  */
-export declare function getNextBehavior(innerHTML: string): DataBindingBehaviorConfig | TemplateDirectiveBehaviorConfig | null;
-/**
- * Gets all the partials with their IDs
- * @param innerHTML - The innerHTML string to evaluate
- * @param offset - The index offset from the innerHTML
- * @param partials - The partials found
- * @returns {[key: string]: PartialTemplateConfig}
- */
-export declare function getAllPartials(innerHTML: string, offset?: number, partials?: {
-    [key: string]: PartialTemplateConfig;
-}): {
-    [key: string]: PartialTemplateConfig;
-};
+export declare function getNextBehavior(innerHTML: string, offset?: number): DataBindingBehaviorConfig | TemplateDirectiveBehaviorConfig | null;
 /**
  * Create a function to resolve a value from an object using a path with dot syntax.
  * e.g. "foo.bar"
@@ -71,32 +82,112 @@ export declare function getAllPartials(innerHTML: string, offset?: number, parti
  * @param self - Where the first item in the path path refers to the item itself (used by repeat).
  * @returns A function to access the value from a given path.
  */
-export declare function pathResolver(path: string, self?: boolean): (accessibleObject: any) => any;
+export declare function pathResolver(path: string, contextPath: string | null, level: number, rootSchema: JSONSchema): (accessibleObject: any, context: any) => any;
+export declare function bindingResolver(previousString: string | null, rootPropertyName: string | null, path: string, parentContext: string | null, type: PathType, schema: Schema, currentContext: string | null, level: number): (accessibleObject: any, context: any) => any;
+export declare function expressionResolver(rootPropertyName: string | null, expression: ChainedExpression, parentContext: string | null, level: number, schema: Schema): (accessibleObject: any, context: any) => any;
 /**
- * Available operators include:
- *
- * - access (no operator)
- * - not (!)
- * - equals (==)
- * - not equal (!=)
- * - greater than or equal (>=)
- * - greater than (>)
- * - less than or equal (<=)
- * - less than (<)
- * - or (||)
- * - and (&&) and the HTML character entity (&amp;&amp;)
+ * Extracts all paths from a ChainedExpression, including nested expressions
+ * @param chainedExpression - The chained expression to extract paths from
+ * @returns A Set containing all unique paths found in the expression chain
  */
-type Operator = "access" | "!" | "==" | "!=" | ">=" | ">" | "<=" | "<" | "||" | "&&" | "&amp;&amp;";
-interface OperatorConfig {
+export declare function extractPathsFromChainedExpression(chainedExpression: ChainedExpression): Set<string>;
+interface Expression {
     operator: Operator;
     left: string;
+    leftIsValue: boolean | null;
     right: string | boolean | number | null;
     rightIsValue: boolean | null;
 }
+export interface ChainedExpression {
+    operator?: LogicalOperator;
+    expression: Expression;
+    next?: ChainedExpression;
+}
+/**
+ * Gets the expression chain as a configuration object
+ * @param value - The binding string value
+ * @returns - A configuration object containing information about the expression
+ */
+export declare function getExpressionChain(value: string): ChainedExpression | void;
+/**
+ * This is the transform utility for rationalizing declarative HTML syntax
+ * with bindings in the ViewTemplate
+ * @param innerHTML The innerHTML to transform
+ * @param index The index to start the current slice of HTML to evaluate
+ */
+export declare function transformInnerHTML(innerHTML: string, index?: number): string;
+/**
+ * Resolves f-when
+ * @param self - Where the first item in the path path refers to the item itself (used by repeat).
+ * @param chainedExpression - The chained expression which includes the expression and the next expression
+ * if there is another in the chain
+ * @returns - A binding that resolves the chained expression logic
+ */
+export declare function resolveWhen(rootPropertyName: string | null, expression: ChainedExpression, parentContext: string | null, level: number, schema: Schema): (x: boolean, c: any) => any;
+/**
+ * Find a definition
+ * This may exist as a $ref at the root or as a $ref in any anyOf or not at all
+ * if the Observer Map has not been enabled on a child component
+ * @param schema - The JSON schema to find the ref in
+ * @returns The definition or null
+ */
+export declare function findDef(schema: JSONSchema | JSONSchemaDefinition): string | null;
+/**
+ * Assign observables to data
+ * @param schema - The schema
+ * @param rootSchema - The root schema mapping to the root property
+ * @param data - The data
+ * @param target - The target custom element
+ * @param rootProperty - The root property
+ * @returns
+ */
+export declare function assignObservables(schema: JSONSchema | JSONSchemaDefinition, rootSchema: JSONSchema, data: any, target: any, rootProperty: string): typeof Proxy;
+/**
+ * Assign a proxy to an object
+ * @param schema - The current schema
+ * @param rootSchema - The root schema for the root property
+ * @param target - The target custom element
+ * @param rootProperty - The root property
+ * @param object - The object to assign the proxy to
+ * @returns Proxy object
+ */
+export declare function assignProxy(schema: JSONSchema | JSONSchemaDefinition, rootSchema: JSONSchema, target: any, rootProperty: string, object: any): typeof Proxy;
+/**
+ * Get the root property name
+ * @param rootPropertyName - The root property
+ * @param path - The dot syntax path
+ * @param context - The context created by a repeat
+ * @param type - The type of path binding
+ * @returns
+ */
+export declare function getRootPropertyName(rootPropertyName: string | null, path: string, context: null | string, type: PathType): string | null;
+/**
+ * Get details of bindings to the attributes of child custom elements
+ * @param previousString - The previous string before the binding
+ * @returns null, or a custom element name and attribute name
+ */
+export declare function getChildrenMap(previousString: string | null): ChildrenMap | null;
+/**
+ * Deeply compares two objects for equality.
+ *
+ * @param obj1 - First object to compare
+ * @param obj2 - Second object to compare
+ * @returns True if the objects are deeply equal, false otherwise
+ */
+export declare function deepEqual(obj1: any, obj2: any): boolean;
 /**
- * Get the operator used.
- * @param value the binded value
- * @returns Operator
+ * Checks if a value is a plain object (not an array, null, or other type).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ */
+export declare function isPlainObject(value: any): value is Record<string, any>;
+/**
+ * Deeply merges the source object into the target object.
+ *
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns boolean indicating whether changes were made
  */
-export declare function getOperator(value: string): OperatorConfig;
+export declare function deepMerge(target: any, source: any): boolean;
 export {};

package/dist/dts/index.d.ts

@@ -1 +1 @@
-export { TemplateElement } from "./components/index.js";
+export { RenderableFASTElement, TemplateElement, ObserverMap, } from "./components/index.js";

package/dist/dts/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.47.0"
+      "packageVersion": "7.57.7"
     }
   ]
 }

package/dist/esm/components/element.js

@@ -0,0 +1,73 @@
+import { attr } from "@microsoft/fast-element";
+import { deferHydrationAttribute } from "@microsoft/fast-element/element-hydration.js";
+import { composedParent } from "@microsoft/fast-element/utilities.js";
+/**
+ * Waits for the `defer-hydration` attribute to be removed from the target element.
+ *
+ * @param target - The target element to wait for attribute removal
+ */
+function waitForAttributeRemoval(target) {
+    if (!target.hasAttribute(deferHydrationAttribute)) {
+        return Promise.resolve();
+    }
+    return new Promise(resolve => {
+        const observer = new MutationObserver(() => {
+            if (!target.hasAttribute(deferHydrationAttribute)) {
+                observer.disconnect();
+                resolve();
+            }
+        });
+        observer.observe(target, { attributeFilter: [deferHydrationAttribute] });
+    });
+}
+/**
+ * Waits until all ancestor elements no longer have the `defer-hydration` attribute.
+ *
+ * @param element - The element to wait for ancestor hydration
+ */
+async function waitForAncestorHydration(element) {
+    let ancestor = composedParent(element);
+    while (ancestor) {
+        if (ancestor instanceof HTMLElement &&
+            ancestor.hasAttribute(deferHydrationAttribute)) {
+            await waitForAttributeRemoval(ancestor);
+        }
+        ancestor = composedParent(ancestor);
+    }
+}
+/**
+ * A mixin function that extends a base class with additional functionality for
+ * rendering and hydration.
+ *
+ * @param BaseCtor - The base class to extend.
+ * @returns A new class that extends the provided base class with additional functionality for rendering and hydration.
+ * @public
+ */
+export function RenderableFASTElement(BaseCtor) {
+    const C = class extends BaseCtor {
+        constructor() {
+            super(...arguments);
+            this.deferHydration = true;
+        }
+        /**
+         * Prepares the element for hydration by calling the user-defined prepare method
+         * and waiting for all ancestor elements to be hydrated.
+         *
+         * @returns A promise that resolves when the element is ready for hydration.
+         */
+        async _prepare() {
+            if (this.prepare) {
+                await this.prepare();
+                this.prepare = undefined;
+            }
+            await waitForAncestorHydration(this);
+            this.deferHydration = false;
+        }
+        connectedCallback() {
+            this._prepare();
+            super.connectedCallback();
+        }
+    };
+    attr({ mode: "boolean", attribute: deferHydrationAttribute })(C.prototype, "deferHydration");
+    return C;
+}

package/dist/esm/components/index.js

@@ -1 +1,3 @@
-export { TemplateElement } from "./template.js";
+export { RenderableFASTElement } from "./element.js";
+export { ObserverMap } from "./observer-map.js";
+export { ObserverMapOption, TemplateElement, } from "./template.js";

package/dist/esm/components/observer-map.js

@@ -0,0 +1,68 @@
+import { Observable } from "@microsoft/fast-element/observable.js";
+import { assignObservables, deepMerge } from "./utilities.js";
+/**
+ * ObserverMap provides functionality for caching binding paths, extracting root properties,
+ * and defining observable properties on class prototypes
+ */
+export class ObserverMap {
+    constructor(classPrototype, schema) {
+        /**
+         * Creates a property change handler function for observable properties
+         * This handler is called when an observable property transitions from undefined to a defined value
+         * @param propertyName - The name of the property for which to create the change handler
+         * @param existingChangedMethod - Optional existing changed method to call after the instance resolver logic
+         * @returns A function that handles property changes and sets up proxies for object values
+         */
+        this.defineChanged = (propertyName, existingChangedMethod) => {
+            const getAndAssignObservablesAlias = this.getAndAssignObservables;
+            const schema = this.schema;
+            function instanceResolverChanged(prev, next) {
+                const isObjectAssignment = next !== null && typeof next === "object";
+                const isManagedArray = Array.isArray(next) && (next === null || next === void 0 ? void 0 : next.$fastController);
+                const shouldAssignProxy = isObjectAssignment && !(next === null || next === void 0 ? void 0 : next.$isProxy) && !isManagedArray;
+                const hasExistingProxy = prev !== null && typeof prev === "object" && prev.$isProxy;
+                if (shouldAssignProxy) {
+                    if (hasExistingProxy) {
+                        deepMerge(prev, next);
+                        this[`_${propertyName}`] = prev;
+                    }
+                    else {
+                        this[propertyName] = getAndAssignObservablesAlias(this, propertyName, next, schema);
+                    }
+                }
+                else if (!isObjectAssignment) {
+                    this[propertyName] = next;
+                }
+                existingChangedMethod === null || existingChangedMethod === void 0 ? void 0 : existingChangedMethod.call(this, prev, next);
+            }
+            return instanceResolverChanged;
+        };
+        this.classPrototype = classPrototype;
+        this.schema = schema;
+    }
+    defineProperties() {
+        const propertyNames = this.schema.getRootProperties();
+        const existingAccessors = Observable.getAccessors(this.classPrototype);
+        for (const propertyName of propertyNames) {
+            // Skip if property already has an accessor (from `@attr` or `@observable` decorator)
+            if (!existingAccessors.some(accessor => accessor.name === propertyName)) {
+                Observable.defineProperty(this.classPrototype, propertyName);
+            }
+            const changedMethodName = `${propertyName}Changed`;
+            const existingChangedMethod = this.classPrototype[changedMethodName];
+            this.classPrototype[changedMethodName] = this.defineChanged(propertyName, existingChangedMethod);
+        }
+    }
+    /**
+     * Creates a proxy for an object that intercepts property mutations and triggers Observable notifications
+     * @param target - The target instance that owns the root property
+     * @param rootProperty - The name of the root property for notification purposes
+     * @param object - The object to wrap with a proxy
+     * @returns A proxy that triggers notifications on property mutations
+     */
+    getAndAssignObservables(target, rootProperty, object, schema) {
+        let proxiedObject = object;
+        proxiedObject = assignObservables(schema.getSchema(rootProperty), schema.getSchema(rootProperty), proxiedObject, target, rootProperty);
+        return proxiedObject;
+    }
+}

package/dist/esm/components/observer-map.spec.js

@@ -0,0 +1,39 @@
+import { expect, test } from "@playwright/test";
+import { ObserverMap } from "./observer-map.js";
+import { Schema, defsPropertyName } from "./schema.js";
+const testElementName = "test-class";
+test.describe("ObserverMap", async () => {
+    let observerMap;
+    let schema;
+    class TestClass {
+    }
+    test.beforeEach(async () => {
+        schema = new Schema(testElementName);
+        // Use TestClass.prototype so instances will have the observable properties
+        observerMap = new ObserverMap(TestClass.prototype, schema);
+    });
+    test("should create new instances", async () => {
+        const instance1 = new ObserverMap(TestClass.prototype, schema);
+        const instance2 = new ObserverMap(TestClass.prototype, schema);
+        expect(instance1).not.toBe(instance2);
+    });
+    test("proxies direct object assignments", async () => {
+        const schemaMap = Schema.jsonSchemaMap.get(testElementName);
+        schemaMap.set("someData", {
+            $schema: "https://json-schema.org/draft/2019-09/schema",
+            $id: `https://fast.design/schemas/${testElementName}/someData.json`,
+            type: "object",
+            properties: {
+                foo: { type: "string" },
+            },
+            [defsPropertyName]: {},
+        });
+        observerMap.defineProperties();
+        const instance = new TestClass();
+        instance.someData = null;
+        const nextValue = { foo: "bar" };
+        instance.someData = nextValue;
+        expect(instance.someData).not.toBe(nextValue);
+        expect(instance.someData.$isProxy).toBeTruthy();
+    });
+});

package/dist/esm/components/schema.js

@@ -0,0 +1,250 @@
+// The context, in most cases the array property e.g. users
+export const fastContextMetaData = "$fast_context";
+// The list of contexts preceeding this context, the first of which should be the root property
+export const fastContextsMetaData = "$fast_parent_contexts";
+export const defsPropertyName = "$defs";
+export const refPropertyName = "$ref";
+/**
+ * A constructed JSON schema from a template
+ */
+export class Schema {
+    constructor(name) {
+        this.customElementName = name;
+        Schema.jsonSchemaMap.set(this.customElementName, new Map());
+    }
+    /**
+     * Add a path to a schema
+     * @param config RegisterPathConfig
+     */
+    addPath(config) {
+        var _a, _b, _c;
+        const splitPath = this.getSplitPath(config.pathConfig.path);
+        let schema = Schema.jsonSchemaMap.get(this.customElementName).get(config.rootPropertyName);
+        let childRef = null;
+        // Create a root level property JSON
+        if (!schema) {
+            this.addNewSchema(config.rootPropertyName);
+            schema = Schema.jsonSchemaMap.get(this.customElementName).get(config.rootPropertyName);
+        }
+        if (config.childrenMap) {
+            childRef = this.getSchemaId(config.childrenMap.customElementName, config.childrenMap.attributeName);
+            if (splitPath.length === 1) {
+                schema.anyOf
+                    ? schema.anyOf.push({ [refPropertyName]: childRef })
+                    : (schema.anyOf = [{ [refPropertyName]: childRef }]);
+            }
+        }
+        switch (config.pathConfig.type) {
+            case "default":
+            case "access": {
+                if (splitPath.length > 1) {
+                    if (config.pathConfig.currentContext === null) {
+                        this.addPropertiesToAnObject(schema, splitPath.slice(1), config.pathConfig.currentContext, childRef);
+                    }
+                    else {
+                        if (!((_a = schema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[splitPath[0]])) {
+                            schema[defsPropertyName] = {
+                                [splitPath[0]]: {},
+                            };
+                        }
+                        this.addPropertiesToAContext(schema[defsPropertyName][splitPath[0]], splitPath.slice(1), config.pathConfig.currentContext, childRef);
+                    }
+                }
+                break;
+            }
+            case "repeat": {
+                this.addContext(schema, splitPath.at(-1), // example items
+                config.pathConfig.currentContext, // example item
+                config.pathConfig.parentContext);
+                if (splitPath.length > 2) {
+                    let updatedSchema = schema;
+                    const hasParentContext = !!config.pathConfig.parentContext;
+                    if (hasParentContext) {
+                        updatedSchema = this.addPropertiesToAnObject((_b = schema[defsPropertyName]) === null || _b === void 0 ? void 0 : _b[config.pathConfig.parentContext], splitPath.slice(1, -1), config.pathConfig.parentContext, childRef);
+                    }
+                    this.addPropertiesToAnObject(updatedSchema, hasParentContext ? splitPath.slice(2) : splitPath.slice(1), config.pathConfig.currentContext, childRef, "array");
+                }
+                else if (splitPath.length > 1) {
+                    let schemaDefinition;
+                    if (config.pathConfig.parentContext) {
+                        schemaDefinition = (_c = schema === null || schema === void 0 ? void 0 : schema[defsPropertyName]) === null || _c === void 0 ? void 0 : _c[config.pathConfig.parentContext];
+                    }
+                    this.addPropertiesToAnObject(schemaDefinition !== null && schemaDefinition !== void 0 ? schemaDefinition : schema, splitPath.slice(1), config.pathConfig.currentContext, childRef, "array");
+                }
+                else {
+                    schema.type = "array";
+                    schema[refPropertyName] = this.getDefsPath(config.pathConfig.currentContext);
+                }
+                break;
+            }
+        }
+    }
+    /**
+     * Gets the JSON schema for a property name
+     * @param rootPropertyName - the root property the JSON schema is mapped to
+     * @returns The JSON schema for the root property
+     */
+    getSchema(rootPropertyName) {
+        var _a;
+        return ((_a = Schema.jsonSchemaMap.get(this.customElementName).get(rootPropertyName)) !== null && _a !== void 0 ? _a : null);
+    }
+    /**
+     * Gets root properties
+     * @returns IterableIterator<string>
+     */
+    getRootProperties() {
+        return Schema.jsonSchemaMap.get(this.customElementName).keys();
+    }
+    /**
+     * Get a path split into property names
+     * @param path The dot syntax path e.g. a.b.c
+     * @returns An array of items in the path
+     */
+    getSplitPath(path) {
+        return path.split(".");
+    }
+    /**
+     * Gets the path to the $def
+     * @param context The context name e.g. {{item in items}} in a repeat creates the "item" context
+     * @returns A string to use as a $ref
+     */
+    getDefsPath(context) {
+        return `#/${defsPropertyName}/${context}`;
+    }
+    /**
+     * Get the schema $id
+     * @param customElementName - The custom element name
+     * @param propertyName - The property name
+     * @returns The ID that can be used in the JSON schema as $id
+     */
+    getSchemaId(customElementName, propertyName) {
+        return `https://fast.design/schemas/${customElementName}/${propertyName}.json`;
+    }
+    /**
+     * Add a new JSON schema to the JSON schema map
+     * @param propertyName The name of the property to assign this JSON schema to
+     */
+    addNewSchema(propertyName) {
+        Schema.jsonSchemaMap.get(this.customElementName).set(propertyName, {
+            $schema: "https://json-schema.org/draft/2019-09/schema",
+            $id: this.getSchemaId(this.customElementName, propertyName),
+            [defsPropertyName]: {},
+        });
+    }
+    /**
+     * Add properties to a context
+     * @param schema The schema to add the properties to
+     * @param splitPath The path split into property/context names
+     * @param context The paths context
+     */
+    addPropertiesToAContext(schema, splitPath, context, childRef) {
+        schema.type = "object";
+        if (schema.properties && !schema.properties[splitPath[0]]) {
+            schema.properties[splitPath[0]] = {};
+        }
+        else if (!schema.properties) {
+            schema.properties = {
+                [splitPath[0]]: {},
+            };
+        }
+        if (splitPath.length > 1) {
+            this.addPropertiesToAnObject(schema.properties[splitPath[0]], splitPath.slice(1), context, childRef);
+        }
+        else if (childRef) {
+            if (schema.properties[splitPath[0]].anyOf) {
+                schema.properties[splitPath[0]].anyOf.push({
+                    [refPropertyName]: childRef,
+                });
+            }
+            else {
+                schema.properties[splitPath[0]].anyOf = [{ [refPropertyName]: childRef }];
+            }
+        }
+    }
+    /**
+     * Add properties to an object
+     * @param schema The schema to add the properties to
+     * @param splitPath The path split into property/context names
+     * @param context The paths context
+     * @param type The data type (see JSON schema for details)
+     */
+    addPropertiesToAnObject(schema, splitPath, context, childRef, type = "object") {
+        schema.type = "object";
+        if (schema.properties && !schema.properties[splitPath[0]]) {
+            schema.properties[splitPath[0]] = {};
+        }
+        else if (!schema.properties) {
+            schema.properties = {
+                [splitPath[0]]: {},
+            };
+        }
+        if (type === "object" && splitPath.length > 1) {
+            return this.addPropertiesToAnObject(schema.properties[splitPath[0]], splitPath.slice(1), context, childRef, type);
+        }
+        else if (type === "array") {
+            if (splitPath.length > 1) {
+                return this.addPropertiesToAnObject(schema.properties[splitPath[0]], splitPath.slice(1), context, childRef, type);
+            }
+            else {
+                return this.addArrayToAnObject(schema.properties[splitPath[0]], context);
+            }
+        }
+        if (schema.properties[splitPath[0]].anyOf && childRef) {
+            schema.properties[splitPath[0]].anyOf.push({ [refPropertyName]: childRef });
+        }
+        else if (childRef) {
+            schema.properties[splitPath[0]].anyOf = [{ [refPropertyName]: childRef }];
+        }
+        return schema.properties[splitPath[0]];
+    }
+    /**
+     * Add an array to an object property
+     * @param schema The schema to add the properties to
+     * @param context The name of the context
+     */
+    addArrayToAnObject(schema, context) {
+        schema.type = "array";
+        schema.items = {
+            [refPropertyName]: this.getDefsPath(context),
+        };
+        return schema.items;
+    }
+    /**
+     * Add a context to the $defs property
+     * @param schema The schema to use
+     * @param propertyName The name of the property the context belongs to
+     * @param currentContext The current context
+     * @param parentContext The parent context
+     * @returns
+     */
+    addContext(schema, propertyName, // e.g items
+    currentContext, // e.g. item
+    parentContext) {
+        if (schema[defsPropertyName][currentContext]) {
+            return;
+        }
+        schema[defsPropertyName][currentContext] = {
+            [fastContextMetaData]: propertyName,
+            [fastContextsMetaData]: this.getParentContexts(schema, parentContext),
+        };
+    }
+    /**
+     * Get parent contexts
+     * @param schema The schema to use
+     * @param parentContext The parent context
+     * @param contexts A list of parent contexts
+     * @returns
+     */
+    getParentContexts(schema, parentContext, contexts = []) {
+        var _a;
+        if (parentContext === null) {
+            return [null, ...contexts];
+        }
+        const parentParentContext = (_a = schema === null || schema === void 0 ? void 0 : schema[defsPropertyName]) === null || _a === void 0 ? void 0 : _a[parentContext][fastContextsMetaData];
+        return this.getParentContexts(schema, parentParentContext.at(-1), [parentContext, ...contexts]);
+    }
+}
+/**
+ * A JSON schema describing each root schema
+ */
+Schema.jsonSchemaMap = new Map();