vona-cli-set-api 1.0.5 → 1.0.11

package/dist/lib/bean/toolsMetadata/generateConfig.d.ts

@@ -1,5 +1,4 @@
-export declare function generateConfig(modulePath: string): Promise<"" | "/** config: begin */\nexport * from '../config/config.js';\nimport { config } from '../config/config.js';\n/** config: end */\n">;
-export declare function generateConstant(modulePath: string): Promise<"" | "/** constant: begin */\nexport * from '../config/constants.js';\nimport { constants } from '../config/constants.js';\n/** constant: end */\n">;
+export declare function generateConfig(modulePath: string): Promise<"" | "/** config: begin */\nexport * from '../config/config.ts';\nimport type { config } from '../config/config.ts';\n/** config: end */\n">;
+export declare function generateConstant(modulePath: string): Promise<"" | "/** constant: begin */\nexport * from '../config/constants.ts';\nimport { constants } from '../config/constants.ts';\n/** constant: end */\n">;
 export declare function generateLocale(modulePath: string): Promise<string>;
-export declare function generateError(modulePath: string): Promise<"" | "/** error: begin */\nexport * from '../config/errors.js';\nimport { Errors } from '../config/errors.js';\n/** error: end */\n">;
-//# sourceMappingURL=generateConfig.d.ts.map
+export declare function generateError(modulePath: string): Promise<"" | "/** error: begin */\nexport * from '../config/errors.ts';\nimport type { Errors } from '../config/errors.ts';\n/** error: end */\n">;

package/dist/lib/bean/toolsMetadata/generateConfig.js

@@ -1,14 +1,14 @@
-import path from 'path';
+import path from 'node:path';
 import fse from 'fs-extra';
