@atls/code-schematics 0.0.2

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+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]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schematics"), exports);

package/dist/migration-engine.host.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationEngineHost = void 0;
+const node_pnp_engine_host_1 = require("./node-pnp-engine.host");
+class MigrationEngineHost extends node_pnp_engine_host_1.NodePnpEngineHost {
+    _resolveCollectionPath(name) {
+        return name;
+    }
+}
+exports.MigrationEngineHost = MigrationEngineHost;

package/dist/node-pnp-engine.host.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodePnpEngineHost = void 0;
+const node_path_1 = require("node:path");
+const node_path_2 = require("node:path");
+const node_path_3 = require("node:path");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const tools_2 = require("@angular-devkit/schematics/tools");
+const tools_3 = require("@angular-devkit/schematics/tools");
+const tools_4 = require("@angular-devkit/schematics/tools");
+const tools_5 = require("@angular-devkit/schematics/tools");
+const tools_6 = require("@angular-devkit/schematics/tools");
+const file_system_utility_1 = require("@angular-devkit/schematics/tools/file-system-utility");
+class NodePnpEngineHost extends tools_4.FileSystemEngineHostBase {
+    constructor(paths) {
+        super();
+        this.paths = paths;
+    }
+    resolve(name, requester, references = new Set()) {
+        if (requester) {
+            if (references.has(requester)) {
+                references.add(requester);
+                throw new Error(`Circular schematic reference detected: ${JSON.stringify(Array.from(references))}`);
+            }
+            else {
+                references.add(requester);
+            }
+        }
+        const relativeBase = requester ? (0, node_path_1.dirname)(requester) : process.cwd();
+        let collectionPath;
+        if (name.startsWith('.')) {
+            name = (0, node_path_3.resolve)(relativeBase, name);
+        }
+        const resolveOptions = {
+            paths: (requester ? [(0, node_path_1.dirname)(requester), ...(this.paths || [])] : this.paths)?.filter(Boolean),
+        };
+        try {
+            const packageJsonPath = require.resolve((0, node_path_2.join)(name, 'package.json'), resolveOptions);
+            const { schematics } = require(packageJsonPath);
+            if (!schematics || typeof schematics !== 'string') {
+                throw new tools_6.NodePackageDoesNotSupportSchematics(name);
+            }
+            collectionPath = this.resolve(schematics, packageJsonPath, references);
+        }
+        catch (e) {
+            if (e.code !== 'MODULE_NOT_FOUND') {
+                throw e;
+            }
+        }
+        if (!collectionPath) {
+            try {
+                collectionPath = require.resolve(name, resolveOptions);
+            }
+            catch (e) {
+                if (e.code !== 'MODULE_NOT_FOUND') {
+                    throw e;
+                }
+            }
+        }
+        if (!collectionPath) {
+            throw new tools_2.CollectionCannotBeResolvedException(name);
+        }
+        return collectionPath;
+    }
+    _resolveCollectionPath(name, requester) {
+        const collectionPath = this.resolve(name, requester);
+        (0, file_system_utility_1.readJsonFile)(collectionPath);
+        return collectionPath;
+    }
+    _resolveReferenceString(refString, parentPath) {
+        const ref = new tools_1.ExportStringRef(refString, parentPath);
+        if (!ref.ref) {
+            return null;
+        }
+        return { ref: ref.ref, path: ref.module };
+    }
+    _transformCollectionDescription(name, desc) {
+        if (!desc.schematics || typeof desc.schematics !== 'object') {
+            throw new tools_3.CollectionMissingSchematicsMapException(name);
+        }
+        return {
+            ...desc,
+            name,
+        };
+    }
+    _transformSchematicDescription(name, _collection, desc) {
+        if (!desc.factoryFn || !desc.path || !desc.description) {
+            throw new tools_5.SchematicMissingFieldsException(name);
+        }
+        return desc;
+    }
+}
+exports.NodePnpEngineHost = NodePnpEngineHost;

