@flarum/cli 1.0.0 → 2.0.0-beta.1

package/lib/commands/infra/backend-testing.d.ts

@@ -1,14 +0,0 @@
-import { StepManager } from '../../steps/step-manager';
-import BaseCommand from '../../base-command';
-export default class BackendTesting extends BaseCommand {
-    static description: string;
-    static flags: {
-        [x: string]: import("@oclif/command/lib/flags").IFlag<any>;
-    };
-    static args: {
-        name: string;
-        description: string;
-    }[];
-    protected steps(stepManager: StepManager): StepManager;
-    protected additionalPreRunChecks(extRoot: string): Promise<void>;
-}

package/lib/commands/infra/backend-testing.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const composer_1 = require("../../steps/misc/composer");
-const base_command_1 = tslib_1.__importDefault(require("../../base-command"));
-const backend_testing_1 = require("../../steps/infra/backend-testing");
-class BackendTesting extends base_command_1.default {
-    steps(stepManager) {
-        return stepManager
-            .namedStep('testing', new backend_testing_1.BackendTestingInfra())
-            .step(new composer_1.ComposerInstall(), { optional: true, confirmationMessage: 'Run `composer update`? (recommended)', default: true }, [
-            {
-                sourceStep: 'testing',
-                exposedName: '__succeeded',
-                dontRunIfFalsy: true,
-            },
-        ]);
-    }
-    async additionalPreRunChecks(extRoot) {
-        await this.confirmOverrideFiles(extRoot, 'tests/integration/setup.php', 'Test infrastructure files already exist. Overwrite with the latest version?');
-    }
-}
-exports.default = BackendTesting;
-BackendTesting.description = 'Add/Update backend testing infrastructure';
-BackendTesting.flags = Object.assign({}, base_command_1.default.flags);
-BackendTesting.args = [...base_command_1.default.args];

package/lib/provider/param-provider.d.ts

@@ -1,15 +0,0 @@
-import { Options, PromptObject } from 'prompts';
-export declare type ParamDef = PromptObject;
-export declare const PROMPTS_OPTIONS: Options;
-export declare class ParamProvider {
-    private cache;
-    constructor(initial?: Record<string, unknown>);
-    get<T>(paramDef: ParamDef): Promise<T>;
-    has(name: string): boolean;
-    /**
-     * @internal
-     */
-    cached(): Record<string, unknown>;
-}
-export declare type ParamProviderFactory = (initial: Record<string, unknown>) => ParamProvider;
-export declare const paramProviderFactory: ParamProviderFactory;

package/lib/provider/param-provider.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paramProviderFactory = exports.ParamProvider = exports.PROMPTS_OPTIONS = void 0;
-const tslib_1 = require("tslib");
-const prompts_1 = tslib_1.__importDefault(require("prompts"));
-const errors_1 = require("@oclif/errors");
-exports.PROMPTS_OPTIONS = { onCancel: () => errors_1.exit() };
-class ParamProvider {
-    constructor(initial = {}) {
-        this.cache = new Map();
-        this.cache = new Map(Object.entries(initial));
-    }
-    async get(paramDef) {
-        const paramName = paramDef.name;
-        if (this.cache.has(paramName)) {
-            return this.cache.get(paramName);
-        }
-        const res = await prompts_1.default(paramDef, exports.PROMPTS_OPTIONS);
-        const resValue = res[paramName];
-        this.cache.set(paramName, resValue);
-        return resValue;
-    }
-    has(name) {
-        return this.cache.has(name);
-    }
-    /**
-     * @internal
-     */
-    cached() {
-        return [...this.cache].reduce((obj, [key, value]) => {
-            obj[key] = value;
-            return obj;
-        }, {});
-    }
-}
-exports.ParamProvider = ParamProvider;
-exports.paramProviderFactory = (initial = {}) => {
-    return new ParamProvider(initial);
-};

package/lib/provider/path-provider.d.ts

@@ -1,19 +0,0 @@
-export interface PathProvider {
-    cwd(...path: string[]): string;
-    ext(...path: string[]): string;
-    boilerplate(...path: string[]): string;
-    requestedDir(...path: string[]): string | null;
-}
-interface Paths {
-    ext: string;
-    requestedDir?: string;
-}
-export declare class PathFsProvider implements PathProvider {
-    private paths;
-    constructor(paths: Paths);
-    cwd(...path: string[]): string;
-    ext(...path: string[]): string;
-    boilerplate(...path: string[]): string;
-    requestedDir(...path: string[]): string | null;
-}
-export {};

