@depup/nestjs__cli 11.0.16-depup.1

package/actions/info.action.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoAction = void 0;
+const ansis_1 = require("ansis");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const package_managers_1 = require("../lib/package-managers");
+const ui_1 = require("../lib/ui");
+const abstract_action_1 = require("./abstract.action");
+const os_info_utils_1 = require("../lib/utils/os-info.utils");
+class InfoAction extends abstract_action_1.AbstractAction {
+    constructor() {
+        super(...arguments);
+        // Nest dependencies whitelist used to compare the major version
+        this.warningMessageDependenciesWhiteList = [
+            '@nestjs/core',
+            '@nestjs/common',
+            '@nestjs/schematics',
+            '@nestjs/platform-express',
+            '@nestjs/platform-fastify',
+            '@nestjs/platform-socket.io',
+            '@nestjs/platform-ws',
+            '@nestjs/websockets',
+        ];
+    }
+    async handle() {
+        this.manager = await package_managers_1.PackageManagerFactory.find();
+        this.displayBanner();
+        await this.displaySystemInformation();
+        await this.displayNestInformation();
+    }
+    displayBanner() {
+        console.info((0, ansis_1.red)(ui_1.BANNER));
+    }
+    async displaySystemInformation() {
+        console.info((0, ansis_1.green) `[System Information]`);
+        console.info('OS Version     :', (0, ansis_1.blue)((0, os_info_utils_1.default)((0, os_1.platform)(), (0, os_1.release)()) + (0, os_1.release)()));
+        console.info('NodeJS Version :', (0, ansis_1.blue)(process.version));
+        await this.displayPackageManagerVersion();
+    }
+    async displayPackageManagerVersion() {
+        try {
+            const version = await this.manager.version();
+            console.info(`${this.manager.name} Version    :`, (0, ansis_1.blue)(version), '\n');
+        }
+        catch {
+            console.error(`${this.manager.name} Version    :`, (0, ansis_1.red) `Unknown`, '\n');
+        }
+    }
+    async displayNestInformation() {
+        this.displayCliVersion();
+        console.info((0, ansis_1.green) `[Nest Platform Information]`);
+        await this.displayNestInformationFromPackage();
+    }
+    async displayNestInformationFromPackage() {
+        try {
+            const dependencies = this.readProjectPackageDependencies();
+            this.displayNestVersions(dependencies);
+        }
+        catch (err) {
+            console.error((0, ansis_1.red)(ui_1.MESSAGES.NEST_INFORMATION_PACKAGE_MANAGER_FAILED));
+        }
+    }
+    displayCliVersion() {
+        console.info((0, ansis_1.green) `[Nest CLI]`);
+        console.info('Nest CLI Version :', (0, ansis_1.blue)(JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json')).toString())
+            .version), '\n');
+    }
+    readProjectPackageDependencies() {
+        const buffer = (0, fs_1.readFileSync)((0, path_1.join)(process.cwd(), 'package.json'));
+        const pack = JSON.parse(buffer.toString());
+        const dependencies = { ...pack.dependencies, ...pack.devDependencies };
+        Object.keys(dependencies).forEach((key) => {
+            dependencies[key] = {
+                version: dependencies[key],
+            };
+        });
+        return dependencies;
+    }
+    displayNestVersions(dependencies) {
+        const nestDependencies = this.buildNestVersionsMessage(dependencies);
+        nestDependencies.forEach((dependency) => console.info(dependency.name, (0, ansis_1.blue)(dependency.value)));
+        this.displayWarningMessage(nestDependencies);
+    }
+    displayWarningMessage(nestDependencies) {
+        try {
+            const warnings = this.buildNestVersionsWarningMessage(nestDependencies);
+            const majorVersions = Object.keys(warnings);
+            if (majorVersions.length > 0) {
+                console.info('\r');
+                console.info((0, ansis_1.yellow) `[Warnings]`);
+                console.info('The following packages are not in the same major version');
+                console.info('This could lead to runtime errors');
+                majorVersions.forEach((version) => {
+                    console.info((0, ansis_1.bold) `* Under version ${version}`);
+                    warnings[version].forEach(({ packageName, value }) => {
+                        console.info(`- ${packageName} ${value}`);
+                    });
+                });
+            }
+        }
+        catch {
+            console.info('\t');
+            console.error((0, ansis_1.red)(ui_1.MESSAGES.NEST_INFORMATION_PACKAGE_WARNING_FAILED(this.warningMessageDependenciesWhiteList)));
+        }
+    }
+    buildNestVersionsWarningMessage(nestDependencies) {
+        const unsortedWarnings = nestDependencies.reduce((depWarningsGroup, { name, packageName, value }) => {
+            if (!this.warningMessageDependenciesWhiteList.includes(packageName)) {
+                return depWarningsGroup;
+            }
+            const [major] = value.replace(/[^\d.]/g, '').split('.', 1);
+            const minimumVersion = major;
+            depWarningsGroup[minimumVersion] = [
+                ...(depWarningsGroup[minimumVersion] || []),
+                { name, packageName, value },
+            ];
+            return depWarningsGroup;
+        }, Object.create(null));
+        const unsortedMinorVersions = Object.keys(unsortedWarnings);
+        if (unsortedMinorVersions.length <= 1) {
+            return {};
+        }
+        const sortedMinorVersions = unsortedMinorVersions.sort((versionA, versionB) => {
+            const numA = parseFloat(versionA);
+            const numB = parseFloat(versionB);
+            if (isNaN(numA) && isNaN(numB)) {
+                // If both are not valid numbers, maintain the current order.
+                return 0;
+            }
+            // NaN is considered greater than any number, so if numA is NaN, place it later.
+            return isNaN(numA) ? 1 : isNaN(numB) ? -1 : numB - numA;
+        });
+        return sortedMinorVersions.reduce((warnings, minorVersion) => {
+            warnings[minorVersion] = unsortedWarnings[minorVersion];
+            return warnings;
+        }, Object.create(null));
+    }
+    buildNestVersionsMessage(dependencies) {
+        const nestDependencies = this.collectNestDependencies(dependencies);
+        return this.format(nestDependencies);
+    }
+    collectNestDependencies(dependencies) {
+        const nestDependencies = [];
+        Object.keys(dependencies).forEach((key) => {
+            if (key.indexOf('@nestjs') > -1) {
+                const depPackagePath = require.resolve(key + '/package.json', {
+                    paths: [process.cwd()],
+                });
+                const depPackage = (0, fs_1.readFileSync)(depPackagePath).toString();
+                const value = JSON.parse(depPackage).version;
+                nestDependencies.push({
+                    name: `${key.replace(/@nestjs\//, '').replace(/@.*/, '')} version`,
+                    value: value || dependencies[key].version,
+                    packageName: key,
+                });
+            }
+        });
+        return nestDependencies;
+    }
+    format(dependencies) {
+        const sorted = dependencies.sort((dependencyA, dependencyB) => dependencyB.name.length - dependencyA.name.length);
+        const length = sorted[0].name.length;
+        sorted.forEach((dependency) => {
+            if (dependency.name.length < length) {
+                dependency.name = this.rightPad(dependency.name, length);
+            }
+            dependency.name = dependency.name.concat(' :');
+            dependency.value = dependency.value.replace(/(\^|\~)/, '');
+        });
+        return sorted;
+    }
+    rightPad(name, length) {
+        while (name.length < length) {
+            name = name.concat(' ');
+        }
+        return name;
+    }
+}
+exports.InfoAction = InfoAction;

