@flarum/cli 1.0.0 → 2.0.0-beta.1

package/lib/boilersmith/exposed-param-manager.d.ts

@@ -0,0 +1,8 @@
+export declare class ExposedParamManager {
+    protected stepsRan: Set<string>;
+    protected exposedParams: Map<string, unknown>;
+    stepRan(stepName: string, packagePath?: string): boolean;
+    has(stepName: string, paramName: string, packagePath?: string): boolean;
+    get<T = unknown>(stepName: string, paramName: string, packagePath?: string): T;
+    add(stepName: string, params: Record<string, unknown>, packagePath?: string): void;
+}

package/lib/boilersmith/exposed-param-manager.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExposedParamManager = void 0;
+function ranKey(stepName, packagePath = '') {
+    return JSON.stringify([stepName, packagePath]);
+}
+function paramKey(stepName, paramName, packagePath = '') {
+    return JSON.stringify([stepName, paramName, packagePath]);
+}
+class ExposedParamManager {
+    constructor() {
+        this.stepsRan = new Set();
+        this.exposedParams = new Map();
+    }
+    stepRan(stepName, packagePath) {
+        return this.stepsRan.has(ranKey(stepName, packagePath));
+    }
+    has(stepName, paramName, packagePath) {
+        return this.exposedParams.has(paramKey(stepName, paramName, packagePath));
+    }
+    get(stepName, paramName, packagePath) {
+        return this.exposedParams.get(paramKey(stepName, paramName, packagePath));
+    }
+    add(stepName, params, packagePath) {
+        this.stepsRan.add(ranKey(stepName, packagePath));
+        Object.entries(params).forEach(([paramName, value]) => {
+            this.exposedParams.set(paramKey(stepName, paramName, packagePath), value);
+        });
+    }
+}
+exports.ExposedParamManager = ExposedParamManager;

package/lib/boilersmith/io.d.ts

@@ -0,0 +1,50 @@
+import { Options, PromptObject } from 'prompts';
+export declare type ParamDef<N extends string = string> = Omit<PromptObject<N>, 'name'> & {
+    name: N;
+};
+export declare type Message = {
+    type: 'info' | 'warning' | 'error';
+    message: string;
+};
+export interface IO {
+    supportsAnsiColor: boolean;
+    /**
+     * Prompt the user for some input data.
+     */
+    getParam<T>(param: ParamDef): Promise<T>;
+    /**
+     * Check if some data has already been prompted for.
+     */
+    hasCached(name: string): boolean;
+    /**
+     * Get all cached params.
+     */
+    cached(): Record<string, unknown>;
+    info(message: string, immediate: boolean): void;
+    warning(message: string, immediate: boolean): void;
+    error(message: string, immediate: boolean): void;
+    /**
+     * Get all messages that have been logged non-immediately.
+     */
+    getOutput(): Message[];
+    newInstance(cache: Record<string, unknown>, messages: Message[]): IO;
+}
+export declare const PROMPTS_OPTIONS: Options;
+export declare class PromptsIO implements IO {
+    supportsAnsiColor: boolean;
+    private cache;
+    private messages;
+    constructor(initial?: Record<string, unknown>, messages?: Message[]);
+    getParam<T>(paramDef: ParamDef): Promise<T>;
+    hasCached(name: string): boolean;
+    /**
+     * @internal
+     */
+    cached(): Record<string, unknown>;
+    info(message: string, immediate: boolean): void;
+    warning(message: string, immediate: boolean): void;
+    error(message: string, immediate: false): void;
+    error(message: string, immediate: true): void;
+    getOutput(): Message[];
+    newInstance(cache: Record<string, unknown>, messages: Message[]): PromptsIO;
+}