package/lib/provider/path-provider.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathFsProvider = void 0;
-const path_1 = require("path");
-class PathFsProvider {
-    constructor(paths) {
-        this.paths = paths;
-    }
-    cwd(...path) {
-        return path_1.resolve(process.cwd(), ...path);
-    }
-    ext(...path) {
-        return path_1.resolve(this.paths.ext, ...path);
-    }
-    boilerplate(...path) {
-        return path_1.resolve(__dirname, '../../boilerplate', ...path);
-    }
-    requestedDir(...path) {
-        if (!this.paths.requestedDir)
-            return null;
-        return path_1.resolve(this.paths.requestedDir, ...path);
-    }
-}
-exports.PathFsProvider = PathFsProvider;

package/lib/steps/infra/backend-testing.d.ts

@@ -1,8 +0,0 @@
-import { BaseInfraStep } from './base';
-export declare class BackendTestingInfra extends BaseInfraStep {
-    type: string;
-    protected filesToReplace: string[];
-    protected jsonToAugment: {
-        'composer.json': string[];
-    };
-}

package/lib/steps/infra/backend-testing.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackendTestingInfra = void 0;
-const base_1 = require("./base");
-class BackendTestingInfra extends base_1.BaseInfraStep {
-    constructor() {
-        super(...arguments);
-        this.type = 'Add/update backend testing infrastructure';
-        this.filesToReplace = [
-            'tests/phpunit.integration.xml',
-            'tests/phpunit.unit.xml',
-            'tests/fixtures/.gitkeep',
-            'tests/integration/setup.php',
-            'tests/unit/.gitkeep',
-            '.github/workflows/test.yml',
-        ];
-        this.jsonToAugment = {
-            'composer.json': ['scripts', 'scripts-description', 'require-dev'],
-        };
-    }
-}
-exports.BackendTestingInfra = BackendTestingInfra;

package/lib/steps/infra/base.d.ts

@@ -1,20 +0,0 @@
-import { Store } from 'mem-fs';
-import { ParamProvider } from '../../provider/param-provider';
-import { PathProvider } from '../../provider/path-provider';
-import { PhpProvider } from '../../provider/php-provider';
-import { Step } from '../step-manager';
-export declare abstract class BaseInfraStep implements Step {
-    abstract type: string;
-    composable: boolean;
-    /**
-     * A list of file paths to replace from the boilerplate
-     */
-    protected abstract filesToReplace: string[];
-    /**
-     * A map of names of JSON files to keys which should be deep-merged from the boilerplate.
-     */
-    protected abstract jsonToAugment: Record<string, string[]>;
-    run(fs: Store, pathProvider: PathProvider, _paramProvider: ParamProvider, _phpProvider: PhpProvider): Promise<Store>;
-    exposes: never[];
-    getExposed(_pathProvider: PathProvider, _paramProvider: ParamProvider): Record<string, unknown>;
-}

package/lib/steps/infra/base.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseInfraStep = void 0;
-const mem_fs_editor_1 = require("mem-fs-editor");
-const pick_1 = require("@zodash/pick");
-const extension_metadata_1 = require("../../utils/extension-metadata");
-class BaseInfraStep {
-    constructor() {
-        this.composable = true;
-        this.exposes = [];
-    }
-    async run(fs, pathProvider, _paramProvider, _phpProvider) {
-        const fsEditor = mem_fs_editor_1.create(fs);
-        this.filesToReplace.forEach(filePath => {
-            fsEditor.copy(pathProvider.boilerplate(`skeleton/extension/${filePath}`), pathProvider.ext(filePath));
-        });
-        const fakeInitData = extension_metadata_1.extensionMetadata(fsEditor.readJSON(pathProvider.ext('composer.json')));
-        fakeInitData.packageNamespace = fakeInitData.packageNamespace.replace('\\', '\\\\');
-        Object.keys(this.jsonToAugment).forEach(jsonPath => {
-            const boilerplatePath = pathProvider.boilerplate('skeleton/extension', jsonPath);
-            const boilerplateTmpPath = pathProvider.boilerplate('skeleton/extension', `${jsonPath}.tmp`);
-            // We copy it to resolve template tags.
-            fsEditor.copyTpl(boilerplatePath, boilerplateTmpPath, fakeInitData);
-            const boilerplateComposerJson = fsEditor.readJSON(boilerplateTmpPath);
-            fsEditor.delete(boilerplateTmpPath);
-            const fieldsToAugment = this.jsonToAugment[jsonPath];
-            const relevant = pick_1.pick(boilerplateComposerJson, fieldsToAugment);
-            fsEditor.extendJSON(pathProvider.ext(jsonPath), relevant);
-        });
-        return fs;
-    }
-    getExposed(_pathProvider, _paramProvider) {
-        return {};
-    }
-}
-exports.BaseInfraStep = BaseInfraStep;

