@angular-devkit/core 14.0.0-next.1 → 14.0.0-next.12

package/src/virtual-fs/path.js

@@ -61,7 +61,7 @@ function extname(path) {
         return '';
     }
     else {
-        return base.substr(i);
+        return base.slice(i);
     }
 }
 exports.extname = extname;
@@ -74,7 +74,7 @@ function basename(path) {
         return fragment(path);
     }
     else {
-        return fragment(path.substr(path.lastIndexOf(exports.NormalizedSep) + 1));
+        return fragment(path.slice(path.lastIndexOf(exports.NormalizedSep) + 1));
     }
 }
 exports.basename = basename;
@@ -87,7 +87,7 @@ function dirname(path) {
         return '';
     }
     const endIndex = index === 0 ? 1 : index; // case of file under root: '/file'
-    return normalize(path.substr(0, endIndex));
+    return normalize(path.slice(0, endIndex));
 }
 exports.dirname = dirname;
 /**
@@ -214,7 +214,7 @@ function noCacheNormalize(path) {
     // Match absolute windows path.
     const original = path;
     if (path.match(/^[A-Z]:[/\\]/i)) {
-        path = '\\' + path[0] + '\\' + path.substr(3);
+        path = '\\' + path[0] + '\\' + path.slice(3);
     }
     // We convert Windows paths as well here.
     const p = path.split(/[/\\]/g);

package/src/workspace/definitions.d.ts

@@ -23,7 +23,7 @@ export interface TargetDefinition {
     defaultConfiguration?: string;
     builder: string;
 }
-export declare type DefinitionCollectionListener<V extends object> = (name: string, action: 'add' | 'remove' | 'replace', newValue: V | undefined, oldValue: V | undefined, collection: DefinitionCollection<V>) => void;
+export declare type DefinitionCollectionListener<V extends object> = (name: string, newValue: V | undefined, collection: DefinitionCollection<V>) => void;
 declare class DefinitionCollection<V extends object> implements ReadonlyMap<string, V> {
     private _listener?;
     private _map;

package/src/workspace/definitions.js

@@ -14,18 +14,19 @@ class DefinitionCollection {
         this._map = new Map(initial && Object.entries(initial));
     }
     delete(key) {
-        const value = this._map.get(key);
+        var _a;
         const result = this._map.delete(key);
-        if (result && value !== undefined && this._listener) {
-            this._listener(key, 'remove', undefined, value, this);
+        if (result) {
+            (_a = this._listener) === null || _a === void 0 ? void 0 : _a.call(this, key, undefined, this);
         }
         return result;
     }
     set(key, value) {
-        const existing = this.get(key);
-        this._map.set(key, value);
-        if (this._listener) {
-            this._listener(key, existing !== undefined ? 'replace' : 'add', value, existing, this);
+        var _a;
+        const updatedValue = value !== this.get(key);
+        if (updatedValue) {
+            this._map.set(key, value);
+            (_a = this._listener) === null || _a === void 0 ? void 0 : _a.call(this, key, value, this);
         }
         return this;
     }

package/src/workspace/index.js

@@ -8,7 +8,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];

package/src/workspace/json/metadata.d.ts

@@ -5,8 +5,8 @@
  * 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 { JSONPath, Node } from 'jsonc-parser';
 import { JsonValue } from '../../json';
-import { JsonAstArray, JsonAstKeyValue, JsonAstNode, JsonAstObject } from '../../json/parser_ast';
 import { ProjectDefinition, TargetDefinition, WorkspaceDefinition } from '../definitions';
 export declare const JsonWorkspaceSymbol: unique symbol;
 export interface JsonWorkspaceDefinition extends WorkspaceDefinition {
@@ -19,23 +19,22 @@ interface ChangeValues {
     projectcollection: Iterable<[string, ProjectDefinition]>;
     targetcollection: Iterable<[string, TargetDefinition]>;
 }
-export interface JsonChange<T extends keyof ChangeValues = keyof ChangeValues> {
-    op: T extends 'json' | 'project' | 'target' ? 'add' | 'remove' | 'replace' : 'add';
-    path: string;
-    node: JsonAstNode | JsonAstKeyValue;
-    value?: ChangeValues[T];
-    type: T;
+export interface JsonChange {
+    value?: unknown;
+    type?: keyof ChangeValues;
+    jsonPath: string[];
 }
 export declare class JsonWorkspaceMetadata {
     readonly filePath: string;
-    readonly ast: JsonAstObject;
+    private readonly ast;
     readonly raw: string;
-    readonly changes: JsonChange[];
-    constructor(filePath: string, ast: JsonAstObject, raw: string);
+    readonly changes: Map<string, JsonChange>;
+    hasLegacyTargetsName: boolean;
+    constructor(filePath: string, ast: Node, raw: string);
     get hasChanges(): boolean;
     get changeCount(): number;
-    findChangesForPath(path: string): JsonChange[];
-    addChange<T extends keyof ChangeValues = keyof ChangeValues>(op: 'add' | 'remove' | 'replace', path: string, node: JsonAstArray | JsonAstObject | JsonAstKeyValue, value?: ChangeValues[T], type?: T): void;
-    reset(): void;
+    getNodeValueFromAst(path: JSONPath): unknown;
+    findChangesForPath(path: string): JsonChange | undefined;
+    addChange<T extends keyof ChangeValues = keyof ChangeValues>(jsonPath: string[], value: ChangeValues[T] | undefined, type?: T): void;
 }
 export {};

package/src/workspace/json/metadata.js

@@ -8,40 +8,49 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonWorkspaceMetadata = exports.JsonWorkspaceSymbol = void 0;
+const jsonc_parser_1 = require("jsonc-parser");
 exports.JsonWorkspaceSymbol = Symbol.for('@angular/core:workspace-json');
+function escapeKey(key) {
+    return key.replace('~', '~0').replace('/', '~1');
+}
 class JsonWorkspaceMetadata {
     constructor(filePath, ast, raw) {
         this.filePath = filePath;
         this.ast = ast;
         this.raw = raw;
-        this.changes = [];
+        this.changes = new Map();
+        this.hasLegacyTargetsName = true;
     }
     get hasChanges() {
-        return this.changes.length > 0;
+        return this.changes.size > 0;
     }
     get changeCount() {
-        return this.changes.length;
+        return this.changes.size;
+    }
+    getNodeValueFromAst(path) {
+        const node = (0, jsonc_parser_1.findNodeAtLocation)(this.ast, path);
+        return node && (0, jsonc_parser_1.getNodeValue)(node);
     }
     findChangesForPath(path) {
-        return this.changes.filter((c) => c.path === path);
+        return this.changes.get(path);
     }
-    addChange(op, path, node, value, type) {
-        // Remove redundant operations
-        if (op === 'remove' || op === 'replace') {
-            for (let i = this.changes.length - 1; i >= 0; --i) {
-                const currentPath = this.changes[i].path;
-                if (currentPath === path || currentPath.startsWith(path + '/')) {
-                    if (op === 'replace' && currentPath === path && this.changes[i].op === 'add') {
-                        op = 'add';
-                    }
-                    this.changes.splice(i, 1);
-                }
+    addChange(jsonPath, value, type) {
+        let currentPath = '';
+        for (let index = 0; index < jsonPath.length - 1; index++) {
+            currentPath = currentPath + '/' + escapeKey(jsonPath[index]);
+            if (this.changes.has(currentPath)) {
+                // Ignore changes on children as parent is updated.
+                return;
             }
         }
-        this.changes.push({ op, path, node, value, type: op === 'remove' || !type ? 'json' : type });
-    }
-    reset() {
-        this.changes.length = 0;
+        const pathKey = '/' + jsonPath.map((k) => escapeKey(k)).join('/');
+        for (const key of this.changes.keys()) {
+            if (key.startsWith(pathKey + '/')) {
+                // changes on the same or child paths are redundant.
+                this.changes.delete(key);
+            }
+        }
+        this.changes.set(pathKey, { jsonPath, type, value });
     }
 }
 exports.JsonWorkspaceMetadata = JsonWorkspaceMetadata;

package/src/workspace/json/reader.js

@@ -8,7 +8,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readJsonWorkspace = void 0;
-const parser_1 = require("../../json/parser");
+const jsonc_parser_1 = require("jsonc-parser");
+const utils_1 = require("../../json/utils");
 const definitions_1 = require("../definitions");
 const metadata_1 = require("./metadata");
 const utilities_1 = require("./utilities");
@@ -17,18 +18,18 @@ async function readJsonWorkspace(path, host) {
     if (raw === undefined) {
         throw new Error('Unable to read workspace file.');
     }
-    const ast = (0, parser_1.parseJsonAst)(raw, parser_1.JsonParseMode.Loose);
-    if (ast.kind !== 'object') {
+    const ast = (0, jsonc_parser_1.parseTree)(raw, undefined, { allowTrailingComma: true, disallowComments: false });
+    if ((ast === null || ast === void 0 ? void 0 : ast.type) !== 'object' || !ast.children) {
         throw new Error('Invalid workspace file - expected JSON object.');
     }
     // Version check
-    const versionNode = ast.properties.find((pair) => pair.key.value === 'version');
+    const versionNode = (0, jsonc_parser_1.findNodeAtLocation)(ast, ['version']);
     if (!versionNode) {
         throw new Error('Unknown format - version specifier not found.');
     }
-    const formatVersion = versionNode.value.value;
-    if (formatVersion !== 1) {
-        throw new Error(`Invalid format version detected - Expected:[ 1 ] Found: [ ${formatVersion} ]`);
+    const version = versionNode.value;
+    if (version !== 1) {
+        throw new Error(`Invalid format version detected - Expected:[ 1 ] Found: [ ${version} ]`);
     }
     const context = {
         host,
@@ -51,38 +52,38 @@ const specialProjectExtensions = ['cli', 'schematics', 'projectType'];
 function parseWorkspace(workspaceNode, context) {
     const jsonMetadata = context.metadata;
     let projects;
-    let projectsNode;
     let extensions;
     if (!context.trackChanges) {
         extensions = Object.create(null);
     }
-    for (const { key, value } of workspaceNode.properties) {
-        const name = key.value;
+    // TODO: `getNodeValue` - looks potentially expensive since it walks the whole tree and instantiates the full object structure each time.
+    // Might be something to look at moving forward to optimize.
+    const workspaceNodeValue = (0, jsonc_parser_1.getNodeValue)(workspaceNode);
+    for (const [name, value] of Object.entries(workspaceNodeValue)) {
         if (name === '$schema' || name === 'version') {
             // skip
         }
         else if (name === 'projects') {
-            if (value.kind !== 'object') {
+            const nodes = (0, jsonc_parser_1.findNodeAtLocation)(workspaceNode, ['projects']);
+            if (!(0, utils_1.isJsonObject)(value) || !nodes) {
                 context.error('Invalid "projects" field found; expected an object.', value);
                 continue;
             }
-            projectsNode = value;
-            projects = parseProjectsObject(value, context);
+            projects = parseProjectsObject(nodes, context);
         }
         else {
             if (!specialWorkspaceExtensions.includes(name) && !/^[a-z]{1,3}-.*/.test(name)) {
-                context.warn(`Project extension with invalid name found.`, key);
+                context.warn(`Project extension with invalid name found.`, name);
             }
             if (extensions) {
-                extensions[name] = value.value;
+                extensions[name] = value;
             }
         }
     }
     let collectionListener;
