cabloy 5.1.231 → 5.1.233

package/zova/packages-cli/cli-set-front/src/lib/bean/toolsMetadata/generateConfig.ts

@@ -7,8 +7,8 @@ export async function generateConfig(modulePath: string) {
   if (!(await fse.pathExists(configFile))) return '';
   // combine
   const content = `/** config: begin */
-export * from '../config/config.js';
-import { config } from '../config/config.js';
+export * from '../config/config.ts';
+import { config } from '../config/config.ts';
 /** config: end */
 `;
   return content;
@@ -19,8 +19,8 @@ export async function generateConstant(modulePath: string) {
   if (!(await fse.pathExists(constantFile))) 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;
@@ -35,7 +35,7 @@ export async function generateLocale1(modulePath: string) {
   for (const file of files) {
     const localeName = path.basename(file, '.ts');
     const className = `locale_${localeName.replace('-', '_')}`;
-    contentImports.push(`import ${className} from '../config/locale/${localeName}.js';`);
+    contentImports.push(`import ${className} from '../config/locale/${localeName}.ts';`);
     contentLocales.push(`  '${localeName}': ${className},`);
   }
   // combine
@@ -52,7 +52,7 @@ export async function generateLocale2(contentLocales: string) {
   if (!contentLocales) return '';
   // combine
   const content = `/** locale: begin */
-import { locales } from './locales.js';
+import { locales } from './locales.ts';
 /** locale: end */
 `;
   return content;
@@ -63,8 +63,8 @@ export async function generateError(modulePath: string) {
   if (!(await fse.pathExists(errorFile))) return '';
   // combine
   const content = `/** error: begin */
-export * from '../config/errors.js';
-import { errors } from '../config/errors.js';
+export * from '../config/errors.ts';
+import { errors } from '../config/errors.ts';
 /** error: end */
 `;
   return content;

package/zova/packages-cli/cli-set-front/src/lib/bean/toolsMetadata/generateMonkey.ts

@@ -22,7 +22,7 @@ async function generateMonkey_common(modulePath: string, commandName: string) {
   if (!(await fse.pathExists(monkeyFile))) return '';
   // combine
   const content = `/** ${commandName}: begin */
-export * from '../${commandName}.js';
+export * from '../${commandName}.ts';
 /** ${commandName}: end */
 `;
   return content;
@@ -33,7 +33,7 @@ async function generateMain_common(modulePath: string, commandName: string) {
   if (!(await fse.pathExists(monkeyFile))) return '';
   // combine
   const content = `/** ${commandName}: begin */
-export * from '../${commandName}.js';
+export * from '../${commandName}.ts';
 /** ${commandName}: end */
 `;
   return content;

package/zova/packages-cli/cli-set-front/src/lib/bean/toolsMetadata/generateScope.ts

@@ -42,7 +42,7 @@ export async function generateScope(
   // combine
   const content = `/** scope: begin */
 import { ${contentImports.join(', ')} } from 'zova';
-import { Scope } from '${moduleName === 'a-bean' ? '../lib/scope.js' : 'zova-module-a-bean'}';
+import { Scope } from '${moduleName === 'a-bean' ? '../lib/scope.ts' : 'zova-module-a-bean'}';
 
 @Scope()
 export class ScopeModule${relativeNameCapitalize} extends BeanScopeBase {}

package/zova/packages-cli/cli-set-front/src/lib/bean/toolsMetadata/generateScopeResourcesMeta.ts

@@ -14,7 +14,7 @@ export async function generateScopeResourcesMeta(
   if (globFiles.length === 0) return '';
   // combine
   const content = `/** meta ${metaName}: begin */
-import { Meta${toUpperCaseFirstChar(metaName)} } from '../bean/meta.${metaName}.js';
+import { Meta${toUpperCaseFirstChar(metaName)} } from '../bean/meta.${metaName}.ts';
 /** meta ${metaName}: end */
 `;
   return content;

package/zova/packages-cli/cli-set-front/src/lib/bean/toolsMetadata/utils.ts

@@ -42,12 +42,8 @@ export async function globAllTsFiles(
     if (fileName.startsWith('_')) continue;
     const parts = fileName.split('.').slice(0, -1);
     const isIgnore = checkIgnoreOfParts(parts);
-    const fileNameJS = fileName.replace('.ts', '.js').replace('.tsx', '.jsx');
-    const fileNameJSRelative = path
-      .relative(pathMetadata, filePath)
-      .replace(/\\/g, '/')
-      .replace('.ts', '.js')
-      .replace('.tsx', '.jsx');
+    const fileNameJS = fileName;
+    const fileNameJSRelative = path.relative(pathMetadata, filePath).replace(/\\/g, '/');
     const fileContent = fse.readFileSync(filePath).toString();
     const isVirtual = fileContent.includes('@Virtual()');
     const isPreload = fileContent.includes('@Preload()');

package/zova/packages-cli/cli-set-front/test/sourceImports.test.ts

@@ -0,0 +1,228 @@
+import type { IMetadataCustomGenerateOptions } from '@cabloy/cli';
+
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { it } from 'node:test';
+
+import generateController from '../../../src/suite-vendor/a-zova/modules/a-bean/cli/controller/metadata/generate.ts';
+import { CliOpenapiGenerate } from '../src/lib/bean/cli.openapi.generate.ts';
+import { CliToolsMetadata } from '../src/lib/bean/cli.tools.metadata.ts';
+import { generateBeanGenerals } from '../src/lib/bean/toolsMetadata/generateBeanGenerals.ts';
+import { generateMetadataCustom } from '../src/lib/bean/toolsMetadata/generateMetadataCustom.ts';
+import { generateOnions } from '../src/lib/bean/toolsMetadata/generateOnions.ts';
+import { generateScopeResources } from '../src/lib/bean/toolsMetadata/generateScopeResources.ts';
+import { globAllTsFiles } from '../src/lib/bean/toolsMetadata/utils.ts';
+
+async function withModule(
+  run: (modulePath: string, put: (file: string, content: string) => Promise<void>) => Promise<void>,
+) {
+  const modulePath = await mkdtemp(path.join(os.tmpdir(), 'zova-source-imports-'));
+  try {
+    await run(modulePath, async (file, content) => {
+      const target = path.join(modulePath, file);
+      await mkdir(path.dirname(target), { recursive: true });
+      await writeFile(target, content);
+    });
+  } finally {
+    await rm(modulePath, { recursive: true, force: true });
+  }
+}
+
+const helper = { async formatFile() {} };
+
+it('keeps source suffixes in filename fields and uses them in metadata imports', async () => {
+  await withModule(async (modulePath, put) => {
+    await put('src/bean/model.example.ts', '\n@Model()\nexport class ModelExample {}');
+    await put(
+      'src/component/example/controller.tsx',
+      '\n@Controller()\nexport class ControllerExample {}',
+    );
+    const files = await globAllTsFiles('test-example', modulePath);
+    assert.equal(files.length, 2);
+    for (const file of files) {
+      const source = path
+        .relative(path.join(modulePath, 'src/.metadata'), file.file)
+        .replace(/\\/g, '/');
+      assert.match(source, /\.tsx?$/);
+      assert.equal(file.fileNameJS, file.fileName);
+      assert.equal(file.fileNameJSRelative, source);
+      const sceneMeta = { optionsNone: true };
+      for (const content of [
+        await generateOnions([file], file.sceneName, sceneMeta, 'test-example', modulePath),
+        await generateBeanGenerals([file], file.sceneName, sceneMeta, 'test-example', modulePath),
+        await generateScopeResources([file], file.sceneName, sceneMeta, 'test-example', modulePath),
+      ]) {
+        assert.ok(content.includes(`from '${source}'`), content);
+        assert.doesNotMatch(content, /from ['"]\.[^'"]*\.jsx?['"]/);
+      }
+    }
+  });
+});
+
+it('generates wrappers from source controller, render and style extensions', async () => {
+  await withModule(async (modulePath, put) => {
+    for (const [name, ext] of [
+      ['first', 'ts'],
+      ['second', 'tsx'],
+    ]) {
+      const className = `Controller${name === 'first' ? 'First' : 'Second'}`;
+      await put(
+        `src/component/${name}/controller.${ext}`,
+        `\n@Controller()\nexport class ${className} {}`,
+      );
+      for (const file of ['render.tsx', 'render.extra.tsx', 'style.ts', 'style.extra.ts']) {
+        await put(`src/component/${name}/${file}`, 'export {};');
+      }
+    }
+    const options = {
+      moduleName: 'test-example',
+      modulePath,
+      cli: { helper, context: { argv: { projectPath: modulePath } } },
+      globFiles: await globAllTsFiles('test-example', modulePath),
+    } as unknown as IMetadataCustomGenerateOptions;
+    const metadata = await generateController(options);
+    assert.match(metadata, /from '\.\/component\/first\.ts'/);
+    for (const [name, ext] of [
+      ['first', 'ts'],
+      ['second', 'tsx'],
+    ]) {
+      const content = await readFile(
+        path.join(modulePath, `src/.metadata/component/${name}.ts`),
+        'utf8',
+      );
+      for (const target of [`controller.${ext}`, 'render.tsx', 'style.ts']) {
+        assert.ok(content.includes(`from '../../component/${name}/${target}'`), content);
+      }
+      assert.doesNotMatch(content, /from ['"]\.[^'"]*\.jsx?['"]/);
+    }
+  });
+});
+
+it('migrates only generator-owned exports and remains idempotent', async () => {
+  await withModule(async (modulePath, put) => {
+    const cli = Object.create(CliToolsMetadata.prototype) as CliToolsMetadata;
+    Object.defineProperty(cli, 'helper', { value: helper });
+    const customThis =
+      '// custom\nexport { other } from \'./custom.js\';\nexport const note = "./index.js";\n';
+    const customIndex =
+      "// custom\nexport { value } from './lib/index.js';\nexport * from './custom.js';\n";
+    await put(
+      'src/.metadata/this.ts',
+      `export const __ThisModule__ = 'test-example';\nexport { ScopeModuleTestExample as ScopeModule } from './index.js';\n${customThis}`,
+    );
+    await put(
+      'src/index.ts',
+      `export * from './.metadata/index.js';\nexport * from './.metadata/index.ts';\nexport * from "./lib/index.js";\n${customIndex}`,
+    );
+    await put('src/.metadata/index.ts', 'export {};');
+    await put('src/lib/index.ts', 'export {};');
+    await cli._generateThis('test-example', 'TestExample', modulePath);
+    await cli._generateIndex(modulePath);
+    const firstThis = await readFile(path.join(modulePath, 'src/.metadata/this.ts'), 'utf8');
+    const firstIndex = await readFile(path.join(modulePath, 'src/index.ts'), 'utf8');
+    assert.ok(firstThis.endsWith(customThis));
+    assert.ok(firstIndex.endsWith(customIndex));
+    assert.match(firstThis, /as ScopeModule \} from '\.\/index\.ts';/);
+    assert.equal(firstIndex.split("export * from './.metadata/index.ts';").length - 1, 1);
+    assert.match(firstIndex, /export \* from '\.\/lib\/index\.ts';/);
+    await cli._generateThis('test-example', 'TestExample', modulePath);
+    await cli._generateIndex(modulePath);
+    assert.equal(await readFile(path.join(modulePath, 'src/.metadata/this.ts'), 'utf8'), firstThis);
+    assert.equal(await readFile(path.join(modulePath, 'src/index.ts'), 'utf8'), firstIndex);
+  });
+});
+
+it('keeps compiled custom-generator lookup on dist-cli JavaScript', async () => {
+  await withModule(async (modulePath, put) => {
+    await put('dist-cli/controller/metadata/generate.js', 'export default () => "compiled";');
+    const calls: string[] = [];
+    const cli = {
+      helper: {
+        async importDynamic(file: string, callback: Function) {
+          calls.push(file);
+          return callback({ default: () => 'generated' });
+        },
+      },
+    };
+    const sceneMeta = {
+      metadataCustom: 'controller/metadata/generate.ts',
+      module: { root: modulePath },
+    };
+    const files = [{}];
+    await generateMetadataCustom(
+      cli as any,
+      files as any,
+      'controller',
+      sceneMeta as any,
+      'test-example',
+      modulePath,
+    );
+    assert.equal(calls[0], path.join(modulePath, 'dist-cli/controller/metadata/generate.js'));
+    await rm(path.join(modulePath, 'dist-cli'), { recursive: true });
+    await generateMetadataCustom(
+      cli as any,
+      files as any,
+      'controller',
+      sceneMeta as any,
+      'test-example',
+      modulePath,
+    );
+    assert.equal(calls[1], path.join(modulePath, 'cli/controller/metadata/generate.ts'));
+  });
+});
+
+it('generates OpenAPI value and type consumers with source suffixes', async () => {
+  await withModule(async modulePath => {
+    const openapiTypescript = await import('@cabloy/openapi-typescript');
+    const cli = Object.create(CliOpenapiGenerate.prototype) as CliOpenapiGenerate;
+    Object.defineProperty(cli, 'helper', { value: helper });
+    const module = { root: modulePath, name: 'test-example' } as any;
+    const config = {
+      source: {
+        openapi: '3.0.3',
+        info: { title: 'test', version: '1' },
+        paths: {
+          '/example': {
+            get: {
+              operationId: 'Example_list',
+              responses: {
+                '200': {
+                  description: 'ok',
+                  content: {
+                    'application/json': {
+                      schema: {
+                        type: 'object',
+                        properties: { data: { $ref: '#/components/schemas/Example' } },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        components: {
+          schemas: { Example: { type: 'object', properties: { id: { type: 'string' } } } },
+        },
+      },
+      apiMeta: true,
+      apiSchema: true,
+      operations: { match: /^Example_/ },
+    } as any;
+    const cache = await cli._outputFiles(openapiTypescript, config, {} as any, module, {});
+    await cli._generateApis(openapiTypescript, cache.ast, config, {} as any, module);
+    for (const file of [
+      'api/openapi/index.ts',
+      'api/openapi/schemas.ts',
+      'api/example.ts',
+      'apiMeta/example.ts',
+      'apiSchema/example.ts',
+    ]) {
+      const content = await readFile(path.join(modulePath, 'src', file), 'utf8');
+      assert.match(content, /from ['"]\.[^'"]*\.ts['"]/);
+      assert.doesNotMatch(content, /from ['"]\.[^'"]*\.jsx?['"]/);
+    }
+  });
+});

package/zova/packages-utils/zova-vite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-vite",
-  "version": "1.1.50",
+  "version": "1.1.51",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "zova vite",
   "keywords": [

package/zova/packages-utils/zova-vite/src/generateEntryFiles.ts

@@ -54,9 +54,7 @@ export async function generateEntryFiles(
       for (let index = 1; index < parts.length - 1; index++) {
         constName += parts[index].charAt(0).toUpperCase() + parts[index].substring(1);
       }
-      imports.push(
-        `import ${constName} from '../src/front/config/config/${filename.replace('.ts', '.js')}';`,
-      );
+      imports.push(`import ${constName} from '../src/front/config/config/${filename}';`);
       constNames.push(constName);
     }
     const contentDest = `${imports.join('\n')}\nexport default [${constNames.join(', ')}];`;

package/zova/packages-utils/zova-vite/templates/app/controller.tsx_

@@ -1,6 +1,6 @@
 import { App, getCurrentInstance } from 'vue';
 import { BeanControllerPageBase, PluginZova, ZovaApplication } from 'zova';
-import { getPluginZovaOptions } from './utils.js';
+import { getPluginZovaOptions } from './utils.ts';
 
 export class ControllerPageApp extends BeanControllerPageBase {
   protected async __init__() {

package/zova/packages-utils/zova-vite/templates/app/utils.ts_

@@ -1,9 +1,9 @@
-import { locales } from '../../src/front/config/locales.js';
-<%=sysMonkey?"import { SysMonkey } from '../../src/front/config/monkeySys.js';":''%>
-<%=appMonkey?"import { AppMonkey } from '../../src/front/config/monkey.js';":''%>
-import config from '../config.js';
-import { env } from '../env.js';
-import { modulesMeta } from '../modules-meta.js';
+import { locales } from '../../src/front/config/locales.ts';
+<%=sysMonkey?"import { SysMonkey } from '../../src/front/config/monkeySys.ts';":''%>
+<%=appMonkey?"import { AppMonkey } from '../../src/front/config/monkey.ts';":''%>
+import config from '../config.ts';
+import { env } from '../env.ts';
+import { modulesMeta } from '../modules-meta.ts';
 
 const options = {
   modulesMeta,

package/zova/packages-utils/zova-vite/test/generateEntryFiles.test.ts

@@ -0,0 +1,41 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+
+import { generateEntryFiles } from '../src/generateEntryFiles.ts';
+
+test('generated application entry files retain actual source suffixes', async () => {
+  const appDir = await mkdtemp(path.join(tmpdir(), 'zova-entry-'));
+  try {
+    const configDir = path.join(appDir, 'src/front/config');
+    await mkdir(path.join(configDir, 'config'), { recursive: true });
+    await writeFile(path.join(configDir, 'config/config.ts'), 'export default {};\n');
+    await writeFile(path.join(configDir, 'monkey.ts'), 'export class AppMonkey {}\n');
+    await writeFile(path.join(configDir, 'monkeySys.ts'), 'export class SysMonkey {}\n');
+    const meta = { flavor: 'cabloyBasicAdmin', mode: 'production', appMode: 'ssr' };
+    const options = { appDir, runtimeDir: '.zova' };
+    const modules = { modules: {}, modulesArray: [] };
+    await generateEntryFiles(meta as any, options as any, modules as any, {});
+    const files = ['config.ts', 'app/controller.tsx', 'app/utils.ts'];
+    const first = await Promise.all(
+      files.map(file => readFile(path.join(appDir, '.zova', file), 'utf8')),
+    );
+    assert.match(first[0], /from '\.\.\/src\/front\/config\/config\/config\.ts'/);
+    assert.match(first[1], /from '\.\/utils\.ts'/);
+    assert.match(first[2], /from '\.\.\/\.\.\/src\/front\/config\/monkey\.ts'/);
+    assert.match(first[2], /from '\.\.\/\.\.\/src\/front\/config\/monkeySys\.ts'/);
+    assert.match(first[2], /from '\.\.\/config\.ts'/);
+    assert.match(first[2], /from '\.\.\/env\.ts'/);
+    assert.match(first[2], /from '\.\.\/modules-meta\.ts'/);
+    assert.doesNotMatch(first.join('\n'), /from ['"]\.[^'"]*\.jsx?['"]/);
+    await generateEntryFiles(meta as any, options as any, modules as any, {});
+    const second = await Promise.all(
+      files.map(file => readFile(path.join(appDir, '.zova', file), 'utf8')),
+    );
+    assert.deepEqual(second, first);
+  } finally {
+    await rm(appDir, { recursive: true, force: true });
+  }
+});

package/zova/packages-zova/zova/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova",
-  "version": "5.1.175",
+  "version": "5.1.176",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A vue3 framework with ioc",
   "keywords": [
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "zova-core": "^5.1.94",
-    "zova-suite-a-zova": "^5.1.174"
+    "zova-suite-a-zova": "^5.1.175"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",

package/zova/pnpm-lock.yaml

@@ -294,7 +294,7 @@ importers:
         specifier: workspace:^
         version: link:packages-zova/zova
       zova-jsx:
-        specifier: ^1.1.93
+        specifier: ^1.1.94
         version: link:packages-utils/zova-jsx
       zova-module-a-api:
         specifier: workspace:^
@@ -887,7 +887,7 @@ importers:
         specifier: ^3.5.38
         version: 3.5.42(typescript@5.9.3)
       zova-core:
-        specifier: ^5.1.93
+        specifier: ^5.1.94
         version: link:../../packages-zova/zova-core
     devDependencies:
       clean-package:
@@ -1028,10 +1028,10 @@ importers:
   packages-zova/zova:
     dependencies:
       zova-core:
-        specifier: ^5.1.93
+        specifier: ^5.1.94
         version: link:../zova-core
       zova-suite-a-zova:
-        specifier: ^5.1.173
+        specifier: ^5.1.174
         version: link:../../src/suite-vendor/a-zova
     devDependencies:
       clean-package:
@@ -1092,8 +1092,8 @@ importers:
         specifier: ^1.1.10
         version: 1.1.10
       '@cabloy/zod-query':
-        specifier: ^2.1.13
-        version: 2.1.13
+        specifier: ^2.1.14
+        version: 2.1.14
       '@types/js-cookie':
         specifier: ^3.0.6
         version: 3.0.6
@@ -1234,7 +1234,7 @@ importers:
         specifier: ^5.1.36
         version: link:modules/a-bean
       zova-module-a-behavior:
-        specifier: ^5.1.26
+        specifier: ^5.1.27
         version: link:modules/a-behavior
       zova-module-a-behaviors:
         specifier: ^5.1.22
@@ -1264,7 +1264,7 @@ importers:
         specifier: ^5.1.38
         version: link:modules/a-model
       zova-module-a-openapi:
-        specifier: ^5.1.57
+        specifier: ^5.1.58
         version: link:modules/a-openapi
       zova-module-a-router:
         specifier: ^5.1.42
@@ -1291,10 +1291,10 @@ importers:
         specifier: ^5.1.44
         version: link:modules/a-table
       zova-module-a-zod:
-        specifier: ^5.1.37
+        specifier: ^5.1.38
         version: link:modules/a-zod
       zova-module-a-zova:
-        specifier: ^5.1.111
+        specifier: ^5.1.112
         version: link:modules/a-zova
 
   src/suite-vendor/a-zova/modules/a-api:
@@ -1584,8 +1584,8 @@ importers:
         specifier: ^1.1.10
         version: 1.1.10
       '@cabloy/zod-query':
-        specifier: ^2.1.13
-        version: 2.1.13
+        specifier: ^2.1.14
+        version: 2.1.14
       zod:
         specifier: npm:@cabloy/zod@4.3.8
         version: '@cabloy/zod@4.3.8'
@@ -1627,7 +1627,7 @@ importers:
         specifier: ^3.7.2
         version: 3.7.2
       zova-jsx:
-        specifier: ^1.1.93
+        specifier: ^1.1.94
         version: link:../../../../../packages-utils/zova-jsx
     devDependencies:
       '@cabloy/cli':
@@ -2616,8 +2616,8 @@ packages:
   '@cabloy/zod-openapi@1.1.10':
     resolution: {integrity: sha512-9FfPM6xlotXZQo6Y0bJAkeVk+sppfy3jIjHdlpbPujjNx1a98yIO27JtjUdI1vHOugRDMHf4+LbkJ9g1d/Yh+A==}
 
-  '@cabloy/zod-query@2.1.13':
-    resolution: {integrity: sha512-M86aeytpaoPlHm2dLzt1OSVqwUHsZeDUwFSBMAzFTdJjRRkoihMWDgk/8rZunI0IyQep+uQx6G0Ih63CbW309A==}
+  '@cabloy/zod-query@2.1.14':
+    resolution: {integrity: sha512-YZcMy1jRleOWvCz/LjvbaDkbjH1ypYmXX8pbwKOq0QiY4JZU07hcaI29ILrBtHJOLIccawVE5c0rhu5X5ItLeg==}
 
   '@cabloy/zod-to-openapi@8.1.6':
     resolution: {integrity: sha512-pb9iUQuvi5SCYHevqeNBVZO65LguRDSvkHlJ6gxxOXNYQRcObwbIzxLag9/ZUj3GejAPPUNJgjb0CPaYM5s98Q==}
@@ -9400,7 +9400,7 @@ snapshots:
       '@cabloy/zod-to-openapi': 8.1.6
       zod: '@cabloy/zod@4.3.8'
 
-  '@cabloy/zod-query@2.1.13':
+  '@cabloy/zod-query@2.1.14':
     dependencies:
       zod: '@cabloy/zod@4.3.8'
 

package/zova/src/boot/app/index.ts

@@ -1,6 +1,6 @@
 import { createZovaComponentPage } from 'zova';
 
 // @ts-ignore ignore
-import { ControllerPageApp } from '../../../.zova/app/controller.jsx';
+import { ControllerPageApp } from '../../../.zova/app/controller.tsx';
 
 export default createZovaComponentPage(ControllerPageApp);

package/zova/src/boot/zova.ts

@@ -2,7 +2,7 @@ import { defineBoot } from '@quasar/app-vite/wrappers';
 import { bootstrap } from 'zova';
 
 // @ts-ignore ignore
-import { getPluginZovaOptions } from '../../.zova/app/utils.js';
+import { getPluginZovaOptions } from '../../.zova/app/utils.ts';
 
 export default defineBoot(async ({ app }) => {
   // @ts-ignore ignore

package/zova/src/front/config/config/config.ts

@@ -9,7 +9,7 @@ import type { IThemeRecord } from 'zova-module-a-style';
 import { colorizer, combine, errors, splatter, timestamp } from '@cabloy/logger';
 import { formatLoggerConsole, formatLoggerFilter } from 'zova';
 
-import { renderError, renderLoading } from './render.jsx';
+import { renderError, renderLoading } from './render.tsx';
 
 export default function (sys: ZovaSys) {
   const config: ZovaConfigOptional = {};

package/zova/src/front/config/locales.ts

@@ -1,5 +1,5 @@
-import en_us from './locale/en-us.js';
-import zh_cn from './locale/zh-cn.js';
+import en_us from './locale/en-us.ts';
+import zh_cn from './locale/zh-cn.ts';
 
 export const locales = {
   'en-us': en_us,