package/lib/boilersmith/io.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptsIO = exports.PROMPTS_OPTIONS = void 0;
+const tslib_1 = require("tslib");
+const prompts_1 = (0, tslib_1.__importDefault)(require("prompts"));
+const errors_1 = require("@oclif/errors");
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+exports.PROMPTS_OPTIONS = { onCancel: () => (0, errors_1.exit)() };
+class PromptsIO {
+    constructor(initial = {}, messages = []) {
+        this.supportsAnsiColor = true;
+        this.cache = new Map();
+        this.messages = [];
+        this.cache = new Map(Object.entries(initial));
+        this.messages = messages;
+    }
+    async getParam(paramDef) {
+        const paramName = paramDef.name;
+        if (this.cache.has(paramName)) {
+            return this.cache.get(paramName);
+        }
+        const res = (await (0, prompts_1.default)(paramDef, exports.PROMPTS_OPTIONS));
+        const resValue = res[paramName];
+        this.cache.set(paramName, resValue);
+        return resValue;
+    }
+    hasCached(name) {
+        return this.cache.has(name);
+    }
+    /**
+     * @internal
+     */
+    cached() {
+        return [...this.cache].reduce((obj, [key, value]) => {
+            obj[key] = value;
+            return obj;
+        }, {});
+    }
+    info(message, immediate) {
+        if (immediate) {
+            console.log(message);
+        }
+        else {
+            this.messages.push({ type: 'info', message });
+        }
+    }
+    warning(message, immediate) {
+        const formatted = `${chalk_1.default.yellow('Warning:')} ${message}`;
+        if (immediate) {
+            console.log(formatted);
+        }
+        else {
+            this.messages.push({ type: 'warning', message: formatted });
+        }
+    }
+    error(message, immediate) {
+        const formatted = `${chalk_1.default.red('Error:')} ${message}`;
+        if (immediate) {
+            throw new Error(message);
+        }
+        else {
+            this.messages.push({ type: 'error', message: formatted });
+        }
+    }
+    getOutput() {
+        return this.messages;
+    }
+    newInstance(cache, messages) {
+        return new PromptsIO(cache, messages);
+    }
+}
+exports.PromptsIO = PromptsIO;

package/lib/boilersmith/paths.d.ts

@@ -0,0 +1,22 @@
+export interface Paths {
+    cwd(...path: string[]): string;
+    package(...path: string[]): string;
+    requestedDir(...path: string[]): string | null;
+    monorepo(...path: string[]): string | null;
+    onMonorepoSub(packagePath: string): Paths;
+}
+declare type InternalPaths = {
+    package: string;
+    monorepo?: string | null;
+    requestedDir?: string | null;
+};
+export declare class NodePaths implements Paths {
+    protected paths: InternalPaths;
+    constructor(paths: InternalPaths);
+    cwd(...path: string[]): string;
+    package(...path: string[]): string;
+    requestedDir(...path: string[]): string | null;
+    monorepo(...path: string[]): string | null;
+    onMonorepoSub(packagePath: string): NodePaths;
+}
+export {};

package/lib/boilersmith/paths.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodePaths = void 0;
+const node_path_1 = require("node:path");
+class NodePaths {
+    constructor(paths) {
+        this.paths = paths;
+    }
+    cwd(...path) {
+        return (0, node_path_1.resolve)(process.cwd(), ...path);
+    }
+    package(...path) {
+        return (0, node_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);
+    }
+    monorepo(...path) {
+        if (!this.paths.monorepo)
+            return null;
+        return (0, node_path_1.resolve)(this.paths.monorepo, ...path);
+    }
+    onMonorepoSub(packagePath) {
+        return new NodePaths(Object.assign(Object.assign({}, this.paths), { monorepo: this.paths.package, package: packagePath }));
+    }
+}
+exports.NodePaths = NodePaths;

package/lib/boilersmith/scaffolding/audit-step-factory.d.ts

