@nestjs/schematics 11.0.8 → 12.0.0-alpha.0

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

@@ -1,24 +1,21 @@
-"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 jsonc_parser_1 = require("jsonc-parser");
-const utils_1 = require("../../utils");
-const defaults_1 = require("../defaults");
-const readers_1 = require("../readers");
-function main(options) {
+import { join, normalize, strings } from '@angular-devkit/core';
+import { apply, branchAndMerge, chain, mergeWith, move, SchematicsException, template, url, } from '@angular-devkit/schematics';
+import { parse } from 'jsonc-parser';
+import { createModuleNameMapper, inPlaceSortByKeys, normalizeToKebabOrSnakeCase, } from '../../utils/index.js';
+import { DEFAULT_LANGUAGE, DEFAULT_LIB_PATH, DEFAULT_PATH_NAME, PROJECT_TYPE, } from '../defaults.js';
+import { FileSystemReader } from '../readers/index.js';
+export function main(options) {
     options = transform(options);
-    return (0, schematics_1.chain)([
+    return chain([
         addLibraryToCliOptions(options.path, options.name),
         updatePackageJson(options),
         updateJestEndToEnd(options),
         updateTsConfig(options.name, options.prefix, options.path),
-        (0, schematics_1.branchAndMerge)((0, schematics_1.mergeWith)(generate(options))),
+        branchAndMerge(mergeWith(generate(options))),
     ]);
 }
 function getDefaultLibraryPrefix(defaultLibraryPrefix = '@app') {
-    const fileSystemReader = new readers_1.FileSystemReader(process.cwd());
+    const fileSystemReader = new FileSystemReader(process.cwd());
     const content = fileSystemReader.readSyncAnyOf([
         'nest-cli.json',
         '.nestcli.json',
@@ -38,16 +35,16 @@ function getDefaultLibraryPrefix(defaultLibraryPrefix = '@app') {
 }
 function transform(options) {
     const target = Object.assign({}, options);
-    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_LIB_PATH;
+    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : DEFAULT_LIB_PATH;
     if (!target.name) {
-        throw new schematics_1.SchematicsException('Option (name) is required.');
+        throw new SchematicsException('Option (name) is required.');
     }
-    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);
     target.prefix = target.prefix || getDefaultLibraryPrefix();
     return target;
 }
@@ -56,7 +53,7 @@ function updatePackageJson(options) {
         if (!host.exists('package.json')) {
             return host;
         }
-        const distRoot = (0, core_1.join)(options.path, options.name, 'src');
+        const distRoot = join(options.path, options.name, 'src');
         const packageKey = options.prefix
             ? options.prefix + '/' + options.name
             : options.name;
@@ -70,11 +67,11 @@ function updateJestConfig(jestOptions, options, packageKey, distRoot) {
     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_LIB_PATH;
+    const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : DEFAULT_LIB_PATH;
     const jestSourceRoot = `<rootDir>/${defaultSourceRoot}/`;
     if (!jestOptions.roots) {
         jestOptions.roots = ['<rootDir>/src/', jestSourceRoot];
@@ -85,10 +82,10 @@ function updateJestConfig(jestOptions, options, packageKey, distRoot) {
     if (!jestOptions.moduleNameMapper) {
         jestOptions.moduleNameMapper = {};
     }
-    const packageRoot = (0, core_1.join)('<rootDir>', distRoot);
-    const newMapper = (0, utils_1.createModuleNameMapper)(packageKey, packageRoot);
+    const packageRoot = join('<rootDir>', distRoot);
+    const newMapper = createModuleNameMapper(packageKey, packageRoot);
     Object.assign(jestOptions.moduleNameMapper, newMapper);
-    (0, utils_1.inPlaceSortByKeys)(jestOptions.moduleNameMapper);
+    inPlaceSortByKeys(jestOptions.moduleNameMapper);
 }
 function updateNpmScripts(scripts, options) {
     if (!scripts) {
@@ -99,19 +96,19 @@ function updateNpmScripts(scripts, options) {
         return;
     }
     if (scripts[defaultFormatScriptName] &&
-        scripts[defaultFormatScriptName].indexOf(defaults_1.DEFAULT_PATH_NAME) >= 0) {
-        const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : defaults_1.DEFAULT_LIB_PATH;
+        scripts[defaultFormatScriptName].indexOf(DEFAULT_PATH_NAME) >= 0) {
+        const defaultSourceRoot = options.rootDir !== undefined ? options.rootDir : DEFAULT_LIB_PATH;
         scripts[defaultFormatScriptName] =
             `prettier --write "src/**/*.ts" "test/**/*.ts" "${defaultSourceRoot}/**/*.ts"`;
     }
 }
 function updateJestEndToEnd(options) {
     return (host) => {
-        const pathToFile = (0, core_1.join)('test', 'jest-e2e.json');
+        const pathToFile = join('test', 'jest-e2e.json');
         if (!host.exists(pathToFile)) {
             return host;
         }
-        const distRoot = (0, core_1.join)(options.path, options.name, 'src');
+        const distRoot = join(options.path, options.name, 'src');
         const packageKey = options.prefix
             ? options.prefix + '/' + options.name
             : options.name;
@@ -120,9 +117,9 @@ function updateJestEndToEnd(options) {
                 jestOptions.moduleNameMapper = {};
             }
             const packageRoot = '<rootDir>/../' + distRoot;
-            const newMapper = (0, utils_1.createModuleNameMapper)(packageKey, packageRoot);
+            const newMapper = createModuleNameMapper(packageKey, packageRoot);
             Object.assign(jestOptions.moduleNameMapper, newMapper);
-            (0, utils_1.inPlaceSortByKeys)(jestOptions.moduleNameMapper);
+            inPlaceSortByKeys(jestOptions.moduleNameMapper);
         });
     };
 }
@@ -130,53 +127,43 @@ function updateJsonFile(host, path, callback) {
     const source = host.read(path);
     if (source) {
         const sourceText = source.toString('utf-8');
-        const json = (0, jsonc_parser_1.parse)(sourceText);
+        const json = parse(sourceText);
         callback(json);
         host.overwrite(path, JSON.stringify(json, null, 2));
     }
     return host;
 }
-function updateTsConfig(packageName, packagePrefix, root) {
+function updateTsConfig(packageName, _packagePrefix, root) {
     return (host) => {
         if (!host.exists('tsconfig.json')) {
             return host;
         }
-        const distRoot = (0, core_1.join)(root, packageName, 'src');
-        const packageKey = packagePrefix
-            ? packagePrefix + '/' + packageName
-            : packageName;
+        const refPath = `./${join(root, packageName, 'tsconfig.lib.json')}`;
         return updateJsonFile(host, 'tsconfig.json', (tsconfig) => {
             if (!tsconfig.compilerOptions) {
                 tsconfig.compilerOptions = {};
             }
-            if (!tsconfig.compilerOptions.baseUrl) {
-                tsconfig.compilerOptions.baseUrl = './';
+            delete tsconfig.compilerOptions.baseUrl;
+            delete tsconfig.compilerOptions.paths;
+            if (!tsconfig.references) {
+                tsconfig.references = [];
             }
-            if (!tsconfig.compilerOptions.paths) {
-                tsconfig.compilerOptions.paths = {};
+            const hasRef = tsconfig.references.some((ref) => ref.path === refPath);
+            if (!hasRef) {
+                tsconfig.references.push({ path: refPath });
             }
-            if (!tsconfig.compilerOptions.paths[packageKey]) {
-                tsconfig.compilerOptions.paths[packageKey] = [];
-            }
-            tsconfig.compilerOptions.paths[packageKey].push(distRoot);
-            const deepPackagePath = packageKey + '/*';
-            if (!tsconfig.compilerOptions.paths[deepPackagePath]) {
-                tsconfig.compilerOptions.paths[deepPackagePath] = [];
-            }
-            tsconfig.compilerOptions.paths[deepPackagePath].push(distRoot + '/*');
-            (0, utils_1.inPlaceSortByKeys)(tsconfig.compilerOptions.paths);
         });
     };
 }
 function addLibraryToCliOptions(projectRoot, projectName) {
-    const rootPath = (0, core_1.join)(projectRoot, projectName);
+    const rootPath = join(projectRoot, projectName);
     const project = {
-        type: defaults_1.PROJECT_TYPE.LIBRARY,
+        type: PROJECT_TYPE.LIBRARY,
         root: rootPath,
         entryFile: 'index',
-        sourceRoot: (0, core_1.join)(rootPath, 'src'),
+        sourceRoot: join(rootPath, 'src'),
         compilerOptions: {
-            tsConfigPath: (0, core_1.join)(rootPath, 'tsconfig.lib.json'),
+            tsConfigPath: join(rootPath, 'tsconfig.lib.json'),
         },
     };
     return (host) => {
@@ -193,24 +180,24 @@ function addLibraryToCliOptions(projectRoot, projectName) {
             if (!optionsFile.compilerOptions) {
                 optionsFile.compilerOptions = {};
             }
-            if (optionsFile.compilerOptions.webpack === undefined) {
-                optionsFile.compilerOptions.webpack = true;
+            if (optionsFile.compilerOptions.builder === undefined) {
+                optionsFile.compilerOptions.builder = 'rspack';
             }
             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);
         });
     };
 }
 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/{lib → src/lib}/middleware/middleware.factory.d.ts

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

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

@@ -0,0 +1,40 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, chain, filter, mergeWith, move, noop, SchematicsException, template, url, } from '@angular-devkit/schematics';
+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 chain([mergeSourceRoot(options), mergeWith(generate(options))]);
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!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(options.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);
+}

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

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

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

@@ -0,0 +1,57 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, branchAndMerge, chain, mergeWith, move, 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';
+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 = 'imports';
+    target.type = 'module';
+    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.path = target.flat
+        ? target.path
+        : join(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url(join('./files', options.language)), [
+        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}/pipe/pipe.factory.d.ts

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

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

@@ -0,0 +1,41 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, chain, filter, mergeWith, move, noop, SchematicsException, template, url, } from '@angular-devkit/schematics';
+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 chain([mergeSourceRoot(options), mergeWith(generate(options))]);
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!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(options.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) => !path.endsWith('.spec.ts')),
+        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);
+}

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

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

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

@@ -0,0 +1,73 @@
+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';
+export function main(options) {
+    options = transform(options);
+    return (tree, context) => {
+        return branchAndMerge(chain([
+            mergeSourceRoot(options),
+            addDeclarationToModule(options),
+            mergeWith(generate(options)),
+        ]))(tree, context);
+    };
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    target.metadata = 'providers';
+    target.specFileSuffix = normalizeToKebabOrSnakeCase(options.specFileSuffix || 'spec');
+    if (!target.name) {
+        throw new SchematicsException('Option (name) is required.');
+    }
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    if (target.name.includes('.')) {
+        target.className = strings.classify(target.name).replace('.', '');
+    }
+    else {
+        target.className = strings.classify(target.name);
+    }
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    target.language = target.language !== undefined ? target.language : 'ts';
+    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}/readers/file-system.reader.d.ts

@@ -1,4 +1,4 @@
-import { Reader } from './reader';
+import { Reader } from './reader.js';
 export declare class FileSystemReader implements Reader {
     private readonly directory;
     constructor(directory: string);

package/dist/{lib → src/lib}/readers/file-system.reader.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemReader = void 0;
-const fs = require("fs");
-const path = require("path");
-class FileSystemReader {
+import * as fs from 'fs';
+import * as path from 'path';
+export class FileSystemReader {
     directory;
     constructor(directory) {
         this.directory = directory;
@@ -42,4 +39,3 @@ class FileSystemReader {
         }
     }
 }
-exports.FileSystemReader = FileSystemReader;

package/dist/src/lib/readers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reader.js';
+export * from './file-system.reader.js';

package/dist/src/lib/readers/index.js

@@ -0,0 +1,2 @@
+export * from './reader.js';
+export * from './file-system.reader.js';

package/dist/src/lib/readers/reader.js

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,68 @@
+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';
+export function main(options) {
+    options = transform(options);
+    return (tree, context) => {
+        return branchAndMerge(chain([
+            mergeSourceRoot(options),
+            addDeclarationToModule(options),
+            mergeWith(generate(options)),
+        ]))(tree, context);
+    };
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new SchematicsException('Option (name) is required.');
+    }
+    target.metadata = 'providers';
+    target.type = 'resolver';
+    target.specFileSuffix = normalizeToKebabOrSnakeCase(options.specFileSuffix || 'spec');
+    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.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}/resource/resource.factory.d.ts

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