@vixt/core 0.4.0 → 0.4.2

package/dist/client/index.d.mts

@@ -0,0 +1,18 @@
+interface VixtApp {
+    appConfig: VixtAppConfig;
+}
+interface VixtAppConfig extends Record<string, any> {
+}
+declare function defineAppConfig(config: VixtAppConfig): VixtAppConfig;
+
+interface PluginDefinition {
+    name?: string;
+    setup?: (this: void, vixt: VixtApp) => any;
+}
+interface VixtPlugin {
+    (this: void, vixt: VixtApp): any;
+}
+declare function defineVixtPlugin(definition: PluginDefinition | VixtPlugin): VixtPlugin;
+
+export { defineAppConfig, defineVixtPlugin };
+export type { PluginDefinition, VixtApp, VixtAppConfig, VixtPlugin };

package/dist/client/index.d.ts

@@ -0,0 +1,18 @@
+interface VixtApp {
+    appConfig: VixtAppConfig;
+}
+interface VixtAppConfig extends Record<string, any> {
+}
+declare function defineAppConfig(config: VixtAppConfig): VixtAppConfig;
+
+interface PluginDefinition {
+    name?: string;
+    setup?: (this: void, vixt: VixtApp) => any;
+}
+interface VixtPlugin {
+    (this: void, vixt: VixtApp): any;
+}
+declare function defineVixtPlugin(definition: PluginDefinition | VixtPlugin): VixtPlugin;
+
+export { defineAppConfig, defineVixtPlugin };
+export type { PluginDefinition, VixtApp, VixtAppConfig, VixtPlugin };

package/dist/client/index.mjs

@@ -0,0 +1,11 @@
+function defineAppConfig(config) {
+  return config;
+}
+
+function defineVixtPlugin(definition) {
+  if (typeof definition == "function")
+    return defineVixtPlugin({ setup: definition });
+  return (vixt) => definition.setup?.(vixt);
+}
+
+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/node/index.mjs