package/actions/new.action.d.ts

@@ -0,0 +1,7 @@
+import { Input } from '../commands';
+import { AbstractAction } from './abstract.action';
+export declare class NewAction extends AbstractAction {
+    handle(inputs: Input[], options: Input[]): Promise<void>;
+}
+export declare const retrieveCols: () => number;
+export declare const exit: () => never;

package/actions/new.action.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exit = exports.retrieveCols = exports.NewAction = void 0;
+const prompts_1 = require("@inquirer/prompts");
+const ansis = require("ansis");
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const path_1 = require("path");
+const defaults_1 = require("../lib/configuration/defaults");
+const package_managers_1 = require("../lib/package-managers");
+const questions_1 = require("../lib/questions/questions");
+const git_runner_1 = require("../lib/runners/git.runner");
+const schematics_1 = require("../lib/schematics");
+const ui_1 = require("../lib/ui");
+const formatting_1 = require("../lib/utils/formatting");
+const gracefully_exit_on_prompt_error_1 = require("../lib/utils/gracefully-exit-on-prompt-error");
+const abstract_action_1 = require("./abstract.action");
+const type_assertions_1 = require("../lib/utils/type-assertions");
+class NewAction extends abstract_action_1.AbstractAction {
+    async handle(inputs, options) {
+        const directoryOption = options.find((option) => option.name === 'directory');
+        const dryRunOption = options.find((option) => option.name === 'dry-run');
+        const isDryRunEnabled = dryRunOption && dryRunOption.value;
+        await askForMissingInformation(inputs, options);
+        await generateApplicationFiles(inputs, options).catch(exports.exit);
+        const shouldSkipInstall = options.some((option) => option.name === 'skip-install' && option.value === true);
+        const shouldSkipGit = options.some((option) => option.name === 'skip-git' && option.value === true);
+        const projectDirectory = getProjectDirectory(getApplicationNameInput(inputs), directoryOption);
+        if (!shouldSkipInstall) {
+            await installPackages(options, isDryRunEnabled, projectDirectory);
+        }
+        if (!isDryRunEnabled) {
+            if (!shouldSkipGit) {
+                await initializeGitRepository(projectDirectory);
+                await createGitIgnoreFile(projectDirectory);
+            }
+            printCollective();
+        }
+        process.exit(0);
+    }
+}
+exports.NewAction = NewAction;
+const getApplicationNameInput = (inputs) => inputs.find((input) => input.name === 'name');
+const getPackageManagerInput = (inputs) => inputs.find((options) => options.name === 'packageManager');
+const getProjectDirectory = (applicationName, directoryOption) => {
+    return ((directoryOption && directoryOption.value) ||
+        (0, formatting_1.normalizeToKebabOrSnakeCase)(applicationName.value));
+};
+const askForMissingInformation = async (inputs, options) => {
+    console.info(ui_1.MESSAGES.PROJECT_INFORMATION_START);
+    console.info();
+    const nameInput = getApplicationNameInput(inputs);
+    if (!nameInput.value) {
+        const message = ui_1.MESSAGES.PROJECT_NAME_QUESTION;
+        const question = (0, questions_1.generateInput)('name', message)('nest-app');
+        const answer = await (0, prompts_1.input)(question).catch(gracefully_exit_on_prompt_error_1.gracefullyExitOnPromptError);
+        replaceInputMissingInformation(inputs, { name: 'name', value: answer });
+    }
+    const packageManagerInput = getPackageManagerInput(options);
+    if (!packageManagerInput.value) {
+        const answer = await askForPackageManager();
+        replaceInputMissingInformation(options, {
+            name: 'packageManager',
+            value: answer,
+        });
+    }
+};
+const replaceInputMissingInformation = (inputs, answer) => {
+    const input = inputs.find((input) => input.name === answer.name);
+    if (input) {
+        input.value = input.value !== undefined ? input.value : answer.value;
+    }
+};
+const generateApplicationFiles = async (args, options) => {
+    const collectionName = options.find((option) => option.name === 'collection' && option.value != null).value;
+    const collection = schematics_1.CollectionFactory.create(collectionName || schematics_1.Collection.NESTJS);
+    const schematicOptions = mapSchematicOptions(args.concat(options));
+    await collection.execute('application', schematicOptions);
+    console.info();
+};
+const mapSchematicOptions = (options) => {
+    return options.reduce((schematicOptions, option) => {
+        if (option.name !== 'skip-install') {
+            (0, type_assertions_1.assertNonArray)(option.value);
+            schematicOptions.push(new schematics_1.SchematicOption(option.name, option.value));
+        }
+        return schematicOptions;
+    }, []);
+};
+const installPackages = async (options, dryRunMode, installDirectory) => {
+    const inputPackageManager = getPackageManagerInput(options).value;
+    let packageManager;
+    if (dryRunMode) {
+        console.info();
+        console.info(ansis.green(ui_1.MESSAGES.DRY_RUN_MODE));
+        console.info();
+        return;
+    }
+    try {
+        packageManager = package_managers_1.PackageManagerFactory.create(inputPackageManager);
+        await packageManager.install(installDirectory, inputPackageManager);
+    }
+    catch (error) {
+        if (error && error.message) {
+            console.error(ansis.red(error.message));
+        }
+    }
+};
+const askForPackageManager = async () => {
+    const question = (0, questions_1.generateSelect)('packageManager')(ui_1.MESSAGES.PACKAGE_MANAGER_QUESTION)([package_managers_1.PackageManager.NPM, package_managers_1.PackageManager.YARN, package_managers_1.PackageManager.PNPM]);
+    return (0, prompts_1.select)(question).catch(gracefully_exit_on_prompt_error_1.gracefullyExitOnPromptError);
+};
+const initializeGitRepository = async (dir) => {
+    const runner = new git_runner_1.GitRunner();
+    await runner.run('init', true, (0, path_1.join)(process.cwd(), dir)).catch(() => {
+        console.error(ansis.red(ui_1.MESSAGES.GIT_INITIALIZATION_ERROR));
+    });
+};
+/**
+ * Write a file `.gitignore` in the root of the newly created project.
+ * `.gitignore` available in `@nestjs/schematics` cannot be published to
+ * NPM (needs to be investigated).
+ *
+ * @param dir Relative path to the project.
+ * @param content (optional) Content written in the `.gitignore`.
+ *
+ * @return Resolves when succeeds, or rejects with any error from `fn.writeFile`.
+ */
+const createGitIgnoreFile = (dir, content) => {
+    const fileContent = content || defaults_1.defaultGitIgnore;
+    const filePath = (0, path_1.join)(process.cwd(), dir, '.gitignore');
+    if (fileExists(filePath)) {
+        return;
+    }
+    return fs.promises.writeFile(filePath, fileContent);
+};
+const printCollective = () => {
+    const dim = print('dim');
+    const yellow = print('yellow');
+    const emptyLine = print();
+    emptyLine();
+    yellow(`Thanks for installing Nest ${ui_1.EMOJIS.PRAY}`);
+    dim('Please consider donating to our open collective');
+    dim('to help us maintain this package.');
+    emptyLine();
+    emptyLine();
+    print()(`${ansis.bold `${ui_1.EMOJIS.WINE}  Donate:`} ${ansis.underline('https://opencollective.com/nest')}`);
+    emptyLine();
+};
+const print = (color = null) => (str = '') => {
+    const terminalCols = (0, exports.retrieveCols)();
+    const strLength = str.replace(/\u001b\[[0-9]{2}m/g, '').length;
+    const leftPaddingLength = Math.floor((terminalCols - strLength) / 2);
+    const leftPadding = ' '.repeat(Math.max(leftPaddingLength, 0));
+    if (color) {
+        str = ansis[color](str);
+    }
+    console.log(leftPadding, str);
+};
+const retrieveCols = () => {
+    const defaultCols = 80;
+    try {
+        const terminalCols = (0, child_process_1.execSync)('tput cols', {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return parseInt(terminalCols.toString(), 10) || defaultCols;
+    }
+    catch {
+        return defaultCols;
+    }
+};
+exports.retrieveCols = retrieveCols;
+const fileExists = (path) => {
+    try {
+        fs.accessSync(path);
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return false;
+        }
+        throw err;
+    }
+};
+const exit = () => process.exit(1);
+exports.exit = exit;

package/actions/start.action.d.ts

@@ -0,0 +1,10 @@
+import { Input } from '../commands';
+import { BuildAction } from './build.action';
+export declare class StartAction extends BuildAction {
+    handle(commandInputs: Input[], commandOptions: Input[]): Promise<void>;
+    createOnSuccessHook(entryFile: string, sourceRoot: string, debugFlag: boolean | string | undefined, outDirName: string, binaryToRun: string, options: {
+        shell: boolean;
+        envFile?: string[];
+    }): () => void;
+    private spawnChildProcess;
+}

package/actions/start.action.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartAction = void 0;
+const ansis_1 = require("ansis");
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const path_1 = require("path");
+const get_tsc_config_path_1 = require("../lib/compiler/helpers/get-tsc-config.path");
+const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
+const defaults_1 = require("../lib/configuration/defaults");
+const ui_1 = require("../lib/ui");
+const tree_kill_1 = require("../lib/utils/tree-kill");
+const type_assertions_1 = require("../lib/utils/type-assertions");
+const build_action_1 = require("./build.action");
+class StartAction extends build_action_1.BuildAction {
+    async handle(commandInputs, commandOptions) {
+        try {
+            const configFileName = commandOptions.find((option) => option.name === 'config').value;
+            const configuration = await this.loader.load(configFileName);
+            const appName = commandInputs.find((input) => input.name === 'app')
+                .value;
+            const pathToTsconfig = (0, get_tsc_config_path_1.getTscConfigPath)(configuration, commandOptions, appName);
+            const debugModeOption = commandOptions.find((option) => option.name === 'debug');
+            const watchModeOption = commandOptions.find((option) => option.name === 'watch');
+            const isWatchEnabled = !!(watchModeOption && watchModeOption.value);
+            const watchAssetsModeOption = commandOptions.find((option) => option.name === 'watchAssets');
+            const isWatchAssetsEnabled = !!(watchAssetsModeOption && watchAssetsModeOption.value);
+            const debugFlag = debugModeOption && debugModeOption.value;
+            (0, type_assertions_1.assertNonArray)(debugFlag);
+            const binaryToRun = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'exec', appName, 'exec', commandOptions, defaults_1.defaultConfiguration.exec);
+            const { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(pathToTsconfig);
+            const outDir = tsOptions.outDir || defaults_1.defaultOutDir;
+            const entryFile = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'entryFile', appName, 'entryFile', commandOptions, defaults_1.defaultConfiguration.entryFile);
+            const sourceRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName, 'sourceRoot', commandOptions, defaults_1.defaultConfiguration.sourceRoot);
+            const shellOption = commandOptions.find((option) => option.name === 'shell');
+            const useShell = !!shellOption?.value;
+            const envFileOption = commandOptions.find((option) => option.name === 'envFile');
+            const envFile = (envFileOption?.value ?? []);
+            const onSuccess = this.createOnSuccessHook(entryFile, sourceRoot, debugFlag, outDir, binaryToRun, {
+                shell: useShell,
+                envFile,
+            });
+            await this.runBuild(commandInputs, commandOptions, isWatchEnabled, isWatchAssetsEnabled, !!debugFlag, onSuccess);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                console.log(`\n${ui_1.ERROR_PREFIX} ${err.message}\n`);
+            }
+            else {
+                console.error(`\n${(0, ansis_1.red)(err)}\n`);
+            }
+        }
+    }
+    createOnSuccessHook(entryFile, sourceRoot, debugFlag, outDirName, binaryToRun, options) {
+        let childProcessRef;
+        process.on('exit', () => childProcessRef && (0, tree_kill_1.treeKillSync)(childProcessRef.pid));
+        return () => {
+            if (childProcessRef) {
+                childProcessRef.removeAllListeners('exit');
+                childProcessRef.on('exit', () => {
+                    childProcessRef = this.spawnChildProcess(entryFile, sourceRoot, debugFlag, outDirName, binaryToRun, {
+                        shell: options.shell,
+                        envFile: options.envFile,
+                    });
+                    childProcessRef.on('exit', () => (childProcessRef = undefined));
+                });
+                childProcessRef.stdin && childProcessRef.stdin.pause();
+                (0, tree_kill_1.treeKillSync)(childProcessRef.pid);
+            }
+            else {
+                childProcessRef = this.spawnChildProcess(entryFile, sourceRoot, debugFlag, outDirName, binaryToRun, {
+                    shell: options.shell,
+                    envFile: options.envFile,
+                });
+                childProcessRef.on('exit', (code) => {
+                    process.exitCode = code;
+                    childProcessRef = undefined;
+                });
+            }
+        };
+    }
+    spawnChildProcess(entryFile, sourceRoot, debug, outDirName, binaryToRun, options) {
+        let outputFilePath = (0, path_1.join)(outDirName, sourceRoot, entryFile);
+        if (!fs.existsSync(outputFilePath + '.js')) {
+            outputFilePath = (0, path_1.join)(outDirName, entryFile);
+        }
+        let childProcessArgs = [];
+        const argsStartIndex = process.argv.indexOf('--');
+        if (argsStartIndex >= 0) {
+            // Prevents the need for users to double escape strings
+            // i.e. I can run the more natural
+            //   nest start -- '{"foo": "bar"}'
+            // instead of
+            //   nest start -- '\'{"foo": "bar"}\''
+            childProcessArgs = process.argv
+                .slice(argsStartIndex + 1)
+                .map((arg) => JSON.stringify(arg));
+        }
+        outputFilePath =
+            outputFilePath.indexOf(' ') >= 0 ? `"${outputFilePath}"` : outputFilePath;
+        const processArgs = [outputFilePath, ...childProcessArgs];
+        if (debug) {
+            const inspectFlag = typeof debug === 'string' ? `--inspect=${debug}` : '--inspect';
+            processArgs.unshift(inspectFlag);
+        }
+        if (options.envFile && options.envFile.length > 0) {
+            const envFileNodeArgs = options.envFile.map((envFilePath) => `--env-file=${envFilePath}`);
+            processArgs.unshift(envFileNodeArgs.join(' '));
+        }
+        processArgs.unshift('--enable-source-maps');
+        const spawnOptions = {
+            stdio: 'inherit',
+            shell: options.shell,
+        };
+        if (options.shell) {
+            const command = [binaryToRun, ...processArgs].join(' ');
+            return (0, child_process_1.spawn)(command, spawnOptions);
+        }
+        return (0, child_process_1.spawn)(binaryToRun, processArgs, spawnOptions);
+    }
+}
+exports.StartAction = StartAction;

