@es-joy/jsoe 0.3.0 → 0.4.1

package/dist/types.d.ts

@@ -0,0 +1,523 @@
+export function getPropertyValueFromLegend(legend: HTMLLegendElement): string;
+export default Types;
+export type StructuredCloneValue = import('./formats.js').StructuredCloneValue;
+export type JamilihArray = import('jamilih').JamilihArray;
+export type RootInfo = {
+    format: import('./formats.js').AvailableFormat;
+    endMatchTypeObjs: TypeObject[];
+    remnant: string;
+    rootHolder: [
+        type: string,
+        parent: object,
+        parentPath: string | number,
+        path: string
+    ][];
+    parent: object;
+    parentPath: string | number;
+};
+export type TypeObject = {
+    /**
+     * Creates the option HTML. May set an option `title` or `value`
+     */
+    option: [
+        string,
+        {
+            value?: AvailableType;
+            title?: string;
+        }?
+    ];
+    /**
+     * 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 | ((nonGrouping?: boolean) => 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?: ((v: StructuredCloneValue) => 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, info?: RootInfo) => StructuredCloneValue;
+    /**
+     * Gets the value for the type
+     */
+    getValue: (info: {
+        root: HTMLDivElement;
+        stateObj?: StateObject;
+        currentPath?: string;
+    }) => StructuredCloneValue;
+    /**
+     * Should set the value of the form's `getInput` element
+     */
+    setValue?: ((info: {
+        root: HTMLDivElement;
+        value: StructuredCloneValue;
+    }) => void) | undefined;
+    viewUI: (info: {
+        value?: StructuredCloneValue;
+        typeNamespace?: string;
+        type?: AvailableType;
+        topRoot?: HTMLDivElement;
+        resultType?: "keys" | "values" | "both";
+        format: import('./formats.js').AvailableFormat;
+    }) => import("jamilih").JamilihArray;
+    editUI: (info: {
+        value?: StructuredCloneValue;
+        typeNamespace?: string;
+        bringIntoFocus?: boolean;
+        format?: import('./formats.js').AvailableFormat;
+        resultType?: "keys" | "values" | "both";
+        type?: AvailableType;
+        buildTypeChoices?: import('./typeChoices.js').BuildTypeChoices;
+        topRoot?: HTMLDivElement;
+    }) => import("jamilih").JamilihArray;
+    /**
+     * Gets the form control (with `value`)
+     */
+    getInput: (info: {
+        root: HTMLDivElement;
+    }) => HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLButtonElement;
+    getSelect?: ((info: {
+        root: HTMLDivElement;
+    }) => HTMLSelectElement) | undefined;
+    /**
+     * Gets the reference. For array
+     * and object references types only
+     */
+    resolveReference?: ((path: string, value: StructuredCloneValue) => StructuredCloneValue) | 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: AvailableType;
+            contexts: string[];
+        };
+    } | undefined;
+};
+export type AvailableType = "null" | "true" | "false" | "number" | "bigint" | "string" | "arrayReference" | "objectReference" | "array" | "object" | "date" | "userObject" | "undef" | "SpecialRealNumber" | "SpecialNumber" | "regexp" | "BooleanObject" | "NumberObject" | "StringObject" | "map" | "set" | "file" | "filelist" | "blobHTML" | "arraybuffer" | "arraybufferview" | "dataview" | "imagedata" | "imagebitmap" | "int8array" | "uint8array" | "uint8clampedarray" | "int16array" | "uint16array" | "int32array" | "uint32array" | "float32array" | "float64array" | "IntlCollator" | "IntlDateTimeFormat" | "IntlNumberFormat" | "sparseUndefined" | "ValidDate" | "arrayNonindexKeys";
+export type GetPossibleSchemasForPathAndType = (keypath: string, parentPath: string, arrayOrObjectPropertyName: string, valueType: string) => StateObject;
+export type StateObject = {
+    typeNamespace?: string | undefined;
+    readonly?: boolean | undefined;
+    format?: import("./formats.js").AvailableFormat | undefined;
+    error?: Error | undefined;
+    rootUI?: Element | undefined;
+    schema?: string | undefined;
+    schemaContent?: object | undefined;
+    getPossibleSchemasForPathAndType?: GetPossibleSchemasForPathAndType | undefined;
+    paths?: {
+        [currentPath: string]: {
+            referentPath: string;
+            expectArrayReferent: boolean;
+        };
+    } | undefined;
+    handlingReference?: boolean | undefined;
+};
+/**
+ * Any other possibilities than `div`?
+ */
+export type RootElement = HTMLDivElement;
+declare namespace Types {
+    namespace availableTypes {
+        export { nullType as null };
+        export { trueType as true };
+        export { falseType as false };
+        export { numberType as number };
+        export { bigintType as bigint };
+        export { stringType as string };
+        export { arrayReferenceType as arrayReference };
+        export { objectReferenceType as objectReference };
+        export { arrayType as array };
+        export { objectType as object };
+        export { dateType as date };
+        export const userObject: string[];
+        export { undefinedType as undef };
+        export { SpecialRealNumberSuperType as SpecialRealNumber };
+        export { SpecialNumberSuperType as SpecialNumber };
+        export { regexpType as regexp };
+        export { BooleanObjectType as BooleanObject };
+        export { NumberObjectType as NumberObject };
+        export { StringObjectType as StringObject };
+        export namespace map {
+            const option: string[];
+        }
+        export namespace set {
+            const option_1: string[];
+            export { option_1 as option };
+        }
+        export namespace file {
+            const option_2: string[];
+            export { option_2 as option };
+        }
+        export namespace filelist {
+            const option_3: string[];
+            export { option_3 as option };
+        }
+        export { blobHTMLType as blobHTML };
+        export namespace arraybuffer {
+            const option_4: string[];
+            export { option_4 as option };
+        }
+        export namespace arraybufferview {
+            const option_5: string[];
+            export { option_5 as option };
+        }
+        export namespace dataview {
+            const option_6: string[];
+            export { option_6 as option };
+        }
+        export namespace imagedata {
+            const option_7: string[];
+            export { option_7 as option };
+        }
+        export namespace imagebitmap {
+            const option_8: string[];
+            export { option_8 as option };
+        }
+        export namespace int8array {
+            const option_9: string[];
+            export { option_9 as option };
+        }
+        export namespace uint8array {
+            const option_10: string[];
+            export { option_10 as option };
+        }
+        export namespace uint8clampedarray {
+            const option_11: string[];
+            export { option_11 as option };
+        }
+        export namespace int16array {
+            const option_12: string[];
+            export { option_12 as option };
+        }
+        export namespace uint16array {
+            const option_13: string[];
+            export { option_13 as option };
+        }
+        export namespace int32array {
+            const option_14: string[];
+            export { option_14 as option };
+        }
+        export namespace uint32array {
+            const option_15: string[];
+            export { option_15 as option };
+        }
+        export namespace float32array {
+            const option_16: string[];
+            export { option_16 as option };
+        }
+        export namespace float64array {
+            const option_17: string[];
+            export { option_17 as option };
+        }
+        export namespace IntlCollator {
+            const option_18: string[];
+            export { option_18 as option };
+        }
+        export namespace IntlDateTimeFormat {
+            const option_19: string[];
+            export { option_19 as option };
+        }
+        export namespace IntlNumberFormat {
+            const option_20: string[];
+            export { option_20 as option };
+        }
+        export { sparseUndefinedType as sparseUndefined };
+        export namespace ValidDate {
+            const valid: boolean;
+        }
+        export namespace arrayNonindexKeys {
+            const sparse: boolean;
+        }
+    }
+    /**
+     * Utility to retrieve the type out of a type root element.
+     * @public
+     * @param {?RootElement} root
+     * @returns {string|undefined|null} Why would it not exist?
+     */
+    function getTypeForRoot(root: HTMLDivElement | null): string | null | undefined;
+    /**
+     * @typedef {(
+     *     keypath: string,
+    *     parentPath: string,
+    *     arrayOrObjectPropertyName: string,
+    *     valueType: string
+    *   ) => StateObject} GetPossibleSchemasForPathAndType
+     */
+    /**
+     * @typedef {{
+     *   typeNamespace?: string,
+     *   "readonly"?: boolean,
+     *   format?: import('./formats.js').AvailableFormat,
+     *   error?: Error,
+     *   rootUI?: Element,
+     *   schema?: string,
+     *   schemaContent?: object,
+     *   getPossibleSchemasForPathAndType?: GetPossibleSchemasForPathAndType,
+     *   paths?: {[currentPath: string]: {
+     *     referentPath: string,
+     *     expectArrayReferent: boolean
+     *   }},
+     *   handlingReference?: boolean
+     * }} 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): any;
+    /**
+     * Utility to get the form control (e.g., input element) for a root.
+     * @public
+     * @param {RootElement} root
+     * @returns {null|
+     *   HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement|HTMLButtonElement}
+     */
+    function getFormControlForRoot(root: HTMLDivElement): HTMLInputElement | HTMLButtonElement | HTMLSelectElement | HTMLTextAreaElement | 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): any;
+    /**
+     * @public
+     * @param {string|Element} selOrEl
+     * @returns {null|HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement|
+     *   HTMLButtonElement}
+     */
+    function getFormControlFromRootAncestor(selOrEl: string | Element): HTMLInputElement | HTMLButtonElement | HTMLSelectElement | HTMLTextAreaElement | null;
+    /**
+     * @param {string} format
+     * @param {string} [state]
+     * @returns {AvailableType[]|undefined}
+     */
+    function getTypesForFormatAndState(format: string, state?: string | undefined): AvailableType[] | undefined;
+    /**
+     * @public
+     * @param {AvailableType} type
+     * @returns {[string, {value: AvailableType, title?: string}]}
+     */
+    function getOptionForType(type: AvailableType): [string, {
+        value: AvailableType;
+        title?: string | undefined;
+    }];
+    /**
+     * @public
+     * @param {string} format
+     * @param {string} [parserState]
+     * @returns {[string, {value: AvailableType, title?: string}][]}
+     */
+    function getTypeOptionsForFormatAndState(format: string, parserState?: string | undefined): [string, {
+        value: AvailableType;
+        title?: string | undefined;
+    }][];
+    /**
+     * @public
+     * @param {object} cfg
+     * @param {boolean} [cfg.readonly]
+     * @param {"both"|"keys"|"values"} [cfg.resultType]
+     * @param {string} [cfg.typeNamespace]
+     * @param {AvailableType} cfg.type
+     * @param {RootElement} [cfg.topRoot]
+     * @param {boolean|undefined} cfg.bringIntoFocus
+     * @param {import('./typeChoices.js').BuildTypeChoices} [cfg.buildTypeChoices]
+     * @param {import('./formats.js').AvailableFormat} cfg.format
+     * @param {object} [cfg.schemaContent]
+     * @param {GetPossibleSchemasForPathAndType} [cfg.schemaState] Not currently
+     *   in use
+     * @param {StructuredCloneValue} cfg.value
+     * @param {boolean} cfg.hasValue
+     * @param {StructuredCloneValue} [cfg.replaced]
+     * @returns {Element}
+     */
+    function getUIForModeAndType({ readonly, resultType, typeNamespace, type, topRoot, bringIntoFocus, buildTypeChoices, format, schemaContent, schemaState, value, hasValue, replaced }: {
+        readonly?: boolean | undefined;
+        resultType?: "keys" | "values" | "both" | undefined;
+        typeNamespace?: string | undefined;
+        type: AvailableType;
+        topRoot?: HTMLDivElement | undefined;
+        bringIntoFocus: boolean | undefined;
+        buildTypeChoices?: import("./typeChoices.js").BuildTypeChoices | undefined;
+        format: import("./formats.js").AvailableFormat;
+        schemaContent?: object | undefined;
+        schemaState?: GetPossibleSchemasForPathAndType | undefined;
+        value: any;
+        hasValue: boolean;
+        replaced?: any;
+    }): Element;
+    const contexts: {
+        [key: string]: {
+            [key: string]: {
+                type: AvailableType;
+                after: AvailableType;
+            }[];
+        };
+    };
+    /**
+     * @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 | undefined;
+        keySelectClass?: string | undefined;
+    }): 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;
+    const customValidateAllReferences: ((info: {
+        topRoot: HTMLDivElement;
+    }) => void) | null;
+    /**
+     * @public
+     * @param {object} cfg
+     * @param {AvailableType} cfg.type
+     * @param {RootElement} cfg.root
+     * @param {RootElement} [cfg.topRoot]
+     * @returns {boolean}
+     */
+    function validate({ type, root, topRoot }: {
+        type: AvailableType;
+        root: HTMLDivElement;
+        topRoot?: HTMLDivElement | undefined;
+    }): boolean;
+    /**
+     * @param {object} cfg
+     * @param {AvailableType} cfg.type
+     * @param {RootElement} cfg.root
+     * @param {StructuredCloneValue} cfg.value
+     * @returns {void}
+     */
+    function setValue({ type, root, value }: {
+        type: AvailableType;
+        root: HTMLDivElement;
+        value: any;
+    }): void;
+    /**
+     * @public
+     * @param {string} s
+     * @param {object} cfg
+     * @param {import('./formats.js').AvailableFormat} cfg.format
+     * @param {string} cfg.state
+     * @param {TypeObject[]} [cfg.endMatchTypeObjs=[]]
+     * @param {boolean} [cfg.firstRun=true]
+     * @param {[
+     *   type: string,
+     *   parent: {[key: string]: any},
+     *   parentPath: string|number,
+     *   path: string
+     * ][]} [cfg.rootHolder=[]]
+     * @param {{[key: string]: any}} cfg.parent
+     * @param {string|number} cfg.parentPath
+     * @returns {[
+     *   value: StructuredCloneValue,
+     *   remnant: string,
+     *   beginOnly: boolean,
+     *   assign: boolean
+     * ]}
+     */
+    function getValueForString(s: string, { format, state, endMatchTypeObjs, firstRun, rootHolder, parent, parentPath }: {
+        format: import("./formats.js").AvailableFormat;
+        state: string;
+        endMatchTypeObjs?: TypeObject[] | undefined;
+        firstRun?: boolean | undefined;
+        rootHolder?: [type: string, parent: {
+            [key: string]: any;
+        }, parentPath: string | number, path: string][] | undefined;
+        parent: {
+            [key: string]: any;
+        };
+        parentPath: string | number;
+    }): [value: any, remnant: string, beginOnly: boolean, assign: boolean];
+}
+import nullType from './fundamentalTypes/nullType.js';
+import trueType from './subTypes/trueType.js';
+import falseType from './subTypes/falseType.js';
+import numberType from './fundamentalTypes/numberType.js';
+import bigintType from './fundamentalTypes/bigintType.js';
+import stringType from './fundamentalTypes/stringType.js';
+import arrayReferenceType from './fundamentalTypes/arrayReferenceType.js';
+import objectReferenceType from './fundamentalTypes/objectReferenceType.js';
+import arrayType from './fundamentalTypes/arrayType.js';
+import objectType from './fundamentalTypes/objectType.js';
+import dateType from './fundamentalTypes/dateType.js';
+import undefinedType from './fundamentalTypes/undefinedType.js';
+import SpecialRealNumberSuperType from './superTypes/SpecialRealNumberSuperType.js';
+import SpecialNumberSuperType from './superTypes/SpecialNumberSuperType.js';
+import regexpType from './fundamentalTypes/regexpType.js';
+import BooleanObjectType from './fundamentalTypes/BooleanObjectType.js';
+import NumberObjectType from './fundamentalTypes/NumberObjectType.js';
+import StringObjectType from './fundamentalTypes/StringObjectType.js';
+import blobHTMLType from './subTypes/blobHTMLType.js';
+import sparseUndefinedType from './fundamentalTypes/sparseUndefinedType.js';
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.js"],"names":[],"mappings":"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"}