@@ -0,0 +1,5 @@
+import { DefaultProviders, Step } from '../step-manager';
+import { Module, ModuleStatusCache } from './module';
+import { TemplateParam } from './template-param';
+import { ExcludeScaffoldingFunc } from './scaffolder';
+export declare function auditStepFactory<MN extends string, Providers extends DefaultProviders>(dry: boolean, scaffoldDir: string, modules: Module<MN>[], templateParams: TemplateParam[], excludeScaffoldingFunc?: ExcludeScaffoldingFunc, moduleStatusCache?: ModuleStatusCache<MN>): Step<Providers>;

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditStepFactory = void 0;
+const tslib_1 = require("tslib");
+const mem_fs_1 = require("mem-fs");
+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");
+function auditStepFactory(dry, scaffoldDir, modules, templateParams, excludeScaffoldingFunc, moduleStatusCache) {
+    let modulesEnabled;
+    return {
+        type: 'Audit for outdated infrastructure files or config.',
+        composable: true,
+        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);
+            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);
+                }
+                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);
+                }
+            }
+            for (const m of actionableModules) {
+                const fs = dry ? (0, mem_fs_1.create)() : _fs;
+                const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : [];
+                (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()); });
+                    if (filesWithChanges.length > 0) {
+                        io.error(`Module ${m.name} has ${filesWithChanges.length} changed files: ${filesWithChanges
+                            .map(f => f.path.replace(paths.package() + '/', ''))
+                            .join(', ')}`, false);
+                    }
+                }
+            }
+            return _fs;
+        },
+        exposes: modules.map(m => `modules.${m.name}`),
+        getExposed(_paths, _paramProvider) {
+            return (0, rename_keys_1.renameKeys)(modulesEnabled, k => `modules.${k}`);
+        },
+    };
+}
+exports.auditStepFactory = auditStepFactory;

package/lib/boilersmith/scaffolding/infra-step-factory.d.ts

@@ -0,0 +1,5 @@
+import { DefaultProviders, Step } from '../step-manager';
+import { Module, ModuleStatusCache } from './module';
+import { TemplateParam } from './template-param';
+import { ExcludeScaffoldingFunc } from './scaffolder';
+export declare function infraStepFactory<MN extends string, Providers extends DefaultProviders>(scaffoldDir: string, moduleName: string, modules: Module<MN>[], templateParams: TemplateParam[], excludeScaffoldingFunc?: ExcludeScaffoldingFunc, moduleStatusCache?: ModuleStatusCache<MN>): Step<Providers>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+    if (!module) {
+        throw new Error(`Module ${moduleName} not found`);
+    }
+    return {
+        type: module.shortDescription,
+        composable: true,
+        async run(fs, paths, io, _providers) {
+            const paramVals = await (0, template_param_1.currParamValues)(templateParams, fs, paths, io);
+            const modulesEnabled = await (0, module_1.currModulesEnabled)(modules, fs, paths, moduleStatusCache);
+            if (!module.updatable) {
+                io.error(`${module.name} is not updatable.`, true);
+            }
+            const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : [];
+            const initializing = !modulesEnabled[module.name];
+            (0, module_1.applyModule)(module, modulesEnabled, paramVals, scaffoldDir, fs, paths, excludeScaffolding, initializing);
+            if (moduleStatusCache) {
+                (0, module_1.setModuleValue)(module, true, fs, paths, moduleStatusCache);
+            }
+            return fs;
+        },
+        exposes: [],
+        getExposed(_paths, _paramProvider) {
+            return {};
+        },
+    };
+}
+exports.infraStepFactory = infraStepFactory;

package/lib/boilersmith/scaffolding/init-step-factory.d.ts