package/lib/steps/init/extension-skeleton.d.ts

@@ -1,12 +0,0 @@
-import { Store } from 'mem-fs';
-import { ParamProvider } from '../../provider/param-provider';
-import { PathProvider } from '../../provider/path-provider';
-import { PhpProvider } from '../../provider/php-provider';
-import { Step } from '../step-manager';
-export declare class ExtensionSkeleton implements Step {
-    type: string;
-    composable: boolean;
-    run(fs: Store, pathProvider: PathProvider, paramProvider: ParamProvider, _phpProvider: PhpProvider): Promise<Store>;
-    exposes: string[];
-    getExposed(_pathProvider: PathProvider, paramProvider: ParamProvider): Record<string, unknown>;
-}

package/lib/steps/init/extension-skeleton.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExtensionSkeleton = void 0;
-const tslib_1 = require("tslib");
-const pick_1 = require("@zodash/pick");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const mem_fs_editor_1 = require("mem-fs-editor");
-const simple_1 = tslib_1.__importDefault(require("spdx-license-list/simple"));
-const extension_metadata_1 = require("../../utils/extension-metadata");
-class ExtensionSkeleton {
-    constructor() {
-        this.type = 'Generate extension skeleton';
-        this.composable = true;
-        this.exposes = ['useJs'];
-    }
-    async run(fs, pathProvider, paramProvider, _phpProvider) {
-        const fsEditor = mem_fs_editor_1.create(fs);
-        const packageName = await paramProvider.get({
-            name: 'packageName',
-            type: 'text',
-            message: `Package ${chalk_1.default.dim('(vendor/extension-name)')}`,
-            validate: s => /^([0-9a-zA-Z-]{2,})\/([0-9a-zA-Z-]{2,})$/.test(s.trim()) || 'Invalid package name format',
-            format: s => s.toLowerCase(),
-        });
-        const packageDescription = await paramProvider.get({
-            name: 'packageDescription',
-            type: 'text',
-            message: 'Package description',
-        });
-        const namespace = await paramProvider.get({
-            name: 'namespace',
-            type: 'text',
-            message: `Package namespace ${chalk_1.default.dim('(Vendor\\ExtensionName)')}`,
-            validate: s => /^([0-9a-zA-Z]+)\\([0-9a-zA-Z]+)$/.test(s.trim()) || 'Invalid namespace format',
-            format: (str) => str &&
-                str
-                    .split('\\')
-                    .map(s => s[0].toUpperCase() + s.slice(1))
-                    .join('\\'),
-        });
-        const authorName = await paramProvider.get({
-            name: 'authorName',
-            type: 'text',
-            message: 'Author name',
-        });
-        const authorEmail = await paramProvider.get({
-            name: 'authorEmail',
-            type: 'text',
-            message: 'Author email',
-            validate: s => !s || /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/.test(s) || 'Invalid email format',
-        });
-        const extensionName = await paramProvider.get({
-            name: 'extensionName',
-            type: 'text',
-            message: 'Extension name',
-            validate: str => Boolean(str.trim()) || 'The extension name is required',
-            format: str => str
-                .split(' ')
-                .map((s) => (s.length > 3 ? s[0].toUpperCase() + s.slice(1) : s))
-                .join(' '),
-        });
-        const licenseType = await paramProvider.get({
-            name: 'license',
-            type: 'autocomplete',
-            message: 'License',
-            choices: [...simple_1.default].map(e => ({ title: e, value: e })),
-        });
-        const admin = await paramProvider.get({
-            name: 'admin',
-            type: 'confirm',
-            message: 'Admin CSS & JS',
-            initial: true,
-        });
-        const forum = await paramProvider.get({
-            name: 'forum',
-            type: 'confirm',
-            message: 'Forum CSS & JS',
-            initial: true,
-        });
-        const useLocale = await paramProvider.get({
-            name: 'useLocale',
-            type: 'confirm',
-            message: 'Locale',
-            initial: true,
-        });
-        const useJs = await paramProvider.get({
-            name: 'useJs',
-            type: () => (admin || forum) && 'confirm',
-            message: 'Javascript',
-            initial: true,
-        });
-        const useCss = await paramProvider.get({
-            name: 'useCss',
-            type: () => (admin || forum) && 'confirm',
-            message: 'CSS',
-            initial: true,
-        });
-        const tpl = {
-            namespace,
-            packageName,
-            packageDescription,
-            authorName,
-            authorEmail,
-            extensionName,
-            licenseType,
-            admin,
-            forum,
-            useLocale,
-            useJs,
-            useCss,
-            packageNamespace: namespace.replace(/\\/, '\\\\'),
-            year: new Date().getFullYear().toString(),
-            extensionId: extension_metadata_1.extensionId(packageName),
-        };
-        fsEditor.copyTpl(pathProvider.boilerplate('skeleton/extension'), pathProvider.ext(''), tpl, undefined, { globOptions: { dot: true } });
-        const license = await require(`spdx-license-list/licenses/${licenseType}`);
-        fsEditor.write(pathProvider.ext('LICENSE.md'), license.licenseText);
-        if (!useLocale)
-            fsEditor.delete(pathProvider.ext('locale'));
-        if (!useJs) {
-            fsEditor.delete(pathProvider.ext('js/.prettierrc.json'));
-            fsEditor.delete(pathProvider.ext('js'));
-        }
-        if (!useCss)
-            fsEditor.delete(pathProvider.ext('less'));
-        if (!admin) {
-            fsEditor.delete(pathProvider.ext('less/admin.less'));
-            fsEditor.delete(pathProvider.ext('js/src/admin'));
-            fsEditor.delete(pathProvider.ext('js/admin.js'));
-        }
-        if (!forum) {
-            fsEditor.delete(pathProvider.ext('less/forum.less'));
-            fsEditor.delete(pathProvider.ext('js/src/forum'));
-            fsEditor.delete(pathProvider.ext('js/forum.js'));
-        }
-        return fs;
-    }
-    getExposed(_pathProvider, paramProvider) {
-        return pick_1.pick(paramProvider.cached(), this.exposes);
-    }
-}
-exports.ExtensionSkeleton = ExtensionSkeleton;

