@fgv/ts-json 5.0.1-8 → 5.0.1

package/dist/packlets/editor/jsonEditor.js

@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) 2020 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { captureResult, fail, failWithDetail, mapDetailedResults, mapResults, succeed, succeedWithDetail } from '@fgv/ts-utils';
+import { ConditionalJsonEditorRule, MultiValueJsonEditorRule, ReferenceJsonEditorRule, TemplatedJsonEditorRule } from './rules';
+import { isJsonArray, isJsonObject, isJsonPrimitive } from '@fgv/ts-json-base';
+import { JsonEditorState } from './jsonEditorState';
+/**
+ * A {@link JsonEditor | JsonEditor} can be used to edit JSON objects in place or to
+ * clone any JSON value, applying a default context and optional set of editor rules that
+ * were supplied at initialization.
+ * @public
+ */
+export class JsonEditor {
+    /**
+     * Protected constructor for {@link JsonEditor | JsonEditor} and derived classes.
+     * External consumers should instantiate via the {@link JsonEditor.create | create static method}.
+     * @param options - Optional partial {@link IJsonEditorOptions | editor options} for the
+     * constructed editor.
+     * @param rules - Any {@link IJsonEditorRule | editor rules} to be applied by the editor.
+     * @internal
+     */
+    constructor(options, rules) {
+        this.options = JsonEditor._getDefaultOptions(options).orThrow();
+        this._rules = rules || JsonEditor.getDefaultRules(this.options).orThrow();
+    }
+    /**
+     * Default singleton {@link JsonEditor | JsonEditor} for simple use. Applies all rules
+     * but with no default context.
+     */
+    static get default() {
+        if (!JsonEditor._default) {
+            const rules = this.getDefaultRules().orDefault();
+            JsonEditor._default = new JsonEditor(undefined, rules);
+        }
+        return JsonEditor._default;
+    }
+    /**
+     * Constructs a new {@link JsonEditor | JsonEditor}.
+     * @param options - Optional partial {@link IJsonEditorOptions | editor options} for the
+     * constructed editor.
+     * @param rules - Optional set of {@link IJsonEditorRule | editor rules} to be applied by the editor.
+     * @readonly A new {@link JsonEditor | JsonEditor}.
+     */
+    static create(options, rules) {
+        return captureResult(() => new JsonEditor(options, rules));
+    }
+    /**
+     * Gets the default set of rules to be applied for a given set of options.
+     * By default, all available rules (templates, conditionals, multi-value and references)
+     * are applied.
+     * @param options - Optional partial {@link IJsonEditorOptions | editor options} for
+     * all rules.
+     * @returns Default {@link IJsonEditorRule | editor rules} with any supplied options
+     * applied.
+     */
+    static getDefaultRules(options) {
+        return mapResults([
+            TemplatedJsonEditorRule.create(options),
+            ConditionalJsonEditorRule.create(options),
+            MultiValueJsonEditorRule.create(options),
+            ReferenceJsonEditorRule.create(options)
+        ]);
+    }
+    /**
+     * Creates a complete IJsonEditorOptions object from partial options, filling in
+     * default values for any missing properties. This ensures all editor instances
+     * have consistent, complete configuration including validation rules and merge behavior.
+     * @param options - Optional partial editor options to merge with defaults
+     * @returns Success with complete editor options, or Failure if validation fails
+     * @internal
+     */
+    static _getDefaultOptions(options) {
+        var _a;
+        const context = options === null || options === void 0 ? void 0 : options.context;
+        let validation = options === null || options === void 0 ? void 0 : options.validation;
+        if (validation === undefined) {
+            validation = {
+                onInvalidPropertyName: 'error',
+                onInvalidPropertyValue: 'error',
+                onUndefinedPropertyValue: 'ignore'
+            };
+        }
+        let merge = options === null || options === void 0 ? void 0 : options.merge;
+        if (merge === undefined) {
+            merge = {
+                arrayMergeBehavior: 'append',
+                nullAsDelete: false
+            };
+        }
+        else {
+            merge = {
+                arrayMergeBehavior: merge.arrayMergeBehavior,
+                nullAsDelete: (_a = merge.nullAsDelete) !== null && _a !== void 0 ? _a : false
+            };
+        }
+        return succeed({ context, validation, merge });
+    }
+    /**
+     * Merges a supplied source object into a supplied target, updating the target object.
+     * @param target - The target `JsonObject` to be updated
+     * @param src - The source `JsonObject` to be merged
+     * @param runtimeContext - An optional {@link IJsonContext | IJsonContext} supplying variables
+     * and references.
+     * @returns `Success` with the original source `JsonObject` if merge was successful.
+     * Returns `Failure` with details if an error occurs.
+     */
+    mergeObjectInPlace(target, src, runtimeContext) {
+        const state = new JsonEditorState(this, this.options, runtimeContext);
+        return this._mergeObjectInPlace(target, src, state).onSuccess((merged) => {
+            return this._finalizeAndMerge(merged, state);
+        });
+    }
+    /**
+     * Merges multiple supplied source objects into a supplied target, updating the target
+     * object and using the default context supplied at creation time.
+     * @param target - The target `JsonObject` to be updated
+     * @param srcObjects - `JsonObject`s to be merged into the target object, in the order
+     * supplied.
+     * @returns `Success` with the original source `JsonObject` if merge was successful.
+     * Returns `Failure` with details if an error occurs.
+     */
+    mergeObjectsInPlace(target, srcObjects) {
+        return this.mergeObjectsInPlaceWithContext(this.options.context, target, srcObjects);
+    }
+    /**
+     * Merges multiple supplied source objects into a supplied target, updating the target
+     * object and using an optional {@link IJsonContext | context} supplied in the call.
+     * @param context - An optional {@link IJsonContext | IJsonContext} supplying variables and
+     * references.
+     * @param base - The base `JsonObject` to be updated
+     * @param srcObjects - Objects to be merged into the target object, in the order supplied.
+     * @returns `Success` with the original source `JsonObject` if merge was successful.
+     * Returns `Failure` with details if an error occurs.
+     */
+    mergeObjectsInPlaceWithContext(context, base, srcObjects) {
+        for (const src of srcObjects) {
+            const mergeResult = this.mergeObjectInPlace(base, src, context);
+            if (mergeResult.isFailure()) {
+                return mergeResult.withFailureDetail('error');
+            }
+        }
+        return succeedWithDetail(base);
+    }
+    /**
+     * Deep clones a supplied `JsonValue`, applying all editor rules and a default
+     * or optionally supplied context
+     * @param src - The `JsonValue` to be cloned.
+     * @param context - An optional {@link IJsonContext | JSON context} supplying variables and references.
+     */
+    clone(src, context) {
+        const state = new JsonEditorState(this, this.options, context);
+        let value = src;
+        let valueResult = this._editValue(src, state);
+        while (valueResult.isSuccess()) {
+            value = valueResult.value;
+            valueResult = this._editValue(value, state);
+        }
+        if (valueResult.detail === 'error' || valueResult.detail === 'ignore') {
+            return valueResult;
+        }
+        if (isJsonPrimitive(value) || value === null) {
+            return succeedWithDetail(value, 'edited');
+        }
+        else if (isJsonObject(value)) {
+            return this._cloneObjectWithoutNullAsDelete({}, value, state);
+        }
+        else if (isJsonArray(value)) {
+            return this._cloneArray(value, state.context);
+        }
+        else if (value === undefined) {
+            return state.failValidation('undefinedPropertyValue');
+        }
+        return state.failValidation('invalidPropertyValue', `Cannot convert invalid JSON: "${JSON.stringify(value)}"`);
+    }
+    /**
+     * Merges properties from a source object into a target object, applying editor rules and
+     * null-as-delete logic. This is the core merge implementation that handles property-by-property
+     * merging with rule processing and deferred property handling.
+     * @param target - The target object to merge properties into
+     * @param src - The source object containing properties to merge
+     * @param state - The editor state containing options and context
+     * @returns Success with the modified target object, or Failure with error details
+     * @internal
+     */
+    _mergeObjectInPlace(target, src, state) {
+        for (const key in src) {
+            if (src.hasOwnProperty(key)) {
+                // Skip dangerous property names to prevent prototype pollution
+                if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+                    continue;
+                }
+                const propResult = this._editProperty(key, src[key], state);
+                if (propResult.isSuccess()) {
+                    if (propResult.detail === 'deferred') {
+                        state.defer(propResult.value);
+                    }
+                    else {
+                        const mergeResult = this._mergeObjectInPlace(target, propResult.value, state);
+                        if (mergeResult.isFailure()) {
+                            return mergeResult;
+                        }
+                    }
+                }
+                else if (propResult.detail === 'inapplicable') {
+                    const valueResult = this.clone(src[key], state.context).onSuccess((cloned) => {
+                        return this._mergeClonedProperty(target, key, cloned, state);
+                    });
+                    if (valueResult.isFailure() && valueResult.detail === 'error') {
+                        return fail(`${key}: ${valueResult.message}`);
+                    }
+                }
+                else if (propResult.detail !== 'ignore') {
+                    return fail(`${key}: ${propResult.message}`);
+                }
+            }
+            else {
+                return fail(`${key}: Cannot merge inherited properties`);
+            }
+        }
+        return succeed(target);
+    }
+    /**
+     * Creates a deep clone of a JSON array by recursively cloning each element.
+     * Each array element is cloned using the main clone method, preserving the
+     * editor's rules and validation settings.
+     * @param src - The source JSON array to clone
+     * @param context - Optional JSON context for cloning operations
+     * @returns Success with the cloned array, or Failure with error details
+     * @internal
+     */
+    _cloneArray(src, context) {
+        const results = src.map((v) => {
+            return this.clone(v, context);
+        });
+        return mapDetailedResults(results, ['ignore'])
+            .onSuccess((converted) => {
+            return succeed(converted);
+        })
+            .withFailureDetail('error');
+    }
+    /**
+     * Merges a single cloned property value into a target object. This method handles
+     * the core merge logic including null-as-delete behavior, array merging, and
+     * recursive object merging. The null-as-delete check occurs before primitive
+     * handling to ensure null values can signal property deletion.
+     * @param target - The target object to merge the property into
+     * @param key - The property key being merged
+     * @param newValue - The cloned value to merge (from source object)
+     * @param state - The editor state containing merge options and context
+     * @returns Success with the merged value, or Failure with error details
+     * @internal
+     */
+    _mergeClonedProperty(target, key, newValue, state) {
+        var _a, _b, _c;
+        // Skip dangerous property names to prevent prototype pollution
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            return succeedWithDetail(newValue, 'edited');
+        }
+        const existing = target[key];
+        // Handle null-as-delete behavior before primitive check
+        /* c8 ignore next 1 - ? is defense in depth */
+        if (newValue === null && ((_a = state.options.merge) === null || _a === void 0 ? void 0 : _a.nullAsDelete) === true) {
+            delete target[key];
+            return succeedWithDetail(null, 'edited');
+        }
+        // merge is called right after clone so this should never happen
+        // since clone itself will have failed
+        if (isJsonPrimitive(newValue)) {
+            target[key] = newValue;
+            return succeedWithDetail(newValue, 'edited');
+        }
+        if (isJsonObject(newValue)) {
+            if (isJsonObject(existing)) {
+                return this.mergeObjectInPlace(existing, newValue, state.context).withFailureDetail('error');
+            }
+            target[key] = newValue;
+            return succeedWithDetail(newValue, 'edited');
+        }
+        /* c8 ignore else */
+        if (isJsonArray(newValue)) {
+            if (isJsonArray(existing)) {
+                /* c8 ignore next 1 - ?? is defense in depth */
+                const arrayMergeBehavior = (_c = (_b = state.options.merge) === null || _b === void 0 ? void 0 : _b.arrayMergeBehavior) !== null && _c !== void 0 ? _c : 'append';
+                switch (arrayMergeBehavior) {
+                    case 'append':
+                        target[key] = existing.concat(...newValue);
+                        break;
+                    case 'replace':
+                        target[key] = newValue;
+                        break;
+                    /* c8 ignore next 2 - exhaustive switch for ArrayMergeBehavior type */
+                    default:
+                        return failWithDetail(`Invalid array merge behavior: ${arrayMergeBehavior}`, 'error');
+                }
+                return succeedWithDetail(target[key], 'edited');
+            }
+            target[key] = newValue;
+            return succeedWithDetail(newValue, 'edited');
+        }
+        /* c8 ignore start */
+        return failWithDetail(`Invalid JSON: ${JSON.stringify(newValue)}`, 'error');
+    } /* c8 ignore stop */
+    /**
+     * Applies editor rules to a single property during merge operations. This method
+     * iterates through all configured editor rules to process the property, handling
+     * templates, conditionals, multi-value properties, and references.
+     * @param key - The property key to edit
+     * @param value - The property value to edit
+     * @param state - The editor state containing rules and context
+     * @returns Success with transformed property object, or Failure if rules cannot process
+     * @internal
+     */
+    _editProperty(key, value, state) {
+        for (const rule of this._rules) {
+            const ruleResult = rule.editProperty(key, value, state);
+            if (ruleResult.isSuccess() || ruleResult.detail !== 'inapplicable') {
+                return ruleResult;
+            }
+        }
+        return failWithDetail('inapplicable', 'inapplicable');
+    }
+    /**
+     * Applies editor rules to a single JSON value during clone operations. This method
+     * iterates through all configured editor rules to process the value, handling
+     * templates, conditionals, multi-value expressions, and references.
+     * @param value - The JSON value to edit and transform
+     * @param state - The editor state containing rules and context
+     * @returns Success with transformed value, or Failure if rules cannot process
+     * @internal
+     */
+    _editValue(value, state) {
+        for (const rule of this._rules) {
+            const ruleResult = rule.editValue(value, state);
+            if (ruleResult.isSuccess() || ruleResult.detail !== 'inapplicable') {
+                return ruleResult;
+            }
+        }
+        return failWithDetail('inapplicable', 'inapplicable');
+    }
+    /**
+     * Clone an object without applying null-as-delete behavior.
+     * This preserves null values during cloning so they can be used for deletion signaling during merge.
+     * @param target - The target object to clone into
+     * @param src - The source object to clone
+     * @param state - The editor state
+     * @returns The cloned object
+     * @internal
+     */
+    _cloneObjectWithoutNullAsDelete(target, src, state) {
+        var _a, _b;
+        // Temporarily disable null-as-delete during cloning
+        const modifiedOptions = {
+            context: state.options.context,
+            validation: state.options.validation,
+            merge: {
+                /* c8 ignore next 1 - ? is defense in depth */
+                arrayMergeBehavior: (_b = (_a = state.options.merge) === null || _a === void 0 ? void 0 : _a.arrayMergeBehavior) !== null && _b !== void 0 ? _b : 'append',
+                nullAsDelete: false
+            }
+        };
+        const modifiedState = new JsonEditorState(state.editor, modifiedOptions, state.context);
+        return this._mergeObjectInPlace(target, src, modifiedState)
+            .onSuccess((merged) => {
+            return this._finalizeAndMerge(merged, modifiedState);
+        })
+            .withFailureDetail('error');
+    }
+    /**
+     * Finalizes the merge operation by processing any deferred properties and merging
+     * them into the target object. Deferred properties are those that require special
+     * processing after the initial merge phase, such as references that depend on
+     * other properties being resolved first.
+     * @param target - The target object that has been merged
+     * @param state - The editor state containing deferred properties and rules
+     * @returns Success with the finalized target object, or Failure with error details
+     * @internal
+     */
+    _finalizeAndMerge(target, state) {
+        const deferred = state.deferred;
+        if (deferred.length > 0) {
+            for (const rule of this._rules) {
+                const ruleResult = rule.finalizeProperties(deferred, state);
+                if (ruleResult.isSuccess()) {
+                    return this.mergeObjectsInPlaceWithContext(state.context, target, ruleResult.value).withFailureDetail('error');
+                }
+                else if (ruleResult.detail === 'ignore') {
+                    succeedWithDetail(target, 'edited');
+                }
+                else if (ruleResult.detail !== 'inapplicable') {
+                    return failWithDetail(ruleResult.message, ruleResult.detail);
+                }
+            }
+        }
+        return succeedWithDetail(target, 'edited');
+    }
+}
+//# sourceMappingURL=jsonEditor.js.map

