@flarum/cli 1.0.0 → 2.0.0-beta.12

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;
-    }
-}

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

@@ -1,49 +0,0 @@
-import { Store } from 'mem-fs';
-import { Editor } from 'mem-fs-editor';
-import { PromptObject } from 'prompts';
-import { ParamProvider } from '../../provider/param-provider';
-import { PathProvider } from '../../provider/path-provider';
-import { PhpProvider } from '../../provider/php-provider';
-import { Step } from '../step-manager';
-interface UserProvidedParam extends Omit<PromptObject, 'type'> {
-    type: string;
-}
-export interface StubGenerationSchema {
-    /**
-     * A period-delimited subdirectory for where the stub should be
-     * located relative to the extension PHP src.
-     */
-    recommendedSubdir: string;
-    forceRecommendedSubdir?: boolean;
-    /**
-     * Where should the file be created in relation to the extension root?
-     *
-     * Defaults to `./src`.
-     */
-    root?: string;
-    /**
-     * The relative path to the stub's source file relative to the
-     * `stubs` directory.
-     */
-    sourceFile: string;
-    params: UserProvidedParam[];
-}
-export declare abstract class BaseStubStep implements Step {
-    abstract type: string;
-    protected abstract defaultRoot: string;
-    protected abstract schema: StubGenerationSchema;
-    composable: boolean;
-    get exposes(): string[];
-    protected additionalExposes: string[];
-    get implicitParams(): string[];
-    protected additionalImplicitParams: string[];
-    protected params: Record<string, unknown>;
-    protected subdir: string;
-    run(fs: Store, pathProvider: PathProvider, paramProvider: ParamProvider, _phpProvider: PhpProvider): Promise<Store>;
-    getExposed(_pathProvider: PathProvider, _paramProvider: ParamProvider): Record<string, unknown>;
-    protected precompileParams(composerJsonContents: any, _fsEditor: Editor, _pathProvider: PathProvider, _paramProvider: ParamProvider): Promise<Record<string, unknown>>;
-    protected compileParams(fsEditor: Editor, pathProvider: PathProvider, paramProvider: ParamProvider): Promise<Record<string, unknown>>;
-    protected abstract getFileName(_fs: Store, _pathProvider: PathProvider, paramProvider: ParamProvider): Promise<string>;
-    protected composerJsonContents(fsEditor: Editor, pathProvider: PathProvider): any;
-}
-export {};

package/lib/steps/stubs/base.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseStubStep = void 0;
-const pick_1 = require("@zodash/pick");
-const mem_fs_editor_1 = require("mem-fs-editor");
-const extension_metadata_1 = require("../../utils/extension-metadata");
-const clone_and_fill_1 = require("../../utils/clone-and-fill");
-class BaseStubStep {
-    constructor() {
-        this.composable = true;
-        this.additionalExposes = [];
-        this.additionalImplicitParams = [];
-        this.params = {};
-    }
-    get exposes() {
-        return this.additionalExposes;
-    }
-    get implicitParams() {
-        return [...this.additionalImplicitParams, 'extensionId'];
-    }
-    async run(fs, pathProvider, paramProvider, _phpProvider) {
-        const fsEditor = mem_fs_editor_1.create(fs);
-        this.params = await this.compileParams(fsEditor, pathProvider, paramProvider);
-        const newFileName = await this.getFileName(fs, pathProvider, paramProvider);
-        const newFilePath = pathProvider.ext(this.schema.root || this.defaultRoot, this.subdir, newFileName);
-        const stub = clone_and_fill_1.cloneAndFill(this.schema.sourceFile, this.params);
-        fsEditor.copyTpl(pathProvider.boilerplate('stubs', stub), newFilePath, this.params);
-        return fs;
-    }
-    getExposed(_pathProvider, _paramProvider) {
-        return pick_1.pick(this.params, this.exposes);
-    }
-    async precompileParams(composerJsonContents, _fsEditor, _pathProvider, _paramProvider) {
-        const params = {
-            extensionId: composerJsonContents.extensionId,
-        };
-        return params;
-    }
-    async compileParams(fsEditor, pathProvider, paramProvider) {
-        const composerJsonContents = this.composerJsonContents(fsEditor, pathProvider);
-        const params = await this.precompileParams(composerJsonContents, fsEditor, pathProvider, paramProvider);
-        const paramDefs = this.schema.params.filter(param => !this.implicitParams.includes(param.name) && !Object.keys(params).includes(param.name));
-        for (let i = 0; i < paramDefs.length; i++) {
-            // eslint-disable-next-line no-await-in-loop
-            params[paramDefs[i].name] = await paramProvider.get(paramDefs[i]);
-        }
-        this.implicitParams.forEach(implicitParam => {
-            if (!params[implicitParam] && paramProvider.has(implicitParam)) {
-                params[implicitParam] = paramProvider.cached()[implicitParam];
-            }
-        });
-        return params;
-    }
-    composerJsonContents(fsEditor, pathProvider) {
-        return extension_metadata_1.extensionMetadata(fsEditor.readJSON(pathProvider.ext('composer.json')));
-    }
-}
-exports.BaseStubStep = BaseStubStep;

package/lib/utils/extension-metadata.d.ts

@@ -1,2 +0,0 @@
-export declare function extensionId(packageName: string): string;
-export declare function extensionMetadata(extensionComposerJson?: any): any;

package/lib/utils/extension-metadata.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extensionMetadata = exports.extensionId = void 0;
-function extensionId(packageName) {
-    return packageName.replace(/(flarum-ext-)|(flarum-)/, '').replace('/', '-');
-}
-exports.extensionId = extensionId;
-function extensionMetadata(extensionComposerJson = {}) {
-    var _a, _b, _c, _d;
-    const data = {};
-    data.packageName = (extensionComposerJson === null || extensionComposerJson === void 0 ? void 0 : extensionComposerJson.name) || '';
-    data.packageDescription = (extensionComposerJson === null || extensionComposerJson === void 0 ? void 0 : extensionComposerJson.description) || '';
-    data.licenseType = (extensionComposerJson === null || extensionComposerJson === void 0 ? void 0 : extensionComposerJson.license) || '';
-    data.authorName = '';
-    data.authorEmail = '';
-    data.packageNamespace = (Object.keys((_b = (_a = extensionComposerJson === null || extensionComposerJson === void 0 ? void 0 : extensionComposerJson.autoload) === null || _a === void 0 ? void 0 : _a['psr-4']) !== null && _b !== void 0 ? _b : {})[0] || '').slice(0, -1);
-    data.extensionName = ((_d = (_c = extensionComposerJson === null || extensionComposerJson === void 0 ? void 0 : extensionComposerJson.extra) === null || _c === void 0 ? void 0 : _c['flarum-extension']) === null || _d === void 0 ? void 0 : _d.title) || '';
-    data.extensionId = extensionId(data.packageName);
-    return data;
-}
-exports.extensionMetadata = extensionMetadata;