package/dist/schematics.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schematics = void 0;
+const node_path_1 = require("node:path");
+const node_path_2 = require("node:path");
+const node_1 = require("@angular-devkit/core/node");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const core_1 = require("@angular-devkit/core");
+const migration_engine_host_1 = require("./migration-engine.host");
+const node_pnp_engine_host_1 = require("./node-pnp-engine.host");
+const utils_1 = require("./utils");
+const utils_2 = require("./utils");
+class Schematics {
+    constructor(cwd, force = false, dryRun = false) {
+        this.cwd = cwd;
+        this.force = force;
+        this.dryRun = dryRun;
+    }
+    async init(schematic, options = {}) {
+        const host = new core_1.virtualFs.ScopedHost(new node_1.NodeJsSyncHost(), this.cwd);
+        const workflow = new tools_1.NodeWorkflow(host, {
+            force: this.force,
+            dryRun: this.dryRun,
+            resolvePaths: [this.cwd],
+            schemaValidation: true,
+            engineHostCreator: ({ resolvePaths }) => new node_pnp_engine_host_1.NodePnpEngineHost(resolvePaths),
+        });
+        const collection = (0, utils_2.resolveSchematics)(this.cwd);
+        const events = [];
+        workflow.reporter.subscribe((event) => {
+            events.push(event);
+        });
+        await workflow
+            .execute({
+            collection,
+            schematic,
+            options: {
+                ...options,
+                cwd: this.cwd,
+            },
+            allowPrivate: true,
+            debug: true,
+        })
+            .toPromise();
+        return events;
+    }
+    async migrate(schematicName, migrationVersion, options = {}) {
+        const host = new core_1.virtualFs.ScopedHost(new node_1.NodeJsSyncHost(), this.cwd);
+        const workflow = new tools_1.NodeWorkflow(host, {
+            force: true,
+            dryRun: false,
+            engineHostCreator: ({ resolvePaths }) => new migration_engine_host_1.MigrationEngineHost(resolvePaths),
+        });
+        const events = [];
+        workflow.reporter.subscribe((event) => {
+            events.push(event);
+        });
+        const collections = (0, utils_1.expandCollections)(this.cwd, (0, utils_2.resolveSchematics)(this.cwd), schematicName);
+        const migrations = collections
+            .map((collection) => {
+            const schematic = collection.description.schematics[schematicName];
+            if (!schematic) {
+                return [];
+            }
+            const migrationsPath = (0, node_path_2.join)((0, node_path_1.dirname)(collection.description.path), (0, node_path_1.dirname)(schematic.schema), 'migrations.json');
+            const data = require(migrationsPath);
+            return Object.keys(data.schematics)
+                .map((key) => ({
+                collection: migrationsPath,
+                schematic: key,
+                migration: data.schematics[key],
+            }))
+                .filter((config) => config.migration.version > migrationVersion);
+        })
+            .flat();
+        for (const migration of migrations) {
+            await workflow
+                .execute({
+                collection: migration.collection,
+                schematic: migration.schematic,
+                debug: false,
+                options: {
+                    ...options,
+                    cwd: this.cwd,
+                },
+            })
+                .toPromise();
+        }
+        return events;
+    }
+}
+exports.Schematics = Schematics;

package/dist/utils/collection.utils.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandCollections = exports.expandCollection = exports.createCollection = void 0;
+const node_1 = require("@angular-devkit/core/node");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const core_1 = require("@angular-devkit/core");
+const core_2 = require("@angular-devkit/core");
+const core_3 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const createCollection = (root, collectionName) => {
+    const fsHost = new core_3.virtualFs.ScopedHost(new node_1.NodeJsSyncHost(), (0, core_1.normalize)(root));
+    const workflow = new tools_1.NodeWorkflow(fsHost, {
+        force: false,
+        dryRun: true,
+        packageManager: 'yarn',
+        root: (0, core_1.normalize)(root),
+        registry: new core_2.schema.CoreSchemaRegistry(schematics_1.formats.standardFormats),
+    });
+    return workflow.engine.createCollection(collectionName);
+};
+exports.createCollection = createCollection;
+const expandCollection = (cwd, collectionName) => {
+    const collection = (0, exports.createCollection)(cwd, collectionName);
+    const collections = [collection];
+    if (collection.baseDescriptions) {
+        const baseCollections = collection.baseDescriptions
+            .map((base) => (0, exports.expandCollection)(cwd, base.name))
+            .flat();
+        return [...collections, ...baseCollections];
+    }
+    return collections;
+};
+exports.expandCollection = expandCollection;
+const expandCollections = (cwd, collectionName, schematicName) => {
+    const collections = (0, exports.expandCollection)(cwd, collectionName).reverse();
+    const nested = collections.map((collection) => {
+        const schematic = collection.description.schematics[schematicName];
+        if (schematic && schematic.extends) {
+            const [extendsCollection, extendsSchematic] = schematic.extends.split(':');
+            return (0, exports.expandCollections)(cwd, extendsCollection, extendsSchematic);
+        }
+        return [];
+    });
+    return [...nested, collections].flat();
+};
+exports.expandCollections = expandCollections;

package/dist/utils/index.js

@@ -0,0 +1,14 @@
+"use strict";
+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]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./collection.utils"), exports);
+__exportStar(require("./resolve.utils"), exports);

package/dist/utils/resolve.utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchematics = void 0;
+const node_path_1 = require("node:path");
+const node_path_2 = require("node:path");
+const dynamicRequire = eval('require');
+const findPnpApiPath = (cwd) => {
+    if (process.versions.pnp) {
+        return require('module').findPnpApi(__filename).resolveRequest('pnpapi', null);
+    }
+    return (0, node_path_2.join)(cwd || process.cwd(), '.pnp.cjs');
+};
+const setupPnp = (cwd) => {
+    const pnpPath = findPnpApiPath(cwd);
+    dynamicRequire(pnpPath).setup();
+};
+const resolveSchematics = (cwd) => {
+    try {
+        return (0, node_path_2.join)((0, node_path_1.dirname)(dynamicRequire.resolve('@atls/schematics')), '..');
+    }
+    catch (error) {
+        setupPnp(cwd);
+        return (0, node_path_2.join)((0, node_path_1.dirname)(dynamicRequire.resolve('@atls/schematics')), '..');
+    }
+};
+exports.resolveSchematics = resolveSchematics;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@atls/code-schematics",
+  "version": "0.0.2",
+  "license": "BSD-3-Clause",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "yarn library build",
+    "build:worker": "rollup -c",
+    "prepack": "yarn run build",
+    "postpack": "rm -rf dist"
+  },
+  "dependencies": {
+    "@angular-devkit/core": "^13.1.1",
+    "@angular-devkit/schematics": "^13.1.1",
+    "@atls/schematics": "0.0.2"
+  },
+  "devDependencies": {
+    "rxjs": "6.6.7"
+  },
+  "publishConfig": {
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+  },
+  "typings": "dist/index.d.ts"
+}