@vixt/core 0.0.2 → 0.0.3

package/dist/index.d.mts

@@ -0,0 +1,163 @@
+import * as vite from 'vite';
+import { PluginOption, UserConfig, TransformResult, ProxyOptions } from 'vite';
+import * as c12 from 'c12';
+import { ConfigLayer, LoadConfigOptions } from 'c12';
+import { TSConfig } from 'pkg-types';
+import Checker from 'vite-plugin-checker';
+
+declare const alias: VixtModule<ModuleOptions>;
+
+interface Vixt {
+    options: VixtOptions;
+    _layers: VixtConfigLayer[];
+    _modules: VixtModule[];
+}
+
+type PluginOptions<Options = any> = (Options extends (...args: any[]) => any ? Parameters<Options>[0] : Options);
+type ModuleOptions = Record<string, any>;
+interface ModuleMeta extends Record<string, any> {
+    name?: string;
+    configKey?: string;
+}
+interface ModuleDefinition<T extends ModuleOptions = ModuleOptions> {
+    meta?: ModuleMeta;
+    defaults?: T | ((vixt: Vixt) => T);
+    setup?: (this: void, resolvedOptions: T, vixt: Vixt) => PluginOption;
+}
+interface VixtModule<T extends ModuleOptions = ModuleOptions> {
+    (this: void, inlineOptions: T, vixt: Vixt): PluginOption;
+    getOptions?: (inlineOptions?: T, Vixt?: Vixt) => T;
+    getMeta?: () => ModuleMeta;
+}
+
+interface VixtOptions extends Record<string, any> {
+    /**
+     * @default '.vixt'
+     */
+    buildDir?: string;
+    /**
+     * @default '.vixt/types'
+     */
+    buildTypesDir?: string;
+    /** layers */
+    extends?: string[];
+    /** modules */
+    modules?: VixtModule[];
+    vite?: UserConfig;
+}
+interface VixtConfigLayer extends ConfigLayer<VixtOptions> {
+}
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        app?: AppOptions;
+    }
+}
+type Property = Record<string, string>;
+interface AppHead {
+    meta?: Property[];
+    link?: Property[];
+    style?: Property[];
+    script?: Property[];
+    title?: Property[];
+    noscript?: Property[];
+}
+interface AppOptions {
+    head?: AppHead;
+    /**
+     * @default BASE_URL=/
+     */
+    baseURL?: string;
+    /**
+     * @default '#app'
+     */
+    rootId?: string;
+    /**
+     * @default 'div'
+     */
+    rootTag?: string;
+    /**
+     * @default '<buildDir>/main.ts'
+     */
+    main?: string;
+    transformMain?: (vixt: Vixt) => Promise<TransformResult | string | null | void> | TransformResult | string | null | void;
+    css?: string[];
+    /**
+     * @default './loading.html'
+     */
+    loadingTemplate?: string;
+}
+declare const app: VixtModule<AppOptions>;
+
+declare const config: VixtModule<ModuleOptions>;
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        devProxy?: DevProxyOptions;
+    }
+}
+interface DevProxyOptions {
+    /**
+     * 环境变量的 key
+     * @default 'VITE_PROXY'
+     */
+    key?: string;
+}
+/**
+ * @param list [prefix,target,rewrite?][]
+ */
+declare function transformProxy(list: string): {
+    [k: string]: ProxyOptions;
+};
+/** 为 vite 开发服务添加代理配置 */
+declare const devProxy: VixtModule<DevProxyOptions>;
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        typescript?: TypescriptOptions;
+    }
+}
+interface TypescriptOptions {
+    references?: (string | {
+        path?: string;
+        content?: string;
+    })[];
+    tsConfig?: TSConfig;
+    /** https://github.com/fi3ework/vite-plugin-checker */
+    typeCheck?: Parameters<typeof Checker>[0] | false;
+}
+declare const typescript: VixtModule<TypescriptOptions>;
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        warmup?: WarmupOptions;
+    }
+}
+interface WarmupOptions {
+    enabled?: boolean;
+    /**
+     * The files to be transformed and used on the client-side. Supports glob patterns.
+     */
+    clientFiles?: string[];
+    /**
+     * The files to be transformed and used in SSR. Supports glob patterns.
+     */
+    ssrFiles?: string[];
+}
+declare const warmup: VixtModule<WarmupOptions>;
+
+declare function defineVixtConfig(input: VixtOptions): VixtOptions;
+declare const buildDir = ".vixt";
+declare const buildTypesDir = ".vixt/types";
+declare function loadVixtConfig(opts?: LoadConfigOptions<VixtOptions>): Promise<c12.ResolvedConfig<VixtOptions, c12.ConfigLayerMeta>>;
+declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
+
+declare function defineVitePlugin<Options = any>(pluginFn: (options?: Options) => PluginOption): (options?: Options) => PluginOption;
+declare function defineVixtModule<T extends ModuleOptions>(definition: ModuleDefinition<T> | VixtModule<T>): VixtModule<T>;
+declare function installModule(module: VixtModule, inlineOptions: any, vixt: Vixt): PluginOption;
+declare function applyLayerModules(layers?: VixtConfigLayer[]): Promise<VixtModule[]>;
+
+declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
+declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
+
+export { type AppHead, type AppOptions, type DevProxyOptions, type ModuleDefinition, type ModuleMeta, type ModuleOptions, type PluginOptions, type TypescriptOptions, type Vixt, type VixtConfigLayer, type VixtModule, type VixtOptions, type WarmupOptions, alias, app, applyLayerModules, buildDir, buildTypesDir, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, devProxy, installModule, loadVixt, loadVixtConfig, resolveLayersDirs, transformProxy, typescript, warmup };

