@powerhousedao/codegen 0.0.4 → 0.0.6

package/dist/codegen/.hygen/templates/powerhouse/generate-editor/editor.esm.t

@@ -0,0 +1,15 @@
+---
+to: "<%= rootDir %>/<%= name %>/editor.tsx"
+unless_exists: true
+---
+<% if(!documentTypes.length){ %>import { Action } from 'document-model/document';<% } %>
+import { EditorProps } from 'document-model-editors';
+<% documentTypes.forEach(type => { _%>
+import { <%= documentTypesMap[type] %>State, <%= documentTypesMap[type] %>Action } from "../.<%= documentModelsDir %>/<%= h.changeCase.param(documentTypesMap[type]) %>";
+%><% }); _%>
+
+export type IProps = <% if(!documentTypes.length){ %>EditorProps<unknown, Action><% } else { %><% documentTypes.forEach((type, index) => { _%>EditorProps<<%= documentTypesMap[type] %>State, <%= documentTypesMap[type] %>Action%>%>><% if(index < documentTypes.length - 1){ %> | <% }%><% }); _%> <% } %>;
+
+export default function Editor(props: IProps) {
+    return <></>;
+};

package/dist/codegen/.hygen/templates/powerhouse/generate-editor/index.d.ts

@@ -0,0 +1,19 @@
+export type Args = {
+    name: string;
+    rootDir: string;
+    documentModelsDir: string;
+    documentTypes: string;
+    documentTypesMap: string;
+};
+declare const _default: {
+    params: ({ args }: {
+        args: Args;
+    }) => {
+        rootDir: string;
+        documentModelsDir: string;
+        name: string;
+        documentTypes: string[];
+        documentTypesMap: unknown;
+    };
+};
+export default _default;

package/dist/codegen/.hygen/templates/powerhouse/generate-editor/index.esm.t

@@ -0,0 +1,16 @@
+---
+to: "<%= rootDir %>/<%= name %>/index.ts"
+force: true
+---
+import { type Editor as EditorModule<% if(!documentTypes.length){ %>, Action<% } %> } from 'document-model/document';
+import Editor from './editor';
+<% documentTypes.forEach(type => { _%>
+import { <%= documentTypesMap[type] %>State, <%= documentTypesMap[type] %>Action } from "../.<%= documentModelsDir %>/<%= h.changeCase.param(documentTypesMap[type]) %>";
+%><% }); _%>
+
+export const module: <% if(!documentTypes.length){ %>EditorModule<unknown, Action><% } else { %><% documentTypes.forEach((type, index) => { _%>EditorModule<<%= documentTypesMap[type] %>State, <%= documentTypesMap[type] %>Action%>%>> <% if(index < documentTypes.length - 1){ %>| <% }%><% }); _%> <% } %>= {
+    Component: Editor,
+    documentTypes: [<% if(!documentTypes.length){ %>'*'<% } else { %><% documentTypes.forEach(type => { _%>"<%= type %>", %><% }); _%> <% } %>],
+};
+
+export default module;

package/dist/codegen/.hygen/templates/powerhouse/generate-editor/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    params: ({ args }) => {
+        return {
+            rootDir: args.rootDir,
+            documentModelsDir: args.documentModelsDir,
+            name: args.name,
+            documentTypes: args.documentTypes
+                .split(',')
+                .filter(type => type !== ''),
+            documentTypesMap: JSON.parse(args.documentTypesMap),
+        };
+    },
+};

package/dist/codegen/.hygen/templates/powerhouse/generate-editor/lib.esm.t

@@ -0,0 +1,9 @@
+---
+to: "<%= rootDir %>/index.ts"
+unless_exists: true
+---
+/**
+* This is a scaffold file meant for customization.
+* Delete the file and run the code generator again to have it reset
+*/
+

package/dist/codegen/.hygen/templates/powerhouse/generate-editor/lib.inject_export.esm.t

@@ -0,0 +1,7 @@
+---
+inject: true
+append: true
+to: "<%= rootDir %>/index.ts"
+skip_if: "<%= h.changeCase.pascal(name) %>"
+---
+export { module as <%= h.changeCase.pascal(name) %> } from './<%= h.changeCase.param(name) %>';