package/lib/steps/step-manager.d.ts

@@ -1,71 +0,0 @@
-import { Store } from 'mem-fs';
-import { ParamProvider, ParamProviderFactory } from '../provider/param-provider';
-import { PathProvider } from '../provider/path-provider';
-import { PhpProvider } from '../provider/php-provider';
-export interface Step {
-    /**
-     * A short string describing what the step does.
-     */
-    type: string;
-    /**
-     * Can this step be composed with other steps?
-     *
-     * This is the case if the step makes no changes to the disk filesystem while running.
-     */
-    composable: boolean;
-    /**
-     * A list of names of params that this step exposes to other steps.
-     */
-    exposes: string[];
-    run: (fs: Store, pathProvider: PathProvider, paramProvider: ParamProvider, phpProvider: PhpProvider) => Promise<Store>;
-    /**
-     * Return an object of exposed params.
-     *
-     * The pathProvider and paramProvider will be the same objects provided to the `run` method.
-     */
-    getExposed(pathProvider: PathProvider, paramProvider: ParamProvider): Record<string, unknown>;
-}
-interface ShouldRunConfig {
-    optional?: boolean;
-    confirmationMessage?: string;
-    default?: boolean;
-}
-interface StoredStep {
-    name?: string;
-    step: Step;
-    shouldRun: ShouldRunConfig;
-    dependencies: StepDependency[];
-    predefinedParams: PredefinedParameters;
-}
-interface StepDependency {
-    sourceStep: string;
-    exposedName: string;
-    consumedName?: string;
-    dontRunIfFalsy?: boolean;
-    modifier?: (value: unknown) => string;
-}
-declare type PredefinedParameters = Record<string, unknown>;
-export declare class StepManager {
-    protected steps: Array<StoredStep | AtomicStepManager>;
-    protected namedSteps: Map<string, StoredStep>;
-    protected exposedParams: Map<string, Record<string, unknown>>;
-    /**
-     * A step is an incremental operation that updates the filesystem.
-     */
-    step(step: Step, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters): this;
-    namedStep(name: string, step: Step, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters): this;
-    atomicGroup(callback: (stepManager: AtomicStepManager) => void): this;
-    protected validateDependencies(step: Step, dependencies: StepDependency[]): void;
-    run(pathProvider: PathProvider, paramProviderFactory: ParamProviderFactory, phpProvider: PhpProvider): Promise<string[]>;
-    protected stepShouldRun(storedStep: StoredStep, paramProviderFactory: ParamProviderFactory): Promise<boolean>;
-    protected runStep(storedStep: StoredStep, pathProvider: PathProvider, paramProviderFactory: ParamProviderFactory, phpProvider: PhpProvider, fs?: Store): Promise<Store>;
-    protected commit(fs: Store): Promise<boolean>;
-}
-declare class AtomicStepManager extends StepManager {
-    constructor(parentNamedSteps: Map<string, StoredStep>, parentExposedParams: Map<string, Record<string, unknown>>);
-    step(step: Step, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters): this;
-    namedStep(name: string, step: Step, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters): this;
-    atomicGroup(_callback: (stepManager: AtomicStepManager) => void): this;
-    run(pathProvider: PathProvider, paramProviderFactory: ParamProviderFactory, phpProvider: PhpProvider): Promise<string[]>;
-}
-export {};