package/bin/nest.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/nest.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander = require("commander");
+const commands_1 = require("../commands");
+const local_binaries_1 = require("../lib/utils/local-binaries");
+const bootstrap = async () => {
+    const program = commander;
+    program
+        .version(require('../package.json').version, '-v, --version', 'Output the current version.')
+        .usage('<command> [options]')
+        .helpOption('-h, --help', 'Output usage information.');
+    if ((0, local_binaries_1.localBinExists)()) {
+        const localCommandLoader = (0, local_binaries_1.loadLocalBinCommandLoader)();
+        await localCommandLoader.load(program);
+    }
+    else {
+        await commands_1.CommandLoader.load(program);
+    }
+    await commander.parseAsync(process.argv);
+    if (!process.argv.slice(2).length) {
+        program.outputHelp();
+    }
+};
+bootstrap();

package/changes.json

@@ -0,0 +1,54 @@
+{
+  "bumped": {
+    "@angular-devkit/core": {
+      "from": "19.2.19",
+      "to": "^21.2.3"
+    },
+    "@angular-devkit/schematics": {
+      "from": "19.2.19",
+      "to": "^21.2.3"
+    },
+    "@angular-devkit/schematics-cli": {
+      "from": "19.2.19",
+      "to": "^21.2.3"
+    },
+    "@inquirer/prompts": {
+      "from": "7.10.1",
+      "to": "^8.3.2"
+    },
+    "@nestjs/schematics": {
+      "from": "^11.0.1",
+      "to": "^11.0.9"
+    },
+    "chokidar": {
+      "from": "4.0.3",
+      "to": "^5.0.0"
+    },
+    "commander": {
+      "from": "4.1.1",
+      "to": "^14.0.3"
+    },
+    "glob": {
+      "from": "13.0.0",
+      "to": "^13.0.6"
+    },
+    "node-emoji": {
+      "from": "1.11.0",
+      "to": "^2.2.0"
+    },
+    "ora": {
+      "from": "5.4.1",
+      "to": "^9.3.0"
+    },
+    "typescript": {
+      "from": "5.9.3",
+      "to": "^6.0.2"
+    },
+    "webpack": {
+      "from": "5.104.1",
+      "to": "^5.105.4"
+    }
+  },
+  "timestamp": "2026-03-23T16:27:57.880Z",
+  "totalUpdated": 12
+}