package/dist/codegen/.hygen/templates/powerhouse/generate-editor/story.esm.t

@@ -0,0 +1,31 @@
+---
+to: "<%= rootDir %>/<%= name %>/<%= name %>.stories.tsx"
+unless_exists: true
+---
+import Editor from './editor';
+import { createDocumentStory } from 'document-model-editors';
+<% if(!documentTypes.length){ %>import { baseReducer, utils } from 'document-model/document';<% } %>
+<% documentTypes.forEach(type => { _%>
+import * as <%= documentTypesMap[type] %>Module from "../.<%= documentModelsDir %>/<%= h.changeCase.param(documentTypesMap[type]) %>";
+%><% }); _%>
+
+<% if(!documentTypes.length){ %>
+const { meta, CreateDocumentStory: <%= h.changeCase.pascal(name) %> } = createDocumentStory(
+    Editor,
+    (...args) => baseReducer(...args, document => document),
+    utils.createExtendedState(),
+);
+export { <%= h.changeCase.pascal(name) %> };
+<% } %>
+
+<% documentTypes.forEach((type, index) => { _%>
+const { <% if(index === 0){ %>meta, <% } %>CreateDocumentStory: <%= documentTypesMap[type] %> } = createDocumentStory(
+    Editor,
+    <%= documentTypesMap[type] %>Module.reducer,
+    <%= documentTypesMap[type] %>Module.utils.createDocument(),
+);
+export { <%= documentTypesMap[type] %> }
+
+%><% }); _%>
+
+export default { ...meta, title: '<%= h.changeCase.title(name) %>' };

package/dist/codegen/graphql.d.ts

@@ -0,0 +1,8 @@
+export declare const generateSchema: (model: string, dir: string, { watch, format }?: {
+    watch?: boolean | undefined;
+    format?: boolean | undefined;
+}) => Promise<any>;
+export declare const generateSchemas: (dir: string, { watch, format }?: {
+    watch?: boolean | undefined;
+    format?: boolean | undefined;
+}) => Promise<any>;

package/dist/codegen/graphql.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemas = exports.generateSchema = void 0;
+const cli_1 = require("@graphql-codegen/cli");
+const fs_1 = require("fs");
+const getDirectories = (source) => (0, fs_1.readdirSync)(source, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name);
+const tsConfig = {
+    strict: true,
+    strictScalars: true,
+    scalars: {
+        Unknown: 'unknown',
+        DateTime: 'string',
+        Attachment: 'string',
+        Address: '`${string}:0x${string}`',
+    },
+    enumsAsTypes: true,
+    allowEnumStringTypes: true,
+    avoidOptionals: {
+        field: true,
+    },
+    useIndexSignature: true,
+    noSchemaStitching: true,
+    skipTypename: true,
+    // maybeValue: "T | null | undefined",
+    inputMaybeValue: 'T | null | undefined',
+};
+function schemaConfig(name, dir) {
+    return {
+        [`${dir}/${name}/gen/schema/types.ts`]: {
+            schema: [
+                {
+                    [`${dir}/${name}/schema.graphql`]: {
+                        skipGraphQLImport: false,
+                    },
+                },
+            ],
+            plugins: ['typescript'],
+            config: tsConfig,
+        },
+        [`${dir}/${name}/gen/schema/zod.ts`]: {
+            schema: `${dir}/${name}/schema.graphql`,
+            plugins: ['@acaldas/graphql-codegen-typescript-validation-schema'],
+            config: {
+                importFrom: `./types`,
+                schema: 'zod',
+                ...tsConfig,
+                scalarSchemas: {
+                    Unknown: 'z.unknown()',
+                    DateTime: 'z.string().datetime()',
+                    Attachment: 'z.string()',
+                    Address: 'z.custom<`${string}:0x${string}`>((val) => /^[a-zA-Z0-9]+:0x[a-fA-F0-9]{40}$/.test(val as string))',
+                },
+                directives: {
+                    equals: {
+                        value: ['regex', '/^$1$/'],
+                    },
+                },
+                withObjectType: true,
+            },
+        },
+    };
+}
+const generateSchema = (model, dir, { watch = false, format = false } = {}) => {
+    const documentModelConfig = schemaConfig(model, dir);
+    const config = {
+        overwrite: true,
+        generates: documentModelConfig,
+        watch,
+        hooks: {
+            afterOneFileWrite: format ? ['prettier --ignore-path --write'] : [],
+        },
+    };
+    return (0, cli_1.generate)(config, true);
+};
+exports.generateSchema = generateSchema;
+const generateSchemas = (dir, { watch = false, format = false } = {}) => {
+    const documentModels = getDirectories(dir);
+    const documentModelConfigs = documentModels.reduce((obj, model) => ({
+        ...obj,
+        ...schemaConfig(model, dir),
+    }), {});
+    const config = {
+        overwrite: true,
+        generates: documentModelConfigs,
+        watch,
+        hooks: {
+            afterOneFileWrite: format ? ['prettier --ignore-path --write'] : [],
+        },
+    };
+    return (0, cli_1.generate)(config, true);
+};
+exports.generateSchemas = generateSchemas;