package/dist/packlets/editor/jsonEditorRule.js

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { failWithDetail } from '@fgv/ts-utils';
+/**
+ * Default base implementation of {@link IJsonEditorRule | IJsonEditorRule} returns inapplicable for all operations so that
+ * derived classes need only implement the operations they actually support.
+ * @public
+ */
+export class JsonEditorRuleBase {
+    /**
+     * {@inheritdoc IJsonEditorRule.editProperty}
+     */
+    /* c8 ignore start */
+    editProperty(__key, __value, __state) {
+        return failWithDetail('inapplicable', 'inapplicable');
+    }
+    /* c8 ignore stop */
+    /**
+     * {@inheritdoc IJsonEditorRule.editValue}
+     */
+    editValue(__value, __state) {
+        return failWithDetail('inapplicable', 'inapplicable');
+    }
+    /**
+     * {@inheritdoc IJsonEditorRule.finalizeProperties}
+     */
+    finalizeProperties(__deferred, __state) {
+        return failWithDetail('inapplicable', 'inapplicable');
+    }
+}
+//# sourceMappingURL=jsonEditorRule.js.map

package/dist/packlets/editor/jsonEditorState.js

@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2020 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { failWithDetail, succeed } from '@fgv/ts-utils';
+import { JsonContextHelper } from '../context';
+/**
+ * Represents the internal state of a {@link JsonEditor | JsonEditor}.
+ * @public
+ */
+export class JsonEditorState {
+    /**
+     * Constructs a new {@link JsonEditorState | JsonEditorState}.
+     * @param editor - The {@link IJsonCloneEditor | editor} to which this state
+     * applies.
+     * @param baseOptions - The {@link IJsonEditorOptions | editor options} that
+     * apply to this rule.
+     * @param runtimeContext - An optional {@link IJsonContext | JSON context} to be used
+     * for json value conversion.
+     */
+    constructor(editor, baseOptions, runtimeContext) {
+        /**
+         * Any deferred JSON objects to be merged during finalization.
+         * @internal
+         */
+        this._deferred = [];
+        this.editor = editor;
+        this.options = JsonEditorState._getEffectiveOptions(baseOptions, runtimeContext).orThrow();
+        this._id = JsonEditorState._nextId++;
+    }
+    /**
+     * The optional {@link IJsonContext | JSON context} for this state.
+     */
+    get context() {
+        return this.options.context;
+    }
+    /**
+     * An array of JSON objects that were deferred for merge during
+     * finalization.
+     */
+    get deferred() {
+        return this._deferred;
+    }
+    /**
+     * Merges an optional {@link IJsonContext | JSON context} into a supplied set
+     * of {@link IJsonEditorOptions | JSON editor options}.
+     * @param options - The {@link IJsonEditorOptions | IJsonEditorOptions} into
+     * which the the new context is to be merged.
+     * @param context - The {@link IJsonContext | JSON context} to be merged into the
+     * editor options.
+     * @returns `Success` with the supplied {@link IJsonEditorOptions | options} if
+     * there was nothing to merge, or aa new {@link IJsonEditorOptions | IJsonEditorOptions}
+     * constructed from the base options merged with the supplied context.  Returns `Failure`
+     * with more information if an error occurs.
+     * @internal
+     */
+    static _getEffectiveOptions(options, context) {
+        if (!context) {
+            return succeed(options);
+        }
+        return JsonContextHelper.mergeContext(options.context, context).onSuccess((merged) => {
+            return succeed({ context: merged, validation: options.validation, merge: options.merge });
+        });
+    }
+    /**
+     * Adds a supplied `JsonObject` to the deferred list.
+     * @param obj - The `JsonObject` to be deferred.
+     */
+    defer(obj) {
+        this._deferred.push(obj);
+    }
+    /**
+     * Gets a {@link TemplateVars | TemplateVars} from the context of this {@link JsonEditorState | JsonEditorState},
+     * or from an optional supplied {@link IJsonContext | IJsonContext} if the current state has no default
+     * context.
+     * @param defaultContext - An optional default {@link IJsonContext | IJsonContext} to use as `TemplateVars`
+     * if the current state does not have context.
+     * @returns A {@link TemplateVars | TemplateVars} reflecting the appropriate {@link IJsonContext | JSON context}, or
+     * `undefined` if no vars are found.
+     */
+    getVars(defaultContext) {
+        var _a, _b;
+        /* c8 ignore next */ // c8 seems to be struggling atm
+        return (_b = (_a = this.options.context) === null || _a === void 0 ? void 0 : _a.vars) !== null && _b !== void 0 ? _b : defaultContext === null || defaultContext === void 0 ? void 0 : defaultContext.vars;
+    }
+    /**
+     * Gets an {@link IJsonReferenceMap | reference map} containing any other values
+     * referenced during the operation.
+     * @param defaultContext - An optional default {@link IJsonContext | IJsonContext} to use as
+     * {@link TemplateVars | TemplateVars} if the current state does not have context.
+     * @returns An {@link IJsonReferenceMap | IJsonReferenceMap} containing any values referenced
+     * during this operation.
+     */
+    getRefs(defaultContext) {
+        var _a, _b;
+        /* c8 ignore next */ // c8 seems to be struggling atm
+        return (_b = (_a = this.options.context) === null || _a === void 0 ? void 0 : _a.refs) !== null && _b !== void 0 ? _b : defaultContext === null || defaultContext === void 0 ? void 0 : defaultContext.refs;
+    }
+    /**
+     * Gets the context of this {@link JsonEditorState | JsonEditorState} or an optionally
+     * supplied default context if this state has no context.
+     * @param defaultContext - The default {@link IJsonContext | JSON context} to use as default
+     * if this state has no context.
+     * @returns The appropriate {@link IJsonContext | IJsonContext} or `undefined` if no context
+     * is available.
+     */
+    getContext(defaultContext) {
+        return JsonContextHelper.mergeContext(defaultContext, this.options.context).orDefault();
+    }
+    /**
+     * Constructs a new {@link IJsonContext | IJsonContext} by merging supplied variables
+     * and references into a supplied existing context.
+     * @param baseContext - The {@link IJsonContext | IJsonContext} into which variables
+     * and references are to be merged, or `undefined` to start with a default empty context.
+     * @param add - The {@link VariableValue | variable values} and/or
+     * {@link IJsonReferenceMap | JSON entity references} to be merged into the base context.
+     * @returns A new {@link IJsonContext | IJsonContext} created by merging the supplied values.
+     */
+    extendContext(baseContext, add) {
+        const context = this.getContext(baseContext);
+        return JsonContextHelper.extendContext(context, add);
+    }
+    /**
+     * Helper method to constructs  `DetailedFailure` with appropriate details and messaging
+     * for various validation failures.
+     * @param rule - The {@link JsonEditorValidationRules | validation rule} that failed.
+     * @param message -  A string message describing the failed validation.
+     * @param validation - The {@link IJsonEditorValidationOptions | validation options}
+     * in effect.
+     * @returns A `DetailedFailure` with appropriate detail and message.
+     */
+    failValidation(rule, message, validation) {
+        let detail = 'error';
+        const effective = validation !== null && validation !== void 0 ? validation : this.options.validation;
+        switch (rule) {
+            case 'invalidPropertyName':
+                detail = effective.onInvalidPropertyName !== 'ignore' ? 'error' : 'inapplicable';
+                break;
+            case 'invalidPropertyValue':
+                detail = effective.onInvalidPropertyValue !== 'ignore' ? 'error' : 'ignore';
+                break;
+            case 'undefinedPropertyValue':
+                detail = effective.onUndefinedPropertyValue !== 'error' ? 'ignore' : 'error';
+                /* c8 ignore next */
+                message = message !== null && message !== void 0 ? message : 'Cannot convert undefined to JSON';
+                break;
+        }
+        /* c8 ignore next */
+        return failWithDetail(message !== null && message !== void 0 ? message : rule, detail);
+    }
+}
+/**
+ * Static global counter used to assign each {@link JsonEditorState | JsonEditorState}
+ * a unique identifier.
+ * @internal
+ */
+JsonEditorState._nextId = 0;
+//# sourceMappingURL=jsonEditorState.js.map