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

package/node/host.js

@@ -111,21 +111,21 @@ class NodeJsAsyncHost {
                 obs.next({
                     path: (0, src_1.normalize)(path),
                     time: new Date(),
-                    type: 0 /* Changed */,
+                    type: 0 /* virtualFs.HostWatchEventType.Changed */,
                 });
             })
                 .on('add', (path) => {
                 obs.next({
                     path: (0, src_1.normalize)(path),
                     time: new Date(),
-                    type: 1 /* Created */,
+                    type: 1 /* virtualFs.HostWatchEventType.Created */,
                 });
             })
                 .on('unlink', (path) => {
                 obs.next({
                     path: (0, src_1.normalize)(path),
                     time: new Date(),
-                    type: 2 /* Deleted */,
+                    type: 2 /* virtualFs.HostWatchEventType.Deleted */,
                 });
             });
             return () => watcher.close();
@@ -209,21 +209,21 @@ class NodeJsSyncHost {
                 obs.next({
                     path: (0, src_1.normalize)(path),
                     time: new Date(),
-                    type: 0 /* Changed */,
+                    type: 0 /* virtualFs.HostWatchEventType.Changed */,
                 });
             })
                 .on('add', (path) => {
                 obs.next({
                     path: (0, src_1.normalize)(path),
                     time: new Date(),
-                    type: 1 /* Created */,
+                    type: 1 /* virtualFs.HostWatchEventType.Created */,
                 });
             })
                 .on('unlink', (path) => {
                 obs.next({
                     path: (0, src_1.normalize)(path),
                     time: new Date(),
-                    type: 2 /* Deleted */,
+                    type: 2 /* virtualFs.HostWatchEventType.Deleted */,
                 });
             });
             return () => watcher.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-devkit/core",
-  "version": "14.0.0-next.7",
+  "version": "14.0.0-rc.0",
   "description": "Angular DevKit - Core Utility Library",
   "main": "src/index.js",
   "typings": "src/index.d.ts",
@@ -15,8 +15,7 @@
   "dependencies": {
     "ajv-formats": "2.1.1",
     "ajv": "8.11.0",
-    "fast-json-stable-stringify": "2.1.0",
-    "magic-string": "0.26.1",
+    "jsonc-parser": "3.0.0",
     "rxjs": "6.6.7",
     "source-map": "0.7.3"
   },

package/src/experimental/jobs/strategy.d.ts

@@ -16,13 +16,13 @@ export declare namespace strategy {
     /**
      * Creates a JobStrategy that will always reuse a running job, and restart it if the job ended.
      * @param replayMessages Replay ALL messages if a job is reused, otherwise just hook up where it
-     *        is.
+     * is.
      */
     function reuse<A extends JsonValue = JsonValue, I extends JsonValue = JsonValue, O extends JsonValue = JsonValue>(replayMessages?: boolean): JobStrategy<A, I, O>;
     /**
      * Creates a JobStrategy that will reuse a running job if the argument matches.
      * @param replayMessages Replay ALL messages if a job is reused, otherwise just hook up where it
-     *        is.
+     * is.
      */
     function memoize<A extends JsonValue = JsonValue, I extends JsonValue = JsonValue, O extends JsonValue = JsonValue>(replayMessages?: boolean): JobStrategy<A, I, O>;
 }

package/src/experimental/jobs/strategy.js

@@ -10,8 +10,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.strategy = void 0;
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
+const json_1 = require("../../json");
 const api_1 = require("./api");
-const stableStringify = require('fast-json-stable-stringify');
 // eslint-disable-next-line @typescript-eslint/no-namespace
 var strategy;
 (function (strategy) {
@@ -35,7 +35,7 @@ var strategy;
     /**
      * Creates a JobStrategy that will always reuse a running job, and restart it if the job ended.
      * @param replayMessages Replay ALL messages if a job is reused, otherwise just hook up where it
-     *        is.
+     * is.
      */
     function reuse(replayMessages = false) {
         let inboundBus = new rxjs_1.Subject();
@@ -70,13 +70,20 @@ var strategy;
     /**
      * Creates a JobStrategy that will reuse a running job if the argument matches.
      * @param replayMessages Replay ALL messages if a job is reused, otherwise just hook up where it
-     *        is.
+     * is.
      */
     function memoize(replayMessages = false) {
         const runs = new Map();
         return (handler, options) => {
             const newHandler = (argument, context) => {
-                const argumentJson = stableStringify(argument);
+                const argumentJson = JSON.stringify((0, json_1.isJsonObject)(argument)
+                    ? Object.keys(argument)
+                        .sort()
+                        .reduce((result, key) => {
+                        result[key] = argument[key];
+                        return result;
+                    }, {})
+                    : argument);
                 const maybeJob = runs.get(argumentJson);
                 if (maybeJob) {
                     return maybeJob;

package/src/utils/object.js

@@ -27,7 +27,7 @@ function deepCopy(value) {
         for (const key of Object.getOwnPropertyNames(valueCasted)) {
             copy[key] = deepCopy(valueCasted[key]);
         }
-        valueCasted[copySymbol] = undefined;
+        delete valueCasted[copySymbol];
         return copy;
     }
     else {

package/src/virtual-fs/host/memory.js

@@ -71,7 +71,7 @@ class SimpleMemoryHost {
             maybeWatcher.forEach((watcher) => {
                 const [options, subject] = watcher;
                 subject.next({ path, time, type });
-                if (!options.persistent && type == 2 /* Deleted */) {
+                if (!options.persistent && type == 2 /* HostWatchEventType.Deleted */) {
                     subject.complete();
                     this._watchers.delete(currentPath);
                 }
@@ -88,7 +88,7 @@ class SimpleMemoryHost {
                         return;
                     }
                     subject.next({ path, time, type });
-                    if (!options.persistent && type == 2 /* Deleted */) {
+                    if (!options.persistent && type == 2 /* HostWatchEventType.Deleted */) {
                         subject.complete();
                         this._watchers.delete(currentPath);
                     }
@@ -127,7 +127,7 @@ class SimpleMemoryHost {
         // Create the stats.
         const stats = this._newFileStats(content, old);
         this._cache.set(path, stats);
-        this._updateWatchers(path, old ? 0 /* Changed */ : 1 /* Created */);
+        this._updateWatchers(path, old ? 0 /* HostWatchEventType.Changed */ : 1 /* HostWatchEventType.Created */);
     }
     _read(path) {
         path = this._toAbsolute(path);
@@ -157,7 +157,7 @@ class SimpleMemoryHost {
         else {
             this._cache.delete(path);
         }
-        this._updateWatchers(path, 2 /* Deleted */);
+        this._updateWatchers(path, 2 /* HostWatchEventType.Deleted */);
     }
     _rename(from, to) {
         from = this._toAbsolute(from);
@@ -204,7 +204,7 @@ class SimpleMemoryHost {
                 this._cache.set(to, content);
             }
         }
-        this._updateWatchers(from, 3 /* Renamed */);
+        this._updateWatchers(from, 3 /* HostWatchEventType.Renamed */);
     }
     _list(path) {
         path = this._toAbsolute(path);

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/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;