package/commands/abstract.command.d.ts

@@ -0,0 +1,7 @@
+import { CommanderStatic } from 'commander';
+import { AbstractAction } from '../actions/abstract.action';
+export declare abstract class AbstractCommand {
+    protected action: AbstractAction;
+    constructor(action: AbstractAction);
+    abstract load(program: CommanderStatic): void;
+}

package/commands/abstract.command.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCommand = void 0;
+class AbstractCommand {
+    constructor(action) {
+        this.action = action;
+    }
+}
+exports.AbstractCommand = AbstractCommand;

package/commands/add.command.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class AddCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+}

package/commands/add.command.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddCommand = void 0;
+const remaining_flags_1 = require("../lib/utils/remaining-flags");
+const abstract_command_1 = require("./abstract.command");
+class AddCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('add <library>')
+            .allowUnknownOption()
+            .description('Adds support for an external library to your project.')
+            .option('-d, --dry-run', 'Report actions that would be performed without writing out results.')
+            .option('-s, --skip-install', 'Skip package installation.', false)
+            .option('-p, --project [project]', 'Project in which to generate files.')
+            .usage('<library> [options] [library-specific-options]')
+            .action(async (library, command) => {
+            const options = [];
+            options.push({ name: 'dry-run', value: !!command.dryRun });
+            options.push({ name: 'skip-install', value: command.skipInstall });
+            options.push({
+                name: 'project',
+                value: command.project,
+            });
+            const inputs = [];
+            inputs.push({ name: 'library', value: library });
+            const flags = (0, remaining_flags_1.getRemainingFlags)(program);
+            try {
+                await this.action.handle(inputs, options, flags);
+            }
+            catch (err) {
+                process.exit(1);
+            }
+        });
+    }
+}
+exports.AddCommand = AddCommand;

package/commands/build.command.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class BuildCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+}