package/dist/codegen/hygen.d.ts

@@ -0,0 +1,12 @@
+import { DocumentModel } from 'document-model';
+export declare function generateAll(dir: string, { watch, format }?: {
+    watch?: boolean | undefined;
+    format?: boolean | undefined;
+}): Promise<void>;
+export declare function generateDocumentModel(documentModel: DocumentModel.DocumentModelState, dir: string, { watch, format }?: {
+    watch?: boolean | undefined;
+    format?: boolean | undefined;
+}): Promise<void>;
+export declare function generateEditor(name: string, documentTypes: string[], documentTypesMap: Record<string, string>, dir: string, documentModelsDir: string, { format }?: {
+    format?: boolean | undefined;
+}): Promise<void>;

package/dist/codegen/hygen.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEditor = exports.generateDocumentModel = exports.generateAll = void 0;
+const fs_1 = __importDefault(require("fs"));
+const hygen_1 = require("hygen");
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const logger = new hygen_1.Logger(console.log.bind(console));
+const defaultTemplates = path_1.default.join(__dirname, '.hygen', 'templates');
+async function run(args, { watch = false, format = false } = {}) {
+    const result = await (0, hygen_1.runner)(args, {
+        templates: defaultTemplates,
+        cwd: process.cwd(),
+        logger,
+        createPrompter: () => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return require('enquirer');
+        },
+        exec: (action, body) => {
+            const opts = body && body.length > 0 ? { input: body } : {};
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-member-access
+            return require('execa').shell(action, opts);
+        },
+        debug: !!process.env.DEBUG,
+    });
+    if (format) {
+        const execa = await import('execa');
+        result.actions
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+            .filter(action => ['added', 'inject'].includes(action.status))
+            .forEach(action => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+            execa.$ `prettier --ignore-path --write ${action.subject.replace('.', process.cwd())}`;
+        });
+    }
+    return result;
+}
+async function generateAll(dir, { watch = false, format = false } = {}) {
+    const files = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    for (const directory of files.filter(f => f.isDirectory())) {
+        const documentModelPath = path_1.default.join(dir, directory.name, `${directory.name}.json`);
+        if (!fs_1.default.existsSync(documentModelPath)) {
+            continue;
+        }
+        try {
+            const documentModel = await (0, utils_1.loadDocumentModel)(documentModelPath);
+            await generateDocumentModel(documentModel, dir, { watch, format });
+        }
+        catch (error) {
+            console.error(directory.name, error);
+        }
+    }
+}
+exports.generateAll = generateAll;
+async function generateDocumentModel(documentModel, dir, { watch = false, format = false } = {}) {
+    // Generate the singular files for the document model logic
+    await run([
+        'powerhouse',
+        'generate-document-model',
+        '--document-model',
+        JSON.stringify(documentModel),
+        '--root-dir',
+        dir,
+    ], { watch, format });
+    // Generate the module-specific files for the document model logic
+    const latestSpec = documentModel.specifications[documentModel.specifications.length - 1];
+    for (const module of latestSpec.modules) {
+        await run([
+            'powerhouse',
+            'generate-document-model-module',
+            '--document-model',
+            JSON.stringify(documentModel),
+            '--root-dir',
+            dir,
+            '--module',
+            module.name,
+        ], { watch, format });
+    }
+}
+exports.generateDocumentModel = generateDocumentModel;
+async function generateEditor(name, documentTypes, documentTypesMap, dir, documentModelsDir, { format = false } = {}) {
+    // Generate the singular files for the document model logic
+    await run([
+        'powerhouse',
+        'generate-editor',
+        '--name',
+        name,
+        '--root-dir',
+        dir,
+        '--document-types',
+        documentTypes.join(','),
+        '--document-types-map',
+        JSON.stringify(documentTypesMap),
+        '--document-models-dir',
+        documentModelsDir,
+    ], { format });
+}
+exports.generateEditor = generateEditor;

