@nestjs/schematics 12.0.0-alpha.1 → 12.0.0-alpha.2

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils/index.js';
+export * from './lib/defaults.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './utils/index.js';
+export * from './lib/defaults.js';

package/dist/lib/application/application.factory.d.ts

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

package/dist/lib/application/application.factory.js

@@ -0,0 +1,64 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, filter, mergeWith, move, noop, template, url, } from '@angular-devkit/schematics';
+import { basename, parse } from 'path';
+import { normalizeToKebabOrSnakeCase } from '../../utils/formatting.js';
+import { DEFAULT_AUTHOR, DEFAULT_DESCRIPTION, DEFAULT_LANGUAGE, DEFAULT_VERSION, } from '../defaults.js';
+export function main(options) {
+    options.name = normalizeToKebabOrSnakeCase(options.name.toString());
+    const path = !options.directory || options.directory === 'undefined'
+        ? options.name
+        : options.directory;
+    options = transform(options);
+    return mergeWith(generate(options, path));
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    target.author = target.author ? target.author : DEFAULT_AUTHOR;
+    target.description = target.description
+        ? target.description
+        : DEFAULT_DESCRIPTION;
+    target.language = target.language ? target.language : DEFAULT_LANGUAGE;
+    target.name = resolvePackageName(target.name.toString());
+    target.version = target.version ? target.version : DEFAULT_VERSION;
+    target.type = target.type ?? 'cjs';
+    target.specFileSuffix = normalizeToKebabOrSnakeCase(options.specFileSuffix || 'spec');
+    target.packageManager =
+        !target.packageManager || target.packageManager === 'undefined'
+            ? 'npm'
+            : target.packageManager;
+    target.dependencies = target.dependencies ? target.dependencies : '';
+    target.devDependencies = target.devDependencies ? target.devDependencies : '';
+    return target;
+}
+function resolvePackageName(path) {
+    const { base: baseFilename, dir: dirname } = parse(path);
+    if (baseFilename === '.') {
+        return basename(process.cwd());
+    }
+    if (dirname.match(/^@[^\s]/)) {
+        return `${dirname}/${baseFilename}`;
+    }
+    return baseFilename;
+}
+function generate(options, path) {
+    const templateDir = options.type === 'esm' && options.language === 'ts'
+        ? 'ts-esm'
+        : options.language;
+    return apply(url(join('./files', templateDir)), [
+        options.spec
+            ? noop()
+            : filter((path) => !path.endsWith('__specFileSuffix__.ts')),
+        options.spec
+            ? noop()
+            : filter((path) => {
+                const languageExtension = options.language || 'ts';
+                const suffix = `__specFileSuffix__.${languageExtension}`;
+                return !path.endsWith(suffix);
+            }),
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(path),
+    ]);
+}

package/dist/lib/class/class.factory.d.ts

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

package/dist/lib/class/class.factory.js

@@ -0,0 +1,48 @@
+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';
+import { DEFAULT_LANGUAGE } from '../defaults.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.specFileSuffix = normalizeToKebabOrSnakeCase(options.specFileSuffix || 'spec');
+    if (target.name.includes('.')) {
+        target.className = strings.classify(target.name).replace('.', '');
+    }
+    else {
+        target.className = target.name;
+    }
+    target.language =
+        target.language !== undefined ? target.language : DEFAULT_LANGUAGE;
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    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/client-app/angular/angular.factory.d.ts

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

package/dist/lib/client-app/angular/angular.factory.js

@@ -0,0 +1,100 @@
+import { strings } from '@angular-devkit/core';
+import { apply, branchAndMerge, chain, externalSchematic, mergeWith, move, noop, template, url, } from '@angular-devkit/schematics';
+import { join } from 'path';
+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([
+            createAngularApplication(options),
+            mergeSourceRoot(options),
+            addDeclarationToModule(options),
+            addGlobalPrefix(),
+            mergeWith(generate(options)),
+        ]))(tree, context);
+    };
+}
+function transform(source) {
+    const target = Object.assign({}, source);
+    target.directory = target.name ? strings.dasherize(target.name) : 'client';
+    target.name = 'Angular';
+    target.metadata = 'imports';
+    target.type = 'module';
+    const location = new NameParser().parse(target);
+    target.name = strings.dasherize(location.name);
+    target.path = join(strings.dasherize(location.path), target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url('./files'), [
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(options.path),
+    ])(context);
+}
+function createAngularApplication(options) {
+    if (!options.initApp) {
+        return noop();
+    }
+    return externalSchematic('@schematics/angular', 'ng-new', {
+        name: options.directory,
+        version: '8.0.0',
+    });
+}
+function addDeclarationToModule(options) {
+    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();
+        const rootPath = `${options.directory}/dist/${options.directory}`;
+        const staticOptions = {
+            name: 'forRoot',
+            value: {
+                rootPath,
+            },
+        };
+        const declarationOptions = {
+            ...options,
+            staticOptions,
+        };
+        tree.overwrite(options.module, declarator.declare(content, declarationOptions));
+        return tree;
+    };
+}
+function addGlobalPrefix() {
+    return (tree) => {
+        const mainFilePath = 'src/main.ts';
+        const fileRef = tree.get(mainFilePath);
+        if (!fileRef) {
+            return tree;
+        }
+        const ts = require('ts-morph');
+        const tsProject = new ts.Project({
+            manipulationSettings: {
+                indentationText: ts.IndentationText.TwoSpaces,
+            },
+        });
+        const tsFile = tsProject.addSourceFileAtPath(mainFilePath);
+        const bootstrapFunction = tsFile.getFunction('bootstrap');
+        const listenStatement = bootstrapFunction.getStatement((node) => node.getText().includes('listen'));
+        const setPrefixStatement = bootstrapFunction.getStatement((node) => node.getText().includes('setGlobalPrefix'));
+        if (!listenStatement || setPrefixStatement) {
+            return tree;
+        }
+        const listenExprIndex = listenStatement.getChildIndex();
+        bootstrapFunction.insertStatements(listenExprIndex, `app.setGlobalPrefix('api');`);
+        tree.overwrite(mainFilePath, tsFile.getFullText());
+        return tree;
+    };
+}