package/dist/index.d.ts

@@ -0,0 +1,163 @@
+import * as vite from 'vite';
+import { PluginOption, UserConfig, TransformResult, ProxyOptions } from 'vite';
+import * as c12 from 'c12';
+import { ConfigLayer, LoadConfigOptions } from 'c12';
+import { TSConfig } from 'pkg-types';
+import Checker from 'vite-plugin-checker';
+
+declare const alias: VixtModule<ModuleOptions>;
+
+interface Vixt {
+    options: VixtOptions;
+    _layers: VixtConfigLayer[];
+    _modules: VixtModule[];
+}
+
+type PluginOptions<Options = any> = (Options extends (...args: any[]) => any ? Parameters<Options>[0] : Options);
+type ModuleOptions = Record<string, any>;
+interface ModuleMeta extends Record<string, any> {
+    name?: string;
+    configKey?: string;
+}
+interface ModuleDefinition<T extends ModuleOptions = ModuleOptions> {
+    meta?: ModuleMeta;
+    defaults?: T | ((vixt: Vixt) => T);
+    setup?: (this: void, resolvedOptions: T, vixt: Vixt) => PluginOption;
+}
+interface VixtModule<T extends ModuleOptions = ModuleOptions> {
+    (this: void, inlineOptions: T, vixt: Vixt): PluginOption;
+    getOptions?: (inlineOptions?: T, Vixt?: Vixt) => T;
+    getMeta?: () => ModuleMeta;
+}
+
+interface VixtOptions extends Record<string, any> {
+    /**
+     * @default '.vixt'
+     */
+    buildDir?: string;
+    /**
+     * @default '.vixt/types'
+     */
+    buildTypesDir?: string;
+    /** layers */
+    extends?: string[];
+    /** modules */
+    modules?: VixtModule[];
+    vite?: UserConfig;
+}
+interface VixtConfigLayer extends ConfigLayer<VixtOptions> {
+}
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        app?: AppOptions;
+    }
+}
+type Property = Record<string, string>;
+interface AppHead {
+    meta?: Property[];
+    link?: Property[];
+    style?: Property[];
+    script?: Property[];
+    title?: Property[];
+    noscript?: Property[];
+}
+interface AppOptions {
+    head?: AppHead;
+    /**
+     * @default BASE_URL=/
+     */
+    baseURL?: string;
+    /**
+     * @default '#app'
+     */
+    rootId?: string;
+    /**
+     * @default 'div'
+     */
+    rootTag?: string;
+    /**
+     * @default '<buildDir>/main.ts'
+     */
+    main?: string;
+    transformMain?: (vixt: Vixt) => Promise<TransformResult | string | null | void> | TransformResult | string | null | void;
+    css?: string[];
+    /**
+     * @default './loading.html'
+     */
+    loadingTemplate?: string;
+}
+declare const app: VixtModule<AppOptions>;
+
+declare const config: VixtModule<ModuleOptions>;
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        devProxy?: DevProxyOptions;
+    }
+}
+interface DevProxyOptions {
+    /**
+     * 环境变量的 key
+     * @default 'VITE_PROXY'
+     */
+    key?: string;
+}
+/**
+ * @param list [prefix,target,rewrite?][]
+ */
+declare function transformProxy(list: string): {
+    [k: string]: ProxyOptions;
+};
+/** 为 vite 开发服务添加代理配置 */
+declare const devProxy: VixtModule<DevProxyOptions>;
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        typescript?: TypescriptOptions;
+    }
+}
+interface TypescriptOptions {
+    references?: (string | {
+        path?: string;
+        content?: string;
+    })[];
+    tsConfig?: TSConfig;
+    /** https://github.com/fi3ework/vite-plugin-checker */
+    typeCheck?: Parameters<typeof Checker>[0] | false;
+}
+declare const typescript: VixtModule<TypescriptOptions>;
+
+declare module '@vixt/core' {
+    interface VixtOptions {
+        warmup?: WarmupOptions;
+    }
+}
+interface WarmupOptions {
+    enabled?: boolean;
+    /**
+     * The files to be transformed and used on the client-side. Supports glob patterns.
+     */
+    clientFiles?: string[];
+    /**
+     * The files to be transformed and used in SSR. Supports glob patterns.
+     */
+    ssrFiles?: string[];
+}
+declare const warmup: VixtModule<WarmupOptions>;
+
+declare function defineVixtConfig(input: VixtOptions): VixtOptions;
+declare const buildDir = ".vixt";
+declare const buildTypesDir = ".vixt/types";
+declare function loadVixtConfig(opts?: LoadConfigOptions<VixtOptions>): Promise<c12.ResolvedConfig<VixtOptions, c12.ConfigLayerMeta>>;
+declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
+
+declare function defineVitePlugin<Options = any>(pluginFn: (options?: Options) => PluginOption): (options?: Options) => PluginOption;
+declare function defineVixtModule<T extends ModuleOptions>(definition: ModuleDefinition<T> | VixtModule<T>): VixtModule<T>;
+declare function installModule(module: VixtModule, inlineOptions: any, vixt: Vixt): PluginOption;
+declare function applyLayerModules(layers?: VixtConfigLayer[]): Promise<VixtModule[]>;
+
+declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
+declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite.PluginOption;
+
+export { type AppHead, type AppOptions, type DevProxyOptions, type ModuleDefinition, type ModuleMeta, type ModuleOptions, type PluginOptions, type TypescriptOptions, type Vixt, type VixtConfigLayer, type VixtModule, type VixtOptions, type WarmupOptions, alias, app, applyLayerModules, buildDir, buildTypesDir, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, devProxy, installModule, loadVixt, loadVixtConfig, resolveLayersDirs, transformProxy, typescript, warmup };