package/dist/utils/dialogs.d.ts

@@ -0,0 +1,109 @@
+export default dialogs;
+export type Locale = {
+    [key: string]: string;
+};
+declare namespace dialogs {
+    const localeStrings: Locale;
+    /**
+     * @param {Locale} [locale={}]
+     * @returns {void}
+     */
+    function setLocale(locale?: Locale | undefined): void;
+    /**
+     * @typedef {object} MakeDialogArgs
+     * @property {import('jamilih').JamilihAttributes} [atts={}]
+     * @property {import('jamilih').JamilihChildren} [children=[]]
+     * @property {import('jamilih').EventHandler} [close]
+     * @property {boolean} [remove=true]
+     */
+    /**
+     * @param {MakeDialogArgs} cfg
+     * @returns {HTMLDialogElement}
+     */
+    function makeDialog({ atts, children, close, remove }?: {
+        atts?: import("jamilih").JamilihAttributes | undefined;
+        children?: import("jamilih").JamilihChildren | undefined;
+        close?: import("jamilih").EventHandler | undefined;
+        remove?: boolean | undefined;
+    }): HTMLDialogElement;
+    /**
+     * @typedef {object} MakeCancelArgs
+     * @property {(
+     *   info: {e: Event, dialog: HTMLDialogElement}
+     * ) => boolean} cancel
+     * @property {string} cancelClass
+     * @property {string} submitClass
+     * @property {...MakeDialogArgs} args
+     */
+    /**
+     * @param {MakeCancelArgs} cfg
+     * @returns {HTMLDialogElement}
+     */
+    function makeCancelDialog({ cancel, cancelClass, submitClass, ...args }: {
+        cancel: (info: {
+            e: Event;
+            dialog: HTMLDialogElement;
+        }) => boolean;
+        cancelClass: string;
+        submitClass: string;
+        args: {
+            atts?: import("jamilih").JamilihAttributes | undefined;
+            children?: import("jamilih").JamilihChildren | undefined;
+            close?: import("jamilih").EventHandler | undefined;
+            remove?: boolean | undefined;
+        } | undefined;
+    }): HTMLDialogElement;
+    /**
+     * @param {object} cfg
+     * @param {(info: {e: Event, dialog: HTMLDialogElement}) => void} cfg.submit
+     * @param {string} [cfg.submitClass="submit"]
+     * @param {MakeCancelArgs} [cfg.args]
+     * @returns {HTMLDialogElement}
+     */
+    function makeSubmitDialog({ submit, submitClass, ...args }: {
+        submit: (info: {
+            e: Event;
+            dialog: HTMLDialogElement;
+        }) => void;
+        submitClass?: string | undefined;
+        args?: {
+            cancel: (info: {
+                e: Event;
+                dialog: HTMLDialogElement;
+            }) => boolean;
+            cancelClass: string;
+            submitClass: string;
+            args: {
+                atts?: import("jamilih").JamilihAttributes | undefined;
+                children?: import("jamilih").JamilihChildren | undefined;
+                close?: import("jamilih").EventHandler | undefined;
+                remove?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+    }): HTMLDialogElement;
+    /**
+     * @param {string|{
+     *   submitClass?: string,
+     *   message: string|import('jamilih').JamilihArray
+     * }} message
+     * @returns {Promise<void>}
+     */
+    function alert(message: string | {
+        submitClass?: string | undefined;
+        message: string | import("jamilih").JamilihArray;
+    }): Promise<void>;
+    /**
+     * @param {object} cfg
+     * @param {import('jamilih').JamilihAttributes} [cfg.atts={}]
+     * @param {string|{message: string}} cfg.message
+     * @param {string} [cfg.submitClass="submit"]
+     */
+    function confirm({ atts, message, submitClass }: {
+        atts?: import("jamilih").JamilihAttributes | undefined;
+        message: string | {
+            message: string;
+        };
+        submitClass?: string | undefined;
+    }): Promise<any>;
+}
+//# sourceMappingURL=dialogs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dialogs.d.ts","sourceRoot":"","sources":["../../src/utils/dialogs.js"],"names":[],"mappings":";;;;;yBAiBa,MAAM;IAEjB;;;OAGG;IACH,sDAEC;IAED;;;;;;OAMG;IACH;;;OAGG;IACH;;;;;0BAmBC;IACD;;;;;;;;OAQG;IACH;;;OAGG;IACH;;;;;;;;;;;;;0BA0BC;IACD;;;;;;OAMG;IACH;;;;;;;;;;;;;;;;;;;;0BAiBC;IACD;;;;;;OAMG;IACH;;;sBAiBC;IACD;;;;;OAKG;IACH;;;;;;qBAwBC"}

package/dist/utils/jsonPointer.d.ts

@@ -0,0 +1,46 @@
+export type ArbitraryObject = any;
+/**
+ * @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[];
+/**
+ * @typedef {any} ArbitraryObject
+ */
+/**
+ * @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/utils/jsonPointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonPointer.d.ts","sourceRoot":"","sources":["../../src/utils/jsonPointer.js"],"names":[],"mappings":"8BA0Ca,GAAG;AA1ChB;;;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;;GAEG;AAEH;;;;GAIG;AACH,4CAJW,eAAe,YACf,MAAM,GACJ,eAAe,GAAC,MAAM,CAQlC;AAED;;;;;GAKG;AACH;IAJuB,IAAI,EAAhB,MAAM;IACe,GAAG,EAAxB,eAAe;IACb,MAAM,GAAC,eAAe,CAOlC;AAED;;;GAGG;AACH,+CAHW,MAAM,GACJ,MAAM,CAYlB"}