@powerhousedao/codegen 0.36.1 → 0.37.0

package/dist/src/codegen/hygen.js

@@ -0,0 +1,162 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Logger, runner } from "hygen";
+import { loadDocumentModel } from "./utils.js";
+import { pascalCase } from "change-case";
+const require = createRequire(import.meta.url);
+const __dirname = import.meta.dirname || path.dirname(fileURLToPath(import.meta.url));
+const logger = new Logger(console.log.bind(console));
+const defaultTemplates = path.join(__dirname, ".hygen", "templates");
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function run(args, { watch = false, skipFormat = false } = {}) {
+    const result = await 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-unsafe-member-access
+            return require("execa").shell(action, opts);
+        },
+        debug: !!process.env.DEBUG,
+    });
+    if (!skipFormat) {
+        const execa = await import("execa");
+        const actions = result.actions;
+        actions
+            .filter((action) => ["added", "inject"].includes(action.status))
+            .forEach((action) => {
+            execa.$ `prettier --ignore-path --write ${action.subject.replace(".", process.cwd())}`.catch((err) => {
+                console.log(err);
+            });
+        });
+    }
+    return result;
+}
+export async function generateAll(dir, { watch = false, skipFormat = false } = {}) {
+    const files = fs.readdirSync(dir, { withFileTypes: true });
+    for (const directory of files.filter((f) => f.isDirectory())) {
+        const documentModelPath = path.join(dir, directory.name, `${directory.name}.json`);
+        if (!fs.existsSync(documentModelPath)) {
+            continue;
+        }
+        try {
+            const documentModel = await loadDocumentModel(documentModelPath);
+            await generateDocumentModel(documentModel, dir, { watch, skipFormat });
+        }
+        catch (error) {
+            console.error(directory.name, error);
+        }
+    }
+}
+export async function generateDocumentModel(documentModelState, dir, { watch = false, skipFormat = false } = {}) {
+    // Generate the singular files for the document model logic
+    await run([
+        "powerhouse",
+        "generate-document-model",
+        "--document-model",
+        JSON.stringify(documentModelState),
+        "--root-dir",
+        dir,
+    ], { watch, skipFormat });
+    const latestSpec = documentModelState.specifications[documentModelState.specifications.length - 1];
+    // Generate the module-specific files for the document model logic
+    for (const module of latestSpec.modules) {
+        await run([
+            "powerhouse",
+            "generate-document-model-module",
+            "--document-model",
+            JSON.stringify(documentModelState),
+            "--root-dir",
+            dir,
+            "--module",
+            module.name,
+        ], { watch, skipFormat });
+    }
+}
+export async function generateEditor(name, documentTypes, documentTypesMap, dir, documentModelsDir, { skipFormat = 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,
+    ], { skipFormat });
+}
+export async function generateProcessor(name, documentTypes, documentTypesMap, dir, documentModelsDir, type = "analytics", { skipFormat = false } = {}) {
+    // Generate the singular files for the document model logic
+    const processorType = type === "operational" ? "operational" : "analytics";
+    await run([
+        "powerhouse",
+        `generate-processor-${processorType}`,
+        "--name",
+        name,
+        "--pascalName",
+        pascalCase(name),
+        "--root-dir",
+        dir,
+        "--document-types",
+        documentTypes.join(","),
+        "--document-types-map",
+        JSON.stringify(documentTypesMap),
+        "--document-models-dir",
+        documentModelsDir,
+    ], { skipFormat });
+}
+export async function generateSubgraph(name, documentModel, dir, { skipFormat = false } = {}) {
+    const params = [
+        "powerhouse",
+        `generate-subgraph`,
+        "--name",
+        name,
+        "--pascalName",
+        pascalCase(name),
+        "--root-dir",
+        dir,
+    ];
+    if (documentModel) {
+        params.push("--loadFromFile", "1");
+    }
+    // Generate the singular files for the document model logic
+    await run(params, { skipFormat });
+    if (documentModel) {
+        // Generate the GraphQL mutation schemas
+        await run([
+            "powerhouse",
+            "generate-document-model-mutations",
+            "--subgraph",
+            name,
+            "--document-model",
+            JSON.stringify(documentModel),
+            "--root-dir",
+            dir,
+        ], { skipFormat });
+    }
+}
+export async function generateImportScript(name, dir, { skipFormat = false } = {}) {
+    // Generate the singular files for the document model logic
+    await run([
+        "powerhouse",
+        `generate-import-script`,
+        "--name",
+        name,
+        "--pascalName",
+        pascalCase(name),
+        "--root-dir",
+        dir,
+    ], { skipFormat });
+}

