@vixt/core 0.5.16 → 0.6.0

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/index.d.mts

@@ -0,0 +1,293 @@
+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[];
+}
+declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
+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;
+}
+interface ModuleDefinition<T extends ModuleOptions = ModuleOptions> {
+  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, 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<T extends ModuleOptions = ModuleOptions>(module: VixtModule<T>, inlineOptions: any, vixt: Vixt): PluginOption;
+declare function applyLayerModules(layers: VixtConfigLayer[]): Promise<VixtModule[]>;
+//#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;
+}
+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<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
+ */
+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>;
+//#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 };