@sprucelabs/spruce-cli/build/features/view/actions/CreateAction.js

Command line interface for building Spruce skills.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const schema_1 = require("@sprucelabs/schema");
const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
const FormComponent_1 = __importDefault(require("../../../components/FormComponent"));
const namedTemplateItem_builder_1 = __importDefault(require("../../../schemas/v2020_07_22/namedTemplateItem.builder"));
const action_utility_1 = __importDefault(require("../../../utilities/action.utility"));
const form_utility_1 = __importDefault(require("../../../utilities/form.utility"));
const AbstractAction_1 = __importDefault(require("../../AbstractAction"));
class CreateAction extends AbstractAction_1.default {
    optionsSchema = optionsSchema;
    commandAliases = ['create.view'];
    invocationMessage = 'Creating your new view controller... 🌲';
    async execute(options) {
        let { viewType, isRoot, nameReadable, namePascal, viewModel } = this.validateAndNormalizeOptions(options);
        const writer = this.Writer('view');
        const shouldAskAboutRootSvc = viewType === 'skillView' &&
            !isRoot &&
            !(await writer.doesRootControllerExist(this.cwd));
        if (shouldAskAboutRootSvc) {
            isRoot = await this.ui.confirm('Do you want to create a root view controller?');
        }
        if (!isRoot && !nameReadable) {
            const form = new FormComponent_1.default({
                ui: this.ui,
                schema: followUpSchema,
                onWillAskQuestion: form_utility_1.default.onWillAskQuestionHandler,
            });
            const answers = await form.present();
            namePascal = answers.namePascal;
            nameReadable = answers.nameReadable;
        }
        if (isRoot) {
            nameReadable = 'Root';
        }
        if (!viewModel && viewType === 'view') {
            viewModel = await this.ui.prompt({
                ...optionsSchema.fields.viewModel,
                isRequired: true,
            });
        }
        namePascal = namePascal ?? spruce_skill_utils_1.namesUtil.toPascal(nameReadable);
        const files = await writer[viewType === 'skillView'
            ? 'writeSkillViewController'
            : 'writeViewController'](this.cwd, {
            viewType,
            namePascal,
            viewModel: viewModel,
            nameKebab: spruce_skill_utils_1.namesUtil.toKebab(namePascal),
        });
        const syncResults = await this.Action('view', 'sync').execute({});
        const merged = action_utility_1.default.mergeActionResults({
            files,
        }, syncResults);
        return merged;
    }
}
exports.default = CreateAction;
const viewTypeChoices = [
    {
        value: 'skillView',
        label: 'Skill View Controller',
    },
    {
        value: 'view',
        label: 'View Controller',
    },
];
const viewModels = [
    'BigForm',
    'Button',
    'Calendar',
    'Card',
    'CardBody',
    'CardHeader',
    'Dialog',
    'Form',
    'List',
    'CalendarEvent',
].sort();
const optionsSchema = (0, schema_1.buildSchema)({
    id: 'createViewOptions',
    description: 'Create a new Heartwood view to render on web enabled and mobile devices.',
    fields: {
        viewType: {
            type: 'select',
            label: 'Which are you creating?',
            isRequired: true,
            options: {
                choices: viewTypeChoices,
            },
        },
        isRoot: {
            type: 'boolean',
            label: 'Make this the Root View Controller?',
        },
        nameReadable: {
            ...namedTemplateItem_builder_1.default.fields.nameReadable,
            label: 'Controller name',
            isRequired: false,
        },
        namePascal: {
            ...namedTemplateItem_builder_1.default.fields.namePascal,
            isRequired: false,
        },
        viewModel: {
            type: 'select',
            label: 'View model',
            hint: 'Which type of view will your controller render?',
            options: {
                choices: viewModels.map((model) => ({
                    value: model,
                    label: model,
                })),
            },
        },
    },
});
const followUpSchema = (0, schema_1.buildSchema)({
    id: 'creatViewFollowup',
    fields: {
        nameReadable: {
            ...optionsSchema.fields.nameReadable,
            isRequired: true,
        },
        namePascal: {
            ...optionsSchema.fields.namePascal,
            isRequired: true,
        },
    },
});
//# sourceMappingURL=CreateAction.js.map