@vixt/core 0.3.5 → 0.4.0

package/package.json

@@ -1,33 +1,30 @@
 {
   "name": "@vixt/core",
   "type": "module",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "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/client/index.d.mts

@@ -1,29 +0,0 @@
-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 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

@@ -1,29 +0,0 @@
-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 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

@@ -1,14 +0,0 @@
-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,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/index.mjs

@@ -1,346 +0,0 @@
-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) {
-    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 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");
-  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);
-          genarateGlobalComponents(options, vixt);
-          generateEnvDts(config.env, vixt);
-        }
-      },
-      Checker(options.typeCheck ?? {})
-    ];
-  }
-});
-
-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, 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 };