package/dist/codegen/index.d.ts

@@ -0,0 +1,5 @@
+#! /usr/bin/env node
+import type { PowerhouseConfig } from '../utils';
+export declare function generate(config: PowerhouseConfig): Promise<void>;
+export declare function generateFromFile(path: string, config: PowerhouseConfig): Promise<void>;
+export declare function generateEditor(name: string, documentTypes: string[], config: PowerhouseConfig): Promise<void>;

package/dist/codegen/index.js

@@ -0,0 +1,88 @@
+#! /usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEditor = exports.generateFromFile = exports.generate = void 0;
+const hygen_1 = require("./hygen");
+const graphql_1 = require("./graphql");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const change_case_1 = require("change-case");
+const utils_1 = require("./utils");
+function generateGraphqlSchema(documentModel) {
+    const spec = documentModel.specifications[documentModel.specifications.length - 1];
+    if (!spec) {
+        console.log(`No spec found for ${documentModel.id}`);
+        return;
+    }
+    const { modules, state: { global, local }, } = spec;
+    const schemas = [
+        global.schema,
+        local.schema,
+        ...modules
+            .map(module => [
+            `# ${module.name}`,
+            ...module.operations.map(op => op.schema),
+        ])
+            .flat()
+            .filter(schema => schema && schema.length > 0),
+    ];
+    return schemas.join('\n\n');
+}
+function getDocumentTypesMap(dir) {
+    const documentTypesMap = {};
+    fs_1.default.readdirSync(dir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name)
+        .forEach(name => {
+        const specPath = (0, path_1.resolve)(dir, name, `${name}.json`);
+        if (!fs_1.default.existsSync(specPath)) {
+            return;
+        }
+        const specRaw = fs_1.default.readFileSync(specPath, 'utf-8');
+        try {
+            const spec = JSON.parse(specRaw);
+            if (spec.id) {
+                documentTypesMap[spec.id] = (0, change_case_1.pascalCase)(name);
+            }
+        }
+        catch {
+            console.error(`Failed to parse ${specPath}`);
+        }
+    });
+    return documentTypesMap;
+}
+async function generate(config) {
+    const { format, watch } = config;
+    await (0, graphql_1.generateSchemas)(config.documentModelsDir, { format, watch });
+    await (0, hygen_1.generateAll)(config.documentModelsDir, { format, watch });
+}
+exports.generate = generate;
+async function generateFromFile(path, config) {
+    // load document model spec from file
+    const documentModel = await (0, utils_1.loadDocumentModel)(path);
+    const name = (0, change_case_1.paramCase)(documentModel.name);
+    // create document model folder and spec as json
+    fs_1.default.mkdirSync((0, path_1.join)(config.documentModelsDir, name), { recursive: true });
+    fs_1.default.writeFileSync((0, path_1.join)(config.documentModelsDir, name, `${name}.json`), JSON.stringify(documentModel, null, 4));
+    // bundle graphql schemas together
+    const schemaStr = generateGraphqlSchema(documentModel);
+    if (schemaStr) {
+        fs_1.default.writeFileSync((0, path_1.join)(config.documentModelsDir, name, `schema.graphql`), schemaStr);
+    }
+    await (0, graphql_1.generateSchema)(name, config.documentModelsDir, config);
+    await (0, hygen_1.generateDocumentModel)(documentModel, config.documentModelsDir, config);
+}
+exports.generateFromFile = generateFromFile;
+async function generateEditor(name, documentTypes, config) {
+    const { documentModelsDir, format } = config;
+    const docummentTypesMap = getDocumentTypesMap(documentModelsDir);
+    const invalidType = documentTypes.find(type => !Object.keys(docummentTypesMap).includes(type));
+    if (invalidType) {
+        throw new Error(`Document model for ${invalidType} not found`);
+    }
+    return (0, hygen_1.generateEditor)(name, documentTypes, docummentTypesMap, config.editorsDir, config.documentModelsDir, { format });
+}
+exports.generateEditor = generateEditor;

