@vixt/core 0.0.15 → 0.1.1

package/dist/client/index.d.mts

@@ -0,0 +1,29 @@
+import { App, Plugin } from 'vue';
+import { Router, RouteRecord } from 'vue-router';
+import { Pinia } from 'pinia';
+import { f as VixtAppConfig } from '../shared/core.66c5bb58.mjs';
+import 'vite';
+import 'c12';
+
+interface VixtApp {
+    app: App;
+    router: Router;
+    routes: RouteRecord[];
+    pinia: Pinia;
+    appConfig: VixtAppConfig;
+}
+
+interface PluginDefinition {
+    name?: string;
+    setup?: (this: void, vixt: VixtApp) => any;
+}
+interface VixtPlugin {
+    (this: void, vixt: VixtApp): any;
+}
+
+declare function defineAppConfig(config: VixtAppConfig): VixtAppConfig;
+
+declare function defineVuePlugin<Options = any[]>(plugin: Plugin<Options>): Plugin<Options>;
+declare function defineVixtPlugin(definition: PluginDefinition | VixtPlugin): VixtPlugin;
+
+export { type PluginDefinition, type VixtApp, VixtAppConfig, type VixtPlugin, defineAppConfig, defineVixtPlugin, defineVuePlugin };

package/dist/client/index.d.ts

@@ -0,0 +1,29 @@
+import { App, Plugin } from 'vue';
+import { Router, RouteRecord } from 'vue-router';
+import { Pinia } from 'pinia';
+import { f as VixtAppConfig } from '../shared/core.66c5bb58.js';
+import 'vite';
+import 'c12';
+
+interface VixtApp {
+    app: App;
+    router: Router;
+    routes: RouteRecord[];
+    pinia: Pinia;
+    appConfig: VixtAppConfig;
+}
+
+interface PluginDefinition {
+    name?: string;
+    setup?: (this: void, vixt: VixtApp) => any;
+}
+interface VixtPlugin {
+    (this: void, vixt: VixtApp): any;
+}
+
+declare function defineAppConfig(config: VixtAppConfig): VixtAppConfig;
+
+declare function defineVuePlugin<Options = any[]>(plugin: Plugin<Options>): Plugin<Options>;
+declare function defineVixtPlugin(definition: PluginDefinition | VixtPlugin): VixtPlugin;
+
+export { type PluginDefinition, type VixtApp, VixtAppConfig, type VixtPlugin, defineAppConfig, defineVixtPlugin, defineVuePlugin };

package/dist/client/index.mjs

@@ -0,0 +1,14 @@
+function defineAppConfig(config) {
+  return config;
+}
+
+function defineVuePlugin(plugin) {
+  return plugin;
+}
+function defineVixtPlugin(definition) {
+  if (typeof definition == "function")
+    return defineVixtPlugin({ setup: definition });
+  return (vixt) => definition.setup?.(vixt);
+}
+
+export { defineAppConfig, defineVixtPlugin, defineVuePlugin };

package/dist/index.d.mts

@@ -1,66 +1,14 @@
-import * as vite from 'vite';
-import { PluginOption, ResolvedConfig, TransformResult } from 'vite';
-import * as c12 from 'c12';
-import { ConfigLayer, LoadConfigOptions } from 'c12';
+import { V as VixtModule, M as ModuleOptions, a as Vixt, b as VixtOptions, c as VixtConfigLayer, d as ModuleDefinition } from './shared/core.66c5bb58.mjs';
+export { g as ModuleMeta, P as PluginOptions, f as VixtAppConfig, e as VixtConfigLayerMeta } from './shared/core.66c5bb58.mjs';
 import { TSConfig } from 'pkg-types';
 import Checker from 'vite-plugin-checker';
+import * as c12 from 'c12';
+import { LoadConfigOptions } from 'c12';
+import * as vite from 'vite';
+import { PluginOption } from 'vite';
 
 declare const alias: VixtModule<ModuleOptions>;
 
