@nstudio/xplat 15.0.4-rc.0 → 15.0.4-rc.1

package/README.md

@@ -42,10 +42,12 @@ You are now ready to create apps:
 nx g app
 ```
 
-**NOTE:** If you encounter any issue, you can try creating an Nx workspace with version specified, for example:
+**NOTE:** If you encounter any issue, you can try creating an Nx workspace with a version specified.
+
+We have tested with the following, for example:
 
 ```
-npx create-nx-workspace@14.1.7
+npx create-nx-workspace@15.9.2
 ```
 
 ## App generation examples

package/migrations/update-13-0-0/update-13-0-0.js

@@ -262,7 +262,7 @@ function updateRootPackage(tree, context) {
     json.dependencies = json.dependencies || {};
     json.dependencies = Object.assign(Object.assign(Object.assign({}, json.dependencies), (hasNativeScriptApps ? nativeScriptDeps : {})), { '@ngx-translate/core': ngxTranslateVersion });
     let ngToolsDeps = {
-        '@ngtools/webpack': angularVersion
+        '@ngtools/webpack': angularVersion,
     };
     if (json.dependencies['@angular/core']) {
         // make sure in sync with current angular versions
@@ -289,7 +289,7 @@ function default_1() {
         updateRootPackage,
         (tree) => {
             return (0, schematics_1.externalSchematic)('@nrwl/workspace', 'convert-to-nx-project', {
-                all: true
+                all: true,
             });
         },
     ]);

package/migrations.json

@@ -12,6 +12,47 @@
     }
   },
   "packageJsonUpdates": {
+    "11.0.21": {
+      "version": "11.0.21",
+      "packages": {
+        "@nstudio/angular": {
+          "version": "11.0.21",
+          "alwaysAddToPackageJson": false
+        },
+        "@nstudio/electron": {
+          "version": "11.0.21",
+          "alwaysAddToPackageJson": false
+        },
+        "@nstudio/electron-angular": {
+          "version": "11.0.21",
+          "alwaysAddToPackageJson": false
+        },
+        "@nstudio/ionic": {
+          "version": "11.0.21",
+          "alwaysAddToPackageJson": false
+        },
+        "@nstudio/ionic-angular": {
+          "version": "11.0.21",
+          "alwaysAddToPackageJson": false
+        },
+        "@nstudio/nativescript": {
+          "version": "11.0.21",
+          "alwaysAddToPackageJson": false
+        },
+        "@nstudio/nativescript-angular": {
+          "version": "11.0.21",
+          "alwaysAddToPackageJson": false
+        },
+        "@nstudio/web": {
+          "version": "11.0.21",
+          "alwaysAddToPackageJson": false
+        },
+        "@nstudio/web-angular": {
+          "version": "11.0.21",
+          "alwaysAddToPackageJson": false
+        }
+      }
+    },
     "12.4.3": {
       "version": "12.4.3",
       "packages": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nstudio/xplat",
-  "version": "15.0.4-rc.0",
+  "version": "15.0.4-rc.1",
   "description": "Cross-platform (xplat) tools for Nx workspaces.",
   "homepage": "https://nstudio.io/xplat",
   "repository": {
@@ -41,8 +41,8 @@
     "postinstall": "node src/utils/postinstall.js"
   },
   "dependencies": {
-    "@nstudio/focus": "15.0.4-rc.0",
-    "@nstudio/xplat-utils": "15.0.4-rc.0"
+    "@nstudio/focus": "15.0.4-rc.1",
+    "@nstudio/xplat-utils": "15.0.4-rc.1"
   },
   "author": "Nathan Walker",
   "license": "MIT",

package/src/utils/ast.d.ts

@@ -1,5 +1,77 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 { Tree } from '@angular-devkit/schematics';
 import * as ts from 'typescript';
-import { Tree } from '@nrwl/devkit';
-import { Tree as NgTree } from '@angular-devkit/schematics';
-export declare function addGlobal(tree: Tree, source: ts.SourceFile, modulePath: string, statement: string, isExport?: boolean): ts.SourceFile[];
-export declare function insert(host: NgTree, modulePath: string, changes: any[]): void;
+export declare function findNodes(node: ts.Node, kind: ts.SyntaxKind | ts.SyntaxKind[], max?: number): ts.Node[];
+export declare function getSourceNodes(sourceFile: ts.SourceFile): ts.Node[];
+export interface Change {
+    apply(host: any): Promise<void>;
+    readonly type: string;
+    readonly path: string | null;
+    readonly order: number;
+    readonly description: string;
+}
+export declare class NoopChange implements Change {
+    type: string;
+    description: string;
+    order: number;
+    path: any;
+    apply(): Promise<void>;
+}
+export declare class InsertChange implements Change {
+    path: string;
+    pos: number;
+    toAdd: string;
+    type: string;
+    order: number;
+    description: string;
+    constructor(path: string, pos: number, toAdd: string);
+    apply(host: any): any;
+}
+export declare class RemoveChange implements Change {
+    path: string;
+    private pos;
+    private toRemove;
+    type: string;
+    order: number;
+    description: string;
+    constructor(path: string, pos: number, toRemove: string);
+    apply(host: any): Promise<void>;
+}
+export declare class ReplaceChange implements Change {
+    path: string;
+    pos: number;
+    oldText: string;
+    newText: string;
+    type: string;
+    order: number;
+    description: string;
+    constructor(path: string, pos: number, oldText: string, newText: string);
+    apply(host: any): Promise<void>;
+}
+export declare function addParameterToConstructor(source: ts.SourceFile, modulePath: string, opts: {
+    className: string;
+    param: string;
+}): Change[];
+export declare function addMethod(source: ts.SourceFile, modulePath: string, opts: {
+    className: string;
+    methodHeader: string;
+    body: string;
+}): Change[];
+export declare function findClass(source: ts.SourceFile, className: string, silent?: boolean): ts.ClassDeclaration;
+export declare function offset(text: string, numberOfTabs: number, wrap: boolean): string;
+export declare function addIncludeToTsConfig(tsConfigPath: string, source: ts.SourceFile, include: string): Change[];
+export declare function getImport(source: ts.SourceFile, predicate: (a: any) => boolean): {
+    moduleSpec: string;
+    bindings: string[];
+}[];
+export declare function addGlobal(source: ts.SourceFile, modulePath: string, statement: string, isExport?: boolean): Change[];
+export declare function insert(host: Tree, modulePath: string, changes: Change[]): void;
+export declare function getProjectConfig(tree: Tree, name: string): any;
+export declare function insertImport(source: ts.SourceFile, fileToEdit: string, symbolName: string, fileName: string, isDefault?: boolean): Change;
+export declare function replaceNodeValue(host: Tree, modulePath: string, node: ts.Node, content: string): void;

package/src/utils/ast.js

@@ -1,33 +1,255 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.insert = exports.addGlobal = void 0;
-const js_1 = require("@nrwl/js");
-const typescript_1 = require("nx/src/utils/typescript");
+exports.replaceNodeValue = exports.insertImport = exports.getProjectConfig = exports.insert = exports.addGlobal = exports.getImport = exports.addIncludeToTsConfig = exports.offset = exports.findClass = exports.addMethod = exports.addParameterToConstructor = exports.ReplaceChange = exports.RemoveChange = exports.InsertChange = exports.NoopChange = exports.getSourceNodes = exports.findNodes = void 0;
 const ts = require("typescript");
 const general_1 = require("./general");
-function addGlobal(tree, source, modulePath, statement, isExport) {
+function nodesByPosition(first, second) {
+    return first.getStart() - second.getStart();
+}
+function insertAfterLastOccurrence(nodes, toInsert, file, fallbackPos, syntaxKind) {
+    // sort() has a side effect, so make a copy so that we won't overwrite the parent's object.
+    let lastItem = [...nodes].sort(nodesByPosition).pop();
+    if (!lastItem) {
+        throw new Error();
+    }
+    if (syntaxKind) {
+        lastItem = findNodes(lastItem, syntaxKind).sort(nodesByPosition).pop();
+    }
+    if (!lastItem && fallbackPos == undefined) {
+        throw new Error(`tried to insert ${toInsert} as first occurence with no fallback position`);
+    }
+    const lastItemPosition = lastItem ? lastItem.getEnd() : fallbackPos;
+    return new InsertChange(file, lastItemPosition, toInsert);
+}
+function findNodes(node, kind, max = Infinity) {
+    if (!node || max == 0) {
+        return [];
+    }
+    const arr = [];
+    const hasMatch = Array.isArray(kind)
+        ? kind.includes(node.kind)
+        : node.kind === kind;
+    if (hasMatch) {
+        arr.push(node);
+        max--;
+    }
+    if (max > 0) {
+        for (const child of node.getChildren()) {
+            findNodes(child, kind, max).forEach((node) => {
+                if (max > 0) {
+                    arr.push(node);
+                }
+                max--;
+            });
+            if (max <= 0) {
+                break;
+            }
+        }
+    }
+    return arr;
+}
+exports.findNodes = findNodes;
+function getSourceNodes(sourceFile) {
+    const nodes = [sourceFile];
+    const result = [];
+    while (nodes.length > 0) {
+        const node = nodes.shift();
+        if (node) {
+            result.push(node);
+            if (node.getChildCount(sourceFile) >= 0) {
+                nodes.unshift(...node.getChildren());
+            }
+        }
+    }
+    return result;
+}
+exports.getSourceNodes = getSourceNodes;
+class NoopChange {
+    constructor() {
+        this.type = 'noop';
+        this.description = 'No operation.';
+        this.order = Infinity;
+        this.path = null;
+    }
+    apply() {
+        return Promise.resolve();
+    }
+}
+exports.NoopChange = NoopChange;
+class InsertChange {
+    constructor(path, pos, toAdd) {
+        this.path = path;
+        this.pos = pos;
+        this.toAdd = toAdd;
+        this.type = 'insert';
+        if (pos < 0) {
+            throw new Error('Negative positions are invalid');
+        }
+        this.description = `Inserted ${toAdd} into position ${pos} of ${path}`;
+        this.order = pos;
+    }
+    apply(host) {
+        return host.read(this.path).then((content) => {
+            const prefix = content.substring(0, this.pos);
+            const suffix = content.substring(this.pos);
+            return host.write(this.path, `${prefix}${this.toAdd}${suffix}`);
+        });
+    }
+}
+exports.InsertChange = InsertChange;
+class RemoveChange {
+    constructor(path, pos, toRemove) {
+        this.path = path;
+        this.pos = pos;
+        this.toRemove = toRemove;
+        this.type = 'remove';
+        if (pos < 0) {
+            throw new Error('Negative positions are invalid');
+        }
+        this.description = `Removed ${toRemove} into position ${pos} of ${path}`;
+        this.order = pos;
+    }
+    apply(host) {
+        return host.read(this.path).then((content) => {
+            const prefix = content.substring(0, this.pos);
+            const suffix = content.substring(this.pos + this.toRemove.length);
+            return host.write(this.path, `${prefix}${suffix}`);
+        });
+    }
+}
+exports.RemoveChange = RemoveChange;
+class ReplaceChange {
+    constructor(path, pos, oldText, newText) {
+        this.path = path;
+        this.pos = pos;
+        this.oldText = oldText;
+        this.newText = newText;
+        this.type = 'replace';
+        if (pos < 0) {
+            throw new Error('Negative positions are invalid');
+        }
+        this.description = `Replaced ${oldText} into position ${pos} of ${path} with ${newText}`;
+        this.order = pos;
+    }
+    apply(host) {
+        return host.read(this.path).then((content) => {
+            const prefix = content.substring(0, this.pos);
+            const suffix = content.substring(this.pos + this.oldText.length);
+            const text = content.substring(this.pos, this.pos + this.oldText.length);
+            if (text !== this.oldText) {
+                return Promise.reject(new Error(`Invalid replace: "${text}" != "${this.oldText}".`));
+            }
+            return host.write(this.path, `${prefix}${this.newText}${suffix}`);
+        });
+    }
+}
+exports.ReplaceChange = ReplaceChange;
+function addParameterToConstructor(source, modulePath, opts) {
+    const clazz = findClass(source, opts.className);
+    const constructor = clazz.members.filter((m) => m.kind === ts.SyntaxKind.Constructor)[0];
+    if (constructor) {
+        throw new Error('Should be tested');
+    }
+    else {
+        const methodHeader = `constructor(${opts.param})`;
+        return addMethod(source, modulePath, {
+            className: opts.className,
+            methodHeader,
+            body: null,
+        });
+    }
+}
+exports.addParameterToConstructor = addParameterToConstructor;
+function addMethod(source, modulePath, opts) {
+    const clazz = findClass(source, opts.className);
+    const body = opts.body
+        ? `
+${opts.methodHeader} {
+${offset(opts.body, 1, false)}
+}
+`
+        : `
+${opts.methodHeader} {}
+`;
+    return [new InsertChange(modulePath, clazz.end - 1, offset(body, 1, true))];
+}
+exports.addMethod = addMethod;
+function findClass(source, className, silent = false) {
+    const nodes = getSourceNodes(source);
+    const clazz = (nodes.filter((n) => n.kind === ts.SyntaxKind.ClassDeclaration &&
+        n.name.text === className)[0]);
+    if (!clazz && !silent) {
+        throw new Error(`Cannot find class '${className}'`);
+    }
+    return clazz;
+}
+exports.findClass = findClass;
+function offset(text, numberOfTabs, wrap) {
+    const lines = text
+        .trim()
+        .split('\n')
+        .map((line) => {
+        let tabs = '';
+        for (let c = 0; c < numberOfTabs; ++c) {
+            tabs += '  ';
+        }
+        return `${tabs}${line}`;
+    })
+        .join('\n');
+    return wrap ? `\n${lines}\n` : lines;
+}
+exports.offset = offset;
+function addIncludeToTsConfig(tsConfigPath, source, include) {
+    const includeKeywordPos = source.text.indexOf('"include":');
+    if (includeKeywordPos > -1) {
+        const includeArrayEndPos = source.text.indexOf(']', includeKeywordPos);
+        return [new InsertChange(tsConfigPath, includeArrayEndPos, include)];
+    }
+    else {
+        return [];
+    }
+}
+exports.addIncludeToTsConfig = addIncludeToTsConfig;
+function getImport(source, predicate) {
+    const allImports = findNodes(source, ts.SyntaxKind.ImportDeclaration);
+    const matching = allImports.filter((i) => predicate(i.moduleSpecifier.getText()));
+    return matching.map((i) => {
+        const moduleSpec = i.moduleSpecifier
+            .getText()
+            .substring(1, i.moduleSpecifier.getText().length - 1);
+        const t = i.importClause.namedBindings.getText();
+        const bindings = t
+            .replace('{', '')
+            .replace('}', '')
+            .split(',')
+            .map((q) => q.trim());
+        return { moduleSpec, bindings };
+    });
+}
+exports.getImport = getImport;
+function addGlobal(source, modulePath, statement, isExport) {
     if (isExport) {
-        const allExports = (0, typescript_1.findNodes)(source, ts.SyntaxKind.ExportDeclaration);
+        const allExports = findNodes(source, ts.SyntaxKind.ExportDeclaration);
         // console.log('allExports:', allExports.length);
         if (allExports.length > 0) {
             const lastExport = allExports[allExports.length - 1];
             // console.log('lastExport.end:', lastExport.end);
-            return [(0, js_1.insertChange)(tree, source, modulePath, lastExport.end, `\n${statement}\n`)];
+            return [new InsertChange(modulePath, lastExport.end, `\n${statement}\n`)];
         }
         else {
-            return [(0, js_1.insertChange)(tree, source, modulePath, 0, `${statement}\n`)];
+            return [new InsertChange(modulePath, 0, `${statement}\n`)];
         }
     }
     else {
-        const allImports = (0, typescript_1.findNodes)(source, ts.SyntaxKind.ImportDeclaration);
+        const allImports = findNodes(source, ts.SyntaxKind.ImportDeclaration);
         if (allImports.length > 0) {
             const lastImport = allImports[allImports.length - 1];
             return [
-                (0, js_1.insertChange)(tree, source, modulePath, lastImport.end + 1, `\n${statement}\n`),
+                new InsertChange(modulePath, lastImport.end + 1, `\n${statement}\n`),
             ];
         }
         else {
-            return [(0, js_1.insertChange)(tree, source, modulePath, 0, `${statement}\n`)];
+            return [new InsertChange(modulePath, 0, `${statement}\n`)];
         }
     }
 }
@@ -40,22 +262,17 @@ function insert(host, modulePath, changes) {
     const orderedChanges = changes.sort((a, b) => b.order - a.order);
     const recorder = host.beginUpdate(modulePath);
     for (const change of orderedChanges) {
-        // console.log('change.type:', change, ' -change.kind:', change.kind)
-        let type = change.type;
-        if (change.kind === 'c' || change.kind === 'o') {
-            type = general_1.actionToFileChangeMap[change.kind];
-        }
-        if (type == 'insert') {
+        if (change.type == 'insert') {
             recorder.insertLeft(change.pos, change.toAdd);
         }
-        else if (type == 'remove') {
+        else if (change.type == 'remove') {
             recorder.remove(change.pos - 1, change.toRemove.length + 1);
         }
-        else if (type == 'replace') {
+        else if (change.type == 'replace') {
             recorder.remove(change.pos, change.oldText.length);
             recorder.insertLeft(change.pos, change.newText);
         }
-        else if (type === 'noop') {
+        else if (change.type === 'noop') {
             // do nothing
         }
         else {
@@ -65,3 +282,71 @@ function insert(host, modulePath, changes) {
     host.commitUpdate(recorder);
 }
 exports.insert = insert;
+function getProjectConfig(tree, name) {
+    const workspaceJson = (0, general_1.readWorkspaceJson)(tree);
+    const projectConfig = workspaceJson.projects[name];
+    if (!projectConfig) {
+        throw new Error(`Cannot find project '${name}'`);
+    }
+    else {
+        return projectConfig;
+    }
+}
+exports.getProjectConfig = getProjectConfig;
+function insertImport(source, fileToEdit, symbolName, fileName, isDefault = false) {
+    const rootNode = source;
+    const allImports = findNodes(rootNode, ts.SyntaxKind.ImportDeclaration);
+    // get nodes that map to import statements from the file fileName
+    const relevantImports = allImports.filter((node) => {
+        // StringLiteral of the ImportDeclaration is the import file (fileName in this case).
+        const importFiles = node
+            .getChildren()
+            .filter((child) => child.kind === ts.SyntaxKind.StringLiteral)
+            .map((n) => n.text);
+        return importFiles.filter((file) => file === fileName).length === 1;
+    });
+    if (relevantImports.length > 0) {
+        let importsAsterisk = false;
+        // imports from import file
+        const imports = [];
+        relevantImports.forEach((n) => {
+            Array.prototype.push.apply(imports, findNodes(n, ts.SyntaxKind.Identifier));
+            if (findNodes(n, ts.SyntaxKind.AsteriskToken).length > 0) {
+                importsAsterisk = true;
+            }
+        });
+        // if imports * from fileName, don't add symbolName
+        if (importsAsterisk) {
+            return new NoopChange();
+        }
+        const importTextNodes = imports.filter((n) => n.text === symbolName);
+        // insert import if it's not there
+        if (importTextNodes.length === 0) {
+            const fallbackPos = findNodes(relevantImports[0], ts.SyntaxKind.CloseBraceToken)[0].getStart() ||
+                findNodes(relevantImports[0], ts.SyntaxKind.FromKeyword)[0].getStart();
+            return insertAfterLastOccurrence(imports, `, ${symbolName}`, fileToEdit, fallbackPos);
+        }
+        return new NoopChange();
+    }
+    // no such import declaration exists
+    const useStrict = findNodes(rootNode, ts.SyntaxKind.StringLiteral).filter((n) => n.text === 'use strict');
+    let fallbackPos = 0;
+    if (useStrict.length > 0) {
+        fallbackPos = useStrict[0].end;
+    }
+    const open = isDefault ? '' : '{ ';
+    const close = isDefault ? '' : ' }';
+    // if there are no imports or 'use strict' statement, insert import at beginning of file
+    const insertAtBeginning = allImports.length === 0 && useStrict.length === 0;
+    const separator = insertAtBeginning ? '' : ';\n';
+    const toInsert = `${separator}import ${open}${symbolName}${close}` +
+        ` from '${fileName}'${insertAtBeginning ? ';\n' : ''}`;
+    return insertAfterLastOccurrence(allImports, toInsert, fileToEdit, fallbackPos, ts.SyntaxKind.StringLiteral);
+}
+exports.insertImport = insertImport;
+function replaceNodeValue(host, modulePath, node, content) {
+    insert(host, modulePath, [
+        new ReplaceChange(modulePath, node.getStart(node.getSourceFile()), node.getFullText(), content),
+    ]);
+}
+exports.replaceNodeValue = replaceNodeValue;

package/src/utils/general.js

@@ -282,7 +282,7 @@ class DevkitTreeFromAngularDevkitTree {
     }
     warnUnsupportedFilePermissionsChange(filePath, mode) {
         console.log(`The Angular DevKit tree does not support changing a file permissions.