package/dist/src/codegen/index.d.ts

@@ -0,0 +1,13 @@
+#! /usr/bin/env node
+import { PowerhouseConfig } from "@powerhousedao/config/powerhouse";
+export type DocumentTypesMap = Record<string, {
+    name: string;
+    importPath: string;
+}>;
+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>;
+export declare function generateSubgraph(name: string, file: string | null, config: PowerhouseConfig): Promise<void>;
+export declare function generateProcessor(name: string, type: "analytics" | "operational", documentTypes: string[], config: PowerhouseConfig): Promise<void>;
+export declare function generateImportScript(name: string, config: PowerhouseConfig): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/codegen/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/codegen/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AA4CpE,MAAM,MAAM,gBAAgB,GAAG,MAAM,CACnC,MAAM,EACN;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CACrC,CAAC;AAyDF,wBAAsB,QAAQ,CAAC,MAAM,EAAE,gBAAgB,iBAItD;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,iBA4B5E;AAED,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EAAE,EACvB,MAAM,EAAE,gBAAgB,iBAwBzB;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,gBAAgB,iBAQzB;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,WAAW,GAAG,aAAa,EACjC,aAAa,EAAE,MAAM,EAAE,EACvB,MAAM,EAAE,gBAAgB,iBAqBzB;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,gBAAgB,iBAGzB"}

package/dist/src/codegen/index.js

@@ -0,0 +1,123 @@
+#! /usr/bin/env node
+import { typeDefs } from "@powerhousedao/scalars";
+import { paramCase, pascalCase } from "change-case";
+import fs from "node:fs";
+import { join, resolve } from "path";
+import { generateSchema, generateSchemas } from "./graphql.js";
+import { generateEditor as _generateEditor, generateImportScript as _generateImportScript, generateProcessor as _generateProcessor, generateSubgraph as _generateSubgraph, generateAll, generateDocumentModel, } from "./hygen.js";
+import { loadDocumentModel } from "./utils.js";
+function generateGraphqlSchema(documentModel) {
+    const spec = documentModel.specifications[documentModel.specifications.length - 1];
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!spec) {
+        throw new Error(`No spec found for ${documentModel.id}`);
+    }
+    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");
+}
+// returns map of document model id to document model name in pascal case and import path
+async function getDocumentTypesMap(dir, pathOrigin = "../../../") {
+    const documentTypesMap = {};
+    // add document types from provided dir
+    if (fs.existsSync(dir)) {
+        fs.readdirSync(dir, { withFileTypes: true })
+            .filter((dirent) => dirent.isDirectory())
+            .map((dirent) => dirent.name)
+            .forEach((name) => {
+            const specPath = resolve(dir, name, `${name}.json`);
+            if (!fs.existsSync(specPath)) {
+                return;
+            }
+            const specRaw = fs.readFileSync(specPath, "utf-8");
+            try {
+                const spec = JSON.parse(specRaw);
+                if (spec.id) {
+                    documentTypesMap[spec.id] = {
+                        name: pascalCase(name),
+                        importPath: join(pathOrigin, dir, name),
+                    };
+                }
+            }
+            catch {
+                console.error(`Failed to parse ${specPath}`);
+            }
+        });
+    }
+    // add documents from document-model-libs if lib is installed
+    try {
+        /* eslint-disable */
+        // @ts-ignore-error TS2307 this import is expected to fail if document-model-libs is not available
+        const documentModels = await import("document-model-libs/document-models");
+        Object.keys(documentModels).forEach((name) => {
+            const documentModel = documentModels[name];
+            documentTypesMap[documentModel.documentModel.id] = {
+                name,
+                importPath: `document-model-libs/${paramCase(name)}`,
+            };
+        });
+        /* eslint-enable */
+    }
+    catch {
+        /* document-model-libs is not available */
+    }
+    return documentTypesMap;
+}
+export async function generate(config) {
+    const { skipFormat, watch } = config;
+    await generateSchemas(config.documentModelsDir, { skipFormat, watch });
+    await generateAll(config.documentModelsDir, { skipFormat, watch });
+}
+export async function generateFromFile(path, config) {
+    // load document model spec from file
+    const documentModel = await loadDocumentModel(path);
+    const name = paramCase(documentModel.name);
+    // create document model folder and spec as json
+    fs.mkdirSync(join(config.documentModelsDir, name), { recursive: true });
+    fs.writeFileSync(join(config.documentModelsDir, name, `${name}.json`), JSON.stringify(documentModel, null, 4));
+    // bundle graphql schemas together
+    const schemaStr = [
+        typeDefs.join("\n"), // inject ph scalars
+        generateGraphqlSchema(documentModel),
+    ].join("\n");
+    if (schemaStr) {
+        fs.writeFileSync(join(config.documentModelsDir, name, `schema.graphql`), schemaStr);
+    }
+    await generateSchema(name, config.documentModelsDir, config);
+    await generateDocumentModel(documentModel, config.documentModelsDir, config);
+}
+export async function generateEditor(name, documentTypes, config) {
+    const pathOrigin = "../../";
+    const { documentModelsDir, skipFormat } = config;
+    const documentTypesMap = await getDocumentTypesMap(documentModelsDir, pathOrigin);
+    const invalidType = documentTypes.find((type) => !Object.keys(documentTypesMap).includes(type));
+    if (invalidType) {
+        throw new Error(`Document model for ${invalidType} not found`);
+    }
+    return _generateEditor(name, documentTypes, documentTypesMap, config.editorsDir, config.documentModelsDir, { skipFormat });
+}
+export async function generateSubgraph(name, file, config) {
+    return _generateSubgraph(name, file !== null ? await loadDocumentModel(file) : null, config.subgraphsDir, config);
+}
+export async function generateProcessor(name, type, documentTypes, config) {
+    const { documentModelsDir, skipFormat } = config;
+    const documentTypesMap = await getDocumentTypesMap(documentModelsDir);
+    const invalidType = documentTypes.find((type) => !Object.keys(documentTypesMap).includes(type));
+    if (invalidType) {
+        throw new Error(`Document model for ${invalidType} not found`);
+    }
+    return _generateProcessor(name, documentTypes, documentTypesMap, config.processorsDir, config.documentModelsDir, type, { skipFormat });
+}
+export async function generateImportScript(name, config) {
+    return _generateImportScript(name, config.importScriptsDir, config);
+}