-    if (context.trackChanges && projectsNode) {
-        const parentNode = projectsNode;
-        collectionListener = (name, action, newValue) => {
-            jsonMetadata.addChange(action, `/projects/${(0, utilities_1.escapeKey)(name)}`, parentNode, newValue, 'project');
+    if (context.trackChanges) {
+        collectionListener = (name, newValue) => {
+            jsonMetadata.addChange(['projects', name], newValue, 'project');
         };
     }
     const projectCollection = new definitions_1.ProjectDefinitionCollection(projects, collectionListener);
@@ -91,31 +92,30 @@ function parseWorkspace(workspaceNode, context) {
         projects: projectCollection,
         // If not tracking changes the `extensions` variable will contain the parsed
         // values.  Otherwise the extensions are tracked via a virtual AST object.
-        extensions: extensions ||
-            (0, utilities_1.createVirtualAstObject)(workspaceNode, {
-                exclude: ['$schema', 'version', 'projects'],
-                listener(op, path, node, value) {
-                    jsonMetadata.addChange(op, path, node, value);
-                },
-            }),
+        extensions: extensions !== null && extensions !== void 0 ? extensions : (0, utilities_1.createVirtualAstObject)(workspaceNodeValue, {
+            exclude: ['$schema', 'version', 'projects'],
+            listener(path, value) {
+                jsonMetadata.addChange(path, value);
+            },
+        }),
     };
 }
 function parseProjectsObject(projectsNode, context) {
     const projects = Object.create(null);
-    for (const { key, value } of projectsNode.properties) {
-        if (value.kind !== 'object') {
+    for (const [name, value] of Object.entries((0, jsonc_parser_1.getNodeValue)(projectsNode))) {
+        const nodes = (0, jsonc_parser_1.findNodeAtLocation)(projectsNode, [name]);
+        if (!(0, utils_1.isJsonObject)(value) || !nodes) {
             context.warn('Skipping invalid project value; expected an object.', value);
             continue;
         }
-        const name = key.value;
-        projects[name] = parseProject(name, value, context);
+        projects[name] = parseProject(name, nodes, context);
     }
     return projects;
 }
 function parseProject(projectName, projectNode, context) {
     const jsonMetadata = context.metadata;
     let targets;
-    let targetsNode;
+    let hasTargets = false;
     let extensions;
     let properties;
     if (!context.trackChanges) {
@@ -123,106 +123,91 @@ function parseProject(projectName, projectNode, context) {
         extensions = Object.create(null);
         properties = Object.create(null);
     }
-    for (const { key, value } of projectNode.properties) {
-        const name = key.value;
+    const projectNodeValue = (0, jsonc_parser_1.getNodeValue)(projectNode);
+    for (const [name, value] of Object.entries(projectNodeValue)) {
         switch (name) {
             case 'targets':
             case 'architect':
-                if (value.kind !== 'object') {
+                const nodes = (0, jsonc_parser_1.findNodeAtLocation)(projectNode, [name]);
+                if (!(0, utils_1.isJsonObject)(value) || !nodes) {
                     context.error(`Invalid "${name}" field found; expected an object.`, value);
                     break;
                 }
-                targetsNode = value;
-                targets = parseTargetsObject(projectName, value, context);
+                hasTargets = true;
+                targets = parseTargetsObject(projectName, nodes, context);
+                jsonMetadata.hasLegacyTargetsName = name === 'architect';
                 break;
             case 'prefix':
             case 'root':
             case 'sourceRoot':
-                if (value.kind !== 'string') {
+                if (typeof value !== 'string') {
                     context.warn(`Project property "${name}" should be a string.`, value);
                 }
                 if (properties) {
-                    properties[name] = value.value;
+                    properties[name] = value;
                 }
                 break;
             default:
                 if (!specialProjectExtensions.includes(name) && !/^[a-z]{1,3}-.*/.test(name)) {
-                    context.warn(`Project extension with invalid name found.`, key);
+                    context.warn(`Project extension with invalid name found.`, name);
                 }
                 if (extensions) {
-                    extensions[name] = value.value;
+                    extensions[name] = value;
                 }
                 break;
         }
     }
     let collectionListener;
     if (context.trackChanges) {
-        if (targetsNode) {
-            const parentNode = targetsNode;
-            collectionListener = (name, action, newValue) => {
-                jsonMetadata.addChange(action, `/projects/${projectName}/targets/${(0, utilities_1.escapeKey)(name)}`, parentNode, newValue, 'target');
-            };
-        }
-        else {
-            let added = false;
-            collectionListener = (_name, action, _new, _old, collection) => {
-                if (added || action !== 'add') {
-                    return;
-                }
-                jsonMetadata.addChange('add', `/projects/${projectName}/targets`, projectNode, collection, 'targetcollection');
-                added = true;
-            };
-        }
+        collectionListener = (name, newValue, collection) => {
+            if (hasTargets) {
+                jsonMetadata.addChange(['projects', projectName, 'targets', name], newValue, 'target');
+            }
+            else {
+                jsonMetadata.addChange(['projects', projectName, 'targets'], collection, 'targetcollection');
+            }
+        };
     }
     const base = {
         targets: new definitions_1.TargetDefinitionCollection(targets, collectionListener),
         // If not tracking changes the `extensions` variable will contain the parsed
         // values.  Otherwise the extensions are tracked via a virtual AST object.
-        extensions: extensions ||
-            (0, utilities_1.createVirtualAstObject)(projectNode, {
-                exclude: ['architect', 'prefix', 'root', 'sourceRoot', 'targets'],
-                listener(op, path, node, value) {
-                    jsonMetadata.addChange(op, `/projects/${projectName}${path}`, node, value);
-                },
-            }),
-    };
-    let project;
-    if (context.trackChanges) {
-        project = (0, utilities_1.createVirtualAstObject)(projectNode, {
-            base,
-            include: ['prefix', 'root', 'sourceRoot'],
-            listener(op, path, node, value) {
-                jsonMetadata.addChange(op, `/projects/${projectName}${path}`, node, value);
+        extensions: extensions !== null && extensions !== void 0 ? extensions : (0, utilities_1.createVirtualAstObject)(projectNodeValue, {
+            exclude: ['architect', 'prefix', 'root', 'sourceRoot', 'targets'],
+            listener(path, value) {
+                jsonMetadata.addChange(['projects', projectName, ...path], value);
             },
-        });
-    }
-    else {
-        project = {
-            ...base,
-            ...properties,
-        };
-    }
-    return project;
+        }),
+    };
+    const baseKeys = new Set(Object.keys(base));
+    const project = properties !== null && properties !== void 0 ? properties : (0, utilities_1.createVirtualAstObject)(projectNodeValue, {
+        include: ['prefix', 'root', 'sourceRoot', ...baseKeys],
+        listener(path, value) {
+            if (!baseKeys.has(path[0])) {
+                jsonMetadata.addChange(['projects', projectName, ...path], value);
+            }
+        },
+    });
+    return Object.assign(project, base);
 }
 function parseTargetsObject(projectName, targetsNode, context) {
     const jsonMetadata = context.metadata;
     const targets = Object.create(null);
-    for (const { key, value } of targetsNode.properties) {
-        if (value.kind !== 'object') {
+    for (const [name, value] of Object.entries((0, jsonc_parser_1.getNodeValue)(targetsNode))) {
+        if (!(0, utils_1.isJsonObject)(value)) {
             context.warn('Skipping invalid target value; expected an object.', value);
             continue;
         }
-        const name = key.value;
         if (context.trackChanges) {
             targets[name] = (0, utilities_1.createVirtualAstObject)(value, {
                 include: ['builder', 'options', 'configurations', 'defaultConfiguration'],
-                listener(op, path, node, value) {
-                    jsonMetadata.addChange(op, `/projects/${projectName}/targets/${name}${path}`, node, value);
+                listener(path, value) {
+                    jsonMetadata.addChange(['projects', projectName, 'targets', name, ...path], value);
                 },
             });
         }
         else {
-            targets[name] = value.value;
+            targets[name] = value;
         }
     }
     return targets;

package/src/workspace/json/utilities.d.ts

@@ -5,14 +5,10 @@
  * 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 { JsonObject, JsonValue } from '../../json';
-import { JsonAstArray, JsonAstKeyValue, JsonAstObject } from '../../json/parser_ast';
-export declare type ChangeListener = (op: 'add' | 'remove' | 'replace', path: string, node: JsonAstArray | JsonAstObject | JsonAstKeyValue, value?: JsonValue) => void;
-export declare function escapeKey(key: string | number): string | number;
-export declare function unescapeKey(key: string | number): string | number;
-export declare function createVirtualAstObject<T extends object = JsonObject>(root: JsonAstObject, options?: {
+import { JsonArray, JsonObject, JsonValue } from '../../json';
+export declare type ChangeListener = (path: string[], newValue: JsonValue | undefined) => void;
+export declare function createVirtualAstObject<T extends object = JsonObject>(root: JsonObject | JsonArray, options?: {
     exclude?: string[];
     include?: string[];
     listener?: ChangeListener;
-    base?: object;
 }): T;