@@ -0,0 +1,5 @@
+import { DefaultProviders, Step } from '../step-manager';
+import { Module, ModuleStatusCache } from './module';
+import { TemplateParam } from './template-param';
+import { ExcludeScaffoldingFunc } from './scaffolder';
+export declare function initStepFactory<MN extends string, Providers extends DefaultProviders>(scaffoldDir: string, modules: Module<MN>[], templateParams: TemplateParam[], excludeScaffoldingFunc?: ExcludeScaffoldingFunc, moduleStatusCache?: ModuleStatusCache<MN>): Step<Providers>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initStepFactory = void 0;
+const rename_keys_1 = require("../utils/rename-keys");
+const module_1 = require("./module");
+const template_param_1 = require("./template-param");
+function initStepFactory(scaffoldDir, modules, templateParams, excludeScaffoldingFunc, moduleStatusCache) {
+    let modulesEnabled;
+    return {
+        type: 'Generate package skeleton',
+        composable: true,
+        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) : [];
+            for (const m of modules) {
+                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 => {
+                    (0, module_1.setModuleValue)(m, modulesEnabled[m.name], fs, paths, moduleStatusCache);
+                });
+            }
+            return fs;
+        },
+        exposes: modules.map(m => `modules.${m.name}`),
+        getExposed(_paths, _paramProvider) {
+            return (0, rename_keys_1.renameKeys)(modulesEnabled, k => `modules.${k}`);
+        },
+    };
+}
+exports.initStepFactory = initStepFactory;

package/lib/boilersmith/scaffolding/module.d.ts