-import eggBornUtils from 'egg-born-utils';
+import { globby } from 'globby';
 export async function generateConfig(modulePath) {
     const configFile = path.join(modulePath, 'src/config/config.ts');
     if (!fse.existsSync(configFile))
         return '';
     // combine
     const content = `/** config: begin */
-export * from '../config/config.js';
-import { config } from '../config/config.js';
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
 /** config: end */
 `;
     return content;
@@ -19,24 +19,23 @@ export async function generateConstant(modulePath) {
         return '';
     // combine
     const content = `/** constant: begin */
-export * from '../config/constants.js';
-import { constants } from '../config/constants.js';
+export * from '../config/constants.ts';
+import { constants } from '../config/constants.ts';
 /** constant: end */
 `;
     return content;
 }
 export async function generateLocale(modulePath) {
-    const pattern = `${modulePath}/src/config/locale/*.ts`;
-    const files = await eggBornUtils.tools.globbyAsync(pattern);
+    const files = await globby('src/config/locale/*.ts', { cwd: modulePath });
     if (files.length === 0)
         return '';
     files.sort();
     const contentImports = [];
     const contentLocales = [];
     for (const file of files) {
-        const localeName = path.basename(file.substring(0, file.length - '.ts'.length));
-        const className = 'locale_' + localeName.replace('-', '_');
-        contentImports.push(`import ${className} from '../config/locale/${localeName}.js';`);
+        const localeName = path.basename(file, '.ts');
+        const className = `locale_${localeName.replace('-', '_')}`;
+        contentImports.push(`import ${className} from '../config/locale/${localeName}.ts';`);
         contentLocales.push(`'${localeName}': ${className},`);
     }
     // combine
@@ -55,10 +54,9 @@ export async function generateError(modulePath) {
         return '';
     // combine
     const content = `/** error: begin */
-export * from '../config/errors.js';
-import { Errors } from '../config/errors.js';
+export * from '../config/errors.ts';
+import type { Errors } from '../config/errors.ts';
 /** error: end */
 `;
     return content;
 }
-//# sourceMappingURL=generateConfig.js.map

package/dist/lib/bean/toolsMetadata/generateMetadataCustom.d.ts

@@ -0,0 +1,3 @@
+import type { BeanCliBase } from '@cabloy/cli';
+import type { OnionSceneMeta } from '@cabloy/module-info';
+export declare function generateMetadataCustom(cli: BeanCliBase, sceneName: string, sceneMeta: OnionSceneMeta, moduleName: string, modulePath: string): Promise<any>;

package/dist/lib/bean/toolsMetadata/generateMetadataCustom.js

@@ -0,0 +1,23 @@
+import path from 'node:path';
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+import { globBeanFiles } from "./utils.js";
+export async function generateMetadataCustom(cli, sceneName, sceneMeta, moduleName, modulePath) {
+    const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+    const globFiles = await globBeanFiles(sceneName, sceneMeta, moduleName, modulePath);
+    if (globFiles.length === 0)
+        return '';
+    // custom
+    const jsFile = path.join(sceneMeta.module.root, sceneMeta.metadataCustom);
+    return await cli.helper.importDynamic(jsFile, async (instance) => {
+        const options = {
+            cli,
+            sceneName,
+            sceneNameCapitalize,
+            sceneMeta,
+            moduleName,
+            modulePath,
+            globFiles,
+        };
+        return await instance.default(options);
+    });
+}

package/dist/lib/bean/toolsMetadata/generateMonkey.d.ts

@@ -1,3 +1,2 @@
-export declare function generateMonkey(modulePath: string): Promise<"" | "/** monkey: begin */\nexport * from '../monkey.js';\n/** monkey: end */\n">;
-export declare function generateMain(modulePath: string): Promise<"" | "/** main: begin */\nexport * from '../main.js';\n/** main: end */\n">;
-//# sourceMappingURL=generateMonkey.d.ts.map
+export declare function generateMonkey(modulePath: string): Promise<"" | "/** monkey: begin */\nexport * from '../monkey.ts';\n/** monkey: end */\n">;
+export declare function generateMain(modulePath: string): Promise<"" | "/** main: begin */\nexport * from '../main.ts';\n/** main: end */\n">;

package/dist/lib/bean/toolsMetadata/generateMonkey.js

@@ -1,4 +1,4 @@
-import path from 'path';
+import path from 'node:path';
 import fse from 'fs-extra';
 export async function generateMonkey(modulePath) {
     const monkeyFile = path.join(modulePath, 'src/monkey.ts');
@@ -6,7 +6,7 @@ export async function generateMonkey(modulePath) {
         return '';
     // combine
     const content = `/** monkey: begin */
-export * from '../monkey.js';
+export * from '../monkey.ts';
 /** monkey: end */
 `;
     return content;
@@ -17,9 +17,8 @@ export async function generateMain(modulePath) {
         return '';
     // combine
     const content = `/** main: begin */
-export * from '../main.js';
+export * from '../main.ts';
 /** main: end */
 `;
     return content;
 }
-//# sourceMappingURL=generateMonkey.js.map

package/dist/lib/bean/toolsMetadata/generateOnions.d.ts

@@ -0,0 +1,2 @@
+import type { OnionSceneMeta } from '@cabloy/module-info';
+export declare function generateOnions(sceneName: string, sceneMeta: OnionSceneMeta, moduleName: string, modulePath: string): Promise<string>;

package/dist/lib/bean/toolsMetadata/generateOnions.js

@@ -0,0 +1,90 @@
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+import { extractBeanInfo, getScopeModuleName, globBeanFiles } from "./utils.js";
+export async function generateOnions(sceneName, sceneMeta, moduleName, modulePath) {
+    const scopeModuleName = getScopeModuleName(moduleName);
+    const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+    const globFiles = await globBeanFiles(sceneName, sceneMeta, moduleName, modulePath);
+    if (globFiles.length === 0)
+        return '';
+    //
+    const contentExports = [];
+    const contentScopes = [];
+    const contentImports = [];
+    const contentRecordsGlobal = [];
+    const contentRecordsLocal = [];
+    let needImportOptionsGlobalInterface;
+    for (const globFile of globFiles) {
+        const { fileContent, fileNameJSRelative, className, beanNameFull, isIgnore, isVirtual } = globFile;
+        contentExports.push(`export * from '${fileNameJSRelative}';`);
+        if (isIgnore)
+            continue; // get scope() also can be ignored
+        // get scope() also can be ignored
+        if (!['entity', 'dto'].includes(sceneName) && !isVirtual) {
+            contentScopes.push(`
+        export interface ${className} {
+          /** @internal */
+          get scope(): ${scopeModuleName};
+        }`);
+        }
+        if (sceneMeta.optionsNone)
+            continue;
+        // fileInfo
+        const fileInfo = extractBeanInfo(sceneName, fileContent, sceneMeta);
+        // import options
+        if (fileInfo.optionsCustomInterface) {
+            contentImports.push(`import type { ${fileInfo.optionsCustomInterface} } from '${fileInfo.optionsCustomInterfaceFrom || fileNameJSRelative}';`);
+        }
+        // record
+        if (fileInfo.isGlobal) {
+            if (fileInfo.optionsCustomInterface) {
+                contentRecordsGlobal.push(`'${beanNameFull}': ${fileInfo.optionsCustomInterface};`);
+            }
+            else {
+                if (sceneMeta.optionsGlobalInterfaceName) {
+                    contentRecordsGlobal.push(`'${beanNameFull}': ${sceneMeta.optionsGlobalInterfaceName};`);
+                    needImportOptionsGlobalInterface = true;
+                }
+                else {
+                    contentRecordsGlobal.push(`'${beanNameFull}': never;`);
+                }
+            }
+        }
+        else {
+            if (fileInfo.optionsCustomInterface) {
+                contentRecordsLocal.push(`'${beanNameFull}': ${fileInfo.optionsCustomInterface};`);
+            }
+            else {
+                contentRecordsLocal.push(`'${beanNameFull}': never;`);
+            }
+        }
+    }
+    // middlewareGlobal
+    const exportRecordsMiddlewareGlobal = `
+    export interface I${sceneNameCapitalize}Record${sceneMeta.hasLocal ? 'Global' : ''} {
+      ${contentRecordsGlobal.join('\n')}
+    }
+`;
+    // middlewareLocal
+    const exportRecordsMiddlewareLocal = `
+export interface I${sceneNameCapitalize}RecordLocal {
+  ${contentRecordsLocal.join('\n')}
+}
+`;
+    // combine
+    const content = `/** ${sceneName}: begin */
+${contentExports.join('\n')}
+${contentImports.join('\n')}
+${needImportOptionsGlobalInterface
+        ? `import { type ${sceneMeta.optionsGlobalInterfaceName} } from '${sceneMeta.optionsGlobalInterfaceFrom || 'vona'}';`
+        : "import 'vona';"}
+declare module '${sceneMeta.optionsGlobalInterfaceFrom || 'vona'}' {
+  ${contentRecordsGlobal.length > 0 ? exportRecordsMiddlewareGlobal : ''}
+  ${contentRecordsLocal.length > 0 ? exportRecordsMiddlewareLocal : ''}
+}
+declare module 'vona-module-${moduleName}' {
+  ${contentScopes.join('\n')} 
+}
+/** ${sceneName}: end */
+`;
+    return content;
+}

package/dist/lib/bean/toolsMetadata/generateScope.d.ts

@@ -3,8 +3,5 @@ export interface GenerateScopeOptions {
     errors: string;
     locales: string;
     constants: string;
-    services: string;
-    models: string;
 }
-export declare function generateScope(moduleName: string, relativeNameCapitalize: string, options: GenerateScopeOptions): Promise<string>;
-//# sourceMappingURL=generateScope.d.ts.map
+export declare function generateScope(moduleName: string, relativeNameCapitalize: string, scopeResources: Record<string, boolean>, options: GenerateScopeOptions): Promise<string>;

package/dist/lib/bean/toolsMetadata/generateScope.js

@@ -1,25 +1,48 @@
-import { toUpperCaseFirstChar } from '@cabloy/word-utils';
-export async function generateScope(moduleName, relativeNameCapitalize, options) {
+import { relativeNameToCapitalize } from '@cabloy/module-info';
+export async function generateScope(moduleName, relativeNameCapitalize, scopeResources, options) {
     // scopeVariable
     const parts = moduleName.split('-');
-    let scopeVariable = parts[0] === 'a' ? toUpperCaseFirstChar(parts[1]) : parts.map(item => toUpperCaseFirstChar(item)).join('');
-    scopeVariable = '$scope' + scopeVariable;
+    const scopeVariable = parts[0] === 'a' ? parts[1] : relativeNameToCapitalize(moduleName, false);
+    const contentImports = [];
+    const contentRecords = [];
+    // basic
+    contentImports.push('BeanScopeBase');
+    // util
+    contentImports.push('type BeanScopeUtil');
+    contentRecords.push('util: BeanScopeUtil;');
+    //
+    if (options.config) {
+        contentImports.push('type TypeModuleConfig');
+        contentRecords.push('config: TypeModuleConfig<typeof config>;');
+    }
+    if (options.errors) {
+        contentImports.push('type TypeModuleErrors');
+        contentRecords.push('error: TypeModuleErrors<typeof Errors>;');
+    }
+    if (options.locales) {
+        contentImports.push('type TypeModuleLocales');
+        contentImports.push('type TypeLocaleBase');
+        contentRecords.push('locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;');
+    }
+    if (options.constants) {
+        contentImports.push('type TypeModuleConstants');
+        contentRecords.push('constant: TypeModuleConstants<typeof constants>;');
+    }
+    // loop
+    for (const sceneName in scopeResources) {
+        contentRecords.push(`${sceneName}: ${scopeResources[sceneName]};`);
+    }
     // combine
     const content = `/** scope: begin */
-import { BeanScopeBase, Scope, ${options.locales ? 'TypeLocaleBase,' : ''} TypeModuleResource } from 'vona';
+import { ${contentImports.join(', ')} } from 'vona';
+import { Scope } from '${moduleName === 'a-bean' ? '../lib/scope.ts' : 'vona-module-a-bean'}';
 
 @Scope()
 export class ScopeModule${relativeNameCapitalize} extends BeanScopeBase {}
 
-export interface ScopeModule${relativeNameCapitalize}
-  extends TypeModuleResource<
-    ${options.config ? 'typeof config' : 'any'},
-    ${options.errors ? 'typeof Errors' : 'any'},
-    ${options.locales ? '(typeof locales)[TypeLocaleBase]' : 'any'},
-    ${options.constants ? 'typeof constants' : 'any'},
-    ${options.services ? 'IModuleService' : 'any'},
-    ${options.models ? 'IModuleModel' : 'any'},
-  > {}
+export interface ScopeModule${relativeNameCapitalize} {
+  ${contentRecords.join('\n')}
+}
 
 import 'vona';
 declare module 'vona' {
@@ -27,7 +50,7 @@ declare module 'vona' {
     '${moduleName}': ScopeModule${relativeNameCapitalize};
   }
 
-  export interface BeanBase {
+  export interface IBeanScopeContainer {
     ${scopeVariable}: ScopeModule${relativeNameCapitalize};
   }
   
@@ -43,8 +66,12 @@ declare module 'vona' {
   }`
         : ''}
 }
+${options.locales
+        ? `\nexport function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): \`${moduleName}::\${K}\` {
+  return \`${moduleName}::\${key}\`;
+}`
+        : ''}
 /** scope: end */
 `;
     return content;
 }
-//# sourceMappingURL=generateScope.js.map

package/dist/lib/bean/toolsMetadata/generateScopeResources.d.ts

@@ -0,0 +1,2 @@
+import type { OnionSceneMeta } from '@cabloy/module-info';
+export declare function generateScopeResources(sceneName: string, sceneMeta: OnionSceneMeta, moduleName: string, modulePath: string): Promise<string>;

package/dist/lib/bean/toolsMetadata/generateScopeResources.js

@@ -0,0 +1,29 @@
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+import { globBeanFiles } from "./utils.js";
+export async function generateScopeResources(sceneName, sceneMeta, moduleName, modulePath) {
+    const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+    const globFiles = await globBeanFiles(sceneName, sceneMeta, moduleName, modulePath);
+    if (globFiles.length === 0)
+        return '';
+    //
+    const contentImports = [];
+    const contentRecords = [];
+    for (const globFile of globFiles) {
+        const { fileNameJSRelative, className, beanName, isIgnore } = globFile;
+        if (isIgnore)
+            continue;
+        contentImports.push(`import type { ${className} } from '${fileNameJSRelative}';`);
+        contentRecords.push(`'${beanName}': ${className};`);
+    }
+    if (contentImports.length === 0)
+        return '';
+    // combine
+    const content = `/** ${sceneName}: begin */
+${contentImports.join('\n')}
+export interface IModule${sceneNameCapitalize} {
+  ${contentRecords.join('\n')}
+}
+/** ${sceneName}: end */
+`;
+    return content;
+}

package/dist/lib/bean/toolsMetadata/generateScopeResourcesMeta.d.ts

@@ -0,0 +1,2 @@
+import type { OnionMetaMeta, OnionSceneMeta } from '@cabloy/module-info';
+export declare function generateScopeResourcesMeta(metaName: string, _metaMeta: OnionMetaMeta, _sceneName: string, _sceneMeta: OnionSceneMeta, _moduleName: string, modulePath: string): Promise<string>;

package/dist/lib/bean/toolsMetadata/generateScopeResourcesMeta.js

@@ -0,0 +1,13 @@
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+import { globby } from 'globby';
+export async function generateScopeResourcesMeta(metaName, _metaMeta, _sceneName, _sceneMeta, _moduleName, modulePath) {
+    const files = await globby(`src/bean/meta.${metaName}.ts`, { cwd: modulePath });
+    if (files.length === 0)
+        return '';
+    // combine
+    const content = `/** meta ${metaName}: begin */
+import type { Meta${toUpperCaseFirstChar(metaName)} } from '../bean/meta.${metaName}.ts';
+/** meta ${metaName}: end */
+`;
+    return content;
+}

package/dist/lib/bean/toolsMetadata/utils.d.ts

@@ -0,0 +1,9 @@
+import type { IGlobBeanFile, OnionSceneMeta } from '@cabloy/module-info';
+export declare function checkIgnoreOfParts(parts: string[]): boolean;
+export declare function getScopeModuleName(moduleName: string): string;
+export declare function globBeanFiles(sceneName: string, sceneMeta: OnionSceneMeta, moduleName: string, modulePath: string): Promise<IGlobBeanFile[]>;
+export declare function extractBeanInfo(sceneName: string, fileContent: string, sceneMeta: OnionSceneMeta): {
+    optionsCustomInterface: string | undefined;
+    optionsCustomInterfaceFrom: string | undefined;
+    isGlobal: boolean | RegExpMatchArray | null;
+};

package/dist/lib/bean/toolsMetadata/utils.js

@@ -0,0 +1,82 @@
+import path from 'node:path';
+import { stringToCapitalize, toUpperCaseFirstChar } from '@cabloy/word-utils';
+import fse from 'fs-extra';
+import { globby } from 'globby';
+export function checkIgnoreOfParts(parts) {
+    const indexLast = parts.length - 1;
+    if (parts[indexLast].endsWith('_')) {
+        parts[indexLast] = parts[indexLast].substring(0, parts[indexLast].length - 1);
+        return true;
+    }
+    return false;
+}
+export function getScopeModuleName(moduleName) {
+    return `ScopeModule${stringToCapitalize(moduleName, '-')}`;
+}
+export async function globBeanFiles(sceneName, sceneMeta, moduleName, modulePath) {
+    const result = [];
+    const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+    const pattern = sceneMeta.sceneIsolate
+        ? `src/${sceneName}/*.ts`
+        : `src/bean/${sceneName}.*.ts`;
+    const files = await globby(pattern, { cwd: modulePath });
+    if (files.length === 0)
+        return result;
+    files.sort();
+    for (const file of files) {
+        const filePath = path.join(modulePath, file);
+        const fileName = path.basename(file);
+        if (fileName.startsWith('_'))
+            continue;
+        const parts = fileName.split('.').slice(0, -1);
+        if (sceneMeta.sceneIsolate && parts.length !== 1)
+            continue;
+        if (!sceneMeta.sceneIsolate && parts.length < 2)
+            continue;
+        const isIgnore = checkIgnoreOfParts(parts);
+        const fileNameJS = fileName; // fileName.replace('.ts', '.js');
+        const fileNameJSRelative = sceneMeta.sceneIsolate ? `../${sceneName}/${fileNameJS}` : `../bean/${fileNameJS}`;
+        const className = (sceneMeta.sceneIsolate ? sceneNameCapitalize : '') + parts.map(item => toUpperCaseFirstChar(item)).join('');
+        const beanName = parts[parts.length - 1];
+        const beanNameFull = `${moduleName}:${beanName}`;
+        const fileContent = isIgnore ? '' : fse.readFileSync(filePath).toString();
+        const isVirtual = fileContent.includes('@Virtual()');
+        result.push({
+            sceneName,
+            sceneNameCapitalize,
+            file: filePath,
+            fileContent,
+            fileName,
+            fileNameJS,
+            fileNameJSRelative,
+            className,
+            beanName,
+            beanNameFull,
+            isIgnore,
+            isVirtual,
+        });
+    }
+    return result;
+}
+export function extractBeanInfo(sceneName, fileContent, sceneMeta) {
+    const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+    // optionsCustomInterface
+    let optionsCustomInterface;
+    let optionsCustomInterfaceFrom;
+    let reg = new RegExp(`@${sceneNameCapitalize}<(I${sceneNameCapitalize}Options[^>]*)>`);
+    let matches = fileContent.match(reg);
+    if (matches) {
+        optionsCustomInterface = matches[1];
+        // optionsCustomInterfaceFrom
+        reg = new RegExp(`import type {[\\s\\S]*?${optionsCustomInterface}[, ][\\s\\S]*?} from '([^']*)'`);
+        matches = fileContent.match(reg);
+        if (matches) {
+            optionsCustomInterfaceFrom = matches[1];
+        }
+    }
+    // isGlobal
+    const isGlobal = sceneMeta.hasLocal
+        ? fileContent.match(/@.*?\(\{([\s\S]*?)global: true([\s\S]*?)\}([\s\S]*?)\)\s*export class/)
+        : true;
+    return { optionsCustomInterface, optionsCustomInterfaceFrom, isGlobal };
+}

package/dist/lib/beans.d.ts

@@ -1,17 +1,46 @@
-import { CliDefaultList } from './bean/cli.default.list.js';
-import { CliCreateSuite } from './bean/cli.create.suite.js';
-import { CliCreateModule } from './bean/cli.create.module.js';
-import { CliCreateBean } from './bean/cli.create.bean.js';
-import { CliToolsDeps } from './bean/cli.tools.deps.js';
-import { CliToolsMetadata } from './bean/cli.tools.metadata.js';
-import { CliToolsBuild } from './bean/cli.tools.build.js';
+import { CliBinBuild } from './bean/cli.bin.build.ts';
+import { CliBinDbReset } from './bean/cli.bin.dbReset.ts';
+import { CliBinDemo } from './bean/cli.bin.demo.ts';
+import { CliBinDev } from './bean/cli.bin.dev.ts';
+import { CliBinTest } from './bean/cli.bin.test.ts';
+import { CliBinTsc } from './bean/cli.bin.tsc.ts';
+import { CliCreateBean } from './bean/cli.create.bean.ts';
+import { CliCreateModule } from './bean/cli.create.module.ts';
+import { CliCreateProject } from './bean/cli.create.project.ts';
+import { CliCreateSuite } from './bean/cli.create.suite.ts';
+import { CliCreateTest } from './bean/cli.create.test.ts';
+import { CliDefaultList } from './bean/cli.default.list.ts';
+import { CliInitConfig } from './bean/cli.init.config.ts';
+import { CliInitConstant } from './bean/cli.init.constant.ts';
+import { CliInitError } from './bean/cli.init.error.ts';
+import { CliInitLocale } from './bean/cli.init.locale.ts';
+import { CliInitMain } from './bean/cli.init.main.ts';
+import { CliInitMonkey } from './bean/cli.init.monkey.ts';
+import { CliInitStatic } from './bean/cli.init.static.ts';
+import { CliToolsCrud } from './bean/cli.tools.crud.ts';
+import { CliToolsDeps } from './bean/cli.tools.deps.ts';
+import { CliToolsMetadata } from './bean/cli.tools.metadata.ts';
 export declare const beans: {
     'default.list': typeof CliDefaultList;
+    'bin.build': typeof CliBinBuild;
+    'bin.dbReset': typeof CliBinDbReset;
+    'bin.demo': typeof CliBinDemo;
+    'bin.dev': typeof CliBinDev;
+    'bin.test': typeof CliBinTest;
+    'bin.tsc': typeof CliBinTsc;
     'create.suite': typeof CliCreateSuite;
     'create.bean': typeof CliCreateBean;
     'create.module': typeof CliCreateModule;
+    'create.project': typeof CliCreateProject;
+    'create.test': typeof CliCreateTest;
+    'init.config': typeof CliInitConfig;
+    'init.constant': typeof CliInitConstant;
+    'init.error': typeof CliInitError;
+    'init.locale': typeof CliInitLocale;
+    'init.monkey': typeof CliInitMonkey;
+    'init.main': typeof CliInitMain;
+    'init.static': typeof CliInitStatic;
     'tools.deps': typeof CliToolsDeps;
     'tools.metadata': typeof CliToolsMetadata;
-    'tools.build': typeof CliToolsBuild;
+    'tools.crud': typeof CliToolsCrud;
 };
-//# sourceMappingURL=beans.d.ts.map

package/dist/lib/beans.js

@@ -1,17 +1,46 @@
-import { CliDefaultList } from './bean/cli.default.list.js';
-import { CliCreateSuite } from './bean/cli.create.suite.js';
-import { CliCreateModule } from './bean/cli.create.module.js';
-import { CliCreateBean } from './bean/cli.create.bean.js';
-import { CliToolsDeps } from './bean/cli.tools.deps.js';
-import { CliToolsMetadata } from './bean/cli.tools.metadata.js';
-import { CliToolsBuild } from './bean/cli.tools.build.js';
+import { CliBinBuild } from "./bean/cli.bin.build.js";
+import { CliBinDbReset } from "./bean/cli.bin.dbReset.js";
+import { CliBinDemo } from "./bean/cli.bin.demo.js";
+import { CliBinDev } from "./bean/cli.bin.dev.js";
+import { CliBinTest } from "./bean/cli.bin.test.js";
+import { CliBinTsc } from "./bean/cli.bin.tsc.js";
+import { CliCreateBean } from "./bean/cli.create.bean.js";
+import { CliCreateModule } from "./bean/cli.create.module.js";
+import { CliCreateProject } from "./bean/cli.create.project.js";
+import { CliCreateSuite } from "./bean/cli.create.suite.js";
+import { CliCreateTest } from "./bean/cli.create.test.js";
+import { CliDefaultList } from "./bean/cli.default.list.js";
+import { CliInitConfig } from "./bean/cli.init.config.js";
+import { CliInitConstant } from "./bean/cli.init.constant.js";
+import { CliInitError } from "./bean/cli.init.error.js";
+import { CliInitLocale } from "./bean/cli.init.locale.js";
+import { CliInitMain } from "./bean/cli.init.main.js";
+import { CliInitMonkey } from "./bean/cli.init.monkey.js";
+import { CliInitStatic } from "./bean/cli.init.static.js";
+import { CliToolsCrud } from "./bean/cli.tools.crud.js";
+import { CliToolsDeps } from "./bean/cli.tools.deps.js";
+import { CliToolsMetadata } from "./bean/cli.tools.metadata.js";
 export const beans = {
     'default.list': CliDefaultList,
+    'bin.build': CliBinBuild,
+    'bin.dbReset': CliBinDbReset,
+    'bin.demo': CliBinDemo,
+    'bin.dev': CliBinDev,
+    'bin.test': CliBinTest,
+    'bin.tsc': CliBinTsc,
     'create.suite': CliCreateSuite,
     'create.bean': CliCreateBean,
     'create.module': CliCreateModule,
+    'create.project': CliCreateProject,
+    'create.test': CliCreateTest,
+    'init.config': CliInitConfig,
+    'init.constant': CliInitConstant,
+    'init.error': CliInitError,
+    'init.locale': CliInitLocale,
+    'init.monkey': CliInitMonkey,
+    'init.main': CliInitMain,
+    'init.static': CliInitStatic,
     'tools.deps': CliToolsDeps,
     'tools.metadata': CliToolsMetadata,
-    'tools.build': CliToolsBuild,
+    'tools.crud': CliToolsCrud,
 };
-//# sourceMappingURL=beans.js.map

package/dist/lib/command/bin.build.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    bean: string;
+    info: {
+        version: string;
+        title: string;
+        usage: string;
+    };
+    options: {
+        workers: {
+            description: string;
+            type: string;
+        };
+        flavor: {
+            description: string;
+            type: string;
+        };
+    };
+};
+export default _default;

package/dist/lib/command/bin.build.js

@@ -0,0 +1,18 @@
+export default {
+    bean: 'bin.build',
+    info: {
+        version: '5.0.0',
+        title: 'Cli: Tools: Bin',
+        usage: 'vona :bin:build [--workers=] [--flavor=] [--sourcemap=]',
+    },
+    options: {
+        workers: {
+            description: 'workers',
+            type: 'number',
+        },
+        flavor: {
+            description: 'flavor',
+            type: 'string',
+        },
+    },
+};

package/dist/lib/command/bin.dbReset.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    bean: string;
+    info: {
+        version: string;
+        title: string;
+        usage: string;
+    };
+    options: {
+        flavor: {
+            description: string;
+            type: string;
+        };
+    };
+};
+export default _default;