@@ -0,0 +1,450 @@
+import { loadConfig } from 'c12';
+import fs from 'fs-extra';
+import path, { resolve, normalize } from 'pathe';
+import { env, cwd } from 'node:process';
+import { cac } from 'cac';
+import { findUpSync } from 'find-up';
+import { loadEnv as loadEnv$1 } from 'vite';
+import defu from 'defu';
+import { pathToFileURL } from 'mlly';
+import 'tsx/esm';
+import Checker from 'vite-plugin-checker';
+
+function defineVixtConfig(input) {
+  return input;
+}
+async function loadVixtConfig(opts) {
+  const result = await loadConfig({
+    name: "vixt",
+    rcFile: false,
+    ...opts
+  });
+  const { config, cwd } = result;
+  config.rootDir ??= cwd;
+  config.buildDir ??= resolve(config.rootDir, ".vixt");
+  config.buildTypesDir ??= resolve(config.buildDir, "types");
+  config.buildLayersDir ??= resolve(config.buildDir, "layers");
+  config.buildImportsDir ??= resolve(config.buildDir, "imports");
+  config.srcDir ??= resolve(config.rootDir, "src");
+  return result;
+}
+function applyLayers(layers, config) {
+  const { rootDir, buildLayersDir } = config;
+  return layers.filter((e) => e.cwd).map((layer) => {
+    const meta = layer.config?.meta ?? {};
+    const layerName = meta.name || layer.cwd.split("/").pop();
+    if (!isSamePath(layer.cwd, resolve(rootDir))) {
+      meta.alias = `#/layers/${layerName}`;
+    }
+    if (layer.cwd?.includes("node_modules")) {
+      const newCwd = resolve(buildLayersDir, layerName);
+      fs.copySync(layer.cwd, newCwd, {
+        filter: (src) => {
+          const nodeModulesPath = resolve(layer.cwd, "node_modules");
+          const tsConfigPath = resolve(layer.cwd, "tsconfig.json");
+          return !isSamePath(src, nodeModulesPath) && !isSamePath(src, tsConfigPath);
+        }
+      });
+      layer.cwd = newCwd;
+    }
+    layer.config ??= {};
+    layer.config.rootDir ??= layer.cwd;
+    layer.config.srcDir ??= resolve(layer.config.rootDir, "src");
+    return { ...layer, meta };
+  });
+}
+function isSamePath(a, b) {
+  return normalize(a) === normalize(b);
+}
+function resolveLayersDirs(layers = []) {
+  const dirs = {};
+  for (const layer of layers) {
+    const srcPath = layer.config.srcDir;
+    const isExist = fs.existsSync(srcPath);
+    const contents = isExist ? fs.readdirSync(srcPath) : [];
+    for (const content of contents) {
+      const fileOrDirPath = resolve(srcPath, content);
+      if (fs.statSync(fileOrDirPath).isDirectory()) {
+        dirs[content] ??= [];
+        dirs[content].push(fileOrDirPath);
+      }
+    }
+  }
+  return dirs;
+}
+
+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",
+    ...loadWorkspaceEnv(mode, prefixes),
+    ...loadEnv$1(mode, envDir || cwd(), prefixes)
+  };
+}
+function findUpWorkspaceDir() {
+  const workspaceManifestLocation = findUpSync(["pnpm-workspace.yaml", "pnpm-workspace.yml"]);
+  return workspaceManifestLocation && path.dirname(workspaceManifestLocation);
+}
+function loadWorkspaceEnv(mode, prefixes) {
+  const workspaceDir = findUpWorkspaceDir();
+  return workspaceDir ? loadEnv$1(mode, workspaceDir, prefixes) : {};
+}
+
+function defineVitePlugin(pluginFn) {
+  return pluginFn;
+}
+function defineVixtModule(definition) {
+  if (typeof definition == "function")
+    return defineVixtModule({ setup: definition });
+  const module = definition;
+  function getOptions(inlineOptions, vixt) {
+    const configKey = module.meta?.configKey || module.meta?.name;
+    const configOptions = configKey ? vixt.options[configKey] : {};
+    const defaultOptions = typeof module.defaults === "function" ? module.defaults(vixt) : module.defaults;
+    const resolvedOptions = defu(inlineOptions, configOptions, defaultOptions);
+    if (configKey) {
+      vixt.options[configKey] = resolvedOptions;
+    }
+    return resolvedOptions;
+  }
+  function normalizedModule(inlineOptions, vixt) {
+    const options = getOptions(inlineOptions, vixt);
+    return module.setup?.(options, vixt);
+  }
+  normalizedModule.getMeta = () => module.meta;
+  normalizedModule.getOptions = getOptions;
+  return normalizedModule;
+}
+function installModule(module, inlineOptions, vixt) {
+  return module(inlineOptions, vixt);
+}
+async function applyLayerModules(layers) {
+  const { modules: modulesDirs = [] } = resolveLayersDirs(layers);
+  const modules = [];
+  for (const m of modulesDirs.reverse()) {
+    if (fs.existsSync(m)) {
+      const files = fs.readdirSync(m);
+      for (const f of files) {
+        const p = path.resolve(m, f);
+        const module = await import(
+          /* @vite-ignore */
+          pathToFileURL(p)
+        ).then((m2) => m2.default);
+        modules.push(module);
+      }
+    }
+  }
+  return modules;
+}
+
+const name$1 = "vixt:config";
+const config = defineVixtModule({
+  meta: { name: name$1 },
+  setup(_, vixt) {
+    let env;
+    return {
+      name: name$1,
+      enforce: "pre",
+      config(config2) {
+        const { rootDir, buildDir, srcDir } = vixt.options;
+        const defaultAlias = {
+          "@": srcDir,
+          "~": srcDir,
+          "@@": rootDir,
+          "~~": rootDir
+        };
+        for (const layer of vixt._layers) {
+          if (layer.meta?.alias) {
+            defaultAlias[layer.meta.alias] = layer.cwd;
+          }
+        }
+        defaultAlias["#"] = buildDir;
+        env = loadEnv(config2.mode, config2.envDir, config2.envPrefix);
+        const defineEnv = Object.fromEntries(
+          Object.entries(env).filter(([k]) => !["MODE", "DEV", "PROD"].includes(k)).map(([k, v]) => [`import.meta.env.${k}`, JSON.stringify(v)])
+        );
+        return {
+          root: rootDir,
+          resolve: {
+            alias: defaultAlias
+          },
+          define: defineEnv
+        };
+      },
+      configResolved(config2) {
+        Object.assign(config2.env, { ...env, ...config2.env });
+        vixt.options.vite = config2;
+      },
+      configureServer(server) {
+        const mode = server.config.mode;
+        const watchFiles = [];
+        const configFiles = vixt._layers.map((layer) => layer.configFile).filter((e) => !e.includes("node_modules"));
+        const modulesDirs = vixt._layers.map((layer) => path.resolve(layer.config.srcDir, "modules")).filter((e) => !e.includes("node_modules"));
+        watchFiles.push(...configFiles, ...modulesDirs);
+        const workspaceManifestLocation = findUpSync(["pnpm-workspace.yaml", "pnpm-workspace.yml"]);
+        if (workspaceManifestLocation) {
+          const workspaceDir = path.dirname(workspaceManifestLocation);
+          const envFiles = [`${workspaceDir}/.env`, `${workspaceDir}/.env.local`, `${workspaceDir}/.env.${mode}`, `${workspaceDir}/.env.${mode}.local`];
+          watchFiles.push(...envFiles);
+        }
+        server.watcher.add(watchFiles);
+        server.watcher.on("all", (_2, file) => {
+          const match = watchFiles.some((e) => path.normalize(file).match(e));
+          if (match)
+            server.restart();
+        });
+      }
+    };
+  }
+});
+
+function generateTsConfig(options, vixt) {
+  const { buildDir } = vixt.options;
+  const codePath = path.resolve(buildDir, "tsconfig.json");
+  const code = JSON.stringify(options.tsConfig, null, 2);
+  fs.outputFileSync(codePath, code);
+}
+function generateVixtDts(options, vixt) {
+  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(buildDir, reference.path), reference.content);
+      return `/// <reference path="${reference.path}" />`;
+    } else {
+      return "";
+    }
+  }).concat("export {}").join("\n");
+  if (code)
+    fs.outputFileSync(codePath, code);
+}
+function genarateShim(options, vixt) {
+  if (!options.shim)
+    return;
+  const { buildTypesDir } = vixt.options;
+  const code = `
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+
+  const component: DefineComponent
+  export default component
+}
+`;
+  const codePath = path.resolve(buildTypesDir, "vue-shim.d.ts");
+  fs.outputFileSync(codePath, code);
+}
+function generateEnvDts(env, vixt) {
+  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 {
+  readonly env: ImportMetaEnv
+}
+interface ImportMetaEnv {
+  ${values}
+}
+`;
+  fs.outputFileSync(codePath, code);
+}
+const name = "vixt:typescript";
+const typescript = defineVixtModule({
+  meta: { name, configKey: "typescript" },
+  defaults(vixt) {
+    const { rootDir, srcDir } = vixt.options;
+    const rootAlias = {};
+    if (rootDir)
+      rootAlias["@@/*"] = rootAlias["~~/*"] = [`${rootDir}/*`];
+    const srcAlias = {};
+    if (srcDir)
+      srcAlias["@/*"] = srcAlias["~/*"] = [`${srcDir}/*`];
+    const layersDirs = [];
+    const layersAlias = {};
+    for (const layer of vixt._layers) {
+      layersDirs.push(layer.cwd);
+      if (layer.meta?.alias)
+        layersAlias[`${layer.meta.alias}/*`] = [`${layer.cwd}/*`];
+    }
+    return {
+      tsConfig: {
+        extends: "@vue/tsconfig/tsconfig.dom.json",
+        compilerOptions: {
+          baseUrl: rootDir,
+          paths: { "#/*": ["./*"], ...layersAlias, ...rootAlias, ...srcAlias },
+          types: ["vite/client"]
+        },
+        include: ["./**/*", ...layersDirs]
+      },
+      typeCheck: {
+        enableBuild: false,
+        overlay: { initialIsOpen: false }
+      }
+    };
+  },
+  setup(options, vixt) {
+    return [
+      {
+        name,
+        configResolved(config) {
+          generateTsConfig(options, vixt);
+          generateVixtDts(options, vixt);
+          genarateShim(options, vixt);
+          generateEnvDts(config.env, vixt);
+        }
+      },
+      Checker(options.typeCheck ?? {})
+    ];
+  }
+});
+
+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: {
+      modules: [config, typescript]
+    }
+  }));
+  const parsedArgv = cac().parse();
+  const isForce = !!parsedArgv.options.force;
+  if (isForce) {
+    fs.removeSync(result.config.buildDir);
+  }
+  result.layers = applyLayers(result.layers ?? [], result.config);
+  const layerModules = await applyLayerModules(result.layers ?? []);
+  const vixt = {
+    options: result.config,
+    _layers: result.layers ?? [],
+    _modules: [...result.config.modules ?? [], ...layerModules]
+  };
+  return vixt;
+}
+function createVixtPlugin(loadOptions) {
+  return defineVitePlugin(async (vixtOptions) => {
+    const vixt = await loadVixt(defu({ defaults: vixtOptions }, loadOptions));
+    const plugins = vixt._modules.map((module) => module({}, vixt));
+    return plugins;
+  });
+}
+
+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,7 +1,7 @@
 {
   "name": "@vixt/core",
   "type": "module",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "author": "SoulLyoko<https://github.com/SoulLyoko>",
   "license": "MIT",
   "homepage": "https://github.com/SoulLyoko/vixt#readme",