package/dist/src/codegen/utils.d.ts

@@ -0,0 +1,4 @@
+import { type DocumentModelState } from "document-model";
+export declare function loadDocumentModel(path: string): Promise<DocumentModelState>;
+export declare function formatWithPrettierBeforeWrite(outputFile: string, content: string): Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/codegen/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/codegen/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,gBAAgB,CAAC;AAIxB,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,kBAAkB,CAAC,CA2B7B;AAED,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,mBAMhB"}

package/dist/src/codegen/utils.js

@@ -0,0 +1,40 @@
+import { documentModelLoadFromFile, } from "document-model";
+import fs from "node:fs";
+import { format } from "prettier";
+export 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 documentModelLoadFromFile(path);
+            documentModel = file.state.global;
+        }
+        else if (path.endsWith(".json")) {
+            const data = fs.readFileSync(path, "utf-8");
+            const parsedData = JSON.parse(data);
+            if ("state" in parsedData) {
+                documentModel = parsedData.state.global;
+            }
+            else {
+                documentModel = parsedData;
+            }
+        }
+        else {
+            throw new Error("File type not supported. Must be zip or json.");
+        }
+        return documentModel;
+    }
+    catch (error) {
+        throw error.code === "MODULE_NOT_FOUND"
+            ? new Error(`Document model not found.`)
+            : error;
+    }
+}
+export async function formatWithPrettierBeforeWrite(outputFile, content) {
+    const modifiedContent = await format(content, {
+        parser: "typescript",
+    });
+    return modifiedContent;
+}

package/dist/src/create-lib/create-project.d.ts

@@ -0,0 +1,25 @@
+export declare const createCommandSpec: {
+    readonly "--name": StringConstructor;
+    readonly "--project-name": "--name";
+    readonly "--version": StringConstructor;
+    readonly "--interactive": BooleanConstructor;
+    readonly "--dev": BooleanConstructor;
+    readonly "--staging": BooleanConstructor;
+    readonly "-p": "--name";
+    readonly "-v": "--version";
+    readonly "--package-manager": StringConstructor;
+};
+export interface ICreateProjectOptions {
+    name: string | undefined;
+    version: string;
+    interactive: boolean;
+    packageManager?: string;
+}
+export declare function parseVersion(args: {
+    version?: string;
+    dev?: boolean;
+    staging?: boolean;
+}): string;
+export declare function initCli(): Promise<void>;
+export declare function createProject(options: ICreateProjectOptions): Promise<void>;
+//# sourceMappingURL=create-project.d.ts.map

package/dist/src/create-lib/create-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-project.d.ts","sourceRoot":"","sources":["../../../src/create-lib/create-project.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,iBAAiB;;;;;;;;;;CAUpB,CAAC;AAEX,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAiED,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,UAWA;AAUD,wBAAgB,OAAO,kBAQtB;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,qBAAqB,iBAmDjE"}

