@vixt/core 0.3.6 → 0.4.1

package/dist/client/index.d.mts

@@ -1,17 +1,9 @@
-import { f as VixtAppConfig } from '../shared/core.zLZQlpAE.mjs';
-import { Pinia } from 'pinia';
-import { App, Plugin } from 'vue';
-import { Router, RouteRecord } from 'vue-router';
-import 'c12';
-import 'vite';
-
 interface VixtApp {
-    app: App;
-    router: Router;
-    routes: RouteRecord[];
-    pinia: Pinia;
     appConfig: VixtAppConfig;
 }
+interface VixtAppConfig extends Record<string, any> {
+}
+declare function defineAppConfig(config: VixtAppConfig): VixtAppConfig;
 
 interface PluginDefinition {
     name?: string;
@@ -20,10 +12,7 @@ interface PluginDefinition {
 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 };
+export { defineAppConfig, defineVixtPlugin };
+export type { PluginDefinition, VixtApp, VixtAppConfig, VixtPlugin };

package/dist/client/index.d.ts

@@ -1,17 +1,9 @@
-import { f as VixtAppConfig } from '../shared/core.zLZQlpAE.js';
-import { Pinia } from 'pinia';
-import { App, Plugin } from 'vue';
-import { Router, RouteRecord } from 'vue-router';
-import 'c12';
-import 'vite';
-
 interface VixtApp {
-    app: App;
-    router: Router;
-    routes: RouteRecord[];
-    pinia: Pinia;
     appConfig: VixtAppConfig;
 }
+interface VixtAppConfig extends Record<string, any> {
+}
+declare function defineAppConfig(config: VixtAppConfig): VixtAppConfig;
 
 interface PluginDefinition {
     name?: string;
@@ -20,10 +12,7 @@ interface PluginDefinition {
 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 };
+export { defineAppConfig, defineVixtPlugin };
+export type { PluginDefinition, VixtApp, VixtAppConfig, VixtPlugin };

package/dist/client/index.mjs

@@ -2,13 +2,10 @@ 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 };
+export { defineAppConfig, defineVixtPlugin };

package/dist/node/index.d.mts

@@ -0,0 +1,182 @@
+import * as c12 from 'c12';
+import { LoadConfigOptions, ConfigLayer, ConfigLayerMeta } from 'c12';
+import * as vite from 'vite';
+import { PluginOption, ResolvedConfig } from 'vite';
+import { RawVueCompilerOptions } from '@vue/language-core';
+import { TSConfig } from 'pkg-types';
+import Checker from 'vite-plugin-checker';
+
+type Property = Record<string, string>;
+interface AppHead {
+    meta?: Property[];
+    link?: Property[];
+    style?: Property[];
+    script?: Property[];
+    title?: Property[];
+    noscript?: Property[];
+}
+interface AppOptions {
+    head?: AppHead;
+    /**
+     * @default /
+     */
+    baseURL?: string;
+    /**
+     * @default 'app'
+     */
+    rootId?: string;
+    /**
+     * @default 'div'
+     */
+    rootTag?: string;
+    /** inject css files */
+    css?: string[];
+    /**
+     * @default './loading.html'
+     */
+    loadingTemplate?: string;
+    /**
+     * @default '/src/main.ts'(vue)
+     * @default '/src/main.tsx'(react)
+     * @example 'entry.ts'(means '/src/entry.ts') or './entry.ts'
+     */
+    entryFile?: string;
+}
+
+interface Vixt {
+    options: VixtOptions;
+    _layers: VixtConfigLayer[];
+    _modules: VixtModule[];
+}
+declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
+declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
+
+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 | void;
+}
+interface VixtModule<T extends ModuleOptions = ModuleOptions> {
+    (this: void, inlineOptions: T, vixt: Vixt): PluginOption;
+    getOptions?: (inlineOptions?: T, Vixt?: Vixt) => T;
+    getMeta?: () => ModuleMeta;
+}
+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[]>;
+
+interface VixtOptions extends Record<string, any> {
+    /**
+     * @default process.cwd()
+     */
+    rootDir?: string;
+    /**
+     * @default '<rootDir>/.vixt'
+     */
+    buildDir?: string;
+    /**
+     * @default '<buildDir>/types'
+     */
+    buildTypesDir?: string;
+    /**
+     * @default '<buildDir>/layers'
+     */
+    buildLayersDir?: string;
+    /**
+     * @default '<buildDir>/imports'
+     */
+    buildImportsDir?: string;
+    /**
+     * @default '<rootDir>/src'
+     */
+    srcDir?: string;
+    /** modules */
+    modules?: VixtModule[];
+    /** use on configResolved */
+    vite?: ResolvedConfig;
+    meta?: VixtConfigLayerMeta;
+    /** layers */
+    extends?: string[];
+    app?: AppOptions;
+}
+interface VixtConfigLayerMeta extends ConfigLayerMeta {
+    /** layer name */
+    name?: string;
+    /** layer alias */
+    alias?: string;
+}
+interface VixtConfigLayer extends ConfigLayer<VixtOptions, VixtConfigLayerMeta> {
+    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, and change cwd */
+    cwd?: string;
+}
+declare function defineVixtConfig(input: VixtOptions): VixtOptions;
+declare function loadVixtConfig(opts?: LoadConfigOptions<VixtOptions>): Promise<c12.ResolvedConfig<VixtOptions, ConfigLayerMeta>>;
+declare function applyLayers(layers: VixtConfigLayer[], config: VixtOptions): {
+    meta: VixtConfigLayerMeta;
+    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, and change cwd */
+    cwd?: string;
+    config: VixtOptions | null;
+    source?: string;
+    sourceOptions?: c12.SourceOptions<VixtOptions, VixtConfigLayerMeta> | undefined;
+    configFile?: string;
+}[];
+declare function isSamePath(a: string, b: string): boolean;
+declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
+
+/**
+ * Load workspace and cwd env variables by default
+ */
+declare function loadEnv(mode?: string, envDir?: string | false, prefixes?: string | string[]): ImportMeta["env"];
+/**
+ * find the workspace dir
+ */
+declare function findUpWorkspaceDir(): string | undefined;
+/**
+ * Load workspace env variables
+ */
+declare function loadWorkspaceEnv(mode?: string, prefixes?: string | string[]): Record<string, string>;
+
+declare const config: VixtModule<ModuleOptions>;
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        typescript?: TypescriptOptions;
+    }
+}
+interface TypescriptOptions {
+    references?: (string | {
+        path?: string;
+        content?: string;
+    })[];
+    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 generateAppConfig(vixt: Vixt): string;
+
+declare function generateClient(vixt: Vixt): void;
+
+declare function generateCss(options: AppOptions): string;
+
+declare function generateIndexHtml(options: AppOptions, vixt: Vixt): string;
+
+declare function generatePlugins(vixt: Vixt): string;
+
+export { applyLayerModules, applyLayers, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, generateAppConfig, generateClient, generateCss, generateIndexHtml, generatePlugins, installModule, isSamePath, loadEnv, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, typescript };
+export type { AppHead, AppOptions, ModuleDefinition, ModuleMeta, ModuleOptions, PluginOptions, TypescriptOptions, Vixt, VixtConfigLayer, VixtConfigLayerMeta, VixtModule, VixtOptions };

package/dist/node/index.d.ts

@@ -0,0 +1,182 @@
+import * as c12 from 'c12';
+import { LoadConfigOptions, ConfigLayer, ConfigLayerMeta } from 'c12';
+import * as vite from 'vite';
+import { PluginOption, ResolvedConfig } from 'vite';
+import { RawVueCompilerOptions } from '@vue/language-core';
+import { TSConfig } from 'pkg-types';
+import Checker from 'vite-plugin-checker';
+
+type Property = Record<string, string>;
+interface AppHead {
+    meta?: Property[];
+    link?: Property[];
+    style?: Property[];
+    script?: Property[];
+    title?: Property[];
+    noscript?: Property[];
+}
+interface AppOptions {
+    head?: AppHead;
+    /**
+     * @default /
+     */
+    baseURL?: string;
+    /**
+     * @default 'app'
+     */
+    rootId?: string;
+    /**
+     * @default 'div'
+     */
+    rootTag?: string;
+    /** inject css files */
+    css?: string[];
+    /**
+     * @default './loading.html'
+     */
+    loadingTemplate?: string;
+    /**
+     * @default '/src/main.ts'(vue)
+     * @default '/src/main.tsx'(react)
+     * @example 'entry.ts'(means '/src/entry.ts') or './entry.ts'
+     */
+    entryFile?: string;
+}
+
+interface Vixt {
+    options: VixtOptions;
+    _layers: VixtConfigLayer[];
+    _modules: VixtModule[];
+}
+declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
+declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
+
+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 | void;
+}
+interface VixtModule<T extends ModuleOptions = ModuleOptions> {
+    (this: void, inlineOptions: T, vixt: Vixt): PluginOption;
+    getOptions?: (inlineOptions?: T, Vixt?: Vixt) => T;
+    getMeta?: () => ModuleMeta;
+}
+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[]>;
+
+interface VixtOptions extends Record<string, any> {
+    /**
+     * @default process.cwd()
+     */
+    rootDir?: string;
+    /**
+     * @default '<rootDir>/.vixt'
+     */
+    buildDir?: string;
+    /**
+     * @default '<buildDir>/types'
+     */
+    buildTypesDir?: string;
+    /**
+     * @default '<buildDir>/layers'
+     */
+    buildLayersDir?: string;
+    /**
+     * @default '<buildDir>/imports'
+     */
+    buildImportsDir?: string;
+    /**
+     * @default '<rootDir>/src'
+     */
+    srcDir?: string;
+    /** modules */
+    modules?: VixtModule[];
+    /** use on configResolved */
+    vite?: ResolvedConfig;
+    meta?: VixtConfigLayerMeta;
+    /** layers */
+    extends?: string[];
+    app?: AppOptions;
+}
+interface VixtConfigLayerMeta extends ConfigLayerMeta {
+    /** layer name */
+    name?: string;
+    /** layer alias */
+    alias?: string;
+}
+interface VixtConfigLayer extends ConfigLayer<VixtOptions, VixtConfigLayerMeta> {
+    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, and change cwd */
+    cwd?: string;
+}
+declare function defineVixtConfig(input: VixtOptions): VixtOptions;
+declare function loadVixtConfig(opts?: LoadConfigOptions<VixtOptions>): Promise<c12.ResolvedConfig<VixtOptions, ConfigLayerMeta>>;
+declare function applyLayers(layers: VixtConfigLayer[], config: VixtOptions): {
+    meta: VixtConfigLayerMeta;
+    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, and change cwd */
+    cwd?: string;
+    config: VixtOptions | null;
+    source?: string;
+    sourceOptions?: c12.SourceOptions<VixtOptions, VixtConfigLayerMeta> | undefined;
+    configFile?: string;
+}[];
+declare function isSamePath(a: string, b: string): boolean;
+declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
+
+/**
+ * Load workspace and cwd env variables by default
+ */
+declare function loadEnv(mode?: string, envDir?: string | false, prefixes?: string | string[]): ImportMeta["env"];
+/**
+ * find the workspace dir
+ */
+declare function findUpWorkspaceDir(): string | undefined;
+/**
+ * Load workspace env variables
+ */
+declare function loadWorkspaceEnv(mode?: string, prefixes?: string | string[]): Record<string, string>;
+
+declare const config: VixtModule<ModuleOptions>;
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        typescript?: TypescriptOptions;
+    }
+}
+interface TypescriptOptions {
+    references?: (string | {
+        path?: string;
+        content?: string;
+    })[];
+    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 generateAppConfig(vixt: Vixt): string;
+
+declare function generateClient(vixt: Vixt): void;
+
+declare function generateCss(options: AppOptions): string;
+
+declare function generateIndexHtml(options: AppOptions, vixt: Vixt): string;
+
+declare function generatePlugins(vixt: Vixt): string;
+
+export { applyLayerModules, applyLayers, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, generateAppConfig, generateClient, generateCss, generateIndexHtml, generatePlugins, installModule, isSamePath, loadEnv, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, typescript };
+export type { AppHead, AppOptions, ModuleDefinition, ModuleMeta, ModuleOptions, PluginOptions, TypescriptOptions, Vixt, VixtConfigLayer, VixtConfigLayerMeta, VixtModule, VixtOptions };

package/dist/{index.mjs → node/index.mjs}

@@ -124,7 +124,7 @@ function installModule(module, inlineOptions, vixt) {
 async function applyLayerModules(layers) {
   const { modules: modulesDirs = [] } = resolveLayersDirs(layers);
   const modules = [];
-  for (const m of modulesDirs) {
+  for (const m of modulesDirs.reverse()) {
     if (fs.existsSync(m)) {
       const files = fs.readdirSync(m);
       for (const f of files) {
@@ -238,18 +238,6 @@ declare module '*.vue' {
   const codePath = path.resolve(buildTypesDir, "vue-shim.d.ts");
   fs.outputFileSync(codePath, code);
 }
-function genarateGlobalComponents(options, vixt) {
-  const { buildTypesDir } = vixt.options;
-  const codePath = path.resolve(buildTypesDir, "global-components.d.ts");
-  const code = `
-import type { GlobalComponents as _GlobalComponents } from '@vue/runtime-core'
-
-declare module 'vue'{
-  interface GlobalComponents extends _GlobalComponents {}
-}
-`;
-  fs.outputFileSync(codePath, code);
-}
 function generateEnvDts(env, vixt) {
   const { buildTypesDir } = vixt.options;
   const codePath = path.resolve(buildTypesDir, "vite-env.d.ts");
@@ -306,7 +294,6 @@ const typescript = defineVixtModule({
           generateTsConfig(options, vixt);
           generateVixtDts(options, vixt);
           genarateShim(options, vixt);
-          genarateGlobalComponents(options, vixt);
           generateEnvDts(config.env, vixt);
         }
       },
@@ -315,6 +302,123 @@ const typescript = defineVixtModule({
   }
 });
 
+function generateAppConfig(vixt) {
+  const { buildImportsDir } = vixt.options;
+  let appConfigsImportTemplate = "";
+  let appConfigsMergeTemplate = "";
+  let i = 0;
+  for (const layer of vixt._layers) {
+    const appConfigPath = path.resolve(layer.config.srcDir, "app.config.ts");
+    if (fs.existsSync(appConfigPath)) {
+      const appConfigName = `__app_config_${i}`;
+      appConfigsImportTemplate += `import ${appConfigName} from '${appConfigPath}'
+`;
+      appConfigsMergeTemplate += `${appConfigName}, `;
+      i++;
+    }
+  }
+  const globalAppConfigKey = "__VIXT_APP_CONFIG";
+  const appConfigTemplate = `
+import { defu } from 'defu'
+${appConfigsImportTemplate}
+const appConfig = defu(${appConfigsMergeTemplate}{})
+globalThis.${globalAppConfigKey} = appConfig
+`;
+  fs.outputFileSync(path.resolve(buildImportsDir, `app.config.ts`), `// Generated by Vixt
+// @ts-nocheck
+import type { VixtAppConfig } from '@vixt/core/client'
+
+export const useAppConfig = () => globalThis.${globalAppConfigKey} as VixtAppConfig
+`);
+  return appConfigTemplate;
+}
+
+function generateClient(vixt) {
+  const { buildImportsDir } = vixt.options;
+  fs.outputFileSync(
+    path.resolve(buildImportsDir, `client.ts`),
+    `// Generated by Vixt
+export { defineAppConfig, defineVixtPlugin } from '@vixt/core/client'
+`
+  );
+}
+
+function generateCss(options) {
+  const cssTemplate = options?.css?.map((css) => `import '${css}'`).join("\n") ?? "";
+  return cssTemplate;
+}
+
+function resolveHeadTag(tag, attrs) {
+  const attrsStr = Object.entries(attrs).filter(([k]) => k !== "children").map(([k, v]) => `${k}="${v}"`).join(" ");
+  return attrs?.children ? `<${tag} ${attrsStr}>${attrs.children}</${tag}>` : `<${tag} ${attrsStr} />`;
+}
+function generateIndexHtml(options, vixt) {
+  const { buildDir, rootDir, srcDir } = vixt.options;
+  const indexHtmlPath = path.resolve(rootDir, "index.html");
+  if (!fs.existsSync(indexHtmlPath))
+    fs.outputFileSync(indexHtmlPath, `<!-- Generated by Vixt -->
+<!-- This file transform from '${path.basename(buildDir)}/index.html' -->
+`);
+  const { head = {}, rootTag, rootId, entryFile } = 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;
+  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;
+      }
+    }
+  }
+  const entryFilePath = /&\.|\//.test(entryFile ?? "") ? entryFile : `${srcDir.replace(rootDir, "")}/${entryFile}`;
+  const code = `<!DOCTYPE html>
+<html>
+  <head>
+${headTemplate}
+  </head>
+  <body>
+    <${rootTag} id="${rootId}">
+${loadingTemplate}
+    </${rootTag}>
+    <script type="module" src="${entryFilePath}"><\/script>
+${noscriptTemplate}
+  </body>
+</html>
+`;
+  fs.outputFileSync(path.resolve(buildDir, "index.html"), code);
+  return code;
+}
+
+function generatePlugins(vixt) {
+  const { plugins: pluginsDirs = [] } = resolveLayersDirs(vixt._layers);
+  let pluginsImportTemplate = "";
+  let pluginsMergeTemplate = "";
+  let i = 0;
+  for (const pluginsDir of pluginsDirs.reverse()) {
+    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}'
+`;
+      pluginsMergeTemplate += `${pluginName}, `;
+      i++;
+    }
+  }
+  const pluginsTemplate = `
+${pluginsImportTemplate}
+const plugins = [${pluginsMergeTemplate}]
+function usePlugins(options) {
+  for (const plugin of plugins) {
+    typeof plugin === 'function' && plugin(options)
+  }
+}
+`;
+  return pluginsTemplate;
+}
+
 async function loadVixt(opts) {
   const result = await loadVixtConfig(defu(opts, {
     defaults: {
@@ -343,4 +447,4 @@ function createVixtPlugin(loadOptions) {
   });
 }
 
-export { applyLayerModules, applyLayers, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, installModule, isSamePath, loadEnv, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, typescript };
+export { applyLayerModules, applyLayers, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, generateAppConfig, generateClient, generateCss, generateIndexHtml, generatePlugins, installModule, isSamePath, loadEnv, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, typescript };

package/package.json

@@ -1,33 +1,30 @@
 {
   "name": "@vixt/core",
   "type": "module",
-  "version": "0.3.6",
+  "version": "0.4.1",
   "author": "SoulLyoko<https://github.com/SoulLyoko>",
   "license": "MIT",
   "homepage": "https://github.com/SoulLyoko/vixt#readme",
   "repository": "https://github.com/SoulLyoko/vixt.git",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node/index.mjs"
     },
     "./client": {
       "types": "./dist/client/index.d.ts",
       "import": "./dist/client/index.mjs"
-    },
-    "./client/App.vue": {
-      "import": "./dist/client/App.vue"
     }
   },
-  "main": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "main": "./dist/node/index.mjs",
+  "types": "./dist/node/index.d.ts",
   "files": [
     "dist"
   ],
   "dependencies": {
     "@types/fs-extra": "^11.0.4",
     "@vue/tsconfig": "^0.7.0",
-    "c12": "^3.0.3",
+    "c12": "^3.0.4",
     "cac": "^6.7.14",
     "defu": "^6.1.4",
     "find-up": "^7.0.0",
@@ -37,10 +34,10 @@
     "pkg-types": "^2.1.0",
     "tsx": "^4.19.4",
     "vite": "^6.3.5",
-    "vite-plugin-checker": "^0.9.3",
-    "vue-tsc": "^2.2.10"
+    "vite-plugin-checker": "^0.9.3"
   },
   "scripts": {
-    "build": "unbuild"
+    "build": "unbuild",
+    "dev": "unbuild --stub"
   }
 }

package/dist/client/App.vue

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

package/dist/index.d.mts

@@ -1,70 +0,0 @@
-import { V as VixtOptions, a as VixtConfigLayer, b as VixtConfigLayerMeta, M as ModuleOptions, c as ModuleDefinition, d as VixtModule, e as Vixt } from './shared/core.zLZQlpAE.mjs';
-export { g as ModuleMeta, P as PluginOptions, f as VixtAppConfig } from './shared/core.zLZQlpAE.mjs';
-import * as c12 from 'c12';
-import { LoadConfigOptions } from 'c12';
-import { RawVueCompilerOptions } from '@vue/language-core';
-import { TSConfig } from 'pkg-types';
-import Checker from 'vite-plugin-checker';
-import * as vite from 'vite';
-import { PluginOption } from 'vite';
-
-declare function defineVixtConfig(input: VixtOptions): VixtOptions;
-declare function loadVixtConfig(opts?: LoadConfigOptions<VixtOptions>): Promise<c12.ResolvedConfig<VixtOptions, c12.ConfigLayerMeta>>;
-declare function applyLayers(layers: VixtConfigLayer[], config: VixtOptions): {
-    meta: VixtConfigLayerMeta;
-    cwd?: string;
-    config: VixtOptions | null;
-    source?: string;
-    sourceOptions?: c12.SourceOptions<VixtOptions, VixtConfigLayerMeta> | undefined;
-    configFile?: string;
-}[];
-declare function isSamePath(a: string, b: string): boolean;
-declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
-
-/**
- * Load workspace and cwd env variables by default
- */
-declare function loadEnv(mode?: string, envDir?: string | false, prefixes?: string | string[]): ImportMeta["env"];
-/**
- * find the workspace dir
- */
-declare function findUpWorkspaceDir(): string | undefined;
-/**
- * Load workspace env variables
- */
-declare function loadWorkspaceEnv(mode?: string, prefixes?: string | string[]): Record<string, string>;
-
-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 const config: VixtModule<ModuleOptions>;
-
-declare module '@vixt/core' {
-    interface VixtOptions {
-        typescript?: TypescriptOptions;
-    }
-}
-interface TypescriptOptions {
-    references?: (string | {
-        path?: string;
-        content?: string;
-    })[];
-    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 loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
-declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
-
-export { ModuleDefinition, ModuleOptions, type TypescriptOptions, Vixt, VixtConfigLayer, VixtConfigLayerMeta, VixtModule, type VixtOptions, applyLayerModules, applyLayers, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, installModule, isSamePath, loadEnv, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, typescript };

package/dist/index.d.ts

@@ -1,70 +0,0 @@
-import { V as VixtOptions, a as VixtConfigLayer, b as VixtConfigLayerMeta, M as ModuleOptions, c as ModuleDefinition, d as VixtModule, e as Vixt } from './shared/core.zLZQlpAE.js';
-export { g as ModuleMeta, P as PluginOptions, f as VixtAppConfig } from './shared/core.zLZQlpAE.js';
-import * as c12 from 'c12';
-import { LoadConfigOptions } from 'c12';
-import { RawVueCompilerOptions } from '@vue/language-core';
-import { TSConfig } from 'pkg-types';
-import Checker from 'vite-plugin-checker';
-import * as vite from 'vite';
-import { PluginOption } from 'vite';
-
-declare function defineVixtConfig(input: VixtOptions): VixtOptions;
-declare function loadVixtConfig(opts?: LoadConfigOptions<VixtOptions>): Promise<c12.ResolvedConfig<VixtOptions, c12.ConfigLayerMeta>>;
-declare function applyLayers(layers: VixtConfigLayer[], config: VixtOptions): {
-    meta: VixtConfigLayerMeta;
-    cwd?: string;
-    config: VixtOptions | null;
-    source?: string;
-    sourceOptions?: c12.SourceOptions<VixtOptions, VixtConfigLayerMeta> | undefined;
-    configFile?: string;
-}[];
-declare function isSamePath(a: string, b: string): boolean;
-declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
-
-/**
- * Load workspace and cwd env variables by default
- */
-declare function loadEnv(mode?: string, envDir?: string | false, prefixes?: string | string[]): ImportMeta["env"];
-/**
- * find the workspace dir
- */
-declare function findUpWorkspaceDir(): string | undefined;
-/**
- * Load workspace env variables
- */
-declare function loadWorkspaceEnv(mode?: string, prefixes?: string | string[]): Record<string, string>;
-
-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 const config: VixtModule<ModuleOptions>;
-
-declare module '@vixt/core' {
-    interface VixtOptions {
-        typescript?: TypescriptOptions;
-    }
-}
-interface TypescriptOptions {
-    references?: (string | {
-        path?: string;
-        content?: string;
-    })[];
-    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 loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
-declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
-
-export { ModuleDefinition, ModuleOptions, type TypescriptOptions, Vixt, VixtConfigLayer, VixtConfigLayerMeta, VixtModule, type VixtOptions, applyLayerModules, applyLayers, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, installModule, isSamePath, loadEnv, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, typescript };

package/dist/shared/core.zLZQlpAE.d.mts

@@ -1,73 +0,0 @@
-import { ConfigLayer, ConfigLayerMeta } from 'c12';
-import { PluginOption, ResolvedConfig } from 'vite';
-
-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 | void;
-}
-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 '<rootDir>/.vixt'
-     */
-    buildDir?: string;
-    /**
-     * @default '<buildDir>/types'
-     */
-    buildTypesDir?: string;
-    /**
-     * @default '<buildDir>/layers'
-     */
-    buildLayersDir?: string;
-    /**
-     * @default '<buildDir>/imports'
-     */
-    buildImportsDir?: string;
-    /**
-     * @default '<rootDir>/src'
-     */
-    srcDir?: 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;
-}
-interface VixtConfigLayer extends ConfigLayer<VixtOptions, VixtConfigLayerMeta> {
-    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, and change cwd */
-    cwd?: string;
-}
-interface VixtAppConfig extends Record<string, any> {
-}
-
-export type { ModuleOptions as M, PluginOptions as P, VixtOptions as V, VixtConfigLayer as a, VixtConfigLayerMeta as b, ModuleDefinition as c, VixtModule as d, Vixt as e, VixtAppConfig as f, ModuleMeta as g };

package/dist/shared/core.zLZQlpAE.d.ts

@@ -1,73 +0,0 @@
-import { ConfigLayer, ConfigLayerMeta } from 'c12';
-import { PluginOption, ResolvedConfig } from 'vite';
-
-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 | void;
-}
-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 '<rootDir>/.vixt'
-     */
-    buildDir?: string;
-    /**
-     * @default '<buildDir>/types'
-     */
-    buildTypesDir?: string;
-    /**
-     * @default '<buildDir>/layers'
-     */
-    buildLayersDir?: string;
-    /**
-     * @default '<buildDir>/imports'
-     */
-    buildImportsDir?: string;
-    /**
-     * @default '<rootDir>/src'
-     */
-    srcDir?: 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;
-}
-interface VixtConfigLayer extends ConfigLayer<VixtOptions, VixtConfigLayerMeta> {
-    /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, and change cwd */
-    cwd?: string;
-}
-interface VixtAppConfig extends Record<string, any> {
-}
-
-export type { ModuleOptions as M, PluginOptions as P, VixtOptions as V, VixtConfigLayer as a, VixtConfigLayerMeta as b, ModuleDefinition as c, VixtModule as d, Vixt as e, VixtAppConfig as f, ModuleMeta as g };