@vixt/core 0.1.9 → 0.1.11

package/dist/client/App.vue

@@ -0,0 +1,3 @@
+<template>
+  <RouterView />
+</template>

package/dist/client/index.d.mts

@@ -1,7 +1,7 @@
 import { App, Plugin } from 'vue';
 import { Router, RouteRecord } from 'vue-router';
 import { Pinia } from 'pinia';
-import { f as VixtAppConfig } from '../shared/core.accf0e85.mjs';
+import { f as VixtAppConfig } from '../shared/core.a9343bb9.mjs';
 import 'vite';
 import 'c12';
 

package/dist/client/index.d.ts

@@ -1,7 +1,7 @@
 import { App, Plugin } from 'vue';
 import { Router, RouteRecord } from 'vue-router';
 import { Pinia } from 'pinia';
-import { f as VixtAppConfig } from '../shared/core.accf0e85.js';
+import { f as VixtAppConfig } from '../shared/core.a9343bb9.js';
 import 'vite';
 import 'c12';
 

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-import { V as VixtModule, M as ModuleOptions, a as Vixt, b as VixtOptions, c as VixtConfigLayer, d as ModuleDefinition } from './shared/core.accf0e85.mjs';
-export { g as ModuleMeta, P as PluginOptions, f as VixtAppConfig, e as VixtConfigLayerMeta } from './shared/core.accf0e85.mjs';
+import { V as VixtModule, M as ModuleOptions, a as Vixt, b as VixtOptions, c as VixtConfigLayer, d as ModuleDefinition } from './shared/core.a9343bb9.mjs';
+export { g as ModuleMeta, P as PluginOptions, f as VixtAppConfig, e as VixtConfigLayerMeta } from './shared/core.a9343bb9.mjs';
 import { TSConfig } from 'pkg-types';
+import { RawVueCompilerOptions } from '@vue/language-core';
 import Checker from 'vite-plugin-checker';
 import * as c12 from 'c12';
 import { LoadConfigOptions } from 'c12';
@@ -37,6 +38,7 @@ interface AppOptions {
      * @default 'div'
      */
     rootTag?: string;
+    /** inject css files */
     css?: string[];
     /**
      * @default './loading.html'
@@ -59,26 +61,31 @@ interface TypescriptOptions {
         path?: string;
         content?: string;
     })[];
-    tsConfig?: TSConfig;
+    tsConfig?: TSConfig & {
+        vueCompilerOptions?: RawVueCompilerOptions;
+    };
     /** https://github.com/fi3ework/vite-plugin-checker */
     typeCheck?: Parameters<typeof Checker>[0];
+    /**
+     * Generate a `*.vue` shim
+     * @default false
+     */
+    shim?: boolean;
 }
 declare const typescript: VixtModule<TypescriptOptions>;
 
 declare function defineVixtConfig(input: VixtOptions): VixtOptions;
-declare const rootDir: string;
-declare const buildDir = ".vixt";
-declare const buildTypesDir = ".vixt/types";
-declare const buildLayersDir = ".vixt/layers";
 declare function loadVixtConfig(opts?: LoadConfigOptions<VixtOptions>): Promise<c12.ResolvedConfig<VixtOptions, c12.ConfigLayerMeta>>;
-declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
+declare function resolveLayersDirs(layers: VixtConfigLayer[] | undefined, config: VixtOptions): Record<string, string[] | undefined>;
+
+declare function loadEnv(mode?: string, envDir?: string, prefixes?: string | string[]): ImportMeta["env"];
 
 declare function defineVitePlugin<Options = any>(pluginFn: (options?: Options) => PluginOption): (options?: Options) => PluginOption;
 declare function defineVixtModule<T extends ModuleOptions>(definition: ModuleDefinition<T> | VixtModule<T>): VixtModule<T>;
 declare function installModule(module: VixtModule, inlineOptions: any, vixt: Vixt): PluginOption;
