@angular-devkit/core 14.0.0-next.7 → 14.0.0-rc.0

package/src/workspace/json/utilities.js

@@ -7,201 +7,89 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVirtualAstObject = exports.unescapeKey = exports.escapeKey = void 0;
-const stableStringify = require('fast-json-stable-stringify');
-function findNode(parent, p) {
-    if (parent.kind === 'object') {
-        const entry = parent.properties.find((entry) => entry.key.value === p);
-        if (entry) {
-            return { node: entry.value, parent: entry };
+exports.createVirtualAstObject = void 0;
+const json_1 = require("../../json");
+function createVirtualAstObject(root, options = {}) {
+    var _a;
+    const reporter = (path, target, oldValue, newValue) => {
+        if (!options.listener) {
+            return;
         }
-    }
-    else {
-        const index = Number(p);
-        if (!isNaN(index)) {
-            return { node: parent.elements[index], parent };
+        if (oldValue === newValue || JSON.stringify(oldValue) === JSON.stringify(newValue)) {
+            // same value
+            return;
         }
-    }
-    return { parent };
-}
-function createPropertyDescriptor(value) {
-    return {
-        configurable: true,
-        enumerable: true,
-        writable: true,
-        value,
-    };
-}
-function escapeKey(key) {
-    if (typeof key === 'number') {
-        return key;
-    }
-    return key.replace('~', '~0').replace('/', '~1');
-}
-exports.escapeKey = escapeKey;
-function unescapeKey(key) {
-    if (typeof key === 'number') {
-        return key;
-    }
-    return key.replace('~1', '/').replace('~0', '~');
-}
-exports.unescapeKey = unescapeKey;
-function createVirtualAstObject(root, options = {}) {
-    const reporter = (path, parent, node, old, current) => {
-        if (options.listener) {
-            if (old === current || stableStringify(old) === stableStringify(current)) {
-                return;
-            }
-            const op = old === undefined ? 'add' : current === undefined ? 'remove' : 'replace';
-            options.listener(op, path, parent, current);
+        if (Array.isArray(target)) {
+            // For arrays we remove the index and update the entire value as keeping
+            // track of changes by indices can be rather complex.
+            options.listener(path.slice(0, -1), target);
+        }
+        else {
+            options.listener(path, newValue);
         }
     };
-    return create(root, '', reporter, new Set(options.exclude), options.include && options.include.length > 0 ? new Set(options.include) : undefined, options.base);
+    return create(Array.isArray(root) ? [...root] : { ...root }, [], reporter, new Set(options.exclude), ((_a = options.include) === null || _a === void 0 ? void 0 : _a.length) ? new Set(options.include) : undefined);
 }
 exports.createVirtualAstObject = createVirtualAstObject;
-function create(ast, path, reporter, excluded = new Set(), included, base) {
-    const cache = new Map();
-    const alteredNodes = new Set();
-    if (!base) {
-        if (ast.kind === 'object') {
-            base = Object.create(null);
-        }
-        else {
-            base = [];
-            base.length = ast.elements.length;
-        }
-    }
-    return new Proxy(base, {
+function create(obj, path, reporter, excluded = new Set(), included) {
+    return new Proxy(obj, {
         getOwnPropertyDescriptor(target, p) {
-            const descriptor = Reflect.getOwnPropertyDescriptor(target, p);
-            if (descriptor || typeof p === 'symbol') {
-                return descriptor;
-            }
-            else if (excluded.has(p) || (included && !included.has(p))) {
+            if (excluded.has(p) || (included && !included.has(p))) {
                 return undefined;
             }
-            const propertyPath = path + '/' + escapeKey(p);
-            const cacheEntry = cache.get(propertyPath);
-            if (cacheEntry) {
-                if (cacheEntry.value !== undefined) {
-                    return createPropertyDescriptor(cacheEntry.value);
-                }
-                return undefined;
-            }
-            const { node } = findNode(ast, p);
-            if (node) {
-                return createPropertyDescriptor(node.value);
-            }
-            return undefined;
+            return Reflect.getOwnPropertyDescriptor(target, p);
         },
         has(target, p) {
-            if (Reflect.has(target, p)) {
-                return true;
-            }
-            else if (typeof p === 'symbol' || excluded.has(p)) {
+            if (typeof p === 'symbol' || excluded.has(p)) {
                 return false;
             }
-            return cache.has(path + '/' + escapeKey(p)) || findNode(ast, p) !== undefined;
+            return Reflect.has(target, p);
         },
         get(target, p) {
-            if (typeof p === 'symbol' || Reflect.has(target, p)) {
-                return Reflect.get(target, p);
-            }
-            else if (excluded.has(p) || (included && !included.has(p))) {
+            if (excluded.has(p) || (included && !included.has(p))) {
                 return undefined;
             }
-            const propertyPath = path + '/' + escapeKey(p);
-            const cacheEntry = cache.get(propertyPath);
-            if (cacheEntry) {
-                return cacheEntry.value;
+            const value = Reflect.get(target, p);
+            if (typeof p === 'symbol') {
+                return value;
             }
-            const { node, parent } = findNode(ast, p);
-            let value;
-            if (node) {
-                if (node.kind === 'object' || node.kind === 'array') {
-                    value = create(node, propertyPath, (path, parent, vnode, old, current) => {
-                        if (!alteredNodes.has(node)) {
-                            reporter(path, parent, vnode, old, current);
-                        }
-                    });
-                }
-                else {
-                    value = node.value;
-                }
-                cache.set(propertyPath, { node, parent, value });
+            if (((0, json_1.isJsonObject)(value) && !(value instanceof Map)) || Array.isArray(value)) {
+                return create(value, [...path, p], reporter);
+            }
+            else {
+                return value;
             }
-            return value;
         },
         set(target, p, value) {
+            var _a, _b;
+            if (excluded.has(p) || (included && !included.has(p))) {
+                return false;
+            }
             if (value === undefined) {
-                // setting to undefined is equivalent to a delete
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                return this.deleteProperty(target, p);
+                // setting to undefined is equivalent to a delete.
+                return (_b = (_a = this.deleteProperty) === null || _a === void 0 ? void 0 : _a.call(this, target, p)) !== null && _b !== void 0 ? _b : false;
             }
-            if (typeof p === 'symbol' || Reflect.has(target, p)) {
+            if (typeof p === 'symbol') {
                 return Reflect.set(target, p, value);
             }
-            else if (excluded.has(p) || (included && !included.has(p))) {
-                return false;
-            }
-            // TODO: Check if is JSON value
-            const jsonValue = value;
-            const propertyPath = path + '/' + escapeKey(p);
-            const cacheEntry = cache.get(propertyPath);
-            if (cacheEntry) {
-                const oldValue = cacheEntry.value;
-                cacheEntry.value = value;
-                if (cacheEntry.node && oldValue !== value) {
-                    alteredNodes.add(cacheEntry.node);
-                }
-                reporter(propertyPath, cacheEntry.parent, cacheEntry.node, oldValue, jsonValue);
-            }
-            else {
-                const { node, parent } = findNode(ast, p);
-                cache.set(propertyPath, { node, parent, value: value });
-                if (node && node.value !== value) {
-                    alteredNodes.add(node);
-                }
-                reporter(propertyPath, parent, node, node && node.value, value);
+            const existingValue = getCurrentValue(target, p);
+            if (Reflect.set(target, p, value)) {
+                reporter([...path, p], target, existingValue, value);
+                return true;
             }
-            return true;
+            return false;
         },
         deleteProperty(target, p) {
-            if (typeof p === 'symbol' || Reflect.has(target, p)) {
-                return Reflect.deleteProperty(target, p);
-            }
-            else if (excluded.has(p) || (included && !included.has(p))) {
+            if (excluded.has(p)) {
                 return false;
             }
-            const propertyPath = path + '/' + escapeKey(p);
-            const cacheEntry = cache.get(propertyPath);
-            if (cacheEntry) {
-                const oldValue = cacheEntry.value;
-                cacheEntry.value = undefined;
-                if (cacheEntry.node) {
-                    alteredNodes.add(cacheEntry.node);
-                }
-                if (cacheEntry.parent.kind === 'keyvalue') {
-                    // Remove the entire key/value pair from this JSON object
-                    reporter(propertyPath, ast, cacheEntry.node, oldValue, undefined);
-                }
-                else {
-                    reporter(propertyPath, cacheEntry.parent, cacheEntry.node, oldValue, undefined);
-                }
+            if (typeof p === 'symbol') {
+                return Reflect.deleteProperty(target, p);
             }
-            else {
-                const { node, parent } = findNode(ast, p);
-                if (node) {
-                    cache.set(propertyPath, { node, parent, value: undefined });
-                    alteredNodes.add(node);
-                    if (parent.kind === 'keyvalue') {
-                        // Remove the entire key/value pair from this JSON object
-                        reporter(propertyPath, ast, node, node && node.value, undefined);
-                    }
-                    else {
-                        reporter(propertyPath, parent, node, node && node.value, undefined);
-                    }
-                }
+            const existingValue = getCurrentValue(target, p);
+            if (Reflect.deleteProperty(target, p)) {
+                reporter([...path, p], target, existingValue, undefined);
+                return true;
             }
             return true;
         },
@@ -212,22 +100,16 @@ function create(ast, path, reporter, excluded = new Set(), included, base) {
             return false;
         },
         ownKeys(target) {
-            let keys;
-            if (ast.kind === 'object') {
-                keys = ast.properties
-                    .map((entry) => entry.key.value)
-                    .filter((p) => !excluded.has(p) && (!included || included.has(p)));
-            }
-            else {
-                keys = [];
-            }
-            for (const key of cache.keys()) {
-                const relativeKey = key.slice(path.length + 1);
-                if (relativeKey.length > 0 && !relativeKey.includes('/')) {
-                    keys.push(`${unescapeKey(relativeKey)}`);
-                }
-            }
-            return [...new Set([...keys, ...Reflect.ownKeys(target)])];
+            return Reflect.ownKeys(target).filter((p) => !excluded.has(p) && (!included || included.has(p)));
         },
     });
 }
+function getCurrentValue(target, property) {
+    if (Array.isArray(target) && isFinite(+property)) {
+        return target[+property];
+    }
+    if (target && property in target) {
+        return target[property];
+    }
+    return undefined;
+}

package/src/workspace/json/writer.js

@@ -6,24 +6,19 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeJsonWorkspace = void 0;
-const magic_string_1 = __importDefault(require("magic-string"));
+const jsonc_parser_1 = require("jsonc-parser");
 const metadata_1 = require("./metadata");
-const utilities_1 = require("./utilities");
 async function writeJsonWorkspace(workspace, host, path, options = {}) {
     const metadata = workspace[metadata_1.JsonWorkspaceSymbol];
     if (metadata) {
         if (!metadata.hasChanges) {
-            // nothing to do
             return;
         }
         // update existing JSON workspace
         const data = updateJsonWorkspace(metadata);
-        return host.writeFile(path || metadata.filePath, data);
+        return host.writeFile(path !== null && path !== void 0 ? path : metadata.filePath, data);
     }
     else {
         // serialize directly
@@ -91,206 +86,45 @@ function convertJsonTargetCollection(collection) {
     }
     return targets;
 }
-function findFullStart(node, raw) {
-    let i = node.start.offset;
-    while (i > 0 && /\s/.test(raw[i - 1])) {
-        --i;
-    }
-    return i;
-}
-function findFullEnd(node, raw) {
-    let i = node.end.offset;
-    if (i >= raw.length) {
-        return raw.length;
-    }
-    else if (raw[i] === ',') {
-        return i + 1;
-    }
-    while (i > node.start.offset && /\s/.test(raw[i - 1])) {
-        --i;
-    }
-    return i;
-}
-function findPrecedingComma(node, raw) {
-    let i = node.start.offset;
-    if (node.comments && node.comments.length > 0) {
-        i = node.comments[0].start.offset;
-    }
-    while (i > 0 && /\s/.test(raw[i - 1])) {
-        --i;
-    }
-    if (raw[i - 1] === ',') {
-        return i - 1;
-    }
-    return -1;
-}
-function stringify(value, multiline, depth, indent) {
+function normalizeValue(value, type) {
     if (value === undefined) {
-        return '';
-    }
-    if (multiline) {
-        const content = JSON.stringify(value, null, indent);
-        const spacing = '\n' + indent.repeat(depth);
-        return content.replace(/\n/g, spacing);
+        return undefined;
     }
-    else {
-        return JSON.stringify(value);
-    }
-}
-function normalizeValue(value, type) {
     switch (type) {
         case 'project':
             return convertJsonProject(value);
         case 'projectcollection':
             const projects = convertJsonProjectCollection(value);
-            return Object.keys(projects).length === 0 ? undefined : projects;
+            return isEmpty(projects) ? undefined : projects;
         case 'target':
             return convertJsonTarget(value);
         case 'targetcollection':
             const targets = convertJsonTargetCollection(value);
-            return Object.keys(targets).length === 0 ? undefined : targets;
+            return isEmpty(targets) ? undefined : targets;
         default:
             return value;
     }
 }
 function updateJsonWorkspace(metadata) {
-    const data = new magic_string_1.default(metadata.raw);
-    const indent = data.getIndentString();
-    const removedCommas = new Set();
-    const nodeChanges = new Map();
-    for (const { op, path, node, value, type } of metadata.changes) {
-        // targets/projects are typically large objects so always use multiline
-        const multiline = node.start.line !== node.end.line || type !== 'json';
-        const pathSegments = path.split('/');
-        const depth = pathSegments.length - 1; // TODO: more complete analysis
-        const propertyOrIndex = (0, utilities_1.unescapeKey)(pathSegments[depth]);
-        const jsonValue = normalizeValue(value, type);
-        if (op === 'add' && jsonValue === undefined) {
-            continue;
-        }
-        // Track changes to the order/size of any modified objects/arrays
-        let elements = nodeChanges.get(node);
-        if (!elements) {
-            if (node.kind === 'array') {
-                elements = node.elements.slice();
-                nodeChanges.set(node, elements);
-            }
-            else if (node.kind === 'object') {
-                elements = node.properties.slice();
-                nodeChanges.set(node, elements);
-            }
-            else {
-                // keyvalue
-                elements = [];
-            }
-        }
-        switch (op) {
-            case 'add':
-                let contentPrefix = '';
-                if (node.kind === 'object') {
-                    contentPrefix = `"${propertyOrIndex}": `;
-                }
-                const spacing = multiline ? '\n' + indent.repeat(depth) : ' ';
-                const content = spacing + contentPrefix + stringify(jsonValue, multiline, depth, indent);
-                // Additions are handled after analyzing all operations
-                // This is mainly to support array operations which can occur at arbitrary indices
-                if (node.kind === 'object') {
-                    // Object property additions are always added at the end for simplicity
-                    elements.push(content);
-                }
-                else {
-                    // Add place holders if adding an index past the length
-                    // An empty string is an impossible real value
-                    for (let i = elements.length; i < +propertyOrIndex; ++i) {
-                        elements[i] = '';
-                    }
-                    if (elements[+propertyOrIndex] === '') {
-                        elements[+propertyOrIndex] = content;
-                    }
-                    else {
-                        elements.splice(+propertyOrIndex, 0, content);
-                    }
-                }
-                break;
-            case 'remove':
-                let removalIndex = -1;
-                if (node.kind === 'object') {
-                    removalIndex = elements.findIndex((e) => {
-                        return typeof e != 'string' && e.kind === 'keyvalue' && e.key.value === propertyOrIndex;
-                    });
-                }
-                else if (node.kind === 'array') {
-                    removalIndex = +propertyOrIndex;
-                }
-                if (removalIndex === -1) {
-                    continue;
-                }
-                const nodeToRemove = elements[removalIndex];
-                if (typeof nodeToRemove === 'string') {
-                    // synthetic
-                    elements.splice(removalIndex, 1);
-                    continue;
-                }
-                if (elements.length - 1 === removalIndex) {
-                    // If the element is a terminal element remove the otherwise trailing comma
-                    const commaIndex = findPrecedingComma(nodeToRemove, data.original);
-                    if (commaIndex !== -1) {
-                        data.remove(commaIndex, commaIndex + 1);
-                        removedCommas.add(commaIndex);
-                    }
-                }
-                data.remove(findFullStart(nodeToRemove, data.original), findFullEnd(nodeToRemove, data.original));
-                elements.splice(removalIndex, 1);
-                break;
-            case 'replace':
-                let nodeToReplace;
-                if (node.kind === 'keyvalue') {
-                    nodeToReplace = node.value;
-                }
-                else if (node.kind === 'array') {
-                    nodeToReplace = elements[+propertyOrIndex];
-                    if (typeof nodeToReplace === 'string') {
-                        // Was already modified. This is already handled.
-                        continue;
-                    }
-                }
-                else {
-                    continue;
-                }
-                nodeChanges.delete(nodeToReplace);
-                data.overwrite(nodeToReplace.start.offset, nodeToReplace.end.offset, stringify(jsonValue, multiline, depth, indent));
-                break;
+    let { raw: content } = metadata;
+    const { changes, hasLegacyTargetsName } = metadata;
+    for (const { jsonPath, value, type } of changes.values()) {
+        // Determine which key to use if (architect or targets)
+        if (hasLegacyTargetsName && jsonPath[2] === 'targets') {
+            jsonPath[2] = 'architect';
         }
-    }
-    for (const [node, elements] of nodeChanges.entries()) {
-        let parentPoint = 1 + data.original.indexOf(node.kind === 'array' ? '[' : '{', node.start.offset);
-        // Short-circuit for simple case
-        if (elements.length === 1 && typeof elements[0] === 'string') {
-            data.appendRight(parentPoint, elements[0]);
-            continue;
-        }
-        // Combine adjecent element additions to minimize/simplify insertions
-        const optimizedElements = [];
-        for (let i = 0; i < elements.length; ++i) {
-            const element = elements[i];
-            if (typeof element === 'string' && i > 0 && typeof elements[i - 1] === 'string') {
-                optimizedElements[optimizedElements.length - 1] += ',' + element;
-            }
-            else {
-                optimizedElements.push(element);
-            }
-        }
-        let prefixComma = false;
-        for (const element of optimizedElements) {
-            if (typeof element === 'string') {
-                data.appendRight(parentPoint, (prefixComma ? ',' : '') + element);
-            }
-            else {
-                parentPoint = findFullEnd(element, data.original);
-                prefixComma = data.original[parentPoint - 1] !== ',' || removedCommas.has(parentPoint - 1);
-            }
-        }
-    }
-    const result = data.toString();
-    return result;
+        // modify
+        const newJsonPath = jsonPath.map((v) => (isFinite(+v) ? +v : v));
+        // TODO: `modify` re-parses the content every time.
+        // See: https://github.com/microsoft/node-jsonc-parser/blob/35d94cd71bd48f9784453b2439262c938e21d49b/src/impl/edit.ts#L18
+        // Ideally this should accept a string or an AST to avoid the potentially expensive repeat parsing operation.
+        const edits = (0, jsonc_parser_1.modify)(content, newJsonPath, normalizeValue(value, type), {
+            formattingOptions: {
+                insertSpaces: true,
+                tabSize: 2,
+            },
+        });
+        content = (0, jsonc_parser_1.applyEdits)(content, edits);
+    }
+    return content;
 }

package/src/json/parser.d.ts

@@ -1,104 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { BaseException } from '../exception';
-import { JsonAstNode, Position } from './parser_ast';
-import { JsonValue } from './utils';
-export declare class JsonException extends BaseException {
-}
-/**
- * A character was invalid in this context.
- * @deprecated
- * @private
- */
-export declare class InvalidJsonCharacterException extends JsonException {
-    invalidChar: string;
-    line: number;
-    character: number;
-    offset: number;
-    constructor(context: JsonParserContext);
-}
-/**
- * More input was expected, but we reached the end of the stream.
- * @deprecated
- * @private
- */
-export declare class UnexpectedEndOfInputException extends JsonException {
-    constructor(_context: JsonParserContext);
-}
-/**
- * An error happened within a file.
- * @deprecated Deprecated since version 11. Use 3rd party JSON parsers such as `jsonc-parser` instead.
- */
-export declare class PathSpecificJsonException extends JsonException {
-    path: string;
-    exception: JsonException;
-    constructor(path: string, exception: JsonException);
-}
-/**
- * Context passed around the parser with information about where we currently are in the parse.
- * @deprecated Deprecated since version 11. Use 3rd party JSON parsers such as `jsonc-parser` instead.
- */
-export interface JsonParserContext {
-    position: Position;
-    previous: Position;
-    readonly original: string;
-    readonly mode: JsonParseMode;
-}
-/**
- * The Parse mode used for parsing the JSON string.
- */
-export declare enum JsonParseMode {
-    Strict = 0,
-    CommentsAllowed = 1,
-    SingleQuotesAllowed = 2,
-    IdentifierKeyNamesAllowed = 4,
-    TrailingCommasAllowed = 8,
-    HexadecimalNumberAllowed = 16,
-    MultiLineStringAllowed = 32,
-    LaxNumberParsingAllowed = 64,
-    NumberConstantsAllowed = 128,
-    Default = 0,
-    Loose = 255,
-    Json = 0,
-    Json5 = 255
-}
-/**
- * Parse the JSON string and return its AST. The AST may be losing data (end comments are
- * discarded for example, and space characters are not represented in the AST), but all values
- * will have a single node in the AST (a 1-to-1 mapping).
- *
- * @deprecated Deprecated since version 11. Use 3rd party JSON parsers such as `jsonc-parser` instead.
- * @param input The string to use.
- * @param mode The mode to parse the input with. {@see JsonParseMode}.
- * @returns {JsonAstNode} The root node of the value of the AST.
- */
-export declare function parseJsonAst(input: string, mode?: JsonParseMode): JsonAstNode;
-/**
- * Options for the parseJson() function.
- * @deprecated Deprecated since version 11. Use 3rd party JSON parsers such as `jsonc-parser` instead.
- */
-export interface ParseJsonOptions {
-    /**
-     * If omitted, will only emit errors related to the content of the JSON. If specified, any
-     * JSON errors will also include the path of the file that caused the error.
-     */
-    path?: string;
-}
-/**
- * Parse a JSON string into its value.  This discards the AST and only returns the value itself.
- *
- * If a path option is pass, it also absorbs JSON parsing errors and return a new error with the
- * path in it. Useful for showing errors when parsing from a file.
- *
- * @deprecated Deprecated since version 11. Use 3rd party JSON parsers such as `jsonc-parser` instead.
- * @param input The string to parse.
- * @param mode The mode to parse the input with. {@see JsonParseMode}.
- * @param options Additional optinos for parsing.
- * @returns {JsonValue} The value represented by the JSON string.
- */
-export declare function parseJson(input: string, mode?: JsonParseMode, options?: ParseJsonOptions): JsonValue;