package/dist/lib/configuration/configuration.factory.d.ts

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

package/dist/lib/configuration/configuration.factory.js

@@ -0,0 +1,24 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, mergeWith, move, template, url, } from '@angular-devkit/schematics';
+import { DEFAULT_LANGUAGE } from '../defaults.js';
+export function main(options) {
+    return mergeWith(generate(transform(options)));
+}
+function transform(options) {
+    const target = Object.assign({}, options);
+    target.language =
+        target.language !== undefined ? target.language : DEFAULT_LANGUAGE;
+    target.collection =
+        target.collection !== undefined ? target.collection : '@nestjs/schematics';
+    return target;
+}
+function generate(options) {
+    const projectOrPath = options.project ?? '.';
+    return apply(url(join('./files', options.language)), [
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(projectOrPath),
+    ]);
+}

package/dist/lib/controller/controller.factory.d.ts

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

package/dist/lib/controller/controller.factory.js

@@ -0,0 +1,69 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, branchAndMerge, chain, filter, mergeWith, move, noop, 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';
+import { DEFAULT_LANGUAGE } from '../defaults.js';
+const ELEMENT_METADATA = 'controllers';
+const ELEMENT_TYPE = 'controller';
+export function main(options) {
+    options = transform(options);
+    return (tree, context) => {
+        return branchAndMerge(chain([
+            mergeSourceRoot(options),
+            mergeWith(generate(options)),
+            addDeclarationToModule(options),
+        ]))(tree, context);
+    };
+}
+function transform(source) {
+    const target = Object.assign({}, source);
+    target.metadata = ELEMENT_METADATA;
+    target.type = ELEMENT_TYPE;
+    const location = new NameParser().parse(target);
+    target.name = normalizeToKebabOrSnakeCase(location.name);
+    target.path = normalizeToKebabOrSnakeCase(location.path);
+    target.language =
+        target.language !== undefined ? target.language : DEFAULT_LANGUAGE;
+    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/decorator/decorator.factory.d.ts

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

package/dist/lib/decorator/decorator.factory.js

@@ -0,0 +1,32 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, chain, mergeWith, move, 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.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);
+}

package/dist/lib/defaults.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_AUTHOR = "";
+export declare const DEFAULT_DESCRIPTION = "";
+export declare const DEFAULT_LANGUAGE = "ts";
+export declare const DEFAULT_VERSION = "0.0.1";
+export declare const DEFAULT_PATH_NAME = "src";
+export declare const DEFAULT_LIB_PATH = "libs";
+export declare const DEFAULT_APPS_PATH = "apps";
+export declare const DEFAULT_APP_NAME = "app";
+export declare const DEFAULT_DIR_ENTRY_APP = "main";
+export declare const TEST_ENV = "test";
+export declare const PROJECT_TYPE: {
+    LIBRARY: string;
+    APPLICATION: string;
+};

package/dist/lib/defaults.js

@@ -0,0 +1,14 @@
+export const DEFAULT_AUTHOR = '';
+export const DEFAULT_DESCRIPTION = '';
+export const DEFAULT_LANGUAGE = 'ts';
+export const DEFAULT_VERSION = '0.0.1';
+export const DEFAULT_PATH_NAME = 'src';
+export const DEFAULT_LIB_PATH = 'libs';
+export const DEFAULT_APPS_PATH = 'apps';
+export const DEFAULT_APP_NAME = 'app';
+export const DEFAULT_DIR_ENTRY_APP = 'main';
+export const TEST_ENV = 'test';
+export const PROJECT_TYPE = {
+    LIBRARY: 'library',
+    APPLICATION: 'application',
+};

package/dist/lib/filter/filter.factory.d.ts

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

package/dist/lib/filter/filter.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/gateway/gateway.factory.d.ts

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

package/dist/lib/gateway/gateway.factory.js

@@ -0,0 +1,69 @@
+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 = 'gateway';
+    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) => !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);
+}
+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/guard/guard.factory.d.ts

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

package/dist/lib/guard/guard.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/interceptor/interceptor.factory.d.ts

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

package/dist/lib/interceptor/interceptor.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/interface/interface.factory.d.ts

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

package/dist/lib/interface/interface.factory.js

@@ -0,0 +1,31 @@
+import { join, strings } from '@angular-devkit/core';
+import { apply, chain, mergeWith, move, 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.path = target.flat
+        ? target.path
+        : join(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => apply(url('./files'), [
+        template({
+            ...strings,
+            ...options,
+        }),
+        move(options.path),
+    ])(context);
+}