@fgv/ts-json 5.0.1-8 → 5.0.1

package/dist/packlets/editor/jsonReferenceMap.js

@@ -0,0 +1,315 @@
+/*
+ * 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, mapResults, recordToMap, succeed, succeedWithDetail } from '@fgv/ts-utils';
+import { isJsonObject } from '@fgv/ts-json-base';
+import { JsonEditor } from './jsonEditor';
+/**
+ * Policy object responsible for validating or correcting
+ * keys in a {@link IJsonReferenceMap | reference map}.
+ * @public
+ */
+export class ReferenceMapKeyPolicy {
+    /**
+     * Constructs a new {@link ReferenceMapKeyPolicy | ReferenceMapKeyPolicy}.
+     * @param options - Optional {@link IReferenceMapKeyPolicyValidateOptions | options}
+     * used to construct the {@link ReferenceMapKeyPolicy}.
+     * @param isValid - An optional predicate to test a supplied key for validity.
+     */
+    constructor(options, isValid) {
+        this._defaultOptions = options;
+        this._isValid = isValid !== null && isValid !== void 0 ? isValid : ReferenceMapKeyPolicy.defaultKeyPredicate;
+    }
+    /**
+     * The static default key name validation predicate rejects keys that contain
+     * mustache templates or which start with the default conditional prefix
+     * `'?'`.
+     * @param key - The key to test.
+     * @returns `true` if the key is valid, `false` otherwise.
+     */
+    static defaultKeyPredicate(key) {
+        return key.length > 0 && !key.includes('{{') && !key.startsWith('?');
+    }
+    /**
+     * Determines if a supplied key and item are valid according to the current policy.
+     * @param key - The key to be tested.
+     * @param item - The item to be tested.
+     * @returns `true` if the key and value are valid, `false` otherwise.
+     */
+    isValid(key, item) {
+        return this._isValid(key, item);
+    }
+    /**
+     * Determines if a supplied key and item are valid according to the current policy.
+     * @param key - The key to be tested.
+     * @param item - The item to be tested.
+     * @returns `Success` with the key if valid, `Failure` with an error message if invalid.
+     */
+    validate(key, item, __options) {
+        return this.isValid(key, item) ? succeed(key) : fail(`${key}: invalid key`);
+    }
+    /**
+     * Validates an array of entries using the validation rules for this policy.
+     * @param items - The array of entries to be validated.
+     * @param options - Optional {@link IReferenceMapKeyPolicyValidateOptions | options} to control
+     * validation.
+     * @returns `Success` with an array of validated entries, or `Failure` with an error message
+     * if validation fails.
+     */
+    validateItems(items, options) {
+        return mapResults(items.map((item) => {
+            return this.validate(...item, options).onSuccess((valid) => {
+                return succeed([valid, item[1]]);
+            });
+        }));
+    }
+    /**
+     * Validates a `Map\<string, T\>` using the validation rules for this policy.
+     * @param items - The `Map\<string, T\>` to be validated.
+     * @param options - Optional {@link IReferenceMapKeyPolicyValidateOptions | options} to control
+     * validation.
+     * @returns `Success` with a new `Map\<string, T\>`, or `Failure` with an error message
+     * if validation fails.
+     */
+    validateMap(map, options) {
+        return this.validateItems(Array.from(map.entries()), options).onSuccess((valid) => {
+            return captureResult(() => new Map(valid));
+        });
+    }
+}
+/**
+ * A {@link PrefixKeyPolicy | PrefixKeyPolicy} enforces that all keys start with a supplied
+ * prefix, optionally adding the prefix as necessary.
+ * @public
+ */
+export class PrefixKeyPolicy extends ReferenceMapKeyPolicy {
+    /**
+     * Constructs a new {@link PrefixKeyPolicy | PrefixKeyPolicy}.
+     * @param prefix - The string prefix to be enforced or applied.
+     * @param options - Optional {@link IReferenceMapKeyPolicyValidateOptions | options} to
+     * configure the policy.
+     */
+    constructor(prefix, options) {
+        super(options);
+        this.prefix = prefix;
+    }
+    /**
+     * Determines if a key is valid according to policy.
+     * @param key - The key to be tested.
+     * @param __item - The item to be tested.
+     * @returns `true` if the key starts with the expected prefix, `false` otherwise.
+     */
+    isValid(key, __item) {
+        return (key.startsWith(this.prefix) && key !== this.prefix && ReferenceMapKeyPolicy.defaultKeyPredicate(key));
+    }
+    /**
+     * Determines if a key is valid according to policy, optionally coercing to a valid value by
+     * adding the required prefix.
+     * @param key - The key to be tested.
+     * @param item - The item which corresponds to the key.
+     * @param options - Optional {@link IReferenceMapKeyPolicyValidateOptions | options} to guide
+     * validation.
+     * @returns `Success` with a valid key name if the supplied key is valid or if `makeValid` is set
+     * in the policy options. Returns `Failure` with an error message if an error occurs.
+     */
+    validate(key, item, options) {
+        var _a;
+        /* c8 ignore next */
+        const makeValid = ((_a = (options !== null && options !== void 0 ? options : this._defaultOptions)) === null || _a === void 0 ? void 0 : _a.makeValid) === true;
+        if (this.isValid(key, item)) {
+            return succeed(key);
+        }
+        else if (makeValid && ReferenceMapKeyPolicy.defaultKeyPredicate(key)) {
+            return succeed(`${this.prefix}${key}`);
+        }
+        return fail(`${key}: invalid key`);
+    }
+}
+/**
+ * Abstract base class with common functionality for simple
+ * {@link IJsonReferenceMap | reference map} implementations.
+ * @public
+ */
+export class SimpleJsonMapBase {
+    /**
+     * Constructs a new {@link SimpleJsonMap | SimpleJsonMap}.
+     * @param values - Initial values for the map.
+     * @param context - An optional {@link IJsonContext | IJsonContext} used for any conversions
+     * involving items in this map.
+     * @param keyPolicy - The {@link ReferenceMapKeyPolicy | key policy} to use for this map.
+     * @internal
+     */
+    constructor(values, context, keyPolicy) {
+        values = SimpleJsonMapBase._toMap(values).orThrow();
+        this._keyPolicy = keyPolicy !== null && keyPolicy !== void 0 ? keyPolicy : new ReferenceMapKeyPolicy();
+        this._values = this._keyPolicy.validateMap(values).orThrow();
+        this._context = context;
+    }
+    /**
+     * Returns a `Map\<string, T\>` derived from a supplied {@link MapOrRecord | MapOrRecord}
+     * @param values - The {@link MapOrRecord | MapOrRecord} to be returned as a map.
+     * @returns `Success` with the corresponding `Map\<string, T\>` or `Failure` with a
+     * message if an error occurs.
+     * @internal
+     */
+    static _toMap(values) {
+        if (values === undefined) {
+            return captureResult(() => new Map());
+        }
+        else if (!(values instanceof Map)) {
+            return recordToMap(values, (__k, v) => succeed(v));
+        }
+        return succeed(values);
+    }
+    /**
+     * Determine if a key might be valid for this map but does not determine if key actually
+     * exists. Allows key range to be constrained.
+     * @param key - key to be tested
+     * @returns `true` if the key is in the valid range, `false` otherwise.
+     */
+    keyIsInRange(key) {
+        return this._keyPolicy.isValid(key);
+    }
+    /**
+     * Determines if an entry with the specified key actually exists in the map.
+     * @param key - key to be tested
+     * @returns `true` if an object with the specified key exists, `false` otherwise.
+     */
+    has(key) {
+        return this._values.has(key);
+    }
+    /**
+     * Gets a `JsonObject` specified by key.
+     * @param key - key of the object to be retrieved
+     * @param context - optional {@link IJsonContext | JSON context} used to format the
+     * returned object.
+     * @returns {@link ts-utils#Success | `Success`} with the formatted object if successful.
+     * {@link ts-utils#Failure | `Failure`} with detail 'unknown' if no such object exists,
+     * or {@link ts-utils#Failure | `Failure`} with detail 'error' if the object was found
+     * but could not be formatted.
+     */
+    getJsonObject(key, context) {
+        return this.getJsonValue(key, context).onSuccess((jv) => {
+            if (!isJsonObject(jv)) {
+                return failWithDetail(`${key}: not an object`, 'error');
+            }
+            return succeedWithDetail(jv);
+        });
+    }
+}
+/**
+ * A {@link SimpleJsonMap | SimpleJsonMap } presents a view of a simple map
+ * of JSON values.
+ * @public
+ */
+export class SimpleJsonMap extends SimpleJsonMapBase {
+    /**
+     * Constructs a new {@link SimpleJsonMap | SimpleJsonMap} from the supplied objects
+     * @param values - A string-keyed `Map` or `Record` of the `JsonValue`
+     * to be returned.
+     * @param context - Optional {@link IJsonContext | IJsonContext} used to format returned values.
+     * @param options - Optional {@link ISimpleJsonMapOptions | ISimpleJsonMapOptions} for initialization.
+     * @public
+     */
+    constructor(values, context, options) {
+        super(values, context, options === null || options === void 0 ? void 0 : options.keyPolicy);
+        this._editor = options === null || options === void 0 ? void 0 : options.editor;
+    }
+    /**
+     * Creates a new {@link SimpleJsonMap | SimpleJsonMap} from the supplied objects
+     * @param values - A string-keyed `Map` or `Record` of the `JsonValue`
+     * to be returned.
+     * @param context - Optional {@link IJsonContext | IJsonContext} used to format returned values.
+     * @param options - Optional {@link ISimpleJsonMapOptions | ISimpleJsonMapOptions} for initialization.
+     * @returns `Success` with a {@link SimpleJsonMap | SimpleJsonMap} or `Failure` with a message if
+     * an error occurs.
+     */
+    static createSimple(values, context, options) {
+        return captureResult(() => new SimpleJsonMap(values, context, options));
+    }
+    /**
+     * Gets a `JsonValue` specified by key.
+     * @param key - key of the value to be retrieved
+     * @param context - Optional {@link IJsonContext | JSON context} used to format the value
+     * @returns Success with the formatted object if successful. Failure with detail 'unknown'
+     * if no such object exists, or failure with detail 'error' if the object was found but
+     * could not be formatted.
+     */
+    getJsonValue(key, context) {
+        context = context !== null && context !== void 0 ? context : this._context;
+        const value = this._values.get(key);
+        if (!value) {
+            return failWithDetail(`${key}: JSON value not found`, 'unknown');
+        }
+        return this._clone(value, context);
+    }
+    /**
+     * @internal
+     */
+    _clone(value, context) {
+        if (!this._editor) {
+            const result = JsonEditor.create();
+            /* c8 ignore next 3 - nearly impossible to reproduce */
+            if (result.isFailure()) {
+                return failWithDetail(result.message, 'error');
+            }
+            this._editor = result.value;
+        }
+        return this._editor.clone(value, context).withFailureDetail('error');
+    }
+}
+/**
+ * A {@link PrefixedJsonMap | PrefixedJsonMap} enforces a supplied prefix for all contained values,
+ * optionally adding the prefix as necessary (default `true`).
+ * @public
+ */
+export class PrefixedJsonMap extends SimpleJsonMap {
+    /**
+     * Constructs a new {@link PrefixedJsonMap | PrefixedJsonMap} from the supplied values
+     * @param prefix - A string prefix to be enforced for and added to key names as necessary
+     * @param values - A string-keyed Map or Record of the `JsonValue` to be returned
+     * @param context - Optional {@link IJsonContext | JSON Context} used to format returned values
+     * @param editor - Optional {@link JsonEditor | JsonEditor} used to format returned values
+     * @public
+     */
+    constructor(values, context, options) {
+        super(values, context, options);
+    }
+    static createPrefixed(prefixOptions, values, context, editor) {
+        return captureResult(() => new PrefixedJsonMap(values, context, { keyPolicy: this._toPolicy(prefixOptions), editor }));
+    }
+    /**
+     * Constructs a new {@link PrefixKeyPolicy | PrefixKeyPolicy} from a supplied prefix
+     * or set of {@link IKeyPrefixOptions | prefix options}.
+     * @param prefixOptions - The prefix or {@link IKeyPrefixOptions | prefix options} or options
+     * for the new policy.
+     * @returns A new {@link ReferenceMapKeyPolicy | ReferenceMapKeyPolicy} which enforces the
+     * supplied prefix or options.
+     * @internal
+     */
+    static _toPolicy(prefixOptions) {
+        if (typeof prefixOptions === 'string') {
+            return new PrefixKeyPolicy(prefixOptions, { makeValid: true });
+        }
+        return new PrefixKeyPolicy(prefixOptions.prefix, { makeValid: prefixOptions.addPrefix !== false });
+    }
+}
+//# sourceMappingURL=jsonReferenceMap.js.map