-interface Vixt {
-    options: VixtOptions;
-    _layers: VixtConfigLayer[];
-    _modules: VixtModule[];
-}
-
-type PluginOptions<Options = any> = (Options extends (...args: any[]) => any ? Parameters<Options>[0] : Options);
-type ModuleOptions = Record<string, any>;
-interface ModuleMeta extends Record<string, any> {
-    name?: string;
-    configKey?: string;
-}
-interface ModuleDefinition<T extends ModuleOptions = ModuleOptions> {
-    meta?: ModuleMeta;
-    defaults?: T | ((vixt: Vixt) => T);
-    setup?: (this: void, resolvedOptions: T, vixt: Vixt) => PluginOption;
-}
-interface VixtModule<T extends ModuleOptions = ModuleOptions> {
-    (this: void, inlineOptions: T, vixt: Vixt): PluginOption;
-    getOptions?: (inlineOptions?: T, Vixt?: Vixt) => T;
-    getMeta?: () => ModuleMeta;
-}
-
-interface VixtOptions extends Record<string, any> {
-    /**
-     * @default process.cwd()
-     */
-    rootDir?: string;
-    /**
-     * @default '.vixt'
-     */
-    buildDir?: string;
-    /**
-     * @default '.vixt/types'
-     */
-    buildTypesDir?: string;
-    /**
-     * @default '.vixt/layers'
-     */
-    buildLayersDir?: string;
-    /** layers */
-    extends?: string[];
-    /** modules */
-    modules?: VixtModule[];
-    /** use on configResolved */
-    vite?: ResolvedConfig;
-}
-interface VixtConfigLayer extends ConfigLayer<VixtOptions> {
-    /** layer path before copy */
-    relatedCwd?: string;
-    /** layer path after copy to buildLayersDir */
-    cwd?: string;
-}
-
 declare module '@vixt/core' {
     interface VixtOptions {
         app?: AppOptions;
@@ -89,11 +37,10 @@ interface AppOptions {
      * @default 'div'
      */
     rootTag?: string;
-    /**
-     * @default '<buildDir>/main.ts'
-     */
+    /** content of main.ts  */
     main?: string;
-    transformMain?: (vixt: Vixt) => Promise<TransformResult | string | null | void> | TransformResult | string | null | void;
+    /** transform main.ts */
+    transformMain?: (code: string, vixt: Vixt) => string | undefined;
     css?: string[];
     /**
      * @default './loading.html'
@@ -136,4 +83,4 @@ declare function applyLayerModules(layers?: VixtConfigLayer[]): Promise<VixtModu
 declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
 declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
 
-export { type AppHead, type AppOptions, type ModuleDefinition, type ModuleMeta, type ModuleOptions, type PluginOptions, type TypescriptOptions, type Vixt, type VixtConfigLayer, type 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, buildDir, buildLayersDir, buildTypesDir, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, installModule, loadVixt, loadVixtConfig, resolveLayersDirs, rootDir, typescript };

package/dist/index.d.ts

@@ -1,66 +1,14 @@
-import * as vite from 'vite';
-import { PluginOption, ResolvedConfig, TransformResult } from 'vite';
-import * as c12 from 'c12';
-import { ConfigLayer, LoadConfigOptions } from 'c12';
+import { V as VixtModule, M as ModuleOptions, a as Vixt, b as VixtOptions, c as VixtConfigLayer, d as ModuleDefinition } from './shared/core.66c5bb58.js';
+export { g as ModuleMeta, P as PluginOptions, f as VixtAppConfig, e as VixtConfigLayerMeta } from './shared/core.66c5bb58.js';
 import { TSConfig } from 'pkg-types';
 import Checker from 'vite-plugin-checker';
+import * as c12 from 'c12';
+import { LoadConfigOptions } from 'c12';
+import * as vite from 'vite';
+import { PluginOption } from 'vite';
 
 declare const alias: VixtModule<ModuleOptions>;
 
-interface Vixt {
-    options: VixtOptions;
-    _layers: VixtConfigLayer[];
-    _modules: VixtModule[];
-}
-
-type PluginOptions<Options = any> = (Options extends (...args: any[]) => any ? Parameters<Options>[0] : Options);
-type ModuleOptions = Record<string, any>;
-interface ModuleMeta extends Record<string, any> {
-    name?: string;
-    configKey?: string;
-}
-interface ModuleDefinition<T extends ModuleOptions = ModuleOptions> {
-    meta?: ModuleMeta;
-    defaults?: T | ((vixt: Vixt) => T);
-    setup?: (this: void, resolvedOptions: T, vixt: Vixt) => PluginOption;
-}
-interface VixtModule<T extends ModuleOptions = ModuleOptions> {
-    (this: void, inlineOptions: T, vixt: Vixt): PluginOption;
-    getOptions?: (inlineOptions?: T, Vixt?: Vixt) => T;
-    getMeta?: () => ModuleMeta;
-}
-
-interface VixtOptions extends Record<string, any> {
-    /**
-     * @default process.cwd()
-     */
-    rootDir?: string;
-    /**
-     * @default '.vixt'
-     */
-    buildDir?: string;
-    /**
-     * @default '.vixt/types'
-     */
-    buildTypesDir?: string;
-    /**
-     * @default '.vixt/layers'
-     */
-    buildLayersDir?: string;
-    /** layers */
-    extends?: string[];
-    /** modules */
-    modules?: VixtModule[];
-    /** use on configResolved */
-    vite?: ResolvedConfig;
-}
-interface VixtConfigLayer extends ConfigLayer<VixtOptions> {
-    /** layer path before copy */
-    relatedCwd?: string;
-    /** layer path after copy to buildLayersDir */
-    cwd?: string;
-}
-
 declare module '@vixt/core' {
     interface VixtOptions {
         app?: AppOptions;
@@ -89,11 +37,10 @@ interface AppOptions {
      * @default 'div'
      */
     rootTag?: string;
-    /**
-     * @default '<buildDir>/main.ts'
-     */
+    /** content of main.ts  */
     main?: string;
-    transformMain?: (vixt: Vixt) => Promise<TransformResult | string | null | void> | TransformResult | string | null | void;
+    /** transform main.ts */
+    transformMain?: (code: string, vixt: Vixt) => string | undefined;
     css?: string[];
     /**
      * @default './loading.html'
@@ -136,4 +83,4 @@ declare function applyLayerModules(layers?: VixtConfigLayer[]): Promise<VixtModu
 declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
 declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
 
-export { type AppHead, type AppOptions, type ModuleDefinition, type ModuleMeta, type ModuleOptions, type PluginOptions, type TypescriptOptions, type Vixt, type VixtConfigLayer, type 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, buildDir, buildLayersDir, buildTypesDir, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, installModule, loadVixt, loadVixtConfig, resolveLayersDirs, rootDir, typescript };

package/dist/index.mjs

@@ -1,9 +1,9 @@
 import path from 'pathe';
-import { cwd } from 'node:process';
 import fs from 'fs-extra';
 import 'tsx/esm';
 import { pathToFileURL } from 'mlly';
 import defu from 'defu';
+import { cwd } from 'node:process';
 import { loadConfig } from 'c12';
 import Checker from 'vite-plugin-checker';
 
@@ -12,19 +12,25 @@ const alias = defineVixtModule({
   meta: { name: name$3 },
   setup(_, vixt) {
     const { rootDir, buildDir } = vixt.options;
+    const defaultAlias = {
+      "@": `${path.resolve(rootDir, "src")}`,
+      "~": `${path.resolve(rootDir, "src")}`,
+      "@@": path.resolve(rootDir),
+      "~~": path.resolve(rootDir)
+    };
+    for (const layer of vixt._layers) {
+      if (layer.meta?.alias) {
+        defaultAlias[layer.meta.alias] = layer.cwd;
+      }
+    }
+    defaultAlias["#"] = path.resolve(rootDir, buildDir);
     return {
       name: name$3,
       config() {
         return {
           root: rootDir,
           resolve: {
-            alias: {
-              "@": `${path.resolve(rootDir, "src")}`,
-              "~": `${path.resolve(rootDir, "src")}`,
-              "@@": path.resolve(rootDir),
-              "~~": path.resolve(rootDir),
-              "#": path.resolve(rootDir, buildDir)
-            }
+            alias: defaultAlias
           }
         };
       }
@@ -52,20 +58,29 @@ async function loadVixtConfig(opts) {
       ...opts?.defaults
     }
   });
-  result.layers = result.layers?.filter((e) => e.cwd).map((e) => {
-    if (e.cwd !== rootDir) {
-      const layerRootDir = e.cwd.split("/").pop();
-      const newCwd = path.resolve(rootDir, buildLayersDir, layerRootDir);
-      fs.copySync(e.cwd, newCwd, { filter: (src) => {
-        const nodeModulesPath = path.resolve(e.cwd, "node_modules");
-        const tsConfigPath = path.resolve(e.cwd, "tsconfig.json");
-        return !isSamePath(src, nodeModulesPath) && !isSamePath(src, tsConfigPath);
-      } });
-      return { ...e, relatedCwd: e.cwd, cwd: newCwd };
+  result.layers = mapLayers(result.layers?.filter((e) => e.cwd) ?? []);
+  return result;
+}
+function mapLayers(layers) {
+  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);
+      fs.copySync(layer.cwd, newCwd, {
+        filter: (src) => {
+          const nodeModulesPath = path.resolve(layer.cwd, "node_modules");
+          const tsConfigPath = path.resolve(layer.cwd, "tsconfig.json");
+          return !isSamePath(src, nodeModulesPath) && !isSamePath(src, tsConfigPath);
+        }
+      });
+      layer.cwd = newCwd;
     }
-    return e;
+    meta.relative = path.join(path.relative(`${rootDir}/src`, `${layer.cwd}/src`));
+    return { ...layer, meta };
   });
-  return result;
 }
 function isSamePath(a, b) {
   return path.resolve(a) === path.resolve(b);
@@ -132,21 +147,24 @@ function resolveHeadTag(tag, attrs) {
   return attrs?.children ? `<${tag} ${attrsStr}>${attrs.children}</${tag}>` : `<${tag} ${attrsStr} />`;
 }
 function generateIndexHtml(options, vixt) {
-  const { buildDir: buildDir2, rootDir } = vixt.options;
-  const { head = {}, rootTag, rootId, main, loadingTemplate: loading = "" } = options || {};
+  const { buildDir, rootDir } = vixt.options;
+  fs.outputFileSync(path.resolve(rootDir, "index.html"), `<!-- Generated by Vixt -->
+<!-- This file transform from '${buildDir}/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 = "";
-  if (/^\.|\//.test(loading)) {
-    const loadingTemplatePath = path.resolve(rootDir, loading);
-    if (fs.existsSync(loadingTemplatePath)) {
-      loadingTemplate = fs.readFileSync(loadingTemplatePath, "utf-8");
+  let { loadingTemplate } = options;
+  if (!loadingTemplate) {
+    for (const layer of vixt._layers) {
+      const loadingTemplatePath = path.resolve(layer.cwd, "loading.html");
+      if (fs.existsSync(loadingTemplatePath)) {
+        loadingTemplate = fs.readFileSync(loadingTemplatePath, "utf-8");
+        break;
+      }
     }
-  } else if (loading) {
-    loadingTemplate = loading;
   }
-  const code = `
-<!doctype html>
+  const code = `<!DOCTYPE html>
 <html>
   <head>
 ${headTemplate}
@@ -155,12 +173,56 @@ ${headTemplate}
     <${rootTag} id="${rootId}">
 ${loadingTemplate}
     </${rootTag}>
-    <script type="module" src="${main}"><\/script>
+    <script type="module" src="/src/main.ts"><\/script>
 ${noscriptTemplate}
   </body>
 </html>
 `;
-  fs.outputFileSync(path.resolve(rootDir, `${buildDir2}/index.html`), code);
+  fs.outputFileSync(path.resolve(rootDir, `${buildDir}/index.html`), code);
+  return code;
+}
+function generateMainTs(options, vixt) {
+  const { buildDir, rootDir } = vixt.options;
+  fs.outputFileSync(path.resolve(rootDir, "src", "main.ts"), `// Generated by Vixt
+// This file transform from '${buildDir}/main.ts'
+`);
+  const cssTemplate = options?.css?.map((css) => `import '${css}'`).reverse().join("\n");
+  let appComponentImportTempate = "";
+  let appConfigsImportTemplate = "";
+  let appConfigsMergeTemplate = "";
+  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]
+`;
+    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 += `...${pluginsName}, `;
+  });
+  let code = `// Generated by Vixt
+// This file transform to 'src/main.ts'
+// @ts-nocheck
+${appComponentImportTempate}
+${cssTemplate}
+import { defu } from 'defu'
+
+${appConfigsImportTemplate}
+${pluginsImportTemplate}
+const appConfig = defu(${appConfigsMergeTemplate}{})
+const plugins = [${pluginsMergeTemplate}].reverse()
+`;
+  code = options.transformMain?.(code, vixt) || code;
+  fs.outputFileSync(path.resolve(rootDir, buildDir, "main.ts"), code);
   return code;
 }
 const name$2 = "vixt:app";
@@ -168,8 +230,6 @@ const defaults$1 = {
   rootId: "app",
   rootTag: "div",
   baseURL: "/",
-  loadingTemplate: "./loading.html",
-  main: `${buildDir}/main.ts`,
   head: {
     meta: [
       { charset: "utf-8" },
@@ -182,22 +242,22 @@ const app = defineVixtModule({
   meta: { name: name$2, configKey: "app" },
   defaults: defaults$1,
   setup(options, vixt) {
-    generateIndexHtml(options, vixt);
+    const indexHtmlCode = generateIndexHtml(options, vixt);
+    const mainTsCode = generateMainTs(options, vixt);
     return {
       name: name$2,
       transformIndexHtml: {
         order: "pre",
         handler() {
-          const { buildDir: buildDir2 } = vixt.options;
-          return fs.readFileSync(path.resolve(cwd(), `${buildDir2}/index.html`), { encoding: "utf-8" });
+          return indexHtmlCode;
         }
       },
       transform: {
         order: "pre",
         handler(code, id) {
-          if (!id.includes(options.main))
+          if (!id.includes("/src/main.ts"))
             return;
-          return options.transformMain?.(vixt);
+          return mainTsCode;
         }
       }
     };
@@ -218,6 +278,21 @@ const config = defineVixtModule({
   }
 });
 
+function generateTsConfig(options, vixt) {
+  const { buildDir, rootDir } = vixt.options;
+  const codePath = path.resolve(rootDir, buildDir, "tsconfig.json");
+  const layersDirs = [];
+  const layersAlias = {};
+  for (const layer of vixt._layers) {
+    layersDirs.push(layer.cwd);
+    if (layer.meta?.alias) {
+      layersAlias[`${layer.meta.alias}/*`] = [`${path.relative(path.resolve(rootDir, buildDir), layer.cwd)}/*`];
+    }
+  }
+  const tsConfig = defu(options.tsConfig, { compilerOptions: { paths: layersAlias }, include: layersDirs });
+  const code = JSON.stringify(tsConfig, null, 2);
+  fs.outputFileSync(codePath, code);
+}
 function generateVixtDts(options, vixt) {
   const { buildDir, rootDir } = vixt.options;
   const codePath = path.resolve(rootDir, buildDir, "vixt.d.ts");
@@ -231,29 +306,8 @@ function generateVixtDts(options, vixt) {
       return "";
     }
   }).concat("export {}").join("\n");
-  code && fs.outputFileSync(codePath, code);
-}
-function generateTsConfig(options, vixt) {
-  const { buildDir, rootDir } = vixt.options;
-  const codePath = path.resolve(rootDir, buildDir, "tsconfig.json");
-  const layersDirs = vixt._layers.map((e) => [e.cwd, e.relatedCwd]).flat().filter((e) => e);
-  const tsConfig = defu(options.tsConfig, { include: layersDirs });
-  const code = JSON.stringify(tsConfig, null, 2);
-  fs.outputFileSync(codePath, code);
-}
-function generateEnvDts(options, vixt, env) {
-  const { buildTypesDir, rootDir } = vixt.options;
-  const codePath = path.resolve(rootDir, buildTypesDir, "vite-env.d.ts");
-  const values = Object.entries(env).map(([key, value]) => `/** ${key}=${value} */
-  ${key}: ${typeof value}`).join("\n  ");
-  const code = `interface ImportMeta {
-  readonly env: ImportMetaEnv
-}
-interface ImportMetaEnv {
-  ${values}
-}
-`;
-  fs.outputFileSync(codePath, code);
+  if (code)
+    fs.outputFileSync(codePath, code);
 }
 function genarateShims(options, vixt) {
   const { buildTypesDir, rootDir } = vixt.options;
@@ -280,6 +334,20 @@ 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 values = Object.entries(env).map(([key, value]) => `/** ${key}=${value} */
+  ${key}: ${typeof value}`).join("\n  ");
+  const code = `interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+interface ImportMetaEnv {
+  ${values}
+}
+`;
+  fs.outputFileSync(codePath, code);
+}
 const name = "vixt:typescript";
 const defaults = {
   // references: ['types/vite-env.d.ts', 'types/shims.d.ts', 'types/global-components.d.ts'],
@@ -287,11 +355,8 @@ const defaults = {
     extends: "@vue/tsconfig/tsconfig.dom.json",
     compilerOptions: {
       paths: {
-        "@": ["../src"],
         "@/*": ["../src/*"],
-        "~": ["../src"],
         "~/*": ["../src/*"],
-        "#": ["."],
         "#/*": ["./*"]
       },
       types: ["vite/client"]
@@ -306,15 +371,15 @@ const typescript = defineVixtModule({
   meta: { name, configKey: "typescript" },
   defaults,
   setup(options, vixt) {
+    generateTsConfig(options, vixt);
+    generateVixtDts(options, vixt);
+    genarateShims(options, vixt);
+    genarateGlobalComponents(options, vixt);
     return [
       {
         name,
         configResolved(config) {
-          generateVixtDts(options, vixt);
-          generateTsConfig(options, vixt);
-          generateEnvDts(options, vixt, config.env);
-          genarateShims(options, vixt);
-          genarateGlobalComponents(options, vixt);
+          generateEnvDts(config.env, vixt);
         }
       },
       Checker(options.typeCheck ?? {})

package/dist/shared/core.66c5bb58.d.mts

@@ -0,0 +1,67 @@
+import { PluginOption, ResolvedConfig } from 'vite';
+import { ConfigLayerMeta, ConfigLayer } from 'c12';
+
+interface Vixt {
+    options: VixtOptions;
+    _layers: VixtConfigLayer[];
+    _modules: VixtModule[];
+}
+
+type PluginOptions<Options = any> = (Options extends (...args: any[]) => any ? Parameters<Options>[0] : Options);
+type ModuleOptions = Record<string, any>;
+interface ModuleMeta extends Record<string, any> {
+    name?: string;
+    configKey?: string;
+}
+interface ModuleDefinition<T extends ModuleOptions = ModuleOptions> {
+    meta?: ModuleMeta;
+    defaults?: T | ((vixt: Vixt) => T);
+    setup?: (this: void, resolvedOptions: T, vixt: Vixt) => PluginOption;
+}
+interface VixtModule<T extends ModuleOptions = ModuleOptions> {
+    (this: void, inlineOptions: T, vixt: Vixt): PluginOption;
+    getOptions?: (inlineOptions?: T, Vixt?: Vixt) => T;
+    getMeta?: () => ModuleMeta;
+}
+
+interface VixtOptions extends Record<string, any> {
+    /**
+     * @default process.cwd()
+     */
+    rootDir?: string;
+    /**
+     * @default '.vixt'
+     */
+    buildDir?: string;
+    /**
+     * @default '.vixt/types'
+     */
+    buildTypesDir?: string;
+    /**
+     * @default '.vixt/layers'
+     */
+    buildLayersDir?: string;
+    /** modules */
+    modules?: VixtModule[];
+    /** use on configResolved */
+    vite?: ResolvedConfig;
+    meta?: VixtConfigLayerMeta;
+    /** layers */
+    extends?: string[];
+}
+interface VixtConfigLayerMeta extends ConfigLayerMeta {
+    /** layer name */
+    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 */
+    cwd?: string;
+}
+interface VixtAppConfig extends Record<string, any> {
+}
+
+export type { ModuleOptions as M, PluginOptions as P, VixtModule as V, Vixt as a, VixtOptions as b, VixtConfigLayer as c, ModuleDefinition as d, VixtConfigLayerMeta as e, VixtAppConfig as f, ModuleMeta as g };

package/dist/shared/core.66c5bb58.d.ts

@@ -0,0 +1,67 @@
+import { PluginOption, ResolvedConfig } from 'vite';
+import { ConfigLayerMeta, ConfigLayer } from 'c12';
+
+interface Vixt {
+    options: VixtOptions;
+    _layers: VixtConfigLayer[];
+    _modules: VixtModule[];
+}
+
+type PluginOptions<Options = any> = (Options extends (...args: any[]) => any ? Parameters<Options>[0] : Options);
+type ModuleOptions = Record<string, any>;
+interface ModuleMeta extends Record<string, any> {
+    name?: string;
+    configKey?: string;
+}
+interface ModuleDefinition<T extends ModuleOptions = ModuleOptions> {
+    meta?: ModuleMeta;
+    defaults?: T | ((vixt: Vixt) => T);
+    setup?: (this: void, resolvedOptions: T, vixt: Vixt) => PluginOption;
+}
+interface VixtModule<T extends ModuleOptions = ModuleOptions> {
+    (this: void, inlineOptions: T, vixt: Vixt): PluginOption;
+    getOptions?: (inlineOptions?: T, Vixt?: Vixt) => T;
+    getMeta?: () => ModuleMeta;
+}
+
+interface VixtOptions extends Record<string, any> {
+    /**
+     * @default process.cwd()
+     */
+    rootDir?: string;
+    /**
+     * @default '.vixt'
+     */
+    buildDir?: string;
+    /**
+     * @default '.vixt/types'
+     */
+    buildTypesDir?: string;
+    /**
+     * @default '.vixt/layers'
+     */
+    buildLayersDir?: string;
+    /** modules */
+    modules?: VixtModule[];
+    /** use on configResolved */
+    vite?: ResolvedConfig;
+    meta?: VixtConfigLayerMeta;
+    /** layers */
+    extends?: string[];
+}
+interface VixtConfigLayerMeta extends ConfigLayerMeta {
+    /** layer name */
+    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 */
+    cwd?: string;
+}
+interface VixtAppConfig extends Record<string, any> {
+}
+
+export type { ModuleOptions as M, PluginOptions as P, VixtModule as V, Vixt as a, VixtOptions as b, VixtConfigLayer as c, ModuleDefinition as d, VixtConfigLayerMeta as e, VixtAppConfig as f, ModuleMeta as g };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vixt/core",
   "type": "module",
-  "version": "0.0.15",
+  "version": "0.1.1",
   "author": "SoulLyoko<https://github.com/SoulLyoko>",
   "license": "MIT",
   "homepage": "https://github.com/SoulLyoko/vixt#readme",
@@ -10,6 +10,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.mjs"
     }
   },
   "main": "dist/index.mjs",