package/lib/steps/step-manager.js

@@ -1,173 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StepManager = void 0;
-/* eslint-disable no-await-in-loop */
-const mem_fs_1 = require("mem-fs");
-const mem_fs_editor_1 = require("mem-fs-editor");
-class StepManager {
-    constructor() {
-        this.steps = [];
-        this.namedSteps = new Map();
-        this.exposedParams = new Map();
-    }
-    /**
-     * A step is an incremental operation that updates the filesystem.
-     */
-    step(step, shouldRun = {}, dependencies = [], predefinedParams = {}) {
-        this.validateDependencies(step, dependencies);
-        this.steps = [...this.steps, { step, shouldRun, dependencies, predefinedParams }];
-        return this;
-    }
-    namedStep(name, step, shouldRun = {}, dependencies = [], predefinedParams = {}) {
-        if (this.namedSteps.has(name)) {
-            throw new Error(`Named steps must have unique names. A step with name "${name}" already exists.`);
-        }
-        this.validateDependencies(step, dependencies);
-        const newStep = { name, step, shouldRun, dependencies, predefinedParams };
-        this.steps = [...this.steps, newStep];
-        this.namedSteps.set(name, newStep);
-        return this;
-    }
-    atomicGroup(callback) {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        const atomicCollection = new AtomicStepManager(this.namedSteps, this.exposedParams);
-        callback(atomicCollection);
-        this.steps = [...this.steps, atomicCollection];
-        return this;
-    }
-    validateDependencies(step, dependencies) {
-        const format = (strings) => strings
-            .map(s => `"${s}"`)
-            .join(', ');
-        const missingDependencySteps = dependencies
-            .map(dep => dep.sourceStep)
-            .filter(stepName => !this.namedSteps.has(stepName));
-        if (missingDependencySteps.length > 0) {
-            throw new Error(`Step of type "${step.type}" depends on nonexistent named steps ${format(missingDependencySteps)}`);
-        }
-        const missingDependencyParams = [];
-        const missingDependencyParamSteps = [];
-        dependencies.forEach(dependency => {
-            const sourceStep = this.namedSteps.get(dependency.sourceStep);
-            if (!(sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.step.exposes.includes(dependency.exposedName)) && dependency.exposedName !== '__succeeded') {
-                missingDependencyParamSteps.push(sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.name);
-                missingDependencyParams.push(dependency.exposedName);
-            }
-        });
-        if (missingDependencyParamSteps.length > 0) {
-            throw new Error(`Step of type "${step.type}" depends on nonexistent exposed params ${format(missingDependencyParams)} from named steps ${format(missingDependencyParamSteps)}`);
-        }
-    }
-    async run(pathProvider, paramProviderFactory, phpProvider) {
-        const stepNames = [];
-        for (let i = 0; i < this.steps.length; i++) {
-            const storedStep = this.steps[i];
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            if (storedStep instanceof AtomicStepManager) {
-                const res = await storedStep.run(pathProvider, paramProviderFactory, phpProvider);
-                stepNames.push(...res);
-            }
-            else {
-                const shouldRun = await this.stepShouldRun(storedStep, paramProviderFactory);
-                if (!shouldRun)
-                    continue;
-                const fs = await this.runStep(storedStep, pathProvider, paramProviderFactory, phpProvider);
-                await this.commit(fs);
-                stepNames.push(storedStep.step.type);
-            }
-        }
-        return stepNames;
-    }
-    async stepShouldRun(storedStep, paramProviderFactory) {
-        let allDependenciesRan = true;
-        let noRequiredNonFalsyDependenciesAreFalsy = true;
-        storedStep.dependencies.forEach(dep => {
-            if (!this.exposedParams.has(dep.sourceStep))
-                allDependenciesRan = false;
-            const sourceDeps = this.exposedParams.get(dep.sourceStep);
-            if (dep.exposedName !== '__succeeded' && dep.dontRunIfFalsy && !sourceDeps[dep.exposedName]) {
-                noRequiredNonFalsyDependenciesAreFalsy = false;
-            }
-        });
-        if (!allDependenciesRan || !noRequiredNonFalsyDependenciesAreFalsy)
-            return false;
-        if (!storedStep.shouldRun.optional)
-            return true;
-        const promptConfirm = await paramProviderFactory({ context: 'Confirm Step' }).get({
-            name: 'execute_step',
-            message: storedStep.shouldRun.confirmationMessage || `Run step of type "${storedStep.step.type}"?`,
-            initial: storedStep.shouldRun.default || false,
-            type: 'confirm',
-        });
-        return promptConfirm;
-    }
-    async runStep(storedStep, pathProvider, paramProviderFactory, phpProvider, fs = mem_fs_1.create()) {
-        const initial = storedStep.dependencies.reduce((initial, dep) => {
-            let depValue;
-            if (dep.exposedName === '__succeeded') {
-                depValue = this.exposedParams.has(dep.sourceStep);
-            }
-            else {
-                depValue = this.exposedParams.get(dep.sourceStep)[dep.exposedName];
-            }
-            if (dep.modifier) {
-                depValue = dep.modifier(depValue);
-            }
-            initial[dep.consumedName || dep.exposedName] = depValue;
-            return initial;
-        }, {});
-        const paramProvider = paramProviderFactory(Object.assign(Object.assign({}, initial), storedStep.predefinedParams));
-        const newFs = await storedStep.step.run(fs, pathProvider, paramProvider, phpProvider);
-        if (storedStep.name) {
-            this.exposedParams.set(storedStep.name, storedStep.step.getExposed(pathProvider, paramProvider));
-        }
-        return newFs;
-    }
-    async commit(fs) {
-        return new Promise((resolve, _reject) => {
-            mem_fs_editor_1.create(fs).commit(err => {
-                if (err) {
-                    throw new Error(err);
-                }
-                resolve(true);
-            });
-        });
-    }
-}
-exports.StepManager = StepManager;
-class AtomicStepManager extends StepManager {
-    constructor(parentNamedSteps, parentExposedParams) {
-        super();
-        this.namedSteps = parentNamedSteps;
-        this.exposedParams = parentExposedParams;
-    }
-    step(step, shouldRun = {}, dependencies = [], predefinedParams = {}) {
-        if (!step.composable) {
-            throw new Error(`Step of type "${step.type}" is not composable, and cannot be added to an atomic group.`);
-        }
-        return super.step(step, shouldRun, dependencies, predefinedParams);
-    }
-    namedStep(name, step, shouldRun = {}, dependencies = [], predefinedParams = {}) {
-        if (!step.composable) {
-            throw new Error(`Step of type "${step.type}" is not composable, and cannot be added to an atomic group.`);
-        }
-        return super.namedStep(name, step, shouldRun, dependencies, predefinedParams);
-    }
-    atomicGroup(_callback) {
-        throw new Error("Atomic groups can't be nested.");
-    }
-    async run(pathProvider, paramProviderFactory, phpProvider) {
-        let fs = mem_fs_1.create();
-        const stepNames = [];
-        for (let i = 0; i < this.steps.length; i++) {
-            const storedStep = this.steps[i];
-            const shouldRun = await this.stepShouldRun(storedStep, paramProviderFactory);
-            if (!shouldRun)
-                continue;
-            fs = await this.runStep(storedStep, pathProvider, paramProviderFactory, phpProvider, fs);
-            stepNames.push(storedStep.step.type);
-        }
-        await this.commit(fs);
-        return stepNames;
-    }
-}