@fgv/ts-json 5.0.1-9 → 5.0.1

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

@@ -0,0 +1,155 @@
+/*
+ * 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, pickJsonObject } from '@fgv/ts-json-base';
+import { captureResult, fail, failWithDetail, succeedWithDetail } from '@fgv/ts-utils';
+import { JsonEditorRuleBase } from '../jsonEditorRule';
+/**
+ * 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 {
+    /**
+     * Creates a new {@link EditorRules.ReferenceJsonEditorRule | ReferenceJsonEditorRule}.
+     * @param options - Optional {@link IJsonEditorOptions | configuration options} for this rule.
+     */
+    constructor(options) {
+        super();
+        this._options = options;
+    }
+    /**
+     * Creates a new {@link EditorRules.ReferenceJsonEditorRule | ReferenceJsonEditorRule}.
+     * @param options - Optional {@link IJsonEditorOptions | configuration options} for this rule.
+     */
+    static create(options) {
+        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.
+     */
+    editProperty(key, value, state) {
+        var _a, _b;
+        /* c8 ignore next 2 */
+        const validation = (_a = this._options) === null || _a === void 0 ? void 0 : _a.validation;
+        const refs = state.getRefs((_b = this._options) === null || _b === void 0 ? void 0 : _b.context);
+        if (refs === null || refs === void 0 ? void 0 : 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(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.
+     */
+    editValue(value, state) {
+        var _a, _b, _c;
+        /* c8 ignore next */
+        const refs = state.getRefs((_a = this._options) === null || _a === void 0 ? void 0 : _a.context);
+        if (refs && typeof value === 'string') {
+            /* c8 ignore next */
+            const context = state.getContext((_b = this._options) === null || _b === void 0 ? void 0 : _b.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, (_c = this._options) === null || _c === void 0 ? void 0 : _c.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
+     */
+    _extendContext(state, supplied) {
+        var _a;
+        const add = {};
+        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((_a = this._options) === null || _a === void 0 ? void 0 : _a.context, add);
+    }
+}
+//# sourceMappingURL=references.js.map

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

@@ -0,0 +1,121 @@
+/*
+ * 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, failWithDetail, succeedWithDetail } from '@fgv/ts-utils';
+import { JsonEditorRuleBase } from '../jsonEditorRule';
+import Mustache from 'mustache';
+/**
+ * The {@link EditorRules.TemplatedJsonEditorRule | Templated JSON editor rule} applies mustache rendering as
+ * appropriate to any keys or values in the object being edited.
+ * @public
+ */
+export class TemplatedJsonEditorRule extends JsonEditorRuleBase {
+    /**
+     * Creates a new {@link EditorRules.TemplatedJsonEditorRule | TemplatedJsonEditorRule}.
+     * @param options - Optional {@link EditorRules.ITemplatedJsonRuleOptions | configuration options}
+     * for this rule.
+     */
+    constructor(options) {
+        super();
+        this._options = options;
+    }
+    /**
+     * Creates a new {@link EditorRules.TemplatedJsonEditorRule | TemplatedJsonEditorRule}.
+     * @param options - Optional {@link EditorRules.ITemplatedJsonRuleOptions | configuration options}
+     * for this rule.
+     */
+    static create(options) {
+        return captureResult(() => new TemplatedJsonEditorRule(options));
+    }
+    /**
+     * Evaluates a property name for template rendering.
+     * @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 detail `'edited'` and an `JsonObject` to
+     * be flattened and merged if the key contained a template. Returns `Failure` with detail `'error'`
+     * if an error occurred or with detail `'inapplicable'` if the property key does not contain
+     * a template or if name rendering is disabled.
+     */
+    editProperty(key, value, state) {
+        var _a, _b;
+        /* c8 ignore next 2 */
+        const validation = (_a = this._options) === null || _a === void 0 ? void 0 : _a.validation;
+        const useNameTemplates = ((_b = this._options) === null || _b === void 0 ? void 0 : _b.useNameTemplates) !== false;
+        if (useNameTemplates !== false) {
+            const result = this._render(key, state).onSuccess((newKey) => {
+                if (newKey.length < 1) {
+                    return state.failValidation('invalidPropertyName', `Template "${key}" renders empty name.`);
+                }
+                const rtrn = {};
+                rtrn[newKey] = value;
+                return succeedWithDetail(rtrn, 'edited');
+            });
+            if (result.isFailure() && result.detail === 'error') {
+                const message = `Cannot render name ${key}: ${result.message}`;
+                return state.failValidation('invalidPropertyName', message, validation);
+            }
+            return result;
+        }
+        return failWithDetail('inapplicable', 'inapplicable');
+    }
+    /**
+     * Evaluates a property, array or literal value for template rendering.
+     * @param value - The `JsonValue` to be edited.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
+     * @returns `Success` with detail `'edited'` if the value contained a template and was edited.
+     * Returns `Failure` with `'ignore'` if the rendered value should be ignored, with `'error'` if
+     * an error occurs, or with `'inapplicable'` if the value was not a string with a template.
+     */
+    editValue(value, state) {
+        var _a, _b;
+        if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.useValueTemplates) !== false && typeof value === 'string' && value.includes('{{')) {
+            const renderResult = this._render(value, state).onSuccess((newValue) => {
+                return succeedWithDetail(newValue, 'edited');
+            });
+            if (renderResult.isFailure() && renderResult.detail === 'error') {
+                const message = `Cannot render value: ${renderResult.message}`;
+                /* c8 ignore next */
+                return state.failValidation('invalidPropertyValue', message, (_b = this._options) === null || _b === void 0 ? void 0 : _b.validation);
+            }
+            return renderResult;
+        }
+        return failWithDetail('inapplicable', 'inapplicable');
+    }
+    /**
+     * Renders a single template string for a supplied {@link JsonEditorState | editor state}.
+     * @param template - The mustache template to be rendered.
+     * @param state - The {@link JsonEditorState | editor state} used to render the template.
+     * @returns `Success` if the template is rendered.  Returns `Failure` with detail `'error'` if the
+     * template could not be rendered (e.g. due to syntax errors) or with detail `'inapplicable'` if the
+     * string is not a template.
+     * @internal
+     */
+    _render(template, state) {
+        var _a;
+        const vars = state.getVars((_a = this._options) === null || _a === void 0 ? void 0 : _a.context);
+        if (vars && template.includes('{{')) {
+            return captureResult(() => Mustache.render(template, vars)).withDetail('error', 'edited');
+        }
+        return failWithDetail('inapplicable', 'inapplicable');
+    }
+}
+//# sourceMappingURL=templates.js.map

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.53.3"
+      "packageVersion": "7.54.0"
     }
   ]
 }

package/lib/index.browser.d.ts

@@ -0,0 +1,2 @@
+export * from './index';
+//# sourceMappingURL=index.browser.d.ts.map

package/lib/index.browser.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+ * Copyright (c) 2023 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Browser entry point - re-exports everything from main index
+__exportStar(require("./index"), exports);
+//# sourceMappingURL=index.browser.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fgv/ts-json",
-  "version": "5.0.1-9",
+  "version": "5.0.1",
   "description": "Typescript utilities for working with JSON",
   "main": "lib/index.js",
   "types": "dist/ts-json.d.ts",
@@ -41,14 +41,29 @@
     "@rushstack/eslint-config": "4.5.3",
     "eslint-plugin-tsdoc": "~0.4.0",
     "@rushstack/heft-jest-plugin": "1.1.3",
-    "@fgv/ts-utils": "5.0.1-9",
-    "@fgv/ts-utils-jest": "5.0.1-9",
-    "@fgv/ts-json-base": "5.0.1-9"
+    "@microsoft/api-extractor": "^7.53.3",
+    "@fgv/heft-dual-rig": "0.1.0",
+    "@fgv/ts-utils": "5.0.1",
+    "@fgv/ts-json-base": "5.0.1",
+    "@fgv/ts-utils-jest": "5.0.1"
   },
   "peerDependencies": {
     "mustache": "^4.2.0",
-    "@fgv/ts-json-base": "5.0.1-9",
-    "@fgv/ts-utils": "5.0.1-9"
+    "@fgv/ts-utils": "5.0.1",
+    "@fgv/ts-json-base": "5.0.1"
+  },
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./lib/index.js",
+        "require": "./lib/index.js"
+      },
+      "default": {
+        "import": "./lib/index.browser.js",
+        "require": "./lib/index.browser.js"
+      },
+      "types": "dist/ts-json.d.ts"
+    }
   },
   "scripts": {
     "build": "heft build --clean",