-declare function applyLayerModules(layers?: VixtConfigLayer[]): Promise<VixtModule[]>;
+declare function applyLayerModules(layers: VixtConfigLayer[], config: VixtOptions): Promise<VixtModule[]>;
 
 declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
 declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
 
-export { type AppHead, type AppOptions, ModuleDefinition, ModuleOptions, type TypescriptOptions, Vixt, VixtConfigLayer, VixtModule, type VixtOptions, alias, app, applyLayerModules, buildDir, buildLayersDir, buildTypesDir, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, installModule, loadVixt, loadVixtConfig, resolveLayersDirs, rootDir, typescript };
+export { type AppHead, type AppOptions, ModuleDefinition, ModuleOptions, type TypescriptOptions, Vixt, VixtConfigLayer, VixtModule, type VixtOptions, alias, app, applyLayerModules, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, installModule, loadEnv, loadVixt, loadVixtConfig, resolveLayersDirs, typescript };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { V as VixtModule, M as ModuleOptions, a as Vixt, b as VixtOptions, c as VixtConfigLayer, d as ModuleDefinition } from './shared/core.accf0e85.js';
-export { g as ModuleMeta, P as PluginOptions, f as VixtAppConfig, e as VixtConfigLayerMeta } from './shared/core.accf0e85.js';
+import { V as VixtModule, M as ModuleOptions, a as Vixt, b as VixtOptions, c as VixtConfigLayer, d as ModuleDefinition } from './shared/core.a9343bb9.js';
+export { g as ModuleMeta, P as PluginOptions, f as VixtAppConfig, e as VixtConfigLayerMeta } from './shared/core.a9343bb9.js';
 import { TSConfig } from 'pkg-types';
+import { RawVueCompilerOptions } from '@vue/language-core';
 import Checker from 'vite-plugin-checker';
 import * as c12 from 'c12';
 import { LoadConfigOptions } from 'c12';
@@ -37,6 +38,7 @@ interface AppOptions {
      * @default 'div'
      */
     rootTag?: string;
+    /** inject css files */
     css?: string[];
     /**
      * @default './loading.html'
@@ -59,26 +61,31 @@ interface TypescriptOptions {
         path?: string;
         content?: string;
     })[];
-    tsConfig?: TSConfig;
+    tsConfig?: TSConfig & {
+        vueCompilerOptions?: RawVueCompilerOptions;
+    };
     /** https://github.com/fi3ework/vite-plugin-checker */
     typeCheck?: Parameters<typeof Checker>[0];
+    /**
+     * Generate a `*.vue` shim
+     * @default false
+     */
+    shim?: boolean;
 }
 declare const typescript: VixtModule<TypescriptOptions>;
 
 declare function defineVixtConfig(input: VixtOptions): VixtOptions;
-declare const rootDir: string;
-declare const buildDir = ".vixt";
-declare const buildTypesDir = ".vixt/types";
-declare const buildLayersDir = ".vixt/layers";
 declare function loadVixtConfig(opts?: LoadConfigOptions<VixtOptions>): Promise<c12.ResolvedConfig<VixtOptions, c12.ConfigLayerMeta>>;
-declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
+declare function resolveLayersDirs(layers: VixtConfigLayer[] | undefined, config: VixtOptions): Record<string, string[] | undefined>;
+
+declare function loadEnv(mode?: string, envDir?: string, prefixes?: string | string[]): ImportMeta["env"];
 
 declare function defineVitePlugin<Options = any>(pluginFn: (options?: Options) => PluginOption): (options?: Options) => PluginOption;
 declare function defineVixtModule<T extends ModuleOptions>(definition: ModuleDefinition<T> | VixtModule<T>): VixtModule<T>;
 declare function installModule(module: VixtModule, inlineOptions: any, vixt: Vixt): PluginOption;
-declare function applyLayerModules(layers?: VixtConfigLayer[]): Promise<VixtModule[]>;
+declare function applyLayerModules(layers: VixtConfigLayer[], config: VixtOptions): Promise<VixtModule[]>;
 
 declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
 declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
 