package/dist/codegen/utils.d.ts

@@ -0,0 +1,2 @@
+import { DocumentModelState } from 'document-model/document-model';
+export declare function loadDocumentModel(path: string): Promise<DocumentModelState>;

package/dist/codegen/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDocumentModel = void 0;
+const document_model_1 = require("document-model/document-model");
+const fs_1 = __importDefault(require("fs"));
+async function loadDocumentModel(path) {
+    let documentModel;
+    try {
+        if (!path) {
+            throw new Error('Document model file not specified');
+        }
+        else if (path.endsWith('.zip')) {
+            const file = await document_model_1.utils.loadFromFile(path);
+            documentModel = file.state.global;
+        }
+        else if (path.endsWith('.json')) {
+            const data = fs_1.default.readFileSync(path, 'utf-8');
+            const document = JSON.parse(data);
+            // z.DocumentModelStateSchema().parse(document);
+            documentModel = document;
+        }
+        else {
+            throw new Error('File type not supported. Must be zip or json.');
+        }
+        return documentModel;
+    }
+    catch (error) {
+        // @ts-expect-error
+        throw error.code === 'MODULE_NOT_FOUND'
+            ? new Error(`Document model not found.`)
+            : error;
+    }
+}
+exports.loadDocumentModel = loadDocumentModel;

package/dist/create-lib/index.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};

package/dist/create-lib/index.js