package/dist/packlets/editor/rules/conditional.js

@@ -0,0 +1,163 @@
+/*
+ * 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 { isJsonObject } from '@fgv/ts-json-base';
+import { captureResult, failWithDetail, succeedWithDetail } from '@fgv/ts-utils';
+import { JsonEditorRuleBase } from '../jsonEditorRule';
+/**
+ * The {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule} evaluates
+ * properties with conditional keys, omitting non-matching keys and merging keys that match,
+ * or default keys only if no other keys match.
+ *
+ * The default syntax for a conditional key is:
+ *    "?value1=value2" - matches if value1 and value2 are the same, is ignored otherwise.
+ *    "?value" - matches if value is a non-empty, non-whitespace string. Is ignored otherwise.
+ *    "?default" - matches only if no other conditional blocks in the same object were matched.
+ * @public
+ */
+export class ConditionalJsonEditorRule extends JsonEditorRuleBase {
+    /**
+     * Creates a new {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
+     * @param options - Optional {@link EditorRules.IConditionalJsonRuleOptions | configuration options}
+     * used for this rule.
+     */
+    constructor(options) {
+        super();
+        this._options = options;
+    }
+    /**
+     * Creates a new {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
+     * @param options - Optional {@link EditorRules.IConditionalJsonRuleOptions | configuration options}
+     * used for this rule.
+     */
+    static create(options) {
+        return captureResult(() => new ConditionalJsonEditorRule(options));
+    }
+    /**
+     * Evaluates a property for conditional application.
+     * @param key - The key of the property to be considered
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
+     * @returns Returns `Success` with detail `'deferred'` and a
+     * {@link EditorRules.IConditionalJsonDeferredObject | IConditionalJsonDeferredObject}.
+     * for a matching, default or unconditional key. Returns `Failure` with detail `'ignore'` for
+     * a non-matching conditional, or with detail `'error'` if an error occurs. Otherwise
+     * fails with detail `'inapplicable'`.
+     */
+    editProperty(key, value, state) {
+        var _a;
+        const result = this._tryParseCondition(key, state).onSuccess((deferred) => {
+            if (isJsonObject(value)) {
+                const rtrn = Object.assign(Object.assign({}, deferred), { value });
+                return succeedWithDetail(rtrn, 'deferred');
+            }
+            return failWithDetail(`${key}: conditional body must be object`, 'error');
+        });
+        if (result.isFailure() && result.detail === 'error') {
+            return state.failValidation('invalidPropertyName', result.message, (_a = this._options) === null || _a === void 0 ? void 0 : _a.validation);
+        }
+        return result;
+    }
+    /**
+     * Finalizes any deferred conditional properties. If the only deferred property is
+     * default, that property is emitted. Otherwise all matching properties are emitted.
+     * @param finalized - The deferred properties to be considered for merge.
+     * @param __state - The {@link JsonEditorState | editor state} for the object
+     * being edited.
+     */
+    finalizeProperties(finalized, __state) {
+        let toMerge = finalized;
+        if (finalized.length > 1) {
+            if (finalized.find((o) => o.matchType === 'match') !== undefined) {
+                toMerge = finalized.filter((o) => o.matchType === 'match' || o.matchType === 'unconditional');
+            }
+        }
+        return succeedWithDetail(toMerge.map((o) => o.value).filter(isJsonObject), 'edited');
+    }
+    /**
+     * Determines if a given property key is conditional. Derived classes can override this
+     * method to use a different format for conditional properties.
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
+     * @returns `Success` with detail `'deferred'` and a
+     * {@link EditorRules.IConditionalJsonKeyResult | IConditionalJsonKeyResult} describing the
+     * match for a default or matching conditional property.  Returns `Failure` with detail `'ignore'`
+     * for a non-matching conditional property. Fails with detail `'error'` if an error occurs
+     * or with detail `'inapplicable'` if the key does not represent a conditional property.
+     * @public
+     */
+    _tryParseCondition(key, state) {
+        var _a, _b;
+        if (key.startsWith('?')) {
+            // ignore everything after any #
+            key = key.split('#')[0].trim();
+            if (key === '?default') {
+                return succeedWithDetail({ matchType: 'default' }, 'deferred');
+            }
+            const parts = key.substring(1).split(/(=|>=|<=|>|<|!=)/);
+            if (parts.length === 3) {
+                if (!this._compare(parts[0].trim(), parts[2].trim(), parts[1])) {
+                    return failWithDetail(`Condition ${key} does not match`, 'ignore');
+                }
+                return succeedWithDetail({ matchType: 'match' }, 'deferred');
+            }
+            else if (parts.length === 1) {
+                if (parts[0].trim().length === 0) {
+                    return failWithDetail(`Condition ${key} does not match`, 'ignore');
+                }
+                return succeedWithDetail({ matchType: 'match' }, 'deferred');
+            }
+            const message = `Malformed condition token ${key}`;
+            return state.failValidation('invalidPropertyName', message, (_a = this._options) === null || _a === void 0 ? void 0 : _a.validation);
+        }
+        else if (((_b = this._options) === null || _b === void 0 ? void 0 : _b.flattenUnconditionalValues) !== false && key.startsWith('!')) {
+            return succeedWithDetail({ matchType: 'unconditional' }, 'deferred');
+        }
+        return failWithDetail('inapplicable', 'inapplicable');
+    }
+    /**
+     * Compares two strings using a supplied operator.
+     * @param left - The first string to be compared.
+     * @param right - The second string to be compared.
+     * @param operator - The operator to be applied.
+     * @returns `true` if the condition is met, `false` otherwise.
+     * @internal
+     */
+    _compare(left, right, operator) {
+        switch (operator) {
+            case '=':
+                return left === right;
+            case '>':
+                return left > right;
+            case '<':
+                return left < right;
+            case '>=':
+                return left >= right;
+            case '<=':
+                return left <= right;
+            case '!=':
+                return left !== right;
+        }
+        /* c8 ignore next 2 - unreachable */
+        return false;
+    }
+}
+//# sourceMappingURL=conditional.js.map