@@ -0,0 +1,68 @@
+import { Store } from 'mem-fs';
+import { IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+interface FileOwnership {
+    /**
+     * The path to the file
+     */
+    path: string;
+    /**
+     * If any of the needed modules aren't enabled, the file won't be updated.
+     */
+    needsOtherModules?: string[];
+    /**
+     * If in a monorepo, should the file be placed relative to the monorepo root?
+     */
+    monorepoPath?: string;
+}
+interface CommonModule<N extends string> {
+    name: N;
+    shortDescription: string;
+    longDescription?: string;
+    /**
+     * Whether files belonging to this module should be kept up to date.
+     */
+    updatable: boolean;
+    /**
+     * A list of scaffolding files managed by this module.
+     */
+    filesToReplace: (string | FileOwnership)[];
+    /**
+     * A map of names of JSON files to keys which should be deep-merged from the scaffolding.
+     */
+    jsonToAugment: Record<string, string[]>;
+    /**
+     * An array of names of template params needed by this module.
+     */
+    needsTemplateParams: string[];
+}
+interface UntoggleableModule<N extends string> extends CommonModule<N> {
+    /**
+     * Whether this module can be enabled/disabled.
+     */
+    togglable: false;
+}
+interface TogglableModule<N extends string> extends CommonModule<N> {
+    /**
+     * Whether this module can be enabled/disabled.
+     */
+    togglable: true;
+    /**
+     * Whether this module is enabled or disabled by default.
+     */
+    defaultEnabled: boolean;
+    /**
+     * Can only be enabled if these other modules are enabled.
+     */
+    dependsOn: string[];
+}
+export declare type Module<N extends string = string> = UntoggleableModule<N> | TogglableModule<N>;
+export declare type ModuleStatusCache<N extends string> = {
+    get: (module: Module<N>, fs: Store, paths: Paths) => Promise<boolean | undefined>;
+    set: (module: Module<N>, val: boolean, fs: Store, paths: Paths) => Promise<void>;
+};
+export declare function promptModulesEnabled<N extends string>(modules: Module<N>[], io: IO): Promise<Record<N, boolean>>;
+export declare function currModulesEnabled<N extends string>(modules: Module<N>[], fs: Store, paths: Paths, cache?: ModuleStatusCache<N>): Promise<Record<N, boolean>>;
+export declare function setModuleValue<MN extends string>(module: Module<MN>, enabled: boolean, fs: Store, paths: Paths, cache: ModuleStatusCache<MN>): Promise<void>;
+export declare function applyModule<MN extends string, TN extends string>(module: Module<MN>, modulesEnabled: Record<string, boolean>, paramVals: Record<TN, unknown>, scaffoldDir: string, fs: Store, paths: Paths, excludeFiles?: string[], isInitial?: boolean): Promise<Store>;
+export {};

package/lib/boilersmith/scaffolding/module.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyModule = exports.setModuleValue = exports.currModulesEnabled = exports.promptModulesEnabled = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const mem_fs_editor_1 = require("mem-fs-editor");
+const node_path_1 = require("node:path");
+const pick_deep_1 = (0, tslib_1.__importDefault)(require("pick-deep"));
+const read_tpl_1 = require("boilersmith/utils/read-tpl");
+const clone_and_fill_1 = require("boilersmith/utils/clone-and-fill");
+const rename_keys_1 = require("boilersmith/utils/rename-keys");
+const cond_format_1 = require("boilersmith/utils/cond-format");
+async function promptModulesEnabled(modules, io) {
+    const modulesEnabled = {};
+    const advanced = await io.getParam({
+        name: 'advancedInstallation',
+        type: 'confirm',
+        initial: false,
+        message: `Advanced Initialization ${(0, cond_format_1.condFormat)(io.supportsAnsiColor, chalk_1.default.dim, '(fine-tune which features are enabled)')}`,
+    });
+    for (const m of modules) {
+        const missingDeps = !m.togglable || m.dependsOn.some(dep => !modulesEnabled[dep]);
+        if (!m.togglable) {
+            modulesEnabled[m.name] = true;
+        }
+        else if (missingDeps) {
+            modulesEnabled[m.name] = false;
+        }
+        else if (advanced) {
+            // eslint-disable-next-line no-await-in-loop
+            modulesEnabled[m.name] = await io.getParam({
+                name: `modules.${m.name}`,
+                type: 'confirm',
+                initial: m.defaultEnabled,
+                message: m.shortDescription + (m.longDescription ? (0, cond_format_1.condFormat)(io.supportsAnsiColor, chalk_1.default.dim, ` (${m.longDescription})`) : ''),
+            });
+        }
+        else {
+            modulesEnabled[m.name] = m.defaultEnabled;
+        }
+    }
+    return modulesEnabled;
+}
+exports.promptModulesEnabled = promptModulesEnabled;
+async function currModulesEnabled(modules, fs, paths, cache) {
+    const modulesEnabled = {};
+    for (const m of modules) {
+        if (m.togglable) {
+            // eslint-disable-next-line no-await-in-loop
+            const cacheVal = await (cache === null || cache === void 0 ? void 0 : cache.get(m, fs, paths));
+            modulesEnabled[m.name] = cacheVal !== null && cacheVal !== void 0 ? cacheVal : m.defaultEnabled;
+        }
+        else {
+            modulesEnabled[m.name] = true;
+        }
+    }
+    return modulesEnabled;
+}
+exports.currModulesEnabled = currModulesEnabled;
+async function setModuleValue(module, enabled, fs, paths, cache) {
+    if (module.togglable) {
+        cache.set(module, enabled, fs, paths);
+    }
+}
+exports.setModuleValue = setModuleValue;
+// eslint-disable-next-line max-params
+async function applyModule(module, modulesEnabled, paramVals, scaffoldDir, fs, paths, excludeFiles = [], isInitial = false) {
+    var _a;
+    const fsEditor = (0, mem_fs_editor_1.create)(fs);
+    // Validate that module can be enabled
+    if (!(modulesEnabled === null || modulesEnabled === void 0 ? void 0 : modulesEnabled[module.name])) {
+        throw new Error(`Could not apply module "${module.name}", because it is not enabled in the provided module statuses.`);
+    }
+    // Validate that dependencies are enabled
+    const missingDeps = module.togglable ? module.dependsOn.filter(dep => !modulesEnabled[dep]) : [];
+    if (missingDeps.length > 0) {
+        throw new Error(`Could not apply module "${module.name}", because the following dependency modules are missing: "${missingDeps.join(', ')}".`);
+    }
+    // Validate that all needed params are present
+    const missingParams = module.needsTemplateParams.filter(p => !(p in paramVals));
+    if (missingParams.length > 0) {
+        throw new Error(`Could not apply module "${module.name}", because the following params are missing: "${missingParams.join(', ')}".`);
+    }
+    if (!isInitial && !module.updatable) {
+        throw new Error(`Cannot update module "${module.name}", as it is not updatable, and has already been initialized.`);
+    }
+    const tplData = {
+        params: paramVals,
+        modules: modulesEnabled,
+    };
+    const tplDataFlat = Object.assign(Object.assign({}, (0, rename_keys_1.renameKeys)(tplData.modules, k => `modules.${k}`)), (0, rename_keys_1.renameKeys)(tplData.params, k => `params.${k}`));
+    for (const file of module.filesToReplace) {
+        const path = typeof file === 'string' ? file : file.path;
+        const needsOtherModules = typeof file === 'string' ? [] : (_a = file.needsOtherModules) !== null && _a !== void 0 ? _a : [];
+        if (!excludeFiles.includes(path) && !needsOtherModules.some(dep => !modulesEnabled[dep])) {
+            const copyToIfMonorepo = typeof file !== 'string' && file.monorepoPath ? paths.monorepo((0, clone_and_fill_1.cloneAndFill)(file.monorepoPath, tplDataFlat)) : undefined;
+            const copyTo = copyToIfMonorepo !== null && copyToIfMonorepo !== void 0 ? copyToIfMonorepo : paths.package(path);
+            fsEditor.copyTpl((0, node_path_1.resolve)(scaffoldDir, path), copyTo, tplData);
+        }
+    }
+    const jsonPaths = (0, clone_and_fill_1.cloneAndFill)(module.jsonToAugment, tplDataFlat);
+    for (const jsonPath of Object.keys(jsonPaths)) {
+        const scaffoldContents = (0, read_tpl_1.readTpl)((0, node_path_1.resolve)(scaffoldDir, jsonPath), tplData);
+        const scaffoldContentsJson = JSON.parse(scaffoldContents);
+        const fieldsToAugment = jsonPaths[jsonPath];
+        const relevant = (0, pick_deep_1.default)(scaffoldContentsJson, fieldsToAugment);
+        fsEditor.extendJSON(paths.package(jsonPath), relevant, undefined, 4);
+    }
+    return fs;
+}
+exports.applyModule = applyModule;

package/lib/boilersmith/scaffolding/scaffolder.d.ts

@@ -0,0 +1,32 @@
+import { Store } from 'mem-fs';
+import { Paths } from '../paths';
+import { DefaultProviders, Step } from '../step-manager';
+import { Module, ModuleStatusCache } from './module';
+import { TemplateParam } from './template-param';
+import { IO } from 'boilersmith/io';
+export declare type ExcludeScaffoldingFunc = (fs: Store, paths: Paths) => string[];
+export declare class Scaffolder<TN extends string = string, MN extends string = string> {
+    private templateParams;
+    private modules;
+    private scaffoldDir;
+    private moduleStatusCache?;
+    private excludeScaffoldingFunc?;
+    constructor(scaffoldDir: string);
+    constructor(scaffoldDir: string, moduleStatusCache: ModuleStatusCache<MN>);
+    constructor(scaffoldDir: string, moduleStatusCache: ModuleStatusCache<MN>, excludeScaffoldingFuncs: ExcludeScaffoldingFunc);
+    registerModule(module: Module<MN>): this;
+    registerTemplateParam<T>(templateParam: TemplateParam<T, TN>): this;
+    genInitStep<Providers extends DefaultProviders>(): Step<Providers>;
+    genInfraStep<Providers extends DefaultProviders>(module: string): Step<Providers>;
+    genAuditStep<Providers extends DefaultProviders>(dry?: boolean): Step<Providers>;
+    templateParamVal<T>(param: TN, fs: Store, paths: Paths, io: IO): Promise<T>;
+    templateParamVals(fs: Store, paths: Paths, io: IO): Promise<Record<TN, unknown>>;
+    modulesEnabled(fs: Store, paths: Paths): Promise<Record<MN, boolean>>;
+    moduleFiles(moduleName: MN): string[];
+    /**
+     * Confirm that all files and configuration keys in the scaffolding dir
+     * are owned by at least one module, and that no modules own nonexistent
+     * files or configuration keys.
+     */
+    validate(): Promise<void>;
+}