package/dist/index.mjs

@@ -0,0 +1,374 @@
+import { cwd } from 'node:process';
+import path from 'pathe';
+import fs from 'fs-extra';
+import 'tsx/esm';
+import { pathToFileURL } from 'mlly';
+import defu from 'defu';
+import Checker from 'vite-plugin-checker';
+import { loadConfig } from 'c12';
+
+const name$5 = "vixt:alias";
+const alias = defineVixtModule({
+  meta: { name: name$5 },
+  setup() {
+    return {
+      name: name$5,
+      config() {
+        return {
+          resolve: {
+            alias: {
+              "@": `${path.resolve(cwd(), "src")}`,
+              "~": `${path.resolve(cwd(), "src")}`,
+              "@@": path.resolve(cwd()),
+              "~~": path.resolve(cwd())
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
+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 defaultOptions = typeof module.defaults === "function" ? module.defaults(vixt) : module.defaults;
+    const resolvedOptions = defu(inlineOptions, configKey ? vixt.options[configKey] : {}, defaultOptions);
+    return resolvedOptions;
+  }
+  function normalizedModule(inlineOptions, vixt) {
+    return module.setup?.(getOptions(inlineOptions, vixt), 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: modulesDir = [] } = resolveLayersDirs(layers);
+  const modules = [];
+  for (const m of modulesDir) {
+    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;
+}
+
+function defineVixtConfig(input) {
+  return input;
+}
+const buildDir = ".vixt";
+const buildTypesDir = `${buildDir}/types`;
+function loadVixtConfig(opts) {
+  return loadConfig({
+    name: "vixt",
+    ...opts,
+    defaults: {
+      buildDir,
+      buildTypesDir,
+      ...opts?.defaults
+    }
+  });
+}
+function resolveLayersDirs(layers) {
+  const dirs = {};
+  for (const layer of layers?.filter((e) => e.cwd) ?? []) {
+    const contents = fs.readdirSync(path.resolve(layer.cwd, "src"));
+    for (const content of contents) {
+      const fileOrDirPath = path.resolve(layer.cwd, "src", content);
+      if (fs.statSync(fileOrDirPath).isDirectory()) {
+        dirs[content] ?? (dirs[content] = []);
+        dirs[content].push(fileOrDirPath);
+      }
+    }
+  }
+  return dirs;
+}
+
+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, config) {
+  const { buildDir: buildDir2 } = vixt.options;
+  const { head = {}, rootTag, rootId, main, loadingTemplate: loading = "" } = options || {};
+  const headTemplate = Object.entries(head).filter(([k]) => k !== "noscript").map(([tag, attrs]) => attrs.map((e) => resolveHeadTag(tag, e))).flat().join("\n");
+  const noscriptTemplate = Object.entries(head).filter(([k]) => k === "noscript").map(([tag, attrs]) => attrs.map((e) => resolveHeadTag(tag, e))).flat().join("\n");
+  let loadingTemplate = "";
+  if (/^\.|\//.test(loading)) {
+    const loadingTemplatePath = path.resolve(config.root, loading);
+    if (fs.existsSync(loadingTemplatePath)) {
+      loadingTemplate = fs.readFileSync(loadingTemplatePath, "utf-8");
+    }
+  } else if (loading) {
+    loadingTemplate = loading;
+  }
+  const code = `
+<!doctype html>
+<html>
+  <head>
+${headTemplate}
+  </head>
+  <body>
+    <${rootTag} id="${rootId}">
+${loadingTemplate}
+    </${rootTag}>
+    <script type="module" src="${main}"><\/script>
+${noscriptTemplate}
+  </body>
+</html>
+`;
+  fs.outputFileSync(path.resolve(config.root, `${buildDir2}/index.html`), code);
+  return code;
+}
+const name$4 = "vixt:app";
+const defaults$2 = {
+  rootId: "app",
+  rootTag: "div",
+  loadingTemplate: "./loading.html",
+  main: `${buildDir}/main.ts`,
+  head: {
+    meta: [
+      { charset: "utf-8" },
+      { name: "viewport", content: "width=device-width, initial-scale=1.0" }
+    ],
+    noscript: [{ children: "This website requires JavaScript to function properly. Please enable JavaScript to continue." }]
+  }
+};
+const app = defineVixtModule({
+  meta: { name: name$4, configKey: "app" },
+  defaults: defaults$2,
+  setup(options, vixt) {
+    return {
+      name: name$4,
+      configResolved(config) {
+        generateIndexHtml(options, vixt, config);
+      },
+      transformIndexHtml: {
+        order: "pre",
+        handler() {
+          const { buildDir: buildDir2 } = vixt.options;
+          return fs.readFileSync(path.resolve(cwd(), `${buildDir2}/index.html`), { encoding: "utf-8" });
+        }
+      },
+      transform: {
+        order: "pre",
+        handler(code, id) {
+          if (!id.includes(options.main))
+            return;
+          return options.transformMain?.(vixt);
+        }
+      }
+    };
+  }
+});
+
+const name$3 = "vixt:config";
+const config = defineVixtModule({
+  meta: { name: name$3 },
+  setup(options, vixt) {
+    return {
+      name: name$3,
+      enforce: "pre",
+      config(config2) {
+        vixt.options.vite = config2;
+      },
+      configResolved(config2) {
+        vixt.options.vite = config2;
+      }
+    };
+  }
+});
+
+function transformProxy(list) {
+  return Object.fromEntries(
+    JSON.parse(list).map(([prefix, target, rewrite]) => {
+      const option = {
+        target,
+        changeOrigin: true,
+        ws: true,
+        secure: /^https:\/\//.test(target)
+      };
+      if (rewrite)
+        option.rewrite = (path) => path.replace(new RegExp(`^${prefix}`), "");
+      return [prefix, option];
+    })
+  );
+}
+const name$2 = "vixt:dev-proxy";
+const devProxy = defineVixtModule({
+  meta: { name: name$2, configKey: "devProxy" },
+  defaults: { key: "VITE_PROXY" },
+  setup(options) {
+    return {
+      name: name$2,
+      configResolved(config) {
+        const { env } = config;
+        const proxyList = env[options.key];
+        if (proxyList) {
+          const proxy = transformProxy(proxyList);
+          config.server.proxy = defu(proxy, config.server.proxy);
+          config.preview.proxy = defu(proxy, config.server.proxy);
+        }
+      }
+    };
+  }
+});
+
+function generateDts(options, vixt, config) {
+  const { root } = config;
+  const { buildDir } = vixt.options;
+  const vixtDts = 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(root, buildDir), reference.content ?? "");
+      return `/// <reference path="${reference.path}" />`;
+    } else {
+      return "";
+    }
+  }).concat("export {}").join("\n");
+  const vixtDtsPath = path.resolve(root, buildDir, "vixt.d.ts");
+  fs.outputFileSync(vixtDtsPath, vixtDts);
+}
+function generateTsConfig(options, vixt, config) {
+  const { root } = config;
+  const { buildDir } = vixt.options;
+  const tsConfigPath = path.resolve(root, buildDir, "tsconfig.json");
+  const layersDirs = vixt._layers.filter((e) => e.cwd).map((e) => e.cwd);
+  const tsConfig = defu(options.tsConfig, { include: layersDirs });
+  fs.outputFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2));
+}
+function generateEnvDts(options, vixt, config) {
+  const { env, root } = config;
+  const { buildDir } = vixt.options;
+  const values = Object.entries(env).map(([key, value]) => `/** ${key}=${value} */
+  ${key}: ${typeof value}`).join("\n  ");
+  const envDts = `interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+interface ImportMetaEnv {
+  ${values}
+}
+`;
+  const envDtsPath = path.resolve(root, buildDir, "types", "vite-env.d.ts");
+  fs.outputFileSync(envDtsPath, envDts);
+}
+function genarateShims(options, vixt, config) {
+  const { root } = config;
+  const { buildDir } = vixt.options;
+  const shimsDts = `
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+
+  const component: DefineComponent
+  export default component
+}
+`;
+  const shimsDtsPath = path.resolve(root, buildDir, "types", "shims.d.ts");
+  fs.outputFileSync(shimsDtsPath, shimsDts);
+}
+const name$1 = "vixt:typescript";
+const defaults$1 = {
+  references: ["./types/vite-env.d.ts", "./types/shims.d.ts"],
+  tsConfig: {
+    extends: "@vue/tsconfig/tsconfig.dom.json",
+    compilerOptions: {
+      paths: {
+        "@": ["../src"],
+        "@/*": ["../src/*"],
+        "~": ["../src"],
+        "~/*": ["../src/*"]
+      },
+      types: ["vite/client"]
+    },
+    include: [
+      "./**/*"
+    ]
+  },
+  typeCheck: { vueTsc: true, enableBuild: false, overlay: { initialIsOpen: false } }
+};
+const typescript = defineVixtModule({
+  meta: { name: name$1, configKey: "typescript" },
+  defaults: defaults$1,
+  setup(options, vixt) {
+    return [
+      {
+        name: name$1,
+        configResolved(config) {
+          generateDts(options, vixt, config);
+          generateTsConfig(options, vixt, config);
+          generateEnvDts(options, vixt, config);
+          genarateShims(options, vixt, config);
+        }
+      },
+      options.typeCheck && Checker(options.typeCheck)
+    ];
+  }
+});
+
+const defaults = {
+  enabled: true,
+  clientFiles: ["./index.html", "./src/**/*.vue", "./src/**/*.ts", "./src/**/*.tsx"],
+  ssrFiles: ["./index.html", "./src/**/*.vue", "./src/**/*.ts", "./src/**/*.tsx"]
+};
+const name = "vixt:warmup";
+const warmup = defineVixtModule({
+  meta: { name, configKey: "warmup" },
+  defaults,
+  setup(options) {
+    return {
+      name,
+      config() {
+        if (!options.enabled)
+          return;
+        return {
+          server: {
+            warmup: options
+          }
+        };
+      }
+    };
+  }
+});
+
+async function loadVixt(opts) {
+  const result = await loadVixtConfig(defu(opts, {
+    defaults: {
+      modules: [alias, app, config, devProxy, typescript, warmup]
+    }
+  }));
+  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 { alias, app, applyLayerModules, buildDir, buildTypesDir, config, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, devProxy, installModule, loadVixt, loadVixtConfig, resolveLayersDirs, transformProxy, typescript, warmup };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vixt/core",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "author": "SoulLyoko<https://github.com/SoulLyoko>",
   "license": "MIT",
   "homepage": "https://github.com/SoulLyoko/vixt#readme",