package/dist/src/create-lib/create-project.js

@@ -0,0 +1,158 @@
+import { parseArgs, promptDirectories } from "#utils/cli";
+import { getPackageManager } from "#utils/package-manager";
+import { execSync } from "child_process";
+import enquirer from "enquirer";
+import fs from "node:fs";
+import path from "path";
+const BOILERPLATE_REPO = "https://github.com/powerhouse-inc/document-model-boilerplate.git";
+const envPackageManager = getPackageManager(process.env.npm_config_user_agent);
+const defaultDirectories = {
+    documentModelsDir: "./document-models",
+    editorsDir: "./editors",
+};
+export const createCommandSpec = {
+    "--name": String,
+    "--project-name": "--name",
+    "--version": String,
+    "--interactive": Boolean,
+    "--dev": Boolean,
+    "--staging": Boolean,
+    "-p": "--name",
+    "-v": "--version",
+    "--package-manager": String,
+};
+const { prompt } = enquirer;
+function buildPackageJson(appPath, projectName) {
+    const packageJson = JSON.parse(fs.readFileSync(path.join(appPath, "package.json"), "utf-8"));
+    const newPackage = {
+        ...packageJson,
+        name: projectName,
+        version: "1.0.0",
+        description: "",
+    };
+    fs.writeFileSync(path.join(appPath, "package.json"), JSON.stringify(newPackage, null, 2), "utf8");
+}
+function buildPowerhouseConfig(appPath, documentModelsDir, editorsDir) {
+    const filePath = path.join(appPath, "powerhouse.config.json");
+    const packageJson = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const newPackage = {
+        ...packageJson,
+        documentModelsDir,
+        editorsDir,
+    };
+    fs.writeFileSync(filePath, JSON.stringify(newPackage, null, 2), "utf8");
+}
+function buildIndex(appPath, documentModelsDir, editorsDir) {
+    fs.writeFileSync(path.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");
+}
+function runCmd(command) {
+    try {
+        execSync(command, { stdio: "inherit" });
+    }
+    catch (error) {
+        console.log("\x1b[31m", error, "\x1b[0m");
+    }
+}
+export function parseVersion(args) {
+    if (args.version) {
+        return args.version;
+    }
+    if (args.dev) {
+        return "dev";
+    }
+    else if (args.staging) {
+        return "staging";
+    }
+    else {
+        return "main";
+    }
+}
+function parseVersionArgs(args) {
+    return parseVersion({
+        version: args["--version"],
+        dev: args["--dev"],
+        staging: args["--staging"],
+    });
+}
+export function initCli() {
+    const args = parseArgs(process.argv.slice(2), createCommandSpec);
+    const options = {
+        name: args["--name"] ?? args._.shift(),
+        interactive: args["--interactive"] ?? false,
+        version: parseVersionArgs(args),
+    };
+    return createProject(options);
+}
+export async function createProject(options) {
+    // checks if a project name was provided
+    let projectName = options.name;
+    if (!projectName) {
+        const result = await prompt([
+            {
+                type: "input",
+                name: "projectName",
+                message: "What is the project name?",
+                required: true,
+                result: (value) => value.toLowerCase().trim().replace(/\s+/g, "-"),
+            },
+        ]);
+        if (!result.projectName) {
+            console.log("\x1b[31m", "You have to provide name to your app.");
+            process.exit(1);
+        }
+        projectName = result.projectName;
+    }
+    const { documentModelsDir, editorsDir, } = options.interactive
+        ? await promptDirectories(defaultDirectories)
+        : defaultDirectories;
+    const appPath = path.join(process.cwd(), projectName);
+    try {
+        fs.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);
+    }
+    handleCreateProject(projectName, documentModelsDir, editorsDir, options.version, options.packageManager);
+}
+function handleCreateProject(projectName, documentModelsDir, editorsDir, version = "main", packageManager) {
+    packageManager = packageManager ?? envPackageManager;
+    try {
+        console.log("\x1b[33m", "Downloading the project structure...", "\x1b[0m");
+        runCmd(`git clone --depth 1 -b ${version} ${BOILERPLATE_REPO} ${projectName}`);
+        const appPath = path.join(process.cwd(), projectName);
+        process.chdir(appPath);
+        console.log("\x1b[34m", `Installing dependencies with ${packageManager}...`, "\x1b[0m");
+        runCmd(`${packageManager} install --loglevel error`);
+        fs.rmSync(path.join(appPath, "./.git"), { recursive: true });
+        runCmd(`git init -b ${version}`);
+        try {
+            fs.mkdirSync(path.join(appPath, documentModelsDir));
+            fs.writeFileSync(path.join(appPath, documentModelsDir, "index.ts"), "");
+            fs.mkdirSync(path.join(appPath, editorsDir));
+            fs.writeFileSync(path.join(appPath, editorsDir, "index.ts"), "");
+        }
+        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();
+    }
+    catch (error) {
+        console.log(error);
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./create-project.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/create-lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/src/create-lib/index.js

@@ -0,0 +1 @@
+export * from "./create-project.js";

package/dist/src/utils/cli.d.ts

@@ -0,0 +1,26 @@
+import arg from "arg";
+export declare const configSpec: {
+    readonly "--document-models": StringConstructor;
+    readonly "--editors": StringConstructor;
+    readonly "--interactive": BooleanConstructor;
+    readonly "--skip-format": BooleanConstructor;
+    readonly "--watch": BooleanConstructor;
+    readonly "-i": "--interactive";
+    readonly "-sf": "--skip-format";
+    readonly "-w": "--watch";
+};
+export declare function parseArgs<T extends arg.Spec>(argv: string[], spec: T): arg.Result<T>;
+export declare function parseConfig(argv: string[]): Partial<{
+    documentModelsDir?: string;
+    editorsDir?: string;
+    skipFormat?: boolean;
+    interactive?: boolean;
+    watch?: boolean;
+}>;
+type DefaultDirectories = {
+    documentModelsDir: string;
+    editorsDir: string;
+};
+export declare function promptDirectories(defaultDirs: DefaultDirectories): Promise<DefaultDirectories>;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/src/utils/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/utils/cli.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAKtB,eAAO,MAAM,UAAU;;;;;;;;;CASb,CAAC;AAEX,wBAAgB,SAAS,CAAC,CAAC,SAAS,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,iBAOpE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE;wBAElB,MAAM;iBACb,MAAM;iBACN,OAAO;kBACN,OAAO;YACb,OAAO;GAuBlB;AAED,KAAK,kBAAkB,GAAG;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,kBAAkB,+BAetE"}

package/dist/src/utils/cli.js

@@ -0,0 +1,56 @@
+import arg from "arg";
+import enquirer from "enquirer";
+const { prompt } = enquirer;
+export const configSpec = {
+    "--document-models": String,
+    "--editors": String,
+    "--interactive": Boolean,
+    "--skip-format": Boolean,
+    "--watch": Boolean,
+    "-i": "--interactive",
+    "-sf": "--skip-format",
+    "-w": "--watch",
+};
+export function parseArgs(argv, spec) {
+    const args = arg(spec, {
+        permissive: true,
+        argv,
+    });
+    return args;
+}
+export function parseConfig(argv) {
+    const config = {};
+    const args = parseArgs(argv, configSpec);
+    if ("--document-models" in args) {
+        config.documentModelsDir = args["--document-models"];
+    }
+    if ("--editors" in args) {
+        config.editorsDir = args["--editors"];
+    }
+    if ("--skip-format" in args) {
+        config.skipFormat = true;
+    }
+    if ("--interactive" in args) {
+        config.interactive = true;
+    }
+    if ("--watch" in args) {
+        config.watch = true;
+    }
+    return config;
+}
+export async function promptDirectories(defaultDirs) {
+    return prompt([
+        {
+            type: "input",
+            name: "documentModelsDir",
+            message: "Where to place the Document Models?",
+            initial: defaultDirs.documentModelsDir,
+        },
+        {
+            type: "input",
+            name: "editorsDir",
+            message: "Where to place the Editors?",
+            initial: defaultDirs.editorsDir,
+        },
+    ]);
+}

package/dist/src/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./cli.js";
+export * from "./mock.js";
+export * from "./package-manager.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC"}

package/dist/src/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./cli.js";
+export * from "./mock.js";
+export * from "./package-manager.js";

package/dist/src/utils/mock.d.ts

@@ -0,0 +1,4 @@
+import { generateMock as zodGenerateMock } from "@anatine/zod-mock";
+export type generateMockTypeFn = typeof zodGenerateMock;
+export declare const generateMock: generateMockTypeFn;
+//# sourceMappingURL=mock.d.ts.map

package/dist/src/utils/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../../src/utils/mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,OAAO,eAAe,CAAC;AAExD,eAAO,MAAM,YAAY,EAAE,kBAE1B,CAAC"}

package/dist/src/utils/mock.js

@@ -0,0 +1,4 @@
+import { generateMock as zodGenerateMock } from "@anatine/zod-mock";
+export const generateMock = (zodRef, options) => {
+    return zodGenerateMock(zodRef, options);
+};