@vixt/core 0.5.17 → 0.6.1

package/dist/client/index.d.ts

@@ -1,18 +1,31 @@
+//#region src/client/app.d.ts
 interface VixtApp {
-    appConfig: VixtAppConfig;
+  app: any;
+  appConfig: VixtAppConfig;
+  [key: string]: unknown;
+}
+interface CreateOptions {
+  app: any;
+  appConfig: VixtAppConfig;
 }
 interface VixtAppConfig extends Record<string, any> {
+  readonly baseURL?: string;
+  readonly rootId?: string;
 }
 declare function defineAppConfig(config: VixtAppConfig): VixtAppConfig;
-
+declare function useAppConfig(): VixtAppConfig;
+declare function useVixtApp(): VixtApp;
+declare function createVixtApp(options: CreateOptions): VixtApp;
+//#endregion
+//#region src/client/plugin.d.ts
 interface PluginDefinition {
-    name?: string;
-    setup?: (this: void, vixt: VixtApp) => any;
+  name?: string;
+  setup?: (this: void, vixt: VixtApp) => any;
 }
 interface VixtPlugin {
-    (this: void, vixt: VixtApp): any;
+  (this: void, vixt: VixtApp): any;
 }
 declare function defineVixtPlugin(definition: PluginDefinition | VixtPlugin): VixtPlugin;
-
-export { defineAppConfig, defineVixtPlugin };
-export type { PluginDefinition, VixtApp, VixtAppConfig, VixtPlugin };
+declare function applyPlugins(vixt: VixtApp, plugins: VixtPlugin[]): Promise<void>;
+//#endregion
+export { CreateOptions, PluginDefinition, VixtApp, VixtAppConfig, VixtPlugin, applyPlugins, createVixtApp, defineAppConfig, defineVixtPlugin, useAppConfig, useVixtApp };

package/dist/client/index.js

@@ -0,0 +1,28 @@
+//#region src/client/app.ts
+function defineAppConfig(config) {
+	return config;
+}
+function useAppConfig() {
+	return useVixtApp()?.appConfig ?? {};
+}
+function useVixtApp() {
+	return globalThis.useVixtApp?.();
+}
+function createVixtApp(options) {
+	const vixtApp = { ...options };
+	globalThis.useVixtApp = () => vixtApp;
+	return vixtApp;
+}
+
+//#endregion
+//#region src/client/plugin.ts
+function defineVixtPlugin(definition) {
+	if (typeof definition == "function") return defineVixtPlugin({ setup: definition });
+	return (vixt) => definition.setup?.(vixt);
+}
+async function applyPlugins(vixt, plugins) {
+	for (const plugin of plugins) typeof plugin === "function" && await plugin(vixt);
+}
+
+//#endregion
+export { applyPlugins, createVixtApp, defineAppConfig, defineVixtPlugin, useAppConfig, useVixtApp };

package/dist/node/index.d.mts

@@ -1,135 +1,274 @@
-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;
-}
+import * as c120 from "c12";
+import { ConfigLayer, ConfigLayerMeta, LoadConfigOptions } from "c12";
+import * as vite0 from "vite";
+import { HtmlTagDescriptor, InlineConfig, LogLevel, PluginOption, ServerOptions, UserConfig } from "vite";
+import Legacy from "@vitejs/plugin-legacy";
+import Analyzer from "vite-bundle-analyzer";
+import Ssl from "@vitejs/plugin-basic-ssl";
+import Checker from "vite-plugin-checker";
+import { RawVueCompilerOptions } from "@vue/language-core";
+import { TSConfig } from "pkg-types";
 