package/dist/packlets/editor/rules/index.js

@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+export * from './conditional';
+export * from './multivalue';
+export * from './references';
+export * from './templates';
+//# sourceMappingURL=index.js.map

package/dist/packlets/editor/rules/multivalue.js

@@ -0,0 +1,137 @@
+/*
+ * 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 { allSucceed, captureResult, failWithDetail, succeed, succeedWithDetail } from '@fgv/ts-utils';
+import { JsonEditorRuleBase } from '../jsonEditorRule';
+/**
+ * The {@link EditorRules.MultiValueJsonEditorRule | Multi-Value JSON editor rule}
+ * expands matching keys multiple times, projecting the value into the template
+ * context for any child objects rendered by the rule.
+ *
+ * The default syntax for a multi-value key is:
+ *  "[[var]]=value1,value2,value3"
+ * Where "var" is the name of the variable that will be passed to
+ * child template resolution, and "value1,value2,value3" is a
+ * comma-separated list of values to be expanded.
+ * @public
+ */
+export class MultiValueJsonEditorRule extends JsonEditorRuleBase {
+    /**
+     * Creates a new {@link EditorRules.MultiValueJsonEditorRule | MultiValueJsonEditorRule}.
+     * @param options - Optional {@link IJsonEditorOptions | configuration options}.
+     */
+    constructor(options) {
+        super();
+        this._options = options;
+    }
+    /**
+     * Creates a new {@link EditorRules.MultiValueJsonEditorRule | MultiValueJsonEditorRule}.
+     * @param options - Optional {@link IJsonEditorOptions | configuration options}.
+     */
+    static create(options) {
+        return captureResult(() => new MultiValueJsonEditorRule(options));
+    }
+    /**
+     * Evaluates a property for multi-value expansion.
+     * @param key - The key of the property to be considered
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
+     * @returns `Success` with an object containing the fully-resolved child values to be merged for
+     * matching multi-value property. Returns `Failure` with detail `'error'` if an error occurs or
+     * with detail `'inapplicable'` if the property key is not a conditional property.
+     */
+    editProperty(key, value, state) {
+        const json = {};
+        const result = this._tryParse(key, state).onSuccess((parts) => {
+            return allSucceed(parts.propertyValues.map((pv) => {
+                return this._deriveContext(state, [parts.propertyVariable, pv]).onSuccess((ctx) => {
+                    return state.editor.clone(value, ctx).onSuccess((cloned) => {
+                        json[pv] = cloned;
+                        return succeedWithDetail(cloned);
+                    });
+                });
+            }), json)
+                .onSuccess(() => {
+                if (parts.asArray) {
+                    const arrayRtrn = {};
+                    arrayRtrn[parts.propertyVariable] = Array.from(Object.values(json));
+                    return succeed(arrayRtrn);
+                }
+                return succeed(json);
+            })
+                .withFailureDetail('error');
+        });
+        if (result.isFailure() && result.detail === 'error') {
+            return state.failValidation('invalidPropertyName', result.message);
+        }
+        return result;
+    }
+    /**
+     * Extends the {@link IJsonContext | current context} with a supplied state and values.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
+     * @param values - An array of {@link VariableValue | VariableValue} to be added to the
+     * context.
+     * @returns The extended {@link IJsonContext | context}.
+     * @public
+     */
+    _deriveContext(state, ...values) {
+        var _a;
+        return state.extendContext((_a = this._options) === null || _a === void 0 ? void 0 : _a.context, { vars: values });
+    }
+    /**
+     * Determines if a given property key is multi-value. Derived classes can override this
+     * method to use a different format for multi-value properties.
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
+     * @returns `Success` with detail `'deferred'` and an
+     * {@link EditorRules.IMultiValuePropertyParts | IMultiValuePropertyParts}
+     * describing the match for matching multi-value property.  Returns `Failure` with detail `'error'` if an error occurs
+     * or with detail `'inapplicable'` if the key does not represent a multi-value property.
+     * @public
+     */
+    _tryParse(token, state) {
+        var _a;
+        let parts = [];
+        let asArray = false;
+        if (token.startsWith('[[')) {
+            parts = token.substring(2).split(']]=');
+            asArray = true;
+        }
+        else if (token.startsWith('*')) {
+            parts = token.substring(1).split('=');
+            asArray = false;
+        }
+        else {
+            return failWithDetail(token, 'inapplicable');
+        }
+        if (parts.length !== 2) {
+            const message = `Malformed multi-value property: ${token}`;
+            return state.failValidation('invalidPropertyName', message, (_a = this._options) === null || _a === void 0 ? void 0 : _a.validation);
+        }
+        if (parts[1].includes('{{')) {
+            return failWithDetail('unresolved template', 'inapplicable');
+        }
+        const propertyVariable = parts[0];
+        const propertyValues = parts[1].split(',');
+        return succeedWithDetail({ token, propertyVariable, propertyValues, asArray });
+    }
+}
+//# sourceMappingURL=multivalue.js.map