-export { type AppHead, type AppOptions, ModuleDefinition, ModuleOptions, type TypescriptOptions, Vixt, VixtConfigLayer, VixtModule, type VixtOptions, alias, app, applyLayerModules, buildDir, buildLayersDir, buildTypesDir, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, installModule, loadVixt, loadVixtConfig, resolveLayersDirs, rootDir, typescript };
+export { type AppHead, type AppOptions, ModuleDefinition, ModuleOptions, type TypescriptOptions, Vixt, VixtConfigLayer, VixtModule, type VixtOptions, alias, app, applyLayerModules, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, installModule, loadEnv, loadVixt, loadVixtConfig, resolveLayersDirs, typescript };

package/dist/index.mjs

@@ -3,27 +3,29 @@ import fs from 'fs-extra';
 import 'tsx/esm';
 import { pathToFileURL } from 'mlly';
 import defu from 'defu';
-import { cwd } from 'node:process';
+import { cwd, env } from 'node:process';
 import { loadConfig } from 'c12';
 import Checker from 'vite-plugin-checker';
+import { cac } from 'cac';
+import { loadEnv as loadEnv$1 } from 'vite';
 
 const name$3 = "vixt:alias";
 const alias = defineVixtModule({
   meta: { name: name$3 },
   setup(_, vixt) {
-    const { rootDir, buildDir } = vixt.options;
+    const { rootDir, buildDir, srcDir } = vixt.options;
     const defaultAlias = {
-      "@": `${path.resolve(rootDir, "src")}`,
-      "~": `${path.resolve(rootDir, "src")}`,
-      "@@": path.resolve(rootDir),
-      "~~": path.resolve(rootDir)
+      "@": srcDir,
+      "~": srcDir,
+      "@@": rootDir,
+      "~~": rootDir
     };
     for (const layer of vixt._layers) {
       if (layer.meta?.alias) {
         defaultAlias[layer.meta.alias] = layer.cwd;
       }
     }
-    defaultAlias["#"] = path.resolve(rootDir, buildDir);
+    defaultAlias["#"] = buildDir;
     return {
       name: name$3,
       config() {
@@ -41,34 +43,43 @@ const alias = defineVixtModule({
 function defineVixtConfig(input) {
   return input;
 }
-const rootDir = path.resolve(cwd());
-const buildDir = ".vixt";
-const buildTypesDir = `${buildDir}/types`;
-const buildLayersDir = `${buildDir}/layers`;
 async function loadVixtConfig(opts) {
+  const rootDir = path.resolve(cwd());
+  const buildDirName = ".vixt";
+  const buildDir = path.resolve(rootDir, buildDirName);
+  const buildTypesDir = path.resolve(buildDir, "types");
+  const buildLayersDir = path.resolve(buildDir, "layers");
+  const buildImportsDir = path.resolve(buildDir, "imports");
+  const srcDirName = "src";
+  const srcDir = path.resolve(rootDir, srcDirName);
   const result = await loadConfig({
     name: "vixt",
     rcFile: false,
     ...opts,
     defaults: {
       rootDir,
+      buildDirName,
       buildDir,
       buildTypesDir,
       buildLayersDir,
+      buildImportsDir,
+      srcDirName,
+      srcDir,
       ...opts?.defaults
     }
   });
-  result.layers = mapLayers(result.layers?.filter((e) => e.cwd) ?? []);
+  result.layers = mapLayers(result.layers?.filter((e) => e.cwd) ?? [], result.config);
   return result;
 }
-function mapLayers(layers) {
+function mapLayers(layers, config) {
+  const { rootDir, buildLayersDir } = config;
   return layers.map((layer) => {
     const meta = layer.config?.meta ?? {};
     const layerName = meta.name || layer.cwd.split("/").pop();
     if (!isSamePath(layer.cwd, path.resolve(rootDir)))
       meta.alias = `#/layers/${layerName}`;
     if (layer.cwd?.includes("node_modules")) {
-      const newCwd = path.resolve(rootDir, buildLayersDir, layerName);
+      const newCwd = path.resolve(buildLayersDir, layerName);
       fs.copySync(layer.cwd, newCwd, {
         filter: (src) => {
           const nodeModulesPath = path.resolve(layer.cwd, "node_modules");
@@ -78,19 +89,19 @@ function mapLayers(layers) {
       });
       layer.cwd = newCwd;
     }
-    meta.relative = path.join(path.relative(`${rootDir}/src`, `${layer.cwd}/src`));
     return { ...layer, meta };
   });
 }
 function isSamePath(a, b) {
   return path.resolve(a) === path.resolve(b);
 }
-function resolveLayersDirs(layers = []) {
+function resolveLayersDirs(layers = [], config) {
+  const { srcDirName } = config;
   const dirs = {};
   for (const layer of layers) {
-    const contents = fs.readdirSync(path.resolve(layer.cwd, "src"));
+    const contents = fs.readdirSync(path.resolve(layer.cwd, srcDirName));
     for (const content of contents) {
-      const fileOrDirPath = path.resolve(layer.cwd, "src", content);
+      const fileOrDirPath = path.resolve(layer.cwd, srcDirName, content);
       if (fs.statSync(fileOrDirPath).isDirectory()) {
         dirs[content] ?? (dirs[content] = []);
         dirs[content].push(fileOrDirPath);
@@ -126,8 +137,8 @@ function defineVixtModule(definition) {
 function installModule(module, inlineOptions, vixt) {
   return module(inlineOptions, vixt);
 }
-async function applyLayerModules(layers) {
-  const { modules: modulesDir = [] } = resolveLayersDirs(layers);
+async function applyLayerModules(layers, config) {
+  const { modules: modulesDir = [] } = resolveLayersDirs(layers, config);
   const modules = [];
   for (const m of modulesDir) {
     if (fs.existsSync(m)) {
@@ -150,16 +161,16 @@ function resolveHeadTag(tag, attrs) {
   return attrs?.children ? `<${tag} ${attrsStr}>${attrs.children}</${tag}>` : `<${tag} ${attrsStr} />`;
 }
 function generateIndexHtml(options, vixt) {
-  const { buildDir, rootDir } = vixt.options;
+  const { buildDir, buildDirName, rootDir } = vixt.options;
   const indexHtmlPath = path.resolve(rootDir, "index.html");
   if (!fs.existsSync(indexHtmlPath))
     fs.outputFileSync(indexHtmlPath, `<!-- Generated by Vixt -->
-<!-- This file transform from '${buildDir}/index.html' -->
+<!-- This file transform from '${buildDirName}/index.html' -->
 `);
   const { head = {}, rootTag, rootId } = options;
   const headTemplate = Object.entries(head).filter(([k]) => k !== "noscript").map(([tag, attrs]) => attrs.map((e) => resolveHeadTag(tag, e))).flat().join("\n");
   const noscriptTemplate = Object.entries(head).filter(([k]) => k === "noscript").map(([tag, attrs]) => attrs.map((e) => resolveHeadTag(tag, e))).flat().join("\n");
-  let { loadingTemplate } = options;
+  let { loadingTemplate = "" } = options;
   if (!loadingTemplate) {
     for (const layer of vixt._layers) {
       const loadingTemplatePath = path.resolve(layer.cwd, "loading.html");
@@ -183,53 +194,96 @@ ${noscriptTemplate}
   </body>
 </html>
 `;
-  fs.outputFileSync(path.resolve(rootDir, `${buildDir}/index.html`), code);
+  fs.outputFileSync(path.resolve(buildDir, "index.html"), code);
   return code;
 }
-function generateMainTs(options, vixt) {
-  const { buildDir, rootDir } = vixt.options;
-  const mainTsPath = path.resolve(rootDir, "src", "main.ts");
-  if (!fs.existsSync(mainTsPath))
-    fs.outputFileSync(mainTsPath, `// Generated by Vixt
-// This file transform from '${buildDir}/main.ts'
-`);
-  const cssTemplate = options?.css?.map((css) => `import '${css}'`).join("\n") ?? "";
-  let appComponentImportTempate = "";
+function generateAppConfig(vixt) {
+  const { buildImportsDir, srcDir, srcDirName } = vixt.options;
   let appConfigsImportTemplate = "";
   let appConfigsMergeTemplate = "";
+  let i = 0;
+  for (const layer of vixt._layers) {
+    const appConfigPath = path.resolve(layer.cwd, srcDirName, "app.config.ts");
+    if (fs.existsSync(appConfigPath)) {
+      const appConfigName = `__app_config_${i}`;
+      appConfigsImportTemplate += `import ${appConfigName} from '${appConfigPath}'
+`;
+      appConfigsMergeTemplate += `${appConfigName}, `;
+      i++;
+    }
+  }
+  const appConfigTemplate = `
+import { defu } from 'defu'
+${appConfigsImportTemplate}
+const appConfig = defu(${appConfigsMergeTemplate}{})
+function useAppConfig() {
+  return appConfig
+} 
+export { useAppConfig }
+`;
+  const mainTsPath = path.resolve(srcDir, "main.ts");
+  fs.outputFileSync(path.resolve(buildImportsDir, `app.config.ts`), `// @ts-nocheck
+export { useAppConfig } from '${mainTsPath}'`);
+  return appConfigTemplate;
+}
+function generatePlugins(vixt) {
+  const { srcDirName } = vixt.options;
   let pluginsImportTemplate = "";
   let pluginsMergeTemplate = "";
-  vixt._layers.forEach((layer, i) => {
-    const appComponentPath = path.resolve(layer.cwd, "src", "App.vue");
-    if (fs.existsSync(appComponentPath) && !appComponentImportTempate) {
-      const appComponentRelativePath = `./${path.join(layer.meta.relative, "App.vue")}`;
-      appComponentImportTempate = `import App from '${appComponentRelativePath}'`;
-    }
-    const appConfigPath = `./${path.join(layer.meta.relative, "app.config.ts")}`;
-    const appConfigsName = `__app_config__${i}`;
-    appConfigsImportTemplate += `const ${appConfigsName} = Object.values(import.meta.glob('${appConfigPath}', { import: 'default', eager: true }))[0]
+  let i = 0;
+  for (const layer of [...vixt._layers].reverse()) {
+    const pluginsDir = path.resolve(layer.cwd, srcDirName, "plugins");
+    const files = fs.existsSync(pluginsDir) ? fs.readdirSync(pluginsDir) : [];
+    for (const f of files) {
+      const p = path.resolve(pluginsDir, f);
+      const pluginName = `__plugin_${i}`;
+      pluginsImportTemplate += `import ${pluginName} from '${p}'
 `;
-    appConfigsMergeTemplate += `${appConfigsName}, `;
-    const pluginsPath = `./${path.join(layer.meta.relative, "plugins/*.ts")}`;
-    const pluginsName = `__plugins__${i}`;
-    pluginsImportTemplate += `const ${pluginsName} = Object.values(import.meta.glob('${pluginsPath}', { import: 'default', eager: true }))
+      pluginsMergeTemplate += `${pluginName}, `;
+      i++;
+    }
+  }
+  const pluginsTemplate = `
+${pluginsImportTemplate}
+const plugins = [${pluginsMergeTemplate}]
+function usePlugins(options) {
+  for (const plugin of plugins) {
+    typeof plugin === 'function' && plugin(options)
+  }
+}
 `;
-    pluginsMergeTemplate += `...${pluginsName}, `;
-  });
+  return pluginsTemplate;
+}
+function getAppComponentPath(vixt) {
+  const { srcDirName } = vixt.options;
+  for (const layer of vixt._layers) {
+    const appComponentPath = path.resolve(layer.cwd, srcDirName, "App.vue");
+    if (fs.existsSync(appComponentPath))
+      return appComponentPath;
+  }
+}
+function generateMainTs(options, vixt) {
+  const { buildDir, buildDirName, srcDir } = vixt.options;
+  const mainTsPath = path.resolve(srcDir, "main.ts");
+  if (!fs.existsSync(mainTsPath))
+    fs.outputFileSync(mainTsPath, `// Generated by Vixt
+// This file transform from '${buildDirName}/main.ts'
+`);
+  const appComponentPath = getAppComponentPath(vixt) || "@vixt/core/client/App.vue";
+  const appComponentTemplate = `import App from '${appComponentPath}'`;
+  const cssTemplate = options?.css?.map((css) => `import '${css}'`).join("\n") ?? "";
+  const appConfigTemplate = generateAppConfig(vixt);
+  const pluginsTemplate = generatePlugins(vixt);
   let code = `// Generated by Vixt
 // This file transform to 'src/main.ts'
 // @ts-nocheck
-${appComponentImportTempate}
+${appComponentTemplate}
 ${cssTemplate}
-import { defu } from 'defu'
-
-${appConfigsImportTemplate}
-${pluginsImportTemplate}
-const appConfig = defu(${appConfigsMergeTemplate}{})
-const plugins = [${pluginsMergeTemplate}].reverse()
+${appConfigTemplate}
+${pluginsTemplate}
 `;
   code = options.transformMain?.(code, vixt) || code;
-  fs.outputFileSync(path.resolve(rootDir, buildDir, "main.ts"), code);
+  fs.outputFileSync(path.resolve(buildDir, "main.ts"), code);
   return code;
 }
 const name$2 = "vixt:app";
@@ -241,9 +295,8 @@ const defaults$1 = {
   head: {
     meta: [
       { charset: "utf-8" },
-      { name: "viewport", content: "width=device-width, initial-scale=1.0" }
-    ],
-    noscript: [{ children: "This website requires JavaScript to function properly. Please enable JavaScript to continue." }]
+      { name: "viewport", content: "width=device-width, initial-scale=1" }
+    ]
   }
 };
 const app = defineVixtModule({
@@ -252,6 +305,7 @@ const app = defineVixtModule({
   setup(options, vixt) {
     let indexHtmlCode;
     let mainTsCode;
+    const mainTsPath = path.resolve(vixt.options.srcDir, "main.ts");
     return {
       name: name$2,
       configResolved() {
@@ -267,7 +321,7 @@ const app = defineVixtModule({
       transform: {
         order: "pre",
         handler(_, id) {
-          if (!id.includes("/src/main.ts"))
+          if (id !== mainTsPath)
             return;
           return mainTsCode;
         }
@@ -291,14 +345,14 @@ const config = defineVixtModule({
 });
 
 function generateTsConfig(options, vixt) {
-  const { buildDir, rootDir } = vixt.options;
-  const codePath = path.resolve(rootDir, buildDir, "tsconfig.json");
+  const { buildDir } = vixt.options;
+  const codePath = path.resolve(buildDir, "tsconfig.json");
   const layersDirs = [];
   const layersAlias = {};
   for (const layer of vixt._layers) {
     layersDirs.push(layer.cwd);
     if (layer.meta?.alias) {
-      const layerRelativePath = `./${path.relative(path.resolve(rootDir, buildDir), layer.cwd)}/*`;
+      const layerRelativePath = `./${path.relative(buildDir, layer.cwd)}/*`;
       layersAlias[`${layer.meta.alias}/*`] = [layerRelativePath];
     }
   }
@@ -307,13 +361,13 @@ function generateTsConfig(options, vixt) {
   fs.outputFileSync(codePath, code);
 }
 function generateVixtDts(options, vixt) {
-  const { buildDir, rootDir } = vixt.options;
-  const codePath = path.resolve(rootDir, buildDir, "vixt.d.ts");
+  const { buildDir } = vixt.options;
+  const codePath = path.resolve(buildDir, "vixt.d.ts");
   const code = options.references?.map((reference) => {
     if (typeof reference === "string") {
       return `/// <reference path="${reference}" />`;
     } else if (typeof reference === "object" && reference.path && reference.content) {
-      fs.outputFileSync(path.resolve(rootDir, buildDir), reference.content ?? "");
+      fs.outputFileSync(path.resolve(buildDir, reference.path), reference.content);
       return `/// <reference path="${reference.path}" />`;
     } else {
       return "";
@@ -322,8 +376,10 @@ function generateVixtDts(options, vixt) {
   if (code)
     fs.outputFileSync(codePath, code);
 }
-function genarateShims(options, vixt) {
-  const { buildTypesDir, rootDir } = vixt.options;
+function genarateShim(options, vixt) {
+  if (!options.shim)
+    return;
+  const { buildTypesDir } = vixt.options;
   const code = `
 declare module '*.vue' {
   import type { DefineComponent } from 'vue'
@@ -332,12 +388,12 @@ declare module '*.vue' {
   export default component
 }
 `;
-  const codePath = path.resolve(rootDir, buildTypesDir, "shims.d.ts");
+  const codePath = path.resolve(buildTypesDir, "vue-shim.d.ts");
   fs.outputFileSync(codePath, code);
 }
 function genarateGlobalComponents(options, vixt) {
-  const { buildTypesDir, rootDir } = vixt.options;
-  const codePath = path.resolve(rootDir, buildTypesDir, "global-components.d.ts");
+  const { buildTypesDir } = vixt.options;
+  const codePath = path.resolve(buildTypesDir, "global-components.d.ts");
   const code = `
 import type { GlobalComponents as _GlobalComponents } from '@vue/runtime-core'
 
@@ -348,8 +404,8 @@ declare module 'vue'{
   fs.outputFileSync(codePath, code);
 }
 function generateEnvDts(env, vixt) {
-  const { buildTypesDir, rootDir } = vixt.options;
-  const codePath = path.resolve(rootDir, buildTypesDir, "vite-env.d.ts");
+  const { buildTypesDir } = vixt.options;
+  const codePath = path.resolve(buildTypesDir, "vite-env.d.ts");
   const values = Object.entries(env).map(([key, value]) => `/** ${key}=${value} */
   ${key}: ${typeof value}`).join("\n  ");
   const code = `interface ImportMeta {
@@ -389,7 +445,7 @@ const typescript = defineVixtModule({
         configResolved(config) {
           generateTsConfig(options, vixt);
           generateVixtDts(options, vixt);
-          genarateShims(options, vixt);
+          genarateShim(options, vixt);
           genarateGlobalComponents(options, vixt);
           generateEnvDts(config.env, vixt);
         }
@@ -399,13 +455,24 @@ const typescript = defineVixtModule({
   }
 });
 
+function loadEnv(mode, envDir, prefixes) {
+  const parsedArgv = cac().parse();
+  mode = mode || parsedArgv.options.mode || parsedArgv.options.m || env.NODE_ENV;
+  return {
+    MODE: mode,
+    DEV: env.NODE_ENV !== "production",
+    PROD: env.NODE_ENV === "production",
+    ...loadEnv$1(mode, envDir || cwd(), prefixes)
+  };
+}
+
 async function loadVixt(opts) {
   const result = await loadVixtConfig(defu(opts, {
     defaults: {
       modules: [alias, app, config, typescript]
     }
   }));
-  const layerModules = await applyLayerModules(result.layers);
+  const layerModules = await applyLayerModules(result.layers ?? [], result.config);
   const vixt = {
     options: result.config,
     _layers: result.layers ?? [],
@@ -421,4 +488,4 @@ function createVixtPlugin(loadOptions) {
   });
 }
 
-export { alias, app, applyLayerModules, buildDir, buildLayersDir, buildTypesDir, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, installModule, loadVixt, loadVixtConfig, resolveLayersDirs, rootDir, typescript };
+export { alias, app, applyLayerModules, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, installModule, loadEnv, loadVixt, loadVixtConfig, resolveLayersDirs, typescript };

package/dist/shared/{core.accf0e85.d.mts → core.a9343bb9.d.mts}

@@ -29,6 +29,10 @@ interface VixtOptions extends Record<string, any> {
      * @default process.cwd()
      */
     rootDir?: string;
+    /**
+     * @default '.vixt'
+     */
+    buildDirName?: string;
     /**
      * @default '<rootDir>/.vixt'
      */
@@ -41,6 +45,14 @@ interface VixtOptions extends Record<string, any> {
      * @default '<buildDir>/layers'
      */
     buildLayersDir?: string;
+    /**
+     * @default '<buildDir>/imports'
+     */
+    buildImportsDir?: string;
+    /**
+     * @default 'src'
+     */
+    srcDirName?: string;
     /**
      * @default '<rootDir>/src'
      */
@@ -58,11 +70,9 @@ interface VixtConfigLayerMeta extends ConfigLayerMeta {
     name?: string;
     /** layer alias */
     alias?: string;
-    /** relative path from `<layer.cwd>/src` to `<rootDir>/src` */
-    relative?: string;
 }
 interface VixtConfigLayer extends ConfigLayer<VixtOptions, VixtConfigLayerMeta> {
-    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, change cwd */
+    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, and change cwd */
     cwd?: string;
 }
 interface VixtAppConfig extends Record<string, any> {

package/dist/shared/{core.accf0e85.d.ts → core.a9343bb9.d.ts}

@@ -29,6 +29,10 @@ interface VixtOptions extends Record<string, any> {
      * @default process.cwd()
      */
     rootDir?: string;
+    /**
+     * @default '.vixt'
+     */
+    buildDirName?: string;
     /**
      * @default '<rootDir>/.vixt'
      */
@@ -41,6 +45,14 @@ interface VixtOptions extends Record<string, any> {
      * @default '<buildDir>/layers'
      */
     buildLayersDir?: string;
+    /**
+     * @default '<buildDir>/imports'
+     */
+    buildImportsDir?: string;
+    /**
+     * @default 'src'
+     */
+    srcDirName?: string;
     /**
      * @default '<rootDir>/src'
      */
@@ -58,11 +70,9 @@ interface VixtConfigLayerMeta extends ConfigLayerMeta {
     name?: string;
     /** layer alias */
     alias?: string;
-    /** relative path from `<layer.cwd>/src` to `<rootDir>/src` */
-    relative?: string;
 }
 interface VixtConfigLayer extends ConfigLayer<VixtOptions, VixtConfigLayerMeta> {
-    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, change cwd */
+    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, and change cwd */
     cwd?: string;
 }
 interface VixtAppConfig extends Record<string, any> {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vixt/core",
   "type": "module",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "author": "SoulLyoko<https://github.com/SoulLyoko>",
   "license": "MIT",
   "homepage": "https://github.com/SoulLyoko/vixt#readme",
@@ -14,6 +14,9 @@
     "./client": {
       "types": "./dist/client/index.d.ts",
       "import": "./dist/client/index.mjs"
+    },
+    "./client/App.vue": {
+      "import": "./dist/client/App.vue"
     }
   },
   "main": "dist/index.mjs",
@@ -25,13 +28,14 @@
     "@types/fs-extra": "11.0.4",
     "@vue/tsconfig": "^0.5.1",
     "c12": "^1.11.1",
+    "cac": "^6.7.14",
     "defu": "^6.1.4",
     "fs-extra": "^11.2.0",
     "mlly": "1.7.1",
     "pathe": "^1.1.2",
     "pkg-types": "^1.1.3",
-    "tsx": "^4.16.5",
-    "vite": "^5.3.5",
+    "tsx": "^4.17.0",
+    "vite": "^5.4.1",
     "vite-plugin-checker": "^0.7.2",
     "vue-tsc": "2.0.26"
   },