@es-joy/jsoe 0.2.0 → 0.4.0

package/dist/src/types.d.ts

@@ -0,0 +1,333 @@
+export function getPropertyValueFromLegend(legend: HTMLLegendElement): string;
+export default Types;
+export type TypeObject = {
+    /**
+     * Creates the option
+     * HTML. May set an option `title` or `value`
+     */
+    option: import('jamilih').JamilihArray;
+    /**
+     * Private context variable. Whether or not
+     * it is an array. Do not use in other types.
+     */
+    array?: boolean | undefined;
+    /**
+     * Used for string parsing.
+     */
+    regexEndings?: string[] | undefined;
+    /**
+     * Used for string parsing. If not
+     * present, use `stringRegexBegin` and `stringRegexEnd`
+     */
+    stringRegex?: RegExp | undefined;
+    /**
+     * Used for string parsing. If not
+     * present, use `stringRegex`
+     */
+    stringRegexBegin?: RegExp | undefined;
+    /**
+     * Used for string parsing. If not
+     * present, use `stringRegex`
+     */
+    stringRegexEnd?: RegExp | undefined;
+    /**
+     * Function to
+     * check whether this subtype matches
+     */
+    valueMatch?: ((ArbitraryValue: any) => boolean) | undefined;
+    /**
+     * The greater fundamental type to which
+     * the type belongs
+     */
+    superType?: string | undefined;
+    /**
+     * Converts from
+     * string to value. May use `stringRegex` to find components.
+     */
+    toValue: (s: string) => ArbitraryValue;
+    /**
+     * Gets the value for the type
+     */
+    getValue: (info: {
+        root?: HTMLDivElement;
+    }) => ArbitraryValue;
+    /**
+     * Should set
+     * the value of the form's `getInput` element
+     */
+    setValue?: ((info: {
+        root?: HTMLDivElement;
+    }) => void) | undefined;
+    viewUI: (info: {
+        value?: ArbitraryValue;
+        typeNamespace?: string;
+        type?: string;
+        topRoot?: HTMLDivElement;
+        resultType?: "keys" | "values" | "both";
+        format?: string;
+    }) => JamilihArray;
+    editUI: (info: {
+        value?: ArbitraryValue;
+        typeNamespace?: string;
+    }) => JamilihArray;
+    /**
+     * Gets the
+     * form control (with `value`)
+     */
+    getInput: (info: {
+        root: HTMLDivElement;
+    }) => HTMLInputElement | HTMLTextareaElement | HTMLSelectElement;
+    /**
+     * Gets the reference. For array and object
+     * references types only
+     */
+    resolveReference?: ((path: string, value: ArbitraryValue) => ArbitraryValue) | undefined;
+    /**
+     * Message will be used if validity is false.
+     */
+    validate?: ((info: {
+        root: HTMLDivElement;
+        topRoot?: HTMLDivElement;
+    }) => {
+        message: string;
+        valid: boolean;
+    }) | undefined;
+    /**
+     * For
+     * validation of array and object references only.
+     */
+    validateAll?: ((info: {
+        topRoot: HTMLDivElement;
+    }) => void) | undefined;
+    /**
+     * The type after which it should be placed and its
+     * context types
+     */
+    stateDependent?: {
+        structuredCloning: {
+            after: string;
+            contexts: string[];
+        };
+    } | undefined;
+};
+export type GetPossibleSchemasForPathAndType = (keypath: string, parentPath: string, arrayOrObjectPropertyName: string, valueType: string) => StateObject;
+export type StateObject = {
+    typeNamespace: string;
+    "readonly": boolean;
+    format: string;
+    error: Error;
+    rootUI: Element;
+    schemaContent: string;
+    getPossibleSchemasForPathAndType: GetPossibleSchemasForPathAndType;
+};
+/**
+ * Any other possibilities than `div`?
+ */
+export type RootElement = HTMLDivElement;
+declare namespace Types {
+    namespace availableTypes {
+        namespace ValidDate {
+            const valid: boolean;
+        }
+        namespace arrayNonindexKeys {
+            const sparse: boolean;
+        }
+    }
+    /**
+     * Utility to retrieve the type out of a type root element.
+     * @public
+     * @param {?RootElement} root
+     * @returns {string|undefined} Why would it not exist?
+     */
+    function getTypeForRoot(root: HTMLDivElement | null): string | undefined;
+    /**
+     * @typedef {(
+     *     keypath: string,
+    *     parentPath: string,
+    *     arrayOrObjectPropertyName: string,
+    *     valueType: string
+    *   ) => StateObject} GetPossibleSchemasForPathAndType
+     */
+    /**
+     * @typedef {{
+     *   typeNamespace: string,
+     *   "readonly": boolean,
+     *   format: string,
+     *   error: Error,
+     *   rootUI: Element,
+     *   schemaContent: string,
+     *   getPossibleSchemasForPathAndType: GetPossibleSchemasForPathAndType
+     * }} StateObject
+     */
+    /**
+     * Utility to get the value out of a type root element with a given
+     *   state and path.
+     * @public
+     * @param {RootElement} root
+     * @param {StateObject} stateObj
+     * @param {string} [currentPath]
+     * @returns {StructuredCloneValue}
+     */
+    function getValueForRoot(root: HTMLDivElement, stateObj: StateObject, currentPath?: string | undefined): StructuredCloneValue;
+    /**
+     * Utility to get the form control (e.g., input element) for a root.
+     * @public
+     * @param {RootElement} root
+     * @returns {null|HTMLInputElement}
+     */
+    function getFormControlForRoot(root: HTMLDivElement): HTMLInputElement | null;
+    /**
+     * Utility to get the value for a root using its ancestor and state.
+     * @public
+     * @param {string|Element} selOrEl
+     * @param {StateObject} stateObj
+     * @returns {StructuredCloneValue}
+     */
+    function getValueFromRootAncestor(selOrEl: string | Element, stateObj: StateObject): StructuredCloneValue;
+    /**
+     * @public
+     * @param {string|Element} selOrEl
+     * @returns {null|HTMLInputElement}
+     */
+    function getFormControlFromRootAncestor(selOrEl: string | Element): HTMLInputElement | null;
+    /**
+     * @param {string} format
+     * @param {string} state
+     * @returns {string[]}
+     */
+    function getTypesForFormatAndState(format: string, state: string): string[];
+    /**
+     * @public
+     * @param {string} type
+     * @returns {JamilihArray}
+     */
+    function getOptionForType(type: string): JamilihArray;
+    /**
+     * @public
+     * @param {string} format
+     * @param {string} parserState
+     * @returns {JamilihArray[]}
+     */
+    function getTypeOptionsForFormatAndState(format: string, parserState: string): JamilihArray[];
+    /**
+     * @public
+     * @param {object} cfg
+     * @param {boolean} cfg."readonly"
+     * @param {"both"|"keys"|"values"} cfg.resultType
+     * @param {string} cfg.typeNamespace
+     * @param {string} cfg.type
+     * @param {RootElement} cfg.topRoot
+     * @param {boolean} cfg.bringIntoFocus
+     * @param {BuildTypeChoices} cfg.buildTypeChoices
+     * @param {string} cfg.format
+     * @param {string} cfg.schemaContent
+     * @param {GetPossibleSchemasForPathAndType} cfg.schemaState Not currently
+     *   in use
+     * @param {StructuredCloneValue} cfg.value
+     * @param {boolean} cfg.hasValue
+     * @returns {Element}
+     */
+    function getUIForModeAndType({ readonly, resultType, typeNamespace, type, topRoot, bringIntoFocus, buildTypeChoices, format, schemaContent, schemaState, value, hasValue }: {
+        "": boolean;
+        resultType: "keys" | "values" | "both";
+        typeNamespace: string;
+        type: string;
+        topRoot: HTMLDivElement;
+        bringIntoFocus: boolean;
+        buildTypeChoices: BuildTypeChoices;
+        format: string;
+        schemaContent: string;
+        schemaState: GetPossibleSchemasForPathAndType;
+        value: StructuredCloneValue;
+        hasValue: boolean;
+    }): Element;
+    const contexts: {};
+    /**
+     * @public
+     * @param {object} cfg
+     * @param {HTMLFormElement} cfg.form
+     * @param {string} cfg.typeNamespace
+     * @param {string} cfg.keySelectClass
+     * @returns {boolean}
+     */
+    function validValuesSet({ form, typeNamespace, keySelectClass }: {
+        form: HTMLFormElement;
+        typeNamespace: string;
+        keySelectClass: string;
+    }): boolean;
+    /**
+     * Any other possibilities than `div`?
+     * @typedef {HTMLDivElement} RootElement
+     */
+    /**
+     * @public
+     * @param {object} cfg
+     * @param {RootElement} cfg.topRoot
+     * @returns {void}
+     */
+    function validateAllReferences({ topRoot }: {
+        topRoot: HTMLDivElement;
+    }): void;
+    /**
+     * @public
+     * @param {object} cfg
+     * @param {string} cfg.type
+     * @param {RootElement} cfg.root
+     * @param {RootElement} cfg.topRoot
+     * @returns {boolean}
+     */
+    function validate({ type, root, topRoot }: {
+        type: string;
+        root: HTMLDivElement;
+        topRoot: HTMLDivElement;
+    }): boolean;
+    /**
+     * @param {object} cfg
+     * @param {string} cfg.type
+     * @param {RootElement} cfg.root
+     * @param {StructuredCloneValue} cfg.value
+     * @returns {void}
+     */
+    function setValue({ type, root, value }: {
+        type: string;
+        root: HTMLDivElement;
+        value: StructuredCloneValue;
+    }): void;
+    /**
+     * @public
+     * @param {string} s
+     * @param {object} cfg
+     * @param {string} cfg.format
+     * @param {string} cfg.state
+     * @param {TypeObject[]} [cfg.endMatchTypeObjs=[]]
+     * @param {boolean} [cfg.firstRun=true]
+     * @param {
+     *   [
+     *     type: string,
+     *     parent: array|object,
+     *     parentPath: string,
+     *     path: string
+     *   ]
+     * } [cfg.rootHolder=[]]
+     * @param {ArbitraryArray|ArbitraryObject} cfg.parent
+     * @param {string} cfg.parentPath
+     * @returns {{
+     *   value: ArbitraryValue,
+     *   remnant: string,
+     *   beginOnly: boolean,
+     *   assign: boolean
+     * }}
+     */
+    function getValueForString(s: string, { format, state, endMatchTypeObjs, firstRun, rootHolder, parent, parentPath }: {
+        format: string;
+        state: string;
+        endMatchTypeObjs?: TypeObject[] | undefined;
+        firstRun?: boolean | undefined;
+    }): {
+        value: ArbitraryValue;
+        remnant: string;
+        beginOnly: boolean;
+        assign: boolean;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.js"],"names":[],"mappings":"AAoCO,mDAHI,iBAAiB,GACf,MAAM,CAOlB;;;;;;;YAMa,OAAO,SAAS,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAWV,OAAO;;;;;;;;;;iBAIvB,MAAM;;;;qBAEH;QAAC,IAAI,CAAC,EAAE,cAAc,CAAA;KAAC;;;;;uBAGvB;QAAC,IAAI,CAAC,EAAE,cAAc,CAAA;KAAC,KAAK,IAAI;mBAEhC;QACpB,KAAS,CAAC,iBAAiB;QAC3B,aAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,IAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAW,CAAC,EAAE,cAAc,CAAC;QAC7B,UAAc,CAAC,EAAE,MAAM,GAAC,QAAQ,GAAC,MAAM,CAAC;QACxC,MAAU,CAAC,EAAE,MAAM,CAAA;KAChB;mBACiB;QACpB,KAAS,CAAC,iBAAiB;QAC3B,aAAiB,CAAC,EAAE,MAAM,CAAC;KACxB;;;;;qBACiB;QAAC,IAAI,EAAE,cAAc,CAAA;KAAC,KAC1C,gBAAoB,yBAAqB,iBAAiB;;;;;+BAEtC,MAAM;;;;uBAGN;QAAC,IAAI,EAAE,cAAc,CAAC;QAAC,OAAO,CAAC,EAAE,cAAc,CAAA;KAAC,KAAK;QACzE,OAAW,EAAE,MAAM,CAAC;QACpB,KAAS,EAAE,OAAO,CAAA;KACf;;;;;0BACiB;QAAC,OAAO,EAAE,cAAc,CAAA;KAAC,KAAK,IAAI;;;;;;2BAG/B;YACvB,KAAW,EAAE,MAAM,CAAC;YACpB,QAAc,EAAE,MAAM,EAAE,CAAA;SACnB;;;yDAsJU,MAAM,cACJ,MAAM,6BACS,MAAM,aACtB,MAAM,KACd,WAAW;0BAIP;IACZ,aAAiB,EAAE,MAAM,CAAC;IAC1B,UAAc,EAAE,OAAO,CAAC;IACxB,MAAU,EAAE,MAAM,CAAC;IACnB,KAAS,EAAE,KAAK,CAAC;IACjB,MAAU,EAAE,OAAO,CAAC;IACpB,aAAiB,EAAE,MAAM,CAAC;IAC1B,gCAAoC,EAAE,gCAAgC,CAAA;CACnE;;;;0BAwMS,cAAc;;;;;;;;;;IApO3B;;;;;OAKG;IACH,yEAEC;IAED;;;;;;;OAOG;IAEH;;;;;;;;;;OAUG;IAEH;;;;;;;;OAQG;IACH,8HAOC;IAED;;;;;OAKG;IACH,8EAOC;IAED;;;;;;OAMG;IACH,0GAEC;IAED;;;;OAIG;IACH,4FAMC;IAED;;;;OAIG;IACH,4EAE6D;IAE7D;;;;OAIG;IACH,sDAIC;IAED;;;;;OAKG;IACH,8FAOC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH;;;;;;;;;;;;;gBA2BC;;IAoBD;;;;;;;OAOG;IACH;;;;gBA4BC;IAED;;;OAGG;IAEH;;;;;OAKG;IACH;;aAkBC;IAED;;;;;;;OAOG;IACH;;;;gBAgBC;IAED;;;;;;OAMG;IACH;;;;aAKC;IAqBD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;;;;;;;;;;MA6GC"}

package/dist/src/utils/dialogs.d.ts

@@ -0,0 +1,29 @@
+export default dialogs;
+declare namespace dialogs {
+    function setLocale(locale?: {}): void;
+    function makeDialog({ atts, children, close, remove }?: {
+        atts?: {} | undefined;
+        children?: any[] | undefined;
+        close: any;
+        remove?: boolean | undefined;
+    }): import("../../vendor/jamilih/dist/jml-es.js").JamilihReturn;
+    function makeSubmitDialog({ submit, submitClass, ...args }: {
+        [x: string]: any;
+        submit: any;
+        submitClass?: string | undefined;
+    }): import("../../vendor/jamilih/dist/jml-es.js").JamilihReturn;
+    function makeCancelDialog({ submit, cancel, cancelClass, submitClass, ...args }: {
+        [x: string]: any;
+        submit: any;
+        cancel: any;
+        cancelClass?: string | undefined;
+        submitClass?: string | undefined;
+    }): import("../../vendor/jamilih/dist/jml-es.js").JamilihReturn;
+    function alert(message: any): Promise<any>;
+    function confirm({ atts, message, submitClass }: {
+        atts?: {} | undefined;
+        message: any;
+        submitClass?: string | undefined;
+    }): Promise<any>;
+}
+//# sourceMappingURL=dialogs.d.ts.map

package/dist/src/utils/dialogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialogs.d.ts","sourceRoot":"","sources":["../../../src/utils/dialogs.js"],"names":[],"mappings":";;IAYE,sCAEC;IACD;;;;;oEAiBC;IACD;;;;oEAcC;IACD;;;;;;oEAsBC;IACD,2CAiBC;IACD;;;;qBAoBC"}

package/dist/src/utils/jsonPointer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @param {...string} args
+ * @returns {string}
+ */
+export function makeJSONPointer(...args: string[]): string;
+/**
+ * @param {string} path
+ * @returns {string}
+ */
+export function escapeJSONPointer(path: string): string;
+/**
+ * @param {string} pathPart
+ * @returns {string}
+ */
+export function unescapeJSONPointerPart(pathPart: string): string;
+/**
+ * @param {string} path
+ * @returns {string[]}
+ */
+export function getJSONPointerParts(path: string): string[];
+/**
+ * @param {ArbitraryObject} obj
+ * @param {string} pathPart
+ * @returns {ArbitraryObject|string}
+ */
+export function reduceJSONPointerParts(obj: ArbitraryObject, pathPart: string): ArbitraryObject | string;
+/**
+ * @param {object} cfg
+ * @param {string} cfg.path
+ * @param {ArbitraryObject} cfg.obj
+ * @returns {string|ArbitraryObject}
+ */
+export function resolveJSONPointer({ path, obj }: {
+    path: string;
+    obj: ArbitraryObject;
+}): string | ArbitraryObject;
+/**
+ * @param {string} path
+ * @returns {string}
+ */
+export function typesonPathToJSONPointer(path: string): string;
+//# sourceMappingURL=jsonPointer.d.ts.map

package/dist/src/utils/jsonPointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonPointer.d.ts","sourceRoot":"","sources":["../../../src/utils/jsonPointer.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,yCAHc,MAAM,KACP,MAAM,CAMlB;AAED;;;GAGG;AACH,wCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;GAGG;AACH,kDAHW,MAAM,GACJ,MAAM,CASlB;AAED;;;GAGG;AACH,0CAHW,MAAM,GACJ,MAAM,EAAE,CAMpB;AAED;;;;GAIG;AACH,uEAHW,MAAM,GACJ,kBAAgB,MAAM,CAQlC;AAED;;;;;GAKG;AACH;IAJuB,IAAI,EAAhB,MAAM;IACe,GAAG;IACtB,MAAM,kBAAgB,CAOlC;AAED;;;GAGG;AACH,+CAHW,MAAM,GACJ,MAAM,CAYlB"}

package/dist/src/utils/templateUtils.d.ts

@@ -0,0 +1,59 @@
+export namespace U {
+    export { nbsp };
+    export { upArrow };
+    export { downArrow };
+}
+/**
+ * @param {string} sel
+ * @returns {Element|null}
+ */
+export function $(sel: string): Element | null;
+/**
+ * @param {string} sel
+ * @returns {Element[]}
+ */
+export function $$(sel: string): Element[];
+/**
+ * @param {Element|string} el
+ * @param {string} descendentsSel
+ * @returns {Element|null}
+ */
+export function $e(el: Element | string, descendentsSel: string): Element | null;
+/**
+ * @param {Element|string} el
+ * @param {string} descendentsSel
+ * @returns {Element[]}
+ */
+export function $$e(el: Element | string, descendentsSel: string): Element[];
+export namespace DOM {
+    export { removeChildren };
+    export { removeIfExists };
+    export { filterChildElements };
+    export { initialCaps };
+}
+declare const nbsp: " ";
+declare const upArrow: "↑";
+declare const downArrow: "↓";
+/**
+ * @param {Node} node
+ * @returns {void}
+ */
+declare function removeChildren(node: Node): void;
+/**
+ * @param {Element|string} sel
+ * @returns {void}
+ */
+declare function removeIfExists(sel: Element | string): void;
+/**
+ * @param {Element} el
+ * @param {string|string[]} selectors
+ * @returns {Element[]}
+ */
+declare function filterChildElements(el: Element, selectors: string | string[]): Element[];
+/**
+ * @param {string} s
+ * @returns {string}
+ */
+declare function initialCaps(s: string): string;
+export {};
+//# sourceMappingURL=templateUtils.d.ts.map

package/dist/src/utils/templateUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/templateUtils.js"],"names":[],"mappings":";;;;;AAMA;;;GAGG;AACH,uBAHW,MAAM,GACJ,OAAO,GAAC,IAAI,CAEqB;AAE9C;;;GAGG;AACH,wBAHW,MAAM,GACJ,OAAO,EAAE,CAEiC;AAEvD;;;;GAIG;AACH,uBAJW,OAAO,GAAC,MAAM,kBACd,MAAM,GACJ,OAAO,GAAC,IAAI,CAQxB;AAED;;;;GAIG;AACH,wBAJW,OAAO,GAAC,MAAM,kBACd,MAAM,GACJ,OAAO,EAAE,CAQrB;;;;;;;AAzCD,wBAAsB;AACtB,2BAAyB;AACzB,6BAA2B;AAyC3B;;;GAGG;AACH,sCAHW,IAAI,GACF,IAAI,CAUhB;AAED;;;GAGG;AACH,qCAHW,OAAO,GAAC,MAAM,GACZ,IAAI,CAOhB;AAED;;;;GAIG;AACH,yCAJW,OAAO,aACP,MAAM,GAAC,MAAM,EAAE,GACb,OAAO,EAAE,CA+BrB;AAED;;;GAGG;AACH,gCAHW,MAAM,GACJ,MAAM,CAIlB"}

package/dist/src/utils/types.d.ts

@@ -0,0 +1,2 @@
+export function isNullish(obj: unknown): boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utils/types.js"],"names":[],"mappings":"AAGO,+BAFI,OAAO,WAIjB"}

package/dist/subTypes/blobHTMLType.d.ts

@@ -0,0 +1,14 @@
+export default blobHTMLType;
+/**
+ * @type {import('../types.js').TypeObject & {
+ *   loadBlob: (blob: Blob) => Promise<FileReader>,
+ *   sceditorInstance: {val: (val?: string) => string|void}
+ * }}
+ */
+declare const blobHTMLType: import("../types.js").TypeObject & {
+    loadBlob: (blob: Blob) => Promise<FileReader>;
+    sceditorInstance: {
+        val: (val?: string) => string | void;
+    };
+};
+//# sourceMappingURL=blobHTMLType.d.ts.map

package/dist/subTypes/blobHTMLType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobHTMLType.d.ts","sourceRoot":"","sources":["../../src/subTypes/blobHTMLType.js"],"names":[],"mappings":";AAOA;;;;;GAKG;AACH;qBAJsB,IAAI,KAAK,QAAQ,UAAU,CAAC;;oBACd,MAAM,KAAK,MAAM,GAAC,IAAI;;EAuKxD"}

package/dist/subTypes/falseType.d.ts

@@ -0,0 +1,8 @@
+export default falseType;
+/**
+ * @type {import('../types.js').TypeObject & {ct: number}}
+ */
+declare const falseType: import('../types.js').TypeObject & {
+    ct: number;
+};
+//# sourceMappingURL=falseType.d.ts.map

package/dist/subTypes/falseType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"falseType.d.ts","sourceRoot":"","sources":["../../src/subTypes/falseType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,yBAFU,OAAO,aAAa,EAAE,UAAU,GAAG;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CAoCvD"}

package/dist/subTypes/trueType.d.ts

@@ -0,0 +1,8 @@
+export default trueType;
+/**
+ * @type {import('../types.js').TypeObject & {ct: number}}
+ */
+declare const trueType: import('../types.js').TypeObject & {
+    ct: number;
+};
+//# sourceMappingURL=trueType.d.ts.map

package/dist/subTypes/trueType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trueType.d.ts","sourceRoot":"","sources":["../../src/subTypes/trueType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,wBAFU,OAAO,aAAa,EAAE,UAAU,GAAG;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CAoCvD"}

package/dist/superTypes/SpecialNumberSuperType.d.ts

@@ -0,0 +1,14 @@
+export default SpecialNumberSuperType;
+export type SuperTypeObject = import('../types.js').TypeObject & {
+    childTypes: string[];
+};
+/**
+ * @typedef {import('../types.js').TypeObject & {
+ *   childTypes: string[]
+ * }} SuperTypeObject
+ */
+/**
+ * @type {SuperTypeObject}
+ */
+declare const SpecialNumberSuperType: SuperTypeObject;
+//# sourceMappingURL=SpecialNumberSuperType.d.ts.map

package/dist/superTypes/SpecialNumberSuperType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecialNumberSuperType.d.ts","sourceRoot":"","sources":["../../src/superTypes/SpecialNumberSuperType.js"],"names":[],"mappings":";8BAGa,OAAO,aAAa,EAAE,UAAU,GAAG;IAC/C,UAAc,EAAE,MAAM,EAAE,CAAA;CACrB;AAHJ;;;;GAIG;AAEH;;GAEG;AACH,sCAFU,eAAe,CAgEvB"}

package/dist/superTypes/SpecialRealNumberSuperType.d.ts

@@ -0,0 +1,6 @@
+export default SpecialRealNumberSuperType;
+/**
+ * @type {import('./SpecialNumberSuperType.js').SuperTypeObject}
+ */
+declare const SpecialRealNumberSuperType: import('./SpecialNumberSuperType.js').SuperTypeObject;
+//# sourceMappingURL=SpecialRealNumberSuperType.d.ts.map

package/dist/superTypes/SpecialRealNumberSuperType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecialRealNumberSuperType.d.ts","sourceRoot":"","sources":["../../src/superTypes/SpecialRealNumberSuperType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,0CAFU,OAAO,6BAA6B,EAAE,eAAe,CAwD7D"}

package/dist/typeChoices.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @typedef {(info: {type: string, editUI: Element}) => void} AddTypeAndEditUI
+ */
+/**
+ * @typedef {(info?: {
+ *   baseValue?: import('./formats.js').StructuredCloneValue,
+ *   bringIntoFocus?: boolean
+ * }) => void} AddAndValidateEditUI
+ */
+/**
+ * @typedef {() => void} SetStyles
+ */
+/**
+ * @typedef {Element & {
+ *   $addAndValidateEditUI: AddAndValidateEditUI,
+ *   $setStyles: SetStyles
+ * }} TypeChoicesElementAPI
+ */
+/**
+ * @callback GetValue
+ * @param {import('./types.js').StateObject} [stateObj] Will
+ *   auto-set `typeNamespace` and `format`
+ * @param {string} [currentPath]
+ * @returns {import('./formats.js').StructuredCloneValue}
+ */
+/**
+ * @callback GetType
+ * @returns {string|null|undefined}
+ */
+/**
+ * @callback ValidValuesSet
+ * @returns {boolean}
+ */
+/**
+ * @callback SetValue
+ * @param {import('./formats.js').StructuredCloneValue} value
+ * @param {import('./types.js').StateObject} stateObj
+ * @returns {Promise<void>}
+ */
+/**
+ * @callback BuildTypeChoices
+ * @param {{
+ *   format: import('./formats.js').AvailableFormat,
+ *   typeNamespace?: string,
+ *   value?: import('./formats.js').StructuredCloneValue,
+ *   setValue?: boolean,
+ *   state?: string,
+ *   keySelectClass?: string,
+ *   requireObject?: boolean,
+ *   objectHasValue?: boolean,
+ *   topRoot: import('./types.js').RootElement,
+ *   schema?: string,
+ *   schemaContent?: object,
+ * }} cfg
+ * @returns {{
+ *   domArray: [select: Element, typeContainer: Element],
+ *   getValue: GetValue,
+ *   getType: GetType,
+ *   validValuesSet: ValidValuesSet,
+ *   setValue: SetValue
+ * }}
+ */
+/**
+ * @type {BuildTypeChoices}
+ */
+export const buildTypeChoices: BuildTypeChoices;
+export type AddTypeAndEditUI = (info: {
+    type: string;
+    editUI: Element;
+}) => void;
+export type AddAndValidateEditUI = (info?: {
+    baseValue?: import('./formats.js').StructuredCloneValue;
+    bringIntoFocus?: boolean;
+}) => void;
+export type SetStyles = () => void;
+export type TypeChoicesElementAPI = Element & {
+    $addAndValidateEditUI: AddAndValidateEditUI;
+    $setStyles: SetStyles;
+};
+export type GetValue = (stateObj?: import("./types.js").StateObject | undefined, currentPath?: string | undefined) => import('./formats.js').StructuredCloneValue;
+export type GetType = () => string | null | undefined;
+export type ValidValuesSet = () => boolean;
+export type SetValue = (value: import('./formats.js').StructuredCloneValue, stateObj: import('./types.js').StateObject) => Promise<void>;
+export type BuildTypeChoices = (cfg: {
+    format: import('./formats.js').AvailableFormat;
+    typeNamespace?: string;
+    value?: import('./formats.js').StructuredCloneValue;
+    setValue?: boolean;
+    state?: string;
+    keySelectClass?: string;
+    requireObject?: boolean;
+    objectHasValue?: boolean;
+    topRoot: import('./types.js').RootElement;
+    schema?: string;
+    schemaContent?: object;
+}) => {
+    domArray: [select: Element, typeContainer: Element];
+    getValue: GetValue;
+    getType: GetType;
+    validValuesSet: ValidValuesSet;
+    setValue: SetValue;
+};
+//# sourceMappingURL=typeChoices.d.ts.map

package/dist/typeChoices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeChoices.d.ts","sourceRoot":"","sources":["../src/typeChoices.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH;;;;;GAKG;AAEH;;GAEG;AAEH;;;;;GAKG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;GAEG;AACH,+BAFU,gBAAgB,CA2PxB;sCAlUkB;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,KAAK,IAAI;2CAIvC;IACpB,SAAa,CAAC,EAAE,OAAO,cAAc,EAAE,oBAAoB,CAAC;IAC5D,cAAkB,CAAC,EAAE,OAAO,CAAA;CACzB,KAAK,IAAI;wBAIA,MAAM,IAAI;oCAIV,OAAO,GAAG;IACtB,qBAAyB,EAAE,oBAAoB,CAAC;IAChD,UAAc,EAAE,SAAS,CAAA;CACtB;sHAQS,OAAO,cAAc,EAAE,oBAAoB;4BAK3C,MAAM,GAAC,IAAI,GAAC,SAAS;mCAKrB,OAAO;+BAKT,OAAO,cAAc,EAAE,oBAAoB,YAC3C,OAAO,YAAY,EAAE,WAAW,KAC9B,QAAQ,IAAI,CAAC;qCAKf;IACV,MAAU,EAAE,OAAO,cAAc,EAAE,eAAe,CAAC;IACnD,aAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,KAAS,CAAC,EAAE,OAAO,cAAc,EAAE,oBAAoB,CAAC;IACxD,QAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,cAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,OAAW,EAAE,OAAO,YAAY,EAAE,WAAW,CAAC;IAC9C,MAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAiB,CAAC,EAAE,MAAM,CAAC;CACxB,KACS;IACZ,QAAY,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACxD,QAAY,EAAE,QAAQ,CAAC;IACvB,OAAW,EAAE,OAAO,CAAC;IACrB,cAAkB,EAAE,cAAc,CAAC;IACnC,QAAY,EAAE,QAAQ,CAAA;CACnB"}