@flarum/cli 2.0.0-beta.9 → 3.0.0

package/lib/base-command.js

@@ -3,17 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocationType = void 0;
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
-const cli_ux_1 = (0, tslib_1.__importDefault)(require("cli-ux"));
-const node_path_1 = require("node:path");
-const globby_1 = (0, tslib_1.__importDefault)(require("globby"));
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = require("node:fs");
+const cli_ux_1 = tslib_1.__importDefault(require("cli-ux"));
+const path_1 = require("path");
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
 const io_1 = require("boilersmith/io");
 const step_manager_1 = require("boilersmith/step-manager");
 const paths_1 = require("boilersmith/paths");
 const php_provider_1 = require("./providers/php-provider");
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const errors_1 = require("@oclif/errors");
+const monorepo_1 = require("./utils/monorepo");
+const mem_fs_1 = require("mem-fs");
 var LocationType;
 (function (LocationType) {
     LocationType[LocationType["FLARUM_EXTENSION"] = 0] = "FLARUM_EXTENSION";
@@ -23,19 +25,24 @@ var LocationType;
 class BaseCommand extends core_1.Command {
     constructor() {
         super(...arguments);
-        this.STUB_PATH = (0, node_path_1.resolve)(__dirname, '../boilerplate/stubs/');
+        this.STUB_PATH = (0, path_1.resolve)(__dirname, '../boilerplate/stubs/');
         this.dry = false;
         this.requireExistingExtension = true;
+        this.skipFinalMessage = false;
+        this.confirmed = false;
     }
-    async run() {
-        const { args, flags } = await this.parse(this.constructor);
+    async runSteps(steps) {
+        const { args } = await this.parse(this.constructor);
         this.args = args;
-        this.flags = flags;
         const path = args.path;
-        const welcomeMessage = this.welcomeMessage();
-        if (welcomeMessage) {
-            this.log(welcomeMessage);
-        }
+        const paths = new paths_1.NodePaths({
+            requestedDir: path,
+            package: await this.extRoot(path),
+        });
+        const phpProvider = new php_provider_1.PhpSubsystemProvider((0, path_1.resolve)(__dirname, '../php-subsystem/index.php'));
+        return steps.run(paths, this.genIO(), { php: phpProvider }, this.dry, args);
+    }
+    async extRoot(path) {
         let extRoot;
         if (this.requireExistingExtension) {
             const rootData = await this.getFlarumExtensionRoot(path || process.cwd());
@@ -46,36 +53,52 @@ class BaseCommand extends core_1.Command {
         else {
             extRoot = path || process.cwd();
         }
+        return extRoot;
+    }
+    async run() {
+        var _a;
+        const { args, flags } = await this.parse(this.constructor);
+        this.args = args;
+        this.flags = flags;
+        const path = args.path;
+        const welcomeMessage = this.welcomeMessage();
+        if (welcomeMessage) {
+            this.log(welcomeMessage);
+            await this.continueWhenReady(this.genIO());
+        }
+        const extRoot = await this.extRoot(path);
         await this.additionalPreRunChecks(extRoot);
-        const paths = new paths_1.NodePaths({
-            requestedDir: path,
-            package: extRoot,
-        });
-        const phpProvider = new php_provider_1.PhpSubsystemProvider((0, node_path_1.resolve)(__dirname, '../php-subsystem/index.php'));
-        const out = await this.steps(new step_manager_1.StepManager())
-            .run(paths, this.genIO(), { php: phpProvider }, this.dry);
-        const errorMessages = out.messages.filter(m => m.type === 'error');
-        this.log('\n\n');
-        if (out.succeeded && errorMessages.length === 0) {
+        const out = await this.runSteps(this.steps(new step_manager_1.StepManager(), extRoot));
+        const errorMessages = out.messages.filter((m) => m.type === 'error');
+        // this.log('\n\n');
+        if (!this.skipFinalMessage && out.succeeded && errorMessages.length === 0) {
             this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.green('Success! The following steps were completed:'))));
         }
-        else if (out.succeeded) {
+        else if (!this.skipFinalMessage && out.succeeded) {
             this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.yellow('All steps completed, but with some errors:'))));
             for (const message of errorMessages) {
                 this.log(chalk_1.default.dim(chalk_1.default.red(message.message)));
             }
             this.log(chalk_1.default.bold(chalk_1.default.yellow('The steps that completed were:')));
         }
-        else if (out.error === 'EEXIT: 0') {
+        else if (!out.succeeded && out.error.startsWith('EEXIT:')) {
             this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.red('Exiting.'))));
-            if (out.stepsRan.length > 0) {
+            if (!this.skipFinalMessage && out.stepsRan.length > 0) {
                 this.log(chalk_1.default.bold(chalk_1.default.yellow('Before the exit, the following steps were completed:')));
             }
         }
-        else {
-            this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.red('Error occurred, and could not complete:'))));
-            this.log(chalk_1.default.red(out.error));
-            if (out.errorTrace) {
+        else if (!out.succeeded) {
+            const prettyPrint = ((_a = out.e) === null || _a === void 0 ? void 0 : _a.code) === 'FL_ERR';
+            if (!prettyPrint)
+                this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.red('Error occurred, and could not complete:'))));
+            if (prettyPrint) {
+                this.log('\n');
+                this.log('\u001B[A     => ' + chalk_1.default.bgRed.bold('   ERROR   ') + ' ' + chalk_1.default.red(out.error));
+            }
+            else {
+                this.log(chalk_1.default.red(out.error));
+            }
+            if (out.errorTrace && !prettyPrint) {
                 this.log(chalk_1.default.dim(chalk_1.default.red(out.errorTrace)));
             }
             if (out.stepsRan.length > 0) {
@@ -83,10 +106,12 @@ class BaseCommand extends core_1.Command {
                 this.log(chalk_1.default.bold(chalk_1.default.yellow('Before the error, the following steps were completed:')));
             }
         }
