@fgv/ts-json 5.0.0-2 → 5.0.0-21

package/src/packlets/editor/rules/conditional.ts

@@ -0,0 +1,222 @@
+/*
+ * 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 { JsonObject, JsonValue, isJsonObject } from '@fgv/ts-json-base';
+import { DetailedResult, Result, captureResult, failWithDetail, succeedWithDetail } from '@fgv/ts-utils';
+import { IJsonEditorOptions, JsonEditFailureReason, JsonPropertyEditFailureReason } from '../common';
+import { JsonEditorRuleBase } from '../jsonEditorRule';
+import { JsonEditorState } from '../jsonEditorState';
+
+/**
+ * Returned by {@link EditorRules.ConditionalJsonEditorRule._tryParseCondition | ConditionalJsonEditorRule._tryParseCondition}
+ * to indicate whether a successful match was due to a matching condition or a default value.
+ * @public
+ */
+export interface IConditionalJsonKeyResult extends JsonObject {
+  matchType: 'default' | 'match' | 'unconditional';
+}
+
+/**
+ * On a successful match, the {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}
+ * stores a {@link EditorRules.IConditionalJsonDeferredObject | IConditionalJsonDeferredObject} describing the
+ * matching result, to be resolved at finalization time.
+ * @public
+ */
+export interface IConditionalJsonDeferredObject extends IConditionalJsonKeyResult {
+  value: JsonValue;
+}
+
+/**
+ * Configuration options for the {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
+ * @public
+ */
+export interface IConditionalJsonRuleOptions extends Partial<IJsonEditorOptions> {
+  /**
+   * If true (default) then properties with unconditional names
+   * (which start with !) are flattened.
+   */
+  flattenUnconditionalValues?: boolean;
+}
+
+/**
+ * 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 {
+  /**
+   * Stored fully-resolved {@link EditorRules.IConditionalJsonRuleOptions | options} for this
+   * rule.
+   * @public
+   */
+  protected _options?: IConditionalJsonRuleOptions;
+
+  /**
+   * Creates a new {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
+   * @param options - Optional {@link EditorRules.IConditionalJsonRuleOptions | configuration options}
+   * used for this rule.
+   */
+  public constructor(options?: IConditionalJsonRuleOptions) {
+    super();
+    this._options = options;
+  }
+
+  /**
+   * Creates a new {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
+   * @param options - Optional {@link EditorRules.IConditionalJsonRuleOptions | configuration options}
+   * used for this rule.
+   */
+  public static create(options?: IConditionalJsonRuleOptions): Result<ConditionalJsonEditorRule> {
+    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'`.
+   */
+  public editProperty(
+    key: string,
+    value: JsonValue,
+    state: JsonEditorState
+  ): DetailedResult<JsonObject, JsonPropertyEditFailureReason> {
+    const result = this._tryParseCondition(key, state).onSuccess((deferred) => {
+      if (isJsonObject(value)) {
+        const rtrn: IConditionalJsonDeferredObject = { ...deferred, value };
+        return succeedWithDetail(rtrn, 'deferred');
+      }
+      return failWithDetail<JsonObject, JsonPropertyEditFailureReason>(
+        `${key}: conditional body must be object`,
+        'error'
+      );
+    });
+
+    if (result.isFailure() && result.detail === 'error') {
+      return state.failValidation('invalidPropertyName', result.message, this._options?.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.
+   */
+  public finalizeProperties(
+    finalized: JsonObject[],
+    __state: JsonEditorState
+  ): DetailedResult<JsonObject[], JsonEditFailureReason> {
+    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
+   */
+  protected _tryParseCondition(
+    key: string,
+    state: JsonEditorState
+  ): DetailedResult<IConditionalJsonKeyResult, JsonPropertyEditFailureReason> {
+    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, this._options?.validation);
+    } else if (this._options?.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
+   */
+  protected _compare(left: string, right: string, operator: string): boolean {
+    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;
+  }
+}

package/src/packlets/editor/rules/index.ts

@@ -0,0 +1,25 @@
+/*
+ * 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';

package/src/packlets/editor/rules/multivalue.ts

@@ -0,0 +1,206 @@
+/*
+ * 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 { JsonObject, JsonValue } from '@fgv/ts-json-base';
+import {
+  DetailedResult,
+  Result,
+  allSucceed,
+  captureResult,
+  failWithDetail,
+  succeed,
+  succeedWithDetail
+} from '@fgv/ts-utils';
+import { IJsonContext, VariableValue } from '../../context';
+import { IJsonEditorOptions, JsonEditFailureReason, JsonPropertyEditFailureReason } from '../common';
+
+import { JsonEditorRuleBase } from '../jsonEditorRule';
+import { JsonEditorState } from '../jsonEditorState';
+
+/**
+ * Represents the parts of a multi-value property key.
+ * @public
+ */
+export interface IMultiValuePropertyParts {
+  /**
+   * The original matched token.
+   */
+  readonly token: string;
+
+  /**
+   * The name of the variable used to project each possible
+   * property value into the child values or objects being
+   * resolved.
+   */
+  readonly propertyVariable: string;
+
+  /**
+   * The set of property values to be expanded.
+   */
+  readonly propertyValues: string[];
+
+  /**
+   * If `true`, the resolved values are added as an array
+   * with the name of the {@link EditorRules.IMultiValuePropertyParts.propertyVariable | propertyVariable}.
+   * If false, values are added as individual properties with names that correspond the value.
+   */
+  readonly asArray: boolean;
+}
+
+/**
+ * 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 {
+  /**
+   * Stored fully-resolved {@link IJsonEditorOptions | editor options}
+   * for this rule.
+   * @public
+   */
+  protected _options?: IJsonEditorOptions;
+
+  /**
+   * Creates a new {@link EditorRules.MultiValueJsonEditorRule | MultiValueJsonEditorRule}.
+   * @param options - Optional {@link IJsonEditorOptions | configuration options}.
+   */
+  public constructor(options?: IJsonEditorOptions) {
+    super();
+    this._options = options;
+  }
+
+  /**
+   * Creates a new {@link EditorRules.MultiValueJsonEditorRule | MultiValueJsonEditorRule}.
+   * @param options - Optional {@link IJsonEditorOptions | configuration options}.
+   */
+  public static create(options?: IJsonEditorOptions): Result<MultiValueJsonEditorRule> {
+    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.
+   */
+  public editProperty(
+    key: string,
+    value: JsonValue,
+    state: JsonEditorState
+  ): DetailedResult<JsonObject, JsonPropertyEditFailureReason> {
+    const json: JsonObject = {};
+    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: JsonObject = {};
+            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
+   */
+  protected _deriveContext(
+    state: JsonEditorState,
+    ...values: VariableValue[]
+  ): Result<IJsonContext | undefined> {
+    return state.extendContext(this._options?.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
+   */
+  protected _tryParse(
+    token: string,
+    state: JsonEditorState
+  ): DetailedResult<IMultiValuePropertyParts, JsonEditFailureReason> {
+    let parts: string[] = [];
+    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, this._options?.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 });
+  }
+}

package/src/packlets/editor/rules/references.ts

@@ -0,0 +1,177 @@
+/*
+ * 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 { JsonObject, JsonValue, isJsonObject, pickJsonObject } from '@fgv/ts-json-base';
+import {
+  DetailedResult,
+  Result,
+  captureResult,
+  fail,
+  failWithDetail,
+  succeedWithDetail
+} from '@fgv/ts-utils';
+import { IJsonContext } from '../../context';
+import { IJsonEditorOptions, JsonEditFailureReason, JsonPropertyEditFailureReason } from '../common';
+import { JsonEditorRuleBase } from '../jsonEditorRule';
+import { JsonEditorState } from '../jsonEditorState';
+
+/**
+ * The {@link EditorRules.ReferenceJsonEditorRule | Reference JSON editor rule} replaces property
+ * keys or values that match some known object with a copy of that referenced object, formatted
+ * according to the current context.
+ *
+ * A property key is matched if it matches any known referenced value.
+ * - If the value of the matched key is `'default'`, then the entire object is formatted
+ *   with the current context, flattened and merged into the current object.
+ * - If the value of the matched key is some other string, then the entire
+ *   object is formatted with the current context, and the child of the resulting
+ *   object at the specified path is flattened and merged into the current object.
+ * - If the value of the matched key is an object, then the entire object is
+ *   formatted with the current context extended to include any properties of
+ *   that object, flattened, and merged into the current object.
+ * - It is an error if the referenced value is not an object.
+ *
+ * Any property, array or literal value is matched if it matches any known
+ * value reference. The referenced value is replaced by the referenced
+ * value, formatted using the current editor context.
+ * @public
+ */
+export class ReferenceJsonEditorRule extends JsonEditorRuleBase {
+  /**
+   * Stored fully-resolved {@link IJsonEditorOptions | editor options} for this rule.
+   * @public
+   */
+  protected _options?: IJsonEditorOptions;
+
+  /**
+   * Creates a new {@link EditorRules.ReferenceJsonEditorRule | ReferenceJsonEditorRule}.
+   * @param options - Optional {@link IJsonEditorOptions | configuration options} for this rule.
+   */
+  public constructor(options?: IJsonEditorOptions) {
+    super();
+    this._options = options;
+  }
+
+  /**
+   * Creates a new {@link EditorRules.ReferenceJsonEditorRule | ReferenceJsonEditorRule}.
+   * @param options - Optional {@link IJsonEditorOptions | configuration options} for this rule.
+   */
+  public static create(options?: IJsonEditorOptions): Result<ReferenceJsonEditorRule> {
+    return captureResult(() => new ReferenceJsonEditorRule(options));
+  }
+
+  /**
+   * Evaluates a property for reference 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 If the reference is successful, returns `Success` with a `JsonObject`
+   * to be flattened and merged into the current object. Returns `Failure` with detail `'inapplicable'`
+   * for non-reference keys or with detail `'error'` if an error occurs.
+   */
+  public editProperty(
+    key: string,
+    value: JsonValue,
+    state: JsonEditorState
+  ): DetailedResult<JsonObject, JsonPropertyEditFailureReason> {
+    /* c8 ignore next 2 */
+    const validation = this._options?.validation;
+    const refs = state.getRefs(this._options?.context);
+    if (refs?.has(key)) {
+      // need to apply any rules to the value before we evaluate it
+      const cloneResult = state.editor.clone(value, state.context);
+      if (cloneResult.isSuccess()) {
+        value = cloneResult.value;
+      } else {
+        const message = `${key}: ${cloneResult.message}`;
+        return state.failValidation('invalidPropertyName', message, validation);
+      }
+
+      const contextResult = this._extendContext(state, value);
+      if (contextResult.isSuccess()) {
+        const objResult = refs.getJsonObject(key, contextResult.value);
+        // guarded by the has above so should never happen
+        /* c8 ignore else */
+        if (objResult.isSuccess()) {
+          if (typeof value !== 'string' || value === 'default') {
+            return succeedWithDetail<JsonObject, JsonEditFailureReason>(objResult.value, 'edited');
+          }
+          const pickResult = pickJsonObject(objResult.value, value);
+          if (pickResult.isFailure()) {
+            const message = `${key}: ${pickResult.message}`;
+            return state.failValidation('invalidPropertyName', message, validation);
+          }
+          return pickResult.withDetail('edited');
+        } else if (objResult.detail !== 'unknown') {
+          const message = `${key}: ${objResult.message}`;
+          return state.failValidation('invalidPropertyName', message, validation);
+        }
+      } else {
+        const message = `${key}: ${contextResult.message}`;
+        return state.failValidation('invalidPropertyName', message, validation);
+      }
+    }
+    return failWithDetail('inapplicable', 'inapplicable');
+  }
+
+  /**
+   * Evaluates a property, array or literal value for reference replacement.
+   * @param value - The `JsonValue` of the property to be considered.
+   * @param state - The {@link JsonEditorState | editor state} for the object being edited.
+   */
+  public editValue(
+    value: JsonValue,
+    state: JsonEditorState
+  ): DetailedResult<JsonValue, JsonEditFailureReason> {
+    /* c8 ignore next */
+    const refs = state.getRefs(this._options?.context);
+
+    if (refs && typeof value === 'string') {
+      /* c8 ignore next */
+      const context = state.getContext(this._options?.context);
+      const result = refs.getJsonValue(value, context);
+      if (result.isSuccess()) {
+        return succeedWithDetail(result.value, 'edited');
+      } else if (result.detail === 'error') {
+        return state.failValidation('invalidPropertyValue', result.message, this._options?.validation);
+      }
+    }
+    return failWithDetail('inapplicable', 'inapplicable');
+  }
+
+  /**
+   * Gets the template variables to use given the value of some property whose name matched a
+   * resource plus the base template context.
+   * @param state - The {@link JsonEditorState | editor state} to be extended.
+   * @param supplied - The string or object supplied in the source json.
+   * @internal
+   */
+  protected _extendContext(state: JsonEditorState, supplied: JsonValue): Result<IJsonContext | undefined> {
+    const add: Record<string, unknown> = {};
+    if (isJsonObject(supplied)) {
+      add.vars = Object.entries(supplied);
+    } else if (typeof supplied !== 'string') {
+      return fail(`Invalid template path or context: "${JSON.stringify(supplied)}"`);
+    }
+    return state.extendContext(this._options?.context, add);
+  }
+}