@nestjs/schematics 11.0.9 → 12.0.0-alpha.0

package/dist/{lib → src/lib}/resource/resource.factory.js

@@ -1,50 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.main = main;
-const core_1 = require("@angular-devkit/core");
-const strings_1 = require("@angular-devkit/core/src/utils/strings");
-const schematics_1 = require("@angular-devkit/schematics");
-const tasks_1 = require("@angular-devkit/schematics/tasks");
-const pluralize = require("pluralize");
-const __1 = require("../..");
-const dependencies_utils_1 = require("../../utils/dependencies.utils");
-const formatting_1 = require("../../utils/formatting");
-const name_parser_1 = require("../../utils/name.parser");
-const source_root_helpers_1 = require("../../utils/source-root.helpers");
-function main(options) {
+import { join, strings } from '@angular-devkit/core';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { apply, branchAndMerge, chain, filter, mergeWith, move, noop, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
+import * as pluralize from 'pluralize';
+import { ModuleDeclarator, ModuleFinder, } from '../../index.js';
+import { addPackageJsonDependency, getPackageJsonDependency, NodeDependencyType, } from '../../utils/dependencies.utils.js';
+import { normalizeToKebabOrSnakeCase } from '../../utils/formatting.js';
+import { NameParser } from '../../utils/name.parser.js';
+import { mergeSourceRoot } from '../../utils/source-root.helpers.js';
+export function main(options) {
     options = transform(options);
     return (tree, context) => {
-        return (0, schematics_1.branchAndMerge)((0, schematics_1.chain)([
+        return branchAndMerge(chain([
             addMappedTypesDependencyIfApplies(options),
-            (0, source_root_helpers_1.mergeSourceRoot)(options),
+            mergeSourceRoot(options),
             addDeclarationToModule(options),
-            (0, schematics_1.mergeWith)(generate(options)),
+            mergeWith(generate(options)),
         ]))(tree, context);
     };
 }
 function transform(options) {
     const target = Object.assign({}, options);
     if (!target.name) {
-        throw new schematics_1.SchematicsException('Option (name) is required.');
+        throw new SchematicsException('Option (name) is required.');
     }
     target.metadata = 'imports';
-    const location = new name_parser_1.NameParser().parse(target);
-    target.name = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.name);
-    target.path = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.path);
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    target.path = normalizeToKebabOrSnakeCase(location.path);
     target.language = target.language !== undefined ? target.language : 'ts';
     if (target.language === 'js') {
         throw new Error('The "resource" schematic does not support JavaScript language (only TypeScript is supported).');
     }
-    target.specFileSuffix = (0, formatting_1.normalizeToKebabOrSnakeCase)(options.specFileSuffix || 'spec');
+    target.specFileSuffix = normalizeToKebabOrSnakeCase(options.specFileSuffix || 'spec');
     target.path = target.flat
         ? target.path
-        : (0, core_1.join)(target.path, target.name);
+        : join(target.path, target.name);
     target.isSwaggerInstalled = options.isSwaggerInstalled ?? false;
     return target;
 }
 function generate(options) {
-    return (context) => (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./files', options.language)), [
-        (0, schematics_1.filter)((path) => {
+    return (context) => apply(url(join('./files', options.language)), [
+        filter((path) => {
             if (path.endsWith('.dto.ts')) {
                 return (options.type !== 'graphql-code-first' &&
                     options.type !== 'graphql-schema-first' &&
@@ -77,22 +74,22 @@ function generate(options) {
             return true;
         }),
         options.spec
-            ? (0, schematics_1.noop)()
-            : (0, schematics_1.filter)((path) => {
+            ? noop()
+            : filter((path) => {
                 const suffix = `.__specFileSuffix__.ts`;
                 return !path.endsWith(suffix);
             }),
-        (0, schematics_1.template)({
-            ...core_1.strings,
+        template({
+            ...strings,
             ...options,
             lowercased: (name) => {
-                const classifiedName = (0, strings_1.classify)(name);
+                const classifiedName = classify(name);
                 return (classifiedName.charAt(0).toLowerCase() + classifiedName.slice(1));
             },
             singular: (name) => pluralize.singular(name),
             ent: (name) => name + '.entity',
         }),
-        (0, schematics_1.move)(options.path),
+        move(options.path),
     ])(context);
 }
 function addDeclarationToModule(options) {
@@ -100,7 +97,7 @@ function addDeclarationToModule(options) {
         if (options.skipImport !== undefined && options.skipImport) {
             return tree;
         }
-        options.module = new __1.ModuleFinder(tree).find({
+        options.module = new ModuleFinder(tree).find({
             name: options.name,
             path: options.path,
         });
@@ -108,7 +105,7 @@ function addDeclarationToModule(options) {
             return tree;
         }
         const content = tree.read(options.module).toString();
-        const declarator = new __1.ModuleDeclarator();
+        const declarator = new ModuleDeclarator();
         tree.overwrite(options.module, declarator.declare(content, {
             ...options,
             type: 'module',
@@ -123,20 +120,20 @@ function addMappedTypesDependencyIfApplies(options) {
                 return;
             }
             if (options.type === 'rest') {
-                const nodeDependencyRef = (0, dependencies_utils_1.getPackageJsonDependency)(host, '@nestjs/swagger');
+                const nodeDependencyRef = getPackageJsonDependency(host, '@nestjs/swagger');
                 if (nodeDependencyRef) {
                     options.isSwaggerInstalled = true;
                     return;
                 }
             }
-            const nodeDependencyRef = (0, dependencies_utils_1.getPackageJsonDependency)(host, '@nestjs/mapped-types');
+            const nodeDependencyRef = getPackageJsonDependency(host, '@nestjs/mapped-types');
             if (!nodeDependencyRef) {
-                (0, dependencies_utils_1.addPackageJsonDependency)(host, {
-                    type: dependencies_utils_1.NodeDependencyType.Default,
+                addPackageJsonDependency(host, {
+                    type: NodeDependencyType.Default,
                     name: '@nestjs/mapped-types',
                     version: '*',
                 });
-                context.addTask(new tasks_1.NodePackageInstallTask());
+                context.addTask(new NodePackageInstallTask());
             }
         }
         catch {

package/dist/{lib → src/lib}/service/service.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { ServiceOptions } from './service.schema';
+import type { ServiceOptions } from './service.schema.js';
 export declare function main(options: ServiceOptions): Rule;

package/dist/src/lib/service/service.factory.js

@@ -0,0 +1,71 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, branchAndMerge, chain, filter, mergeWith, move, noop, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { normalizeToKebabOrSnakeCase } from '../../utils/formatting.js';
+import { ModuleDeclarator, } from '../../utils/module.declarator.js';
+import { ModuleFinder } from '../../utils/module.finder.js';
+import { NameParser } from '../../utils/name.parser.js';
+import { mergeSourceRoot } from '../../utils/source-root.helpers.js';
+function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+export function main(options) {
+    options = transform(options);
+    return (tree, context) => {
+        return branchAndMerge(chain([
+            mergeSourceRoot(options),
+            addDeclarationToModule(options),
+            mergeWith(generate(options)),
+        ]))(tree, context);
+    };
+}
+function transform(source) {
+    const target = Object.assign({}, source);
+    target.metadata = 'providers';
+    target.type = 'service';
+    if (isNullOrUndefined(target.name)) {
+        throw new SchematicsException('Option (name) is required.');
+    }
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    target.specFileSuffix = normalizeToKebabOrSnakeCase(source.specFileSuffix || 'spec');
+    target.path = target.flat
+        ? target.path
+        : join(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url(join('./files', options.language)), [
+        options.spec
+            ? noop()
+            : filter((path) => {
+                const languageExtension = options.language || 'ts';
+                const suffix = `.__specFileSuffix__.${languageExtension}`;
+                return !path.endsWith(suffix);
+            }),
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(options.path),
+    ])(context);
+}
+function addDeclarationToModule(options) {
+    return (tree) => {
+        if (options.skipImport !== undefined && options.skipImport) {
+            return tree;
+        }
+        options.module = new ModuleFinder(tree).find({
+            name: options.name,
+            path: options.path,
+        });
+        if (!options.module) {
+            return tree;
+        }
+        const content = tree.read(options.module).toString();
+        const declarator = new ModuleDeclarator();
+        tree.overwrite(options.module, declarator.declare(content, options));
+        return tree;
+    };
+}

package/dist/{lib → src/lib}/sub-app/sub-app.factory.d.ts

@@ -1,3 +1,3 @@
 import { Rule } from '@angular-devkit/schematics';
-import { SubAppOptions } from './sub-app.schema';
+import type { SubAppOptions } from './sub-app.schema.js';
 export declare function main(options: SubAppOptions): Rule;

package/dist/{lib → src/lib}/sub-app/sub-app.factory.js

@@ -1,43 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.main = main;
-const core_1 = require("@angular-devkit/core");
-const schematics_1 = require("@angular-devkit/schematics");
-const fs_1 = require("fs");
-const comment_json_1 = require("comment-json");
-const utils_1 = require("../../utils");
-const defaults_1 = require("../defaults");
-function main(options) {
+import { join, normalize, strings } from '@angular-devkit/core';
+import { apply, branchAndMerge, chain, mergeWith, move, noop, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { existsSync, readFileSync } from 'fs';
+import { parse, stringify } from 'comment-json';
+import { inPlaceSortByKeys, normalizeToKebabOrSnakeCase, } from '../../utils/index.js';
+import { DEFAULT_APPS_PATH, DEFAULT_APP_NAME, DEFAULT_DIR_ENTRY_APP, DEFAULT_LANGUAGE, DEFAULT_LIB_PATH, DEFAULT_PATH_NAME, PROJECT_TYPE, TEST_ENV, } from '../defaults.js';
+export function main(options) {
     const appName = getAppNameFromPackageJson();
     options = transform(options);
-    return (0, schematics_1.chain)([
-        updateTsConfig(),
+    return chain([
+        updateTsConfig(options.path, appName),
         updatePackageJson(options, appName),
         (tree, context) => isMonorepo(tree)
-            ? (0, schematics_1.noop)()(tree, context)
-            : (0, schematics_1.chain)([
-                (0, schematics_1.branchAndMerge)((0, schematics_1.mergeWith)(generateWorkspace(options, appName))),
+            ? noop()(tree, context)
+            : chain([
+                branchAndMerge(mergeWith(generateWorkspace(options, appName))),
                 moveDefaultAppToApps(options.path, appName, options.sourceRoot),
             ])(tree, context),
         addAppsToCliOptions(options.path, options.name, appName),
-        (0, schematics_1.branchAndMerge)((0, schematics_1.mergeWith)(generate(options))),
+        addTsConfigReference(options.path, options.name),
+        branchAndMerge(mergeWith(generate(options))),
     ]);
 }
 function getAppNameFromPackageJson() {
     try {
-        if (!(0, fs_1.existsSync)('./package.json')) {
-            return defaults_1.DEFAULT_DIR_ENTRY_APP;
+        if (!existsSync('./package.json')) {
+            return DEFAULT_DIR_ENTRY_APP;
         }
-        const packageJson = JSON.parse(stripBom((0, fs_1.readFileSync)('./package.json', 'utf-8')));
+        const packageJson = JSON.parse(stripBom(readFileSync('./package.json', 'utf-8')));
         if (!packageJson.name) {
-            return defaults_1.DEFAULT_DIR_ENTRY_APP;
+            return DEFAULT_DIR_ENTRY_APP;
         }
         let name = packageJson.name;
         name = name.replace(/[^\w.]+/g, '-').replace(/-+/g, '-');
         return name[0] === '-' ? name.substr(1) : name;
     }
     catch {
-        return defaults_1.DEFAULT_DIR_ENTRY_APP;
+        return DEFAULT_DIR_ENTRY_APP;
     }
 }
 function stripBom(value) {
@@ -48,16 +46,16 @@ function stripBom(value) {
 }
 function transform(options) {
     const target = Object.assign({}, options);
-    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_APPS_PATH;
+    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : DEFAULT_APPS_PATH;
     if (!target.name) {
-        target.name = defaults_1.DEFAULT_APP_NAME;
+        target.name = DEFAULT_APP_NAME;
     }
-    target.language = target.language ? target.language : defaults_1.DEFAULT_LANGUAGE;
-    target.name = (0, utils_1.normalizeToKebabOrSnakeCase)(target.name);
+    target.language = target.language ? target.language : DEFAULT_LANGUAGE;
+    target.name = normalizeToKebabOrSnakeCase(target.name);
     target.path =
         target.path !== undefined
-            ? (0, core_1.join)((0, core_1.normalize)(defaultSourceRoot), target.path)
-            : (0, core_1.normalize)(defaultSourceRoot);
+            ? join(normalize(defaultSourceRoot), target.path)
+            : normalize(defaultSourceRoot);
     return target;
 }
 function isMonorepo(host) {
@@ -72,20 +70,20 @@ function isMonorepo(host) {
         return false;
     }
     const sourceText = source.toString('utf-8');
-    const optionsObj = (0, comment_json_1.parse)(sourceText);
+    const optionsObj = parse(sourceText);
     return !!optionsObj.monorepo;
 }
 function updateJsonFile(host, path, callback) {
     const source = host.read(path);
     if (source) {
         const sourceText = source.toString('utf-8');
-        const json = (0, comment_json_1.parse)(sourceText);
+        const json = parse(sourceText);
         callback(json);
-        host.overwrite(path, (0, comment_json_1.stringify)(json, null, 2));
+        host.overwrite(path, stringify(json, null, 2));
     }
     return host;
 }
-function updateTsConfig() {
+function updateTsConfig(projectRoot, appName) {
     return (host) => {
         if (!host.exists('tsconfig.json')) {
             return host;
@@ -94,13 +92,40 @@ function updateTsConfig() {
             if (!tsconfig.compilerOptions) {
                 tsconfig.compilerOptions = {};
             }
-            if (!tsconfig.compilerOptions.baseUrl) {
-                tsconfig.compilerOptions.baseUrl = './';
+            delete tsconfig.compilerOptions.baseUrl;
+            delete tsconfig.compilerOptions.paths;
+            if (!tsconfig.files) {
+                tsconfig.files = [];
             }
-            if (!tsconfig.compilerOptions.paths) {
-                tsconfig.compilerOptions.paths = {};
+            delete tsconfig.include;
+            delete tsconfig.exclude;
+            if (!tsconfig.references) {
+                tsconfig.references = [];
+            }
+            const workspaceAppTsConfigPath = join(projectRoot, appName, 'tsconfig.app.json');
+            const hasWorkspaceRef = tsconfig.references.some((ref) => ref.path === `./${workspaceAppTsConfigPath}`);
+            if (!hasWorkspaceRef) {
+                tsconfig.references.push({
+                    path: `./${workspaceAppTsConfigPath}`,
+                });
+            }
+        });
+    };
+}
+function addTsConfigReference(projectRoot, projectName) {
+    return (host) => {
+        if (!host.exists('tsconfig.json')) {
+            return host;
+        }
+        return updateJsonFile(host, 'tsconfig.json', (tsconfig) => {
+            if (!tsconfig.references) {
+                tsconfig.references = [];
+            }
+            const refPath = `./${join(projectRoot, projectName, 'tsconfig.app.json')}`;
+            const hasRef = tsconfig.references.some((ref) => ref.path === refPath);
+            if (!hasRef) {
+                tsconfig.references.push({ path: refPath });
             }
-            (0, utils_1.inPlaceSortByKeys)(tsconfig.compilerOptions.paths);
         });
     };
 }
@@ -130,18 +155,18 @@ function updateNpmScripts(scripts, options, defaultAppName) {
     if (scripts[defaultTestScriptName] &&
         scripts[defaultTestScriptName].indexOf(options.path) < 0) {
         const defaultTestDir = 'test';
-        const newTestDir = (0, core_1.join)(options.path, defaultAppName, defaultTestDir);
+        const newTestDir = join(options.path, defaultAppName, defaultTestDir);
         scripts[defaultTestScriptName] = scripts[defaultTestScriptName].replace(defaultTestDir, newTestDir);
     }
     if (scripts[defaultFormatScriptName] &&
-        scripts[defaultFormatScriptName].indexOf(defaults_1.DEFAULT_PATH_NAME) >= 0) {
-        const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_APPS_PATH;
+        scripts[defaultFormatScriptName].indexOf(DEFAULT_PATH_NAME) >= 0) {
+        const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : DEFAULT_APPS_PATH;
         scripts[defaultFormatScriptName] =
-            `prettier --write "${defaultSourceRoot}/**/*.ts" "${defaults_1.DEFAULT_LIB_PATH}/**/*.ts"`;
+            `prettier --write "${defaultSourceRoot}/**/*.ts" "${DEFAULT_LIB_PATH}/**/*.ts"`;
     }
     if (scripts[defaultStartScriptName] &&
         scripts[defaultStartScriptName].indexOf('dist/main') >= 0) {
-        const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_APPS_PATH;
+        const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : DEFAULT_APPS_PATH;
         scripts[defaultStartScriptName] =
             `node dist/${defaultSourceRoot}/${defaultAppName}/main`;
     }
@@ -150,11 +175,11 @@ function updateJestOptions(jestOptions, options) {
     if (!jestOptions) {
         return;
     }
-    if (jestOptions.rootDir === defaults_1.DEFAULT_PATH_NAME) {
+    if (jestOptions.rootDir === DEFAULT_PATH_NAME) {
         jestOptions.rootDir = '.';
         jestOptions.coverageDirectory = './coverage';
     }
-    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_APPS_PATH;
+    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : DEFAULT_APPS_PATH;
     const jestSourceRoot = `<rootDir>/${defaultSourceRoot}/`;
     if (!jestOptions.roots) {
         jestOptions.roots = [jestSourceRoot];
@@ -168,12 +193,12 @@ function updateJestOptions(jestOptions, options) {
         }
     }
 }
-function moveDefaultAppToApps(projectRoot, appName, sourceRoot = defaults_1.DEFAULT_PATH_NAME) {
+function moveDefaultAppToApps(projectRoot, appName, sourceRoot = DEFAULT_PATH_NAME) {
     return (host) => {
-        if (process.env.NODE_ENV === defaults_1.TEST_ENV) {
+        if (process.env.NODE_ENV === TEST_ENV) {
             return host;
         }
-        const appDestination = (0, core_1.join)(projectRoot, appName);
+        const appDestination = join(projectRoot, appName);
         moveDirectoryTo(sourceRoot, appDestination, host);
         moveDirectoryTo('test', appDestination, host);
         return host;
@@ -183,7 +208,7 @@ function moveDirectoryTo(srcDir, destination, tree) {
     let srcDirExists = false;
     tree.getDir(srcDir).visit((filePath, file) => {
         srcDirExists = true;
-        const newFilePath = (0, core_1.join)(destination, filePath);
+        const newFilePath = join(destination, filePath);
         tree.create(newFilePath, file.content);
     });
     if (srcDirExists) {
@@ -191,14 +216,14 @@ function moveDirectoryTo(srcDir, destination, tree) {
     }
 }
 function addAppsToCliOptions(projectRoot, projectName, appName) {
-    const rootPath = (0, core_1.join)(projectRoot, projectName);
+    const rootPath = join(projectRoot, projectName);
     const project = {
-        type: defaults_1.PROJECT_TYPE.APPLICATION,
+        type: PROJECT_TYPE.APPLICATION,
         root: rootPath,
         entryFile: 'main',
-        sourceRoot: (0, core_1.join)(rootPath, defaults_1.DEFAULT_PATH_NAME),
+        sourceRoot: join(rootPath, DEFAULT_PATH_NAME),
         compilerOptions: {
-            tsConfigPath: (0, core_1.join)(rootPath, 'tsconfig.app.json'),
+            tsConfigPath: join(rootPath, 'tsconfig.app.json'),
         },
     };
     return (host) => {
@@ -214,10 +239,10 @@ function addAppsToCliOptions(projectRoot, projectName, appName) {
                 optionsFile.projects = {};
             }
             if (optionsFile.projects[projectName]) {
-                throw new schematics_1.SchematicsException(`Project "${projectName}" exists in this workspace already.`);
+                throw new SchematicsException(`Project "${projectName}" exists in this workspace already.`);
             }
             optionsFile.projects[projectName] = project;
-            (0, utils_1.inPlaceSortByKeys)(optionsFile.projects);
+            inPlaceSortByKeys(optionsFile.projects);
         });
     };
 }
@@ -225,47 +250,47 @@ function updateMainAppOptions(optionsFile, projectRoot, appName) {
     if (optionsFile.monorepo) {
         return;
     }
-    const rootFilePath = (0, core_1.join)(projectRoot, appName);
-    const tsConfigPath = (0, core_1.join)(rootFilePath, 'tsconfig.app.json');
+    const rootFilePath = join(projectRoot, appName);
+    const tsConfigPath = join(rootFilePath, 'tsconfig.app.json');
     optionsFile.monorepo = true;
     optionsFile.root = rootFilePath;
-    optionsFile.sourceRoot = (0, core_1.join)(projectRoot, appName, optionsFile.sourceRoot || defaults_1.DEFAULT_PATH_NAME);
+    optionsFile.sourceRoot = join(projectRoot, appName, optionsFile.sourceRoot || DEFAULT_PATH_NAME);
     if (!optionsFile.compilerOptions) {
         optionsFile.compilerOptions = {};
     }
-    optionsFile.compilerOptions.webpack = true;
+    optionsFile.compilerOptions.builder = 'rspack';
     optionsFile.compilerOptions.tsConfigPath = tsConfigPath;
     if (!optionsFile.projects) {
         optionsFile.projects = {};
     }
     optionsFile.projects[appName] = {
-        type: defaults_1.PROJECT_TYPE.APPLICATION,
+        type: PROJECT_TYPE.APPLICATION,
         root: rootFilePath,
         entryFile: optionsFile.entryFile || 'main',
-        sourceRoot: (0, core_1.join)(rootFilePath, defaults_1.DEFAULT_PATH_NAME),
+        sourceRoot: join(rootFilePath, DEFAULT_PATH_NAME),
         compilerOptions: {
             tsConfigPath,
         },
     };
 }
 function generateWorkspace(options, appName) {
-    const path = (0, core_1.join)(options.path, appName);
-    return (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./workspace', options.language)), [
-        (0, schematics_1.template)({
-            ...core_1.strings,
+    const path = join(options.path, appName);
+    return apply(url(join('./workspace', options.language)), [
+        template({
+            ...strings,
             ...options,
             name: appName,
         }),
-        (0, schematics_1.move)(path),
+        move(path),
     ]);
 }
 function generate(options) {
-    const path = (0, core_1.join)(options.path, options.name);
-    return (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./files', options.language)), [
-        (0, schematics_1.template)({
-            ...core_1.strings,
+    const path = join(options.path, options.name);
+    return apply(url(join('./files', options.language)), [
+        template({
+            ...strings,
             ...options,
         }),
-        (0, schematics_1.move)(path),
+        move(path),
     ]);
 }

package/dist/{utils → src/utils}/dependencies.utils.js

@@ -1,33 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeDependencyType = void 0;
-exports.addPackageJsonDependency = addPackageJsonDependency;
-exports.getPackageJsonDependency = getPackageJsonDependency;
-const json_file_util_1 = require("./json-file.util");
+import { JSONFile } from './json-file.util.js';
 const PKG_JSON_PATH = '/package.json';
-var NodeDependencyType;
+export var NodeDependencyType;
 (function (NodeDependencyType) {
     NodeDependencyType["Default"] = "dependencies";
     NodeDependencyType["Dev"] = "devDependencies";
     NodeDependencyType["Peer"] = "peerDependencies";
     NodeDependencyType["Optional"] = "optionalDependencies";
-})(NodeDependencyType || (exports.NodeDependencyType = NodeDependencyType = {}));
+})(NodeDependencyType || (NodeDependencyType = {}));
 const ALL_DEPENDENCY_TYPE = [
     NodeDependencyType.Default,
     NodeDependencyType.Dev,
     NodeDependencyType.Optional,
     NodeDependencyType.Peer,
 ];
-function addPackageJsonDependency(tree, dependency, pkgJsonPath = PKG_JSON_PATH) {
-    const json = new json_file_util_1.JSONFile(tree, pkgJsonPath);
+export function addPackageJsonDependency(tree, dependency, pkgJsonPath = PKG_JSON_PATH) {
+    const json = new JSONFile(tree, pkgJsonPath);
     const { overwrite, type, name, version } = dependency;
     const path = [type, name];
     if (overwrite || !json.get(path)) {
         json.modify(path, version);
     }
 }
-function getPackageJsonDependency(tree, name, pkgJsonPath = PKG_JSON_PATH) {
-    const json = new json_file_util_1.JSONFile(tree, pkgJsonPath);
+export function getPackageJsonDependency(tree, name, pkgJsonPath = PKG_JSON_PATH) {
+    const json = new JSONFile(tree, pkgJsonPath);
     for (const depType of ALL_DEPENDENCY_TYPE) {
         const version = json.get([depType, name]);
         if (typeof version === 'string') {

package/dist/{utils → src/utils}/formatting.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeToKebabOrSnakeCase = normalizeToKebabOrSnakeCase;
-function normalizeToKebabOrSnakeCase(str) {
+export function normalizeToKebabOrSnakeCase(str) {
     const STRING_DASHERIZE_REGEXP = /\s/g;
     const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
     return str

package/dist/src/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './metadata.manager.js';
+export * from './module-import.declarator.js';
+export * from './module-metadata.declarator.js';
+export * from './module.declarator.js';
+export * from './module.finder.js';
+export * from './name.parser.js';
+export * from './path.solver.js';
+export * from './source-root.helpers.js';
+export * from './formatting.js';
+export * from './jest-module-mapper.js';
+export * from './object-sorting.js';

package/dist/src/utils/index.js

@@ -0,0 +1,11 @@
+export * from './metadata.manager.js';
+export * from './module-import.declarator.js';
+export * from './module-metadata.declarator.js';
+export * from './module.declarator.js';
+export * from './module.finder.js';
+export * from './name.parser.js';
+export * from './path.solver.js';
+export * from './source-root.helpers.js';
+export * from './formatting.js';
+export * from './jest-module-mapper.js';
+export * from './object-sorting.js';

package/dist/src/utils/jest-module-mapper.js

@@ -0,0 +1,6 @@
+export function createModuleNameMapper(packageKey, packageRoot) {
+    const moduleNameMapper = {};
+    const packageKeyRegex = '^' + packageKey + '(|/.*)$';
+    moduleNameMapper[packageKeyRegex] = packageRoot + '/$1';
+    return moduleNameMapper;
+}