+//#region src/node/vixt.d.ts
 interface Vixt {
-    options: VixtOptions;
-    _layers: VixtConfigLayer[];
-    _modules: VixtModule[];
+  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);
+declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => vite0.PluginOption;
+//#endregion
+//#region src/node/module.d.ts
+type ExtractPluginOptions<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;
+  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;
+  meta?: ModuleMeta;
+  defaults?: Partial<T> | ((vixt: Vixt) => Partial<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;
+  (this: void, resolvedOptions: T, vixt: Vixt): PluginOption;
+  getOptions?: (inlineOptions: Partial<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 installModule<T extends ModuleOptions = ModuleOptions>(module: VixtModule<T>, 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;
+//#endregion
+//#region src/node/config.d.ts
+interface VixtOptions {
+  /**
+   * Vixt App configuration.
+   */
+  app?: AppOptions;
+  /**
+   * Shared build configuration.
+   */
+  build?: BuildOptions;
+  /**
+   * Define the root directory of your application.
+   * @default process.cwd()
+   */
+  rootDir?: string;
+  /**
+   * Define the monorepo workspace directory of your application.
+   */
+  workspaceDir?: string;
+  /**
+   * Define the source directory of your application.
+   * @default '<rootDir>/src'
+   */
+  srcDir?: string;
+  /**
+   * Define the server directory of your application.
+   * @default '<rootDir>/server'
+   */
+  serverDir?: string;
+  /**
+   * Define the directory where your built files will be placed.
+   * @default '<rootDir>/.vixt'
+   */
+  buildDir?: string;
+  /**
+   * @default '<buildDir>/types'
+   */
+  buildTypesDir?: string;
+  /**
+   * @default '<buildDir>/layers'
+   */
+  buildLayersDir?: string;
+  /**
+   * @default '<buildDir>/imports'
+   */
+  buildImportsDir?: string;
+  /**
+   * Define the directory of your Vixt modules.
+   * @default '<srcDir>/modules'
+   */
+  modulesDir?: string;
+  /**
+   * Define the directory of your Vixt plugins.
+   * @default '<srcDir>/plugins'
+   */
+  pluginsDir?: string;
+  /**
+   * Whether your app is running in development mode.
+   * @default false
+   */
+  dev?: boolean;
+  /**
+   * Whether your app is being unit tested.
+   * @default false
+   */
+  test?: boolean;
+  /**
+   * Set to `true` to enable debug mode.
+   * @default false
+   */
+  debug?: boolean;
+  /**
+   * Whether to enable rendering of HTML.
+   * @default false
+   */
+  ssr?: boolean;
+  /**
+   * You can improve your DX by defining additional aliases to access custom directories within your JavaScript and CSS.
+   */
+  alias?: AliasOptions;
+  /**
+   * Configuration that will be passed directly to Vite.
+   */
+  appConfig?: Record<string, any>;
+  devServer?: DevServerOptions;
+  /** Vite config input */
+  vite?: Omit<UserConfig, 'plugins'>;
+  /** layer meta */
+  meta?: VixtConfigLayerMeta;
+  /** layers */
+  extends?: string[];
+  /** modules */
+  modules?: VixtModule[];
+  /** plugins */
+  plugins?: string[];
+  /** typescript */
+  typescript?: TypescriptOptions;
+  /** custom options */
+  [key: string]: any;
+}
+interface AppHeadAttrs {
+  children?: string;
+  injectTo?: HtmlTagDescriptor['injectTo'];
+  [key: string]: string | boolean | undefined;
+}
+interface AppHead {
+  title?: AppHeadAttrs[];
+  link?: AppHeadAttrs[];
+  meta?: AppHeadAttrs[];
+  style?: AppHeadAttrs[];
+  script?: AppHeadAttrs[];
+  noscript?: AppHeadAttrs[];
+}
+interface AppOptions {
+  /**
+   * The base path of your Nuxt application.
+   * @default '/'
+   */
+  baseURL?: string;
+  /**
+   * You can define the CSS files/modules/libraries you want to set globally.
+   */
+  css?: string[];
+  /**
+   * The entry file relative to <srcDir>
+   * @default 'main.ts'(vue)
+   * @default 'main.tsx'(react)
+   * @example 'entry.ts'(means '/<srcDir>/entry.ts')
+   */
+  entryFile?: string;
+  entryCode?: string;
+  /**
+   * Set default configuration for `<head>`.
+   */
+  head?: AppHead;
+  /**
+   * The path to an HTML file with the contents of which will be inserted into index.html.
+   * Some good sources for spinners are [SpinKit](https://github.com/tobiasahlin/SpinKit) or [SVG Spinners](https://icones.js.org/collection/svg-spinners).
+   */
+  loadingTemplate?: string;
+  /**
+   * Customize Vixt root element id.
+   * @default 'app'
+   */
+  rootId?: string;
+  /**
+   * Customize Vixt root element tag.
+   * @default 'div'
+   */
+  rootTag?: string;
+}
+interface AliasOptions {
+  [find: string]: string;
+}
+interface DevServerOptions extends Pick<ServerOptions, 'port' | 'host' | 'cors'> {
+  /** https://github.com/vitejs/vite-plugin-basic-ssl */
+  https?: boolean | ExtractPluginOptions<typeof Ssl> & {
+    enabled?: boolean;
+  };
+  /**
+   * The watch property lets you define patterns that will restart the dev server when changed.
+   */
+  watch?: string[];
+}
+interface BuildOptions {
+  /** https://github.com/nonzzz/vite-bundle-analyzer */
+  analyze?: boolean | ExtractPluginOptions<typeof Analyzer> & {
+    enabled?: boolean;
+  };
+  /** https://github.com/vitejs/vite/tree/main/packages/plugin-legacy */
+  legacy?: boolean | ExtractPluginOptions<typeof Legacy> & {
+    enabled?: boolean;
+  };
+}
+interface TypescriptOptions {
+  references?: (string | {
+    path?: string;
+    content?: string;
+  })[];
+  tsConfig?: TSConfig & {
+    vueCompilerOptions?: RawVueCompilerOptions;
+  };
+  /** https://github.com/fi3ework/vite-plugin-checker */
+  typeCheck?: ExtractPluginOptions<typeof Checker>;
+  /**
+   * Generate a `*.vue` shim
+   * @default false
+   */
+  shim?: boolean;
 }
 interface VixtConfigLayerMeta extends ConfigLayerMeta {
-    /** layer name */
-    name?: string;
-    /** layer alias */
-    alias?: string;
+  /** 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;
+  /** 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 loadVixtConfig(opts?: LoadConfigOptions<VixtOptions>): Promise<c120.ResolvedConfig<VixtOptions, ConfigLayerMeta>>;
+declare function applyLayers(layers: VixtConfigLayer[], config: VixtOptions): VixtConfigLayer[];
 declare function isSamePath(a: string, b: string): boolean;
 declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
-
+declare const VixtClientAutoImports: Record<string, string[]>;
+//#endregion
+//#region src/node/env.d.ts
+/** https://github.com/vitejs/vite/blob/v8.0.0-beta.3/packages/vite/src/node/cli.ts */
+interface GlobalCLIOptions {
+  '--'?: string[];
+  'c'?: boolean | string;
+  'config'?: string;
+  'base'?: string;
+  'l'?: LogLevel;
+  'logLevel'?: LogLevel;
+  'clearScreen'?: boolean;
+  'configLoader'?: InlineConfig['configLoader'];
+  'd'?: boolean | string;
+  'debug'?: boolean | string;
+  'f'?: string;
+  'filter'?: string;
+  'm'?: string;
+  'mode'?: string;
+  'force'?: boolean;
+  'w'?: boolean;
+}
+declare function loadCLIOptions(): GlobalCLIOptions;
+declare function loadMode(): string | undefined;
 /**
  * Load workspace and cwd env variables by default
  */
@@ -142,41 +281,13 @@ 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 };
+//#endregion
+//#region src/node/modules/index.d.ts
+declare const virtualModuleIds: {
+  css: string | undefined;
+  appConfig: string | undefined;
+  plugins: string | undefined;
+};
+declare const builtinModules: (VixtModule<ModuleOptions> | VixtModule<AliasOptions> | VixtModule<AppOptions> | VixtModule<BuildOptions> | VixtModule<DevServerOptions> | VixtModule<TypescriptOptions>)[];
+//#endregion
+export { AliasOptions, AppHead, AppHeadAttrs, AppOptions, BuildOptions, DevServerOptions, ExtractPluginOptions, GlobalCLIOptions, ModuleDefinition, ModuleMeta, ModuleOptions, TypescriptOptions, Vixt, VixtClientAutoImports, VixtConfigLayer, VixtConfigLayerMeta, VixtModule, VixtOptions, applyLayerModules, applyLayers, builtinModules, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, installModule, isSamePath, loadCLIOptions, loadEnv, loadMode, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, virtualModuleIds };