-                    Ignoring changing ${filePath} permissions to ${mode}.`);
+                      Ignoring changing ${filePath} permissions to ${mode}.`);
     }
 }
 exports.DevkitTreeFromAngularDevkitTree = DevkitTreeFromAngularDevkitTree;

package/src/utils/versions.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nxVersion = exports.xplatVersion = void 0;
-exports.xplatVersion = '15.0.4-rc.0';
+exports.xplatVersion = '15.0.4-rc.1';
 exports.nxVersion = '^15.0.0';

package/src/utils/xplat.js

@@ -42,7 +42,8 @@ var XplatHelpers;
      */
     function addPackageWithNgAdd(packageName, options, callSchematicIfAdded) {
         return (host) => {
-            const { dependencies, devDependencies } = (0, xplat_utils_1.getJsonFromFile)(host, 'package.json');
+            const json = (0, xplat_utils_1.getJsonFromFile)(host, 'package.json');
+            const { dependencies, devDependencies } = json;
             return dependencies[packageName] || devDependencies[packageName]
                 ? callSchematicIfAdded
                     ? (0, schematics_1.externalSchematic)(packageName, callSchematicIfAdded, options, {
@@ -768,25 +769,15 @@ var XplatFeatureHelpers;
     }
     XplatFeatureHelpers.addFiles = addFiles;
     function adjustBarrelIndex(options, indexFilePath) {
-        return (tree, context) => {
-            const devKitTree = (0, general_1.convertNgTreeToDevKit)(tree, context);
+        return (tree) => {
             // console.log('adjustBarrelIndex indexFilePath:', indexFilePath);
             // console.log('tree.exists(indexFilePath):', tree.exists(indexFilePath));
             const indexSource = tree.read(indexFilePath).toString('utf-8');
             const indexSourceFile = (0, typescript_1.createSourceFile)(indexFilePath, indexSource, typescript_1.ScriptTarget.Latest, true);
-            // insert(tree, indexFilePath, [
-            //   ...addGlobal(
-            //     devKitTree,
-            //     indexSourceFile,
-            //     indexFilePath,
-            //     `export * from './${
-            //       options.directory ? options.directory + '/' : ''
-            //     }${options.name.toLowerCase()}';`,
-            //     true
-            //   ),
-            // ]);
-            (0, ast_1.addGlobal)(devKitTree, indexSourceFile, indexFilePath, `export * from './${options.directory ? options.directory + '/' : ''}${options.name.toLowerCase()}';`, true);
-            return devKitTree.tree;
+            (0, ast_1.insert)(tree, indexFilePath, [
+                ...(0, ast_1.addGlobal)(indexSourceFile, indexFilePath, `export * from './${options.directory ? options.directory + '/' : ''}${options.name.toLowerCase()}';`, true),
+            ]);
+            return tree;
         };
     }
     XplatFeatureHelpers.adjustBarrelIndex = adjustBarrelIndex;