@@ -0,0 +1,127 @@
+#! /usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const enquirer_1 = require("enquirer");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = __importDefault(require("util"));
+const utils_1 = require("../utils");
+const exec = util_1.default.promisify(child_process_1.exec);
+const BOILERPLATE_REPO = 'https://github.com/powerhouse-inc/document-model-boilerplate.git';
+function isUsingYarn() {
+    return (process.env.npm_config_user_agent || '').startsWith('yarn');
+}
+function buildPackageJson(appPath, projectName) {
+    const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(appPath, 'package.json'), 'utf-8'));
+    const newPackage = {
+        ...packageJson,
+        name: projectName,
+        version: '1.0.0',
+        description: '',
+    };
+    fs_1.default.writeFileSync(path_1.default.join(appPath, 'package.json'), JSON.stringify(newPackage, null, 2), 'utf8');
+}
+function buildPowerhouseConfig(appPath, documentModelsDir, editorsDir) {
+    const filePath = path_1.default.join(appPath, 'powerhouse.config.json');
+    const packageJson = JSON.parse(fs_1.default.readFileSync(filePath, 'utf-8'));
+    const newPackage = {
+        ...packageJson,
+        documentModelsDir,
+        editorsDir,
+    };
+    fs_1.default.writeFileSync(filePath, JSON.stringify(newPackage, null, 2), 'utf8');
+}
+function buildIndex(appPath, documentModelsDir, editorsDir) {
+    fs_1.default.writeFileSync(path_1.default.join(appPath, 'index.ts'), `import * as documentModelsExports from '${documentModelsDir}';
+        import * as editorsExports from '${editorsDir}';
+
+        export const documentModels = Object.values(documentModelsExports);
+        export const editors = Object.values(editorsExports);`, 'utf8');
+}
+async function runCmd(command) {
+    try {
+        const { stdout, stderr } = await exec(command);
+        console.log(stdout);
+        console.log(stderr);
+    }
+    catch (error) {
+        console.log('\x1b[31m', error, '\x1b[0m');
+    }
+}
+async function init() {
+    const args = (0, utils_1.parseArgs)(process.argv.slice(2), utils_1.configSpec);
+    // checks if a project name was provided
+    let projectName = args._.shift();
+    if (!projectName) {
+        const result = await (0, enquirer_1.prompt)([
+            {
+                type: 'input',
+                name: 'projectName',
+                message: 'What is the project name?',
+                required: true,
+            },
+        ]);
+        if (!result.projectName) {
+            console.log('\x1b[31m', 'You have to provide name to your app.');
+            process.exit(1);
+        }
+        projectName = result.projectName;
+    }
+    const { documentModelsDir, editorsDir } = args['--interactive']
+        ? await (0, utils_1.promptDirectories)()
+        : utils_1.DEFAULT_CONFIG;
+    const appPath = path_1.default.join(process.cwd(), projectName);
+    try {
+        fs_1.default.mkdirSync(appPath);
+    }
+    catch (err) {
+        if (err.code === 'EEXIST') {
+            console.log('\x1b[31m', `The folder ${projectName} already exists in the current directory, please give it another name.`, '\x1b[0m');
+        }
+        else {
+            console.log(err);
+        }
+        process.exit(1);
+    }
+    createProject(projectName, documentModelsDir, editorsDir);
+}
+async function createProject(projectName, documentModelsDir, editorsDir) {
+    try {
+        const useYarn = isUsingYarn();
+        console.log('\x1b[33m', 'Downloading the project structure...', '\x1b[0m');
+        await runCmd(`git clone --depth 1 ${BOILERPLATE_REPO} ${projectName}`);
+        const appPath = path_1.default.join(process.cwd(), projectName);
+        process.chdir(appPath);
+        console.log('\x1b[34m', 'Installing dependencies...', '\x1b[0m');
+        await runCmd(useYarn ? 'yarn install' : 'npm install');
+        console.log();
+        fs_1.default.rmSync(path_1.default.join(appPath, './.git'), { recursive: true });
+        await runCmd('git init');
+        try {
+            fs_1.default.mkdirSync(path_1.default.join(appPath, documentModelsDir));
+            fs_1.default.mkdirSync(path_1.default.join(appPath, editorsDir));
+        }
+        catch (error) {
+            if (!error.message.includes('EEXIST')) {
+                throw error;
+            }
+        }
+        buildPackageJson(appPath, projectName);
+        buildPowerhouseConfig(appPath, documentModelsDir, editorsDir);
+        buildIndex(appPath, documentModelsDir, editorsDir);
+        console.log('\x1b[32m', 'The installation is done!', '\x1b[0m');
+        console.log();
+        console.log('\x1b[34m', 'You can start by typing:');
+        console.log(`    cd ${projectName}`);
+        console.log(useYarn ? '    yarn generate' : '    npm run generate', '\x1b[0m');
+        console.log();
+    }
+    catch (error) {
+        console.log(error);
+    }
+}
+init();

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './codegen';
+export * from './utils';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./codegen"), exports);
+__exportStar(require("./utils"), exports);

package/dist/utils.d.ts

@@ -0,0 +1,27 @@
+import { generateMock as zodGenerateMock } from '@anatine/zod-mock';
+import arg from 'arg';
+export type PowerhouseConfig = {
+    documentModelsDir: string;
+    editorsDir: string;
+    interactive?: boolean;
+    format?: boolean;
+    watch?: boolean;
+};
+export declare const DEFAULT_CONFIG: PowerhouseConfig;
+export declare const configSpec: {
+    readonly '--document-models': StringConstructor;
+    readonly '--editors': StringConstructor;
+    readonly '--interactive': BooleanConstructor;
+    readonly '--format': BooleanConstructor;
+    readonly '--watch': BooleanConstructor;
+    readonly '-i': "--interactive";
+    readonly '-f': "--format";
+    readonly '-w': "--watch";
+};
+export declare function getConfig(): PowerhouseConfig;
+export declare function writeConfig(config: PowerhouseConfig): void;
+export declare function parseArgs<T extends arg.Spec>(argv: string[], spec: T): arg.Result<T>;
+export declare function parseConfig(argv: string[]): Partial<PowerhouseConfig>;
+export declare function promptDirectories(config?: PowerhouseConfig): Promise<Pick<PowerhouseConfig, "documentModelsDir" | "editorsDir">>;
+export type generateMockTypeFn = typeof zodGenerateMock;
+export declare const generateMock: generateMockTypeFn;