-        for (const stepName of out.stepsRan)
-            this.log(`- ${chalk_1.default.dim(stepName)}`);
+        if (!this.skipFinalMessage) {
+            for (const stepName of out.stepsRan)
+                this.log(`- ${chalk_1.default.dim(stepName)}`);
+        }
         this.log('');
-        const nonErrorMessages = out.messages.filter(m => m.type !== 'error');
+        const nonErrorMessages = out.messages.filter((m) => m.type !== 'error');
         if (nonErrorMessages.length > 0) {
             this.log('');
             this.log('The following messages were generated during execution:');
@@ -115,64 +140,75 @@ class BaseCommand extends core_1.Command {
     // Confirmation
     // ----------------------------------------------------------------
     genIO() {
-        return new io_1.PromptsIO({}, [], this.flags['no-interaction'], errors_1.exit);
+        return new io_1.PromptsIO(this.args, [], this.flags['no-interaction'], errors_1.exit);
     }
     monorepoPaths(options) {
+        var _a, _b;
         try {
-            const monorepoConfig = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(process.cwd(), 'flarum-monorepo.json'));
-            const contents = JSON.parse(monorepoConfig.toString());
+            const monorepoConfig = (0, monorepo_1.getMonorepoConf)((0, mem_fs_1.create)(), new paths_1.NodePaths({ package: process.cwd() }));
             return [
-                ...(options.includeCore ? [contents.packages.core] : []),
-                ...(options.includeExtensions ? contents.packages.extensions : []),
-                ...(options.includePhpPackages ? contents.packages.composerPackages : []),
-                ...(options.includeJSPackages ? contents.packages.npmPackages : []),
+                ...(options.includeCore && monorepoConfig.packages.core ? [(0, monorepo_1.corePath)(monorepoConfig.packages.core.name)] : []),
+                ...(options.includeExtensions ? monorepoConfig.packages.extensions : []).map((ext) => (0, monorepo_1.extensionPath)(ext.name)),
+                ...(options.includePhpPackages ? (_a = monorepoConfig.packages.composer) !== null && _a !== void 0 ? _a : [] : []).map((lib) => (0, monorepo_1.composerPath)(lib.name)),
+                ...(options.includeJSPackages ? (_b = monorepoConfig.packages.npm) !== null && _b !== void 0 ? _b : [] : []).map((lib) => (0, monorepo_1.npmPath)(lib.name)),
             ];
         }
-        catch (_a) {
+        catch (_c) {
             this.error('Could not run monorepo command: `flarum-monorepo.json` file is missing or invalid.');
         }
     }
+    isFlarumMonorepo(path) {
+        return (0, fs_1.existsSync)((0, path_1.resolve)(path, 'flarum-monorepo.json'));
+    }
     isFlarumCore(path) {
         try {
-            const composerJsonPath = (0, node_path_1.resolve)(path, 'composer.json');
-            const val = JSON.parse((0, node_fs_1.readFileSync)(composerJsonPath, 'utf8'));
+            const composerJsonPath = (0, path_1.resolve)(path, 'composer.json');
+            const val = JSON.parse((0, fs_1.readFileSync)(composerJsonPath, 'utf8'));
             return val.name === 'flarum/core';
         }
         catch (_a) {
             return false;
         }
     }
+    jsPackageManager(currDir) {
+        if (!(0, fs_1.existsSync)((0, path_1.resolve)(currDir, 'js')))
+            return null;
+        return (0, fs_1.existsSync)((0, path_1.resolve)(currDir, 'js/yarn.lock')) ? 'yarn' : 'npm';
+    }
     async getFlarumExtensionRoot(currDir) {
-        let currPath = (0, node_path_1.resolve)(currDir);
+        let currPath = (0, path_1.resolve)(currDir);
         while (currPath !== '/') {
-            if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(currPath, 'flarum-monorepo.json'))) {
+            if ((0, fs_1.existsSync)((0, path_1.resolve)(currPath, 'flarum-monorepo.json'))) {
                 return { path: currPath, type: LocationType.FLARUM_MONOREPO };
             }
-            if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(currPath, 'composer.json')) && (0, node_fs_1.existsSync)((0, node_path_1.resolve)(currPath, 'extend.php'))) {
+            if ((0, fs_1.existsSync)((0, path_1.resolve)(currPath, 'composer.json')) && (0, fs_1.existsSync)((0, path_1.resolve)(currPath, 'extend.php'))) {
                 return { path: currPath, type: LocationType.FLARUM_EXTENSION };
             }
             if (this.isFlarumCore(currPath)) {
                 return { path: currPath, type: LocationType.FLARUM_CORE };
             }
-            currPath = (0, node_path_1.resolve)(currPath, '..');
+            currPath = (0, path_1.resolve)(currPath, '..');
         }
-        this.error(`${(0, node_path_1.resolve)(currDir)} is not located in a valid Flarum package!
+        this.error(`${(0, path_1.resolve)(currDir)} is not located in a valid Flarum package!
 - Flarum extensions must contain (at a minimum) 'extend.php' and 'composer.json' files.
 - Flarum core must contain a 'composer.json' file with the name 'flarum/core'.
 - Flarum monorepos must have a valid 'flarum-monorepo.json' file`);
     }
     async confirmExtDir(extRoot) {
+        if (this.confirmed)
+            return;
         const verify = await this.genIO().getParam({
             name: 'verify',
             type: 'confirm',
-            message: `Work in Flarum package located at ${(0, node_path_1.resolve)(extRoot)}?`,
+            message: `Work in Flarum package located at ${(0, path_1.resolve)(extRoot)}?`,
             initial: true,
         });
         if (!verify)
             this.exit();
+        this.confirmed = true;
     }
     async ensureComposerInstallRan(extRoot) {
-        if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(extRoot, 'vendor/flarum/core/composer.json')))
+        if ((0, fs_1.existsSync)((0, path_1.resolve)(extRoot, 'vendor/flarum/core/composer.json')))
             return;
         this.log("This command requires `composer install` to have been ran in your extension's root directory.");
         const composer = await this.genIO().getParam({
@@ -183,13 +219,26 @@ class BaseCommand extends core_1.Command {
         });
         if (composer) {
             cli_ux_1.default.action.start('Installing composer packages');
-            (0, node_child_process_1.execSync)('composer install', { cwd: extRoot });
+            (0, child_process_1.execSync)('composer install', { cwd: extRoot });
             cli_ux_1.default.action.stop();
         }
         else {
             this.error("Run `composer install` in your extension's root directory, then try again.");
         }
     }
+    async continueWhenReady(io) {
+        const continueUpgrade = await io.getParam({
+            name: 'continue',
+            type: 'confirm',
+            message: 'Ready to continue?',
+            initial: true,
+        });
+        if (!continueUpgrade) {
+            this.log('');
+            this.log('Aborted.');
+            this.exit();
+        }
+    }
     /**
      * If false, files do not exist so no need to override.
      * If true, files should be overriden.
@@ -197,7 +246,7 @@ class BaseCommand extends core_1.Command {
      */
     async confirmOverrideFiles(dir, pattern, confirmationMessage) {
         const paths = Array.isArray(pattern) ? pattern : [pattern];
-        const files = await (0, globby_1.default)(paths.map(p => (0, node_path_1.resolve)(dir, p)));
+        const files = await (0, globby_1.default)(paths.map((p) => (0, path_1.resolve)(dir, p)));
         const empty = files.length === 0 || (files.length === 1 && files[0] === '.git');
         if (empty)
             return false;
@@ -212,13 +261,17 @@ class BaseCommand extends core_1.Command {
         return true;
     }
     async deleteFiles(dir, pattern) {
-        const pathsToDelete = await (0, globby_1.default)((0, node_path_1.resolve)(dir, pattern));
-        pathsToDelete.forEach(node_fs_1.unlinkSync);
+        const pathsToDelete = await (0, globby_1.default)((0, path_1.resolve)(dir, pattern));
+        pathsToDelete.forEach(fs_1.unlinkSync);
     }
 }
 exports.default = BaseCommand;
 BaseCommand.flags = {
-    'no-interaction': core_1.Flags.boolean({ char: 'n', description: 'Do not ask any interactive questions, assume defaults. When impossible, error.', default: false }),
+    'no-interaction': core_1.Flags.boolean({
+        char: 'n',
+        description: 'Do not ask any interactive questions, assume defaults. When impossible, error.',
+        default: false,
+    }),
     help: core_1.Flags.help({ char: 'h' }),
 };
 BaseCommand.args = [
@@ -227,3 +280,8 @@ BaseCommand.args = [
         description: 'Where should this command be executed?',
     },
 ];
+BaseCommand.classNameArg = {
+    name: 'className',
+    description: 'The name of the class to generate',
+    required: false,
+};

package/lib/boilersmith/io.d.ts

@@ -1,8 +1,13 @@
-import { PromptObject } from 'prompts';
-export declare type ParamDef<N extends string = string> = Omit<PromptObject<N>, 'name'> & {
+import { PromptObject, PromptType } from 'prompts';
+type BooleanPromptType = PromptType & ('confirm' | 'toggle');
+type StringPromptType = PromptType & ('text' | 'password' | 'invisible' | 'autocomplete');
+type DatePromptType = PromptType & 'date';
+type ListPromptType = PromptType & 'list';
+export type ParamDef<N extends string = string> = Omit<PromptObject<N>, 'name'> & {
     name: N;
+    message: string;
 };
-export declare type Message = {
+export type Message = {
     type: 'info' | 'warning' | 'error';
     message: string;
 };
@@ -11,7 +16,19 @@ export interface IO {
     /**
      * Prompt the user for some input data.
      */
-    getParam<T>(param: ParamDef): Promise<T>;
+    getParam(param: ParamDef & {
+        type: BooleanPromptType;
+    }, noCache?: boolean): Promise<boolean>;
+    getParam(param: ParamDef & {
+        type: StringPromptType;
+    }, noCache?: boolean): Promise<string>;
+    getParam(param: ParamDef & {
+        type: DatePromptType;
+    }, noCache?: boolean): Promise<Date>;
+    getParam(param: ParamDef & {
+        type: ListPromptType;
+    }, noCache?: boolean): Promise<string[]>;
+    getParam<T>(param: ParamDef, noCache?: boolean): Promise<T>;
     /**
      * Check if some data has already been prompted for.
      */
@@ -28,22 +45,27 @@ export interface IO {
      */
     getOutput(): Message[];
     newInstance(cache: Record<string, unknown>, messages: Message[]): IO;
+    pushCache(params: Record<string, unknown>): void;
 }
-declare type OnCancel = () => void;
+type OnCancel = () => void;
 export declare class PromptsIO implements IO {
     supportsAnsiColor: boolean;
-    private cache;
-    private messages;
-    private noInteraction;
-    private onCancel?;
-    private prev?;
+    protected cache: Map<string, unknown>;
+    protected messages: Message[];
+    protected noInteraction: boolean;
+    protected onCancel?: OnCancel;
+    protected prev?: {
+        val: any;
+        prompt: ParamDef;
+    };
     constructor(initial?: Record<string, unknown>, messages?: Message[], noInteraction?: boolean, onCancel?: OnCancel);
-    getParam<T>(paramDef: ParamDef): Promise<T>;
+    getParam<T>(paramDef: ParamDef, noCache?: boolean): Promise<T>;
     hasCached(name: string): boolean;
     /**
      * @internal
      */
     cached(): Record<string, unknown>;
+    pushCache(params: Record<string, unknown>): void;
     info(message: string, immediate: boolean): void;
     warning(message: string, immediate: boolean): void;
     error(message: string, immediate: false): void;

package/lib/boilersmith/io.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptsIO = void 0;
 const tslib_1 = require("tslib");
-const prompts_1 = (0, tslib_1.__importDefault)(require("prompts"));
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const prompts_1 = tslib_1.__importDefault(require("prompts"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 class PromptsIO {
     constructor(initial = {}, messages = [], noInteraction = false, onCancel = () => {
         throw new Error('EEXIT: 0');
@@ -15,26 +15,34 @@ class PromptsIO {
         this.noInteraction = noInteraction;
         this.onCancel = onCancel;
     }
-    async getParam(paramDef) {
+    async getParam(paramDef, noCache = false) {
         var _a, _b, _c;
         const paramName = paramDef.name;
         if (this.cache.has(paramName)) {
             return this.cache.get(paramName);
         }
+        let initial = null;
+        if (paramDef.initial && paramDef.initial instanceof Function) {
+            initial = paramDef.initial((_a = this.prev) === null || _a === void 0 ? void 0 : _a.val, this.cache, (_b = this.prev) === null || _b === void 0 ? void 0 : _b.prompt);
+        }
+        else if (paramDef.type === 'confirm' || paramDef.type === 'toggle') {
+            initial = ((_c = paramDef.initial) !== null && _c !== void 0 ? _c : false);
+        }
+        else if ('initial' in paramDef) {
+            initial = paramDef.initial;
+        }
+        else if ('choices' in paramDef) {
+            initial = paramDef.choices.filter((c) => c.selected).map((c) => c.value);
+        }
+        else if (this.noInteraction) {
+            return this.error(`No-Interaction mode is on, but input is required for param "${paramName}".`, true);
+        }
+        if (initial) {
+            paramDef.initial = initial;
+        }
         let resValue;
-        if (this.noInteraction) {
-            if (paramDef.initial && paramDef.initial instanceof Function) {
-                resValue = paramDef.initial((_a = this.prev) === null || _a === void 0 ? void 0 : _a.val, this.cache, (_b = this.prev) === null || _b === void 0 ? void 0 : _b.prompt);
-            }
-            else if (paramDef.type === 'confirm' || paramDef.type === 'toggle') {
-                resValue = ((_c = paramDef.initial) !== null && _c !== void 0 ? _c : false);
-            }
-            else if ('initial' in paramDef) {
-                resValue = paramDef.initial;
-            }
-            else {
-                return this.error(`No-Interaction mode is on, but input is required for param "${paramName}".`, true);
-            }
+        if (initial !== null && this.noInteraction) {
+            resValue = initial;
         }
         else {
             const res = (await (0, prompts_1.default)(paramDef, {
@@ -42,7 +50,9 @@ class PromptsIO {
             }));
             resValue = res[paramName];
         }
-        this.cache.set(paramName, resValue);
+        if (!noCache) {
+            this.cache.set(paramName, resValue);
+        }
         this.prev = {
             val: resValue,
             prompt: paramDef,
@@ -61,6 +71,11 @@ class PromptsIO {
             return obj;
         }, {});
     }
+    pushCache(params) {
+        for (const [key, value] of Object.entries(params)) {
+            this.cache.set(key, value);
+        }
+    }
     info(message, immediate) {
         if (immediate) {
             console.log(message);

package/lib/boilersmith/paths.d.ts

@@ -3,9 +3,9 @@ export interface Paths {
     package(...path: string[]): string;
     requestedDir(...path: string[]): string | null;
     monorepo(...path: string[]): string | null;
-    onMonorepoSub(packagePath: string): Paths;
+    onMonorepoSub(packagePath: string, monorepoPath?: string): Paths;
 }
-declare type InternalPaths = {
+type InternalPaths = {
     package: string;
     monorepo?: string | null;
     requestedDir?: string | null;
@@ -17,6 +17,6 @@ export declare class NodePaths implements Paths {
     package(...path: string[]): string;
     requestedDir(...path: string[]): string | null;
     monorepo(...path: string[]): string | null;
-    onMonorepoSub(packagePath: string): NodePaths;
+    onMonorepoSub(packagePath: string, monorepoPath?: string): NodePaths;
 }
 export {};

package/lib/boilersmith/paths.js

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodePaths = void 0;
-const node_path_1 = require("node:path");
+const path_1 = require("path");
 class NodePaths {
     constructor(paths) {
         this.paths = paths;
     }
     cwd(...path) {
-        return (0, node_path_1.resolve)(process.cwd(), ...path);
+        return (0, path_1.resolve)(process.cwd(), ...path);
     }
     package(...path) {
-        return (0, node_path_1.resolve)(this.paths.package, ...path);
+        return (0, path_1.resolve)(this.paths.package, ...path);
     }
     requestedDir(...path) {
         if (!this.paths.requestedDir)
             return null;
-        return (0, node_path_1.resolve)(this.paths.requestedDir, ...path);
+        return (0, path_1.resolve)(this.paths.requestedDir, ...path);
     }
     monorepo(...path) {
         if (!this.paths.monorepo)
             return null;
-        return (0, node_path_1.resolve)(this.paths.monorepo, ...path);
+        return (0, path_1.resolve)(this.paths.monorepo, ...path);
     }
-    onMonorepoSub(packagePath) {
-        return new NodePaths(Object.assign(Object.assign({}, this.paths), { monorepo: this.paths.package, package: packagePath }));
+    onMonorepoSub(packagePath, monorepoPath) {
+        return new NodePaths(Object.assign(Object.assign({}, this.paths), { monorepo: monorepoPath !== null && monorepoPath !== void 0 ? monorepoPath : this.paths.package, package: packagePath }));
     }
 }
 exports.NodePaths = NodePaths;

package/lib/boilersmith/scaffolding/audit-step-factory.js

@@ -7,8 +7,8 @@ const rename_keys_1 = require("../utils/rename-keys");
 const module_1 = require("./module");
 const template_param_1 = require("./template-param");
 const cond_format_1 = require("boilersmith/utils/cond-format");
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
-const node_fs_1 = require("node:fs");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = require("fs");
 function auditStepFactory(dry, scaffoldDir, modules, templateParams, excludeScaffoldingFunc, moduleStatusCache) {
     let modulesEnabled;
     return {
@@ -17,28 +17,28 @@ function auditStepFactory(dry, scaffoldDir, modules, templateParams, excludeScaf
         async run(_fs, paths, io, _providers) {
             const paramVals = await (0, template_param_1.currParamValues)(templateParams, _fs, paths, io);
             modulesEnabled = await (0, module_1.currModulesEnabled)(modules, _fs, paths, moduleStatusCache);
-            const actionableModules = modules.filter(m => m.updatable && modulesEnabled[m.name] && (!m.togglable || !m.dependsOn.some(dep => !modulesEnabled[dep])));
-            io.info((0, cond_format_1.condFormat)(io.supportsAnsiColor, m => chalk_1.default.yellow(chalk_1.default.bold(chalk_1.default.underline(m))), `Auditing infrastructure for ${actionableModules.length} enabled modules:`), true);
+            const actionableModules = modules.filter((m) => m.updatable && modulesEnabled[m.name] && (!m.togglable || !m.dependsOn.some((dep) => !modulesEnabled[dep])));
+            io.info((0, cond_format_1.condFormat)(io.supportsAnsiColor, (m) => chalk_1.default.yellow(chalk_1.default.bold(chalk_1.default.underline(m))), `Auditing infrastructure for ${actionableModules.length} enabled modules:`), true);
             for (const m of modules) {
                 if (actionableModules.includes(m)) {
-                    io.info((0, cond_format_1.condFormat)(io.supportsAnsiColor, m => chalk_1.default.dim(chalk_1.default.green(m)), `✓ ${m.name}: ${m.shortDescription}`), true);
+                    io.info((0, cond_format_1.condFormat)(io.supportsAnsiColor, (m) => chalk_1.default.dim(chalk_1.default.green(m)), `✓ ${m.name}: ${m.shortDescription}`), true);
                 }
                 else if (m.updatable) {
-                    io.info((0, cond_format_1.condFormat)(io.supportsAnsiColor, m => chalk_1.default.dim(chalk_1.default.red(m)), `𐄂 ${m.name}: ${m.shortDescription} (disabled)`), true);
+                    io.info((0, cond_format_1.condFormat)(io.supportsAnsiColor, (m) => chalk_1.default.dim(chalk_1.default.red(m)), `✕ ${m.name}: ${m.shortDescription} (disabled)`), true);
                 }
             }
             for (const m of actionableModules) {
                 const fs = dry ? (0, mem_fs_1.create)() : _fs;
-                const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : [];
+                const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : { files: [], configKeys: {} };
                 (0, module_1.applyModule)(m, modulesEnabled, paramVals, scaffoldDir, fs, paths, excludeScaffolding, true);
                 if (dry) {
                     const filesWithChanges = fs
                         .all()
-                        .filter(f => f.state && f.state !== 'deleted')
-                        .filter(f => { var _a; return !(0, node_fs_1.existsSync)(f.path) || (0, node_fs_1.readFileSync)(f.path, 'utf8').toString() !== ((_a = f.contents) === null || _a === void 0 ? void 0 : _a.toString()); });
+                        .filter((f) => f.state && f.state !== 'deleted')
+                        .filter((f) => { var _a; return !(0, fs_1.existsSync)(f.path) || (0, fs_1.readFileSync)(f.path, 'utf8').toString() !== ((_a = f.contents) === null || _a === void 0 ? void 0 : _a.toString()); });
                     if (filesWithChanges.length > 0) {
                         io.error(`Module ${m.name} has ${filesWithChanges.length} changed files: ${filesWithChanges
-                            .map(f => f.path.replace(paths.package() + '/', ''))
+                            .map((f) => f.path.replace(paths.package() + '/', ''))
                             .join(', ')}`, false);
                     }
                 }
@@ -52,9 +52,9 @@ function auditStepFactory(dry, scaffoldDir, modules, templateParams, excludeScaf
             }
             return _fs;
         },
-        exposes: modules.map(m => `modules.${m.name}`),
+        exposes: modules.map((m) => `modules.${m.name}`),
         getExposed(_paths, _paramProvider) {
-            return (0, rename_keys_1.renameKeys)(modulesEnabled, k => `modules.${k}`);
+            return (0, rename_keys_1.renameKeys)(modulesEnabled, (k) => `modules.${k}`);
         },
     };
 }

package/lib/boilersmith/scaffolding/infra-step-factory.js

@@ -4,7 +4,7 @@ exports.infraStepFactory = void 0;
 const module_1 = require("./module");
 const template_param_1 = require("./template-param");
 function infraStepFactory(scaffoldDir, moduleName, modules, templateParams, excludeScaffoldingFunc, moduleStatusCache) {
-    const module = modules.find(m => m.name === moduleName);
+    const module = modules.find((m) => m.name === moduleName);
     if (!module) {
         throw new Error(`Module ${moduleName} not found`);
     }
@@ -17,7 +17,7 @@ function infraStepFactory(scaffoldDir, moduleName, modules, templateParams, excl
             if (!module.updatable) {
                 io.error(`${module.name} is not updatable.`, true);
             }
-            const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : [];
+            const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : { files: [], configKeys: {} };
             const initializing = !modulesEnabled[module.name];
             (0, module_1.applyModule)(module, Object.assign(Object.assign({}, modulesEnabled), { [module.name]: true }), paramVals, scaffoldDir, fs, paths, excludeScaffolding, initializing);
             if (moduleStatusCache) {

package/lib/boilersmith/scaffolding/init-step-factory.js

@@ -12,22 +12,22 @@ function initStepFactory(scaffoldDir, modules, templateParams, excludeScaffoldin
         async run(fs, paths, io, _providers) {
             const paramVals = await (0, template_param_1.promptParamValues)(templateParams, paths, io);
             modulesEnabled = await (0, module_1.promptModulesEnabled)(modules, io);
-            const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : [];
+            const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : { files: [], configKeys: {} };
             for (const m of modules) {
-                if (modulesEnabled[m.name] && (!m.togglable || !m.dependsOn.some(dep => !modulesEnabled[dep]))) {
+                if (modulesEnabled[m.name] && (!m.togglable || !m.dependsOn.some((dep) => !modulesEnabled[dep]))) {
                     (0, module_1.applyModule)(m, modulesEnabled, paramVals, scaffoldDir, fs, paths, excludeScaffolding, true);
                 }
             }
             if (moduleStatusCache) {
-                modules.forEach(m => {
+                modules.forEach((m) => {
                     (0, module_1.setModuleValue)(m, modulesEnabled[m.name], fs, paths, moduleStatusCache);
                 });
             }
             return fs;
         },
-        exposes: modules.map(m => `modules.${m.name}`),
+        exposes: modules.map((m) => `modules.${m.name}`),
         getExposed(_paths, _paramProvider) {
-            return (0, rename_keys_1.renameKeys)(modulesEnabled, k => `modules.${k}`);
+            return (0, rename_keys_1.renameKeys)(modulesEnabled, (k) => `modules.${k}`);
         },
     };
 }