@ubean/modules 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,127 @@
+import { createHooks } from "hookable";
+import { Plugin } from "vite";
+import { ModuleDefinition, ResolvedConfig, ResolvedModule } from "@ubean/config";
+import { MiddlewareHandler } from "hono";
+import { UbeanApp } from "@ubean/app";
+import { UbeanEnv } from "@ubean/types";
+//#region src/kit.d.ts
+interface DevToolsCustomTab {
+  id: string;
+  title: string;
+  icon?: string;
+  component?: any;
+}
+interface ModuleHooks {
+  'app:created': (app: UbeanApp) => void | Promise<void>;
+  'app:before:register': (app: UbeanApp) => void | Promise<void>;
+  'app:after:register': (app: UbeanApp) => void | Promise<void>;
+  'app:ready': (app: UbeanApp) => void | Promise<void>;
+  'build:before': () => void | Promise<void>;
+  'build:after': () => void | Promise<void>;
+  'dev:setup': () => void | Promise<void>;
+  'dev:listen': (info: {
+    port: number;
+    host: string;
+    url: string;
+  }) => void | Promise<void>;
+  'request:start': (c: any) => void | Promise<void>;
+  'request:end': (c: any, res: Response) => void | Promise<void>;
+}
+interface ModuleKitContext {
+  moduleName: string;
+  options: Record<string, unknown>;
+  hooks: {
+    hook: <T extends keyof ModuleHooks>(name: T, fn: ModuleHooks[T]) => void;
+    callHook: <T extends keyof ModuleHooks>(name: T, ...args: Parameters<ModuleHooks[T]>) => Promise<void>;
+  };
+  addServerHandler: (handler: ServerHandlerRegistration) => void;
+  addDevServerHandler: (handler: DevServerHandlerRegistration) => void;
+  addVitePlugin: (plugin: Plugin | Plugin[]) => void;
+  addVirtualImports: (imports: VirtualImportRegistration) => void;
+  addComponentsDir: (dir: ComponentsDirRegistration) => void;
+  addAutoImport: (imports: AutoImportRegistration) => void;
+  addDevToolsTab: (tab: DevToolsCustomTab) => void;
+  _vitePlugins: Plugin[];
+  _serverHandlers: ServerHandlerRegistration[];
+  _devServerHandlers: DevServerHandlerRegistration[];
+  _virtualImports: VirtualImportRegistration[];
+  _componentsDirs: ComponentsDirRegistration[];
+  _autoImports: AutoImportRegistration[];
+  _devToolsTabs: DevToolsCustomTab[];
+}
+interface ServerHandlerRegistration {
+  route: string;
+  handler: MiddlewareHandler<UbeanEnv> | ((...args: any[]) => any);
+  method?: string | string[];
+  middleware?: boolean;
+}
+interface DevServerHandlerRegistration {
+  route: string;
+  handler: MiddlewareHandler<UbeanEnv> | ((...args: any[]) => any);
+  method?: string | string[];
+}
+interface VirtualImportRegistration {
+  imports: Array<{
+    name: string;
+    as?: string;
+    from: string;
+  }>;
+  from?: string;
+}
+interface ComponentsDirRegistration {
+  path: string;
+  pattern?: string;
+  pathPrefix?: boolean;
+  global?: boolean;
+}
+interface AutoImportRegistration {
+  imports: Array<string | {
+    name: string;
+    as?: string;
+    from: string;
+  }>;
+  from?: string;
+}
+declare function createModuleKitContext(moduleName: string, options: Record<string, unknown>): ModuleKitContext;
+declare function topologicalSort<T extends {
+  key: string;
+  name: string;
+  dependsOn: string[];
+}>(modules: T[], keyToIndex: Map<string, number>): T[];
+//#endregion
+//#region src/builtins.d.ts
+interface BuiltinModuleDefinition {
+  key: 'icon' | 'pwa' | 'auth' | 'image' | 'fonts' | 'electron' | 'ui';
+  modulePath: string;
+  factoryExport?: string;
+  pluginName: string;
+}
+declare const BUILTIN_MODULES: BuiltinModuleDefinition[];
+declare function getBuiltinModuleByKey(key: string): BuiltinModuleDefinition | undefined;
+declare function isBuiltinModuleConfig(value: unknown): value is {
+  disabled?: boolean;
+} & Record<string, unknown>;
+declare function extractBuiltinOptions(value: unknown): Record<string, unknown>;
+declare function isBuiltinDisabled(value: unknown): boolean;
+//#endregion
+//#region src/index.d.ts
+interface ResolveModulesOptions {
+  cwd: string;
+  config: ResolvedConfig;
+  builtinPlugins: Plugin[];
+}
+interface ResolveModulesResult {
+  plugins: Plugin[];
+  modules: ResolvedModule[];
+  setupFns: Array<(kit?: ModuleKitContext) => void | Promise<void>>;
+  hooks: ReturnType<typeof createHooks<ModuleHooks>>;
+  serverHandlers: ServerHandlerRegistration[];
+  devServerHandlers: DevServerHandlerRegistration[];
+  devToolsTabs: DevToolsCustomTab[];
+}
+declare function resolveModules(options: ResolveModulesOptions): Promise<ResolveModulesResult>;
+declare function defineModule<TOptions = unknown>(def: ModuleDefinition & {
+  setup?: (options: TOptions, kit: ModuleKitContext) => void | Promise<void>;
+}): ModuleDefinition;
+//#endregion
+export { type AutoImportRegistration, BUILTIN_MODULES, type BuiltinModuleDefinition, type ComponentsDirRegistration, type DevServerHandlerRegistration, type DevToolsCustomTab, type ModuleHooks, type ModuleKitContext, ResolveModulesOptions, ResolveModulesResult, type ServerHandlerRegistration, type VirtualImportRegistration, createModuleKitContext, defineModule, extractBuiltinOptions, getBuiltinModuleByKey, isBuiltinDisabled, isBuiltinModuleConfig, resolveModules, topologicalSort };

package/dist/index.js

@@ -0,0 +1,408 @@
+import { createHooks } from "hookable";
+//#region src/builtins.ts
+const BUILTIN_MODULES = [
+	{
+		key: "icon",
+		modulePath: "@ubean/icon/vite",
+		factoryExport: "ubeanIconPlugin",
+		pluginName: "ubean:icon"
+	},
+	{
+		key: "pwa",
+		modulePath: "@ubean/pwa/vite",
+		factoryExport: "ubeanPwaPlugin",
+		pluginName: "ubean:pwa"
+	},
+	{
+		key: "auth",
+		modulePath: "@ubean/auth/vite",
+		factoryExport: "ubeanAuthPlugin",
+		pluginName: "ubean:auth"
+	},
+	{
+		key: "image",
+		modulePath: "@ubean/image/vite",
+		factoryExport: "ubeanImagePlugin",
+		pluginName: "ubean:image"
+	},
+	{
+		key: "fonts",
+		modulePath: "@ubean/fonts/vite",
+		factoryExport: "ubeanFontsPlugin",
+		pluginName: "ubean:fonts"
+	},
+	{
+		key: "electron",
+		modulePath: "@ubean/electron/vite",
+		factoryExport: "ubeanElectronPlugin",
+		pluginName: "ubean:electron"
+	},
+	{
+		key: "ui",
+		modulePath: "@ubean/ui/vite",
+		factoryExport: "ubeanUiPlugin",
+		pluginName: "ubean:ui"
+	}
+];
+function getBuiltinModuleByKey(key) {
+	return BUILTIN_MODULES.find((m) => m.key === key);
+}
+function isBuiltinModuleConfig(value) {
+	return value === true || typeof value === "object" && value !== null;
+}
+function extractBuiltinOptions(value) {
+	if (value === true) return {};
+	if (typeof value === "object" && value !== null) {
+		const { disabled: _disabled, ...options } = value;
+		return options;
+	}
+	return {};
+}
+function isBuiltinDisabled(value) {
+	if (value === false) return true;
+	if (value === true) return false;
+	if (typeof value === "object" && value !== null) return value.disabled === true;
+	return true;
+}
+//#endregion
+//#region src/kit.ts
+function createModuleKitContext(moduleName, options) {
+	const ctx = {
+		moduleName,
+		options,
+		hooks: {
+			hook: () => {},
+			callHook: async () => {}
+		},
+		addServerHandler: (handler) => {
+			ctx._serverHandlers.push(handler);
+		},
+		addDevServerHandler: (handler) => {
+			ctx._devServerHandlers.push(handler);
+		},
+		addVitePlugin: (plugin) => {
+			const plugins = Array.isArray(plugin) ? plugin : [plugin];
+			ctx._vitePlugins.push(...plugins);
+		},
+		addVirtualImports: (imports) => {
+			ctx._virtualImports.push(imports);
+		},
+		addComponentsDir: (dir) => {
+			ctx._componentsDirs.push(dir);
+		},
+		addAutoImport: (imports) => {
+			ctx._autoImports.push(imports);
+		},
+		addDevToolsTab: (tab) => {
+			ctx._devToolsTabs.push(tab);
+		},
+		_vitePlugins: [],
+		_serverHandlers: [],
+		_devServerHandlers: [],
+		_virtualImports: [],
+		_componentsDirs: [],
+		_autoImports: [],
+		_devToolsTabs: []
+	};
+	return ctx;
+}
+function topologicalSort(modules, keyToIndex) {
+	const inDegree = /* @__PURE__ */ new Map();
+	const graph = /* @__PURE__ */ new Map();
+	const sorted = [];
+	for (const mod of modules) {
+		inDegree.set(mod.key, 0);
+		graph.set(mod.key, []);
+	}
+	for (const mod of modules) for (const dep of mod.dependsOn) {
+		const depKey = dep;
+		if (keyToIndex.has(depKey)) {
+			graph.get(depKey).push(mod.key);
+			inDegree.set(mod.key, (inDegree.get(mod.key) || 0) + 1);
+		}
+	}
+	const queue = [];
+	for (const mod of modules) if ((inDegree.get(mod.key) || 0) === 0) queue.push(mod.key);
+	while (queue.length > 0) {
+		const key = queue.shift();
+		const idx = keyToIndex.get(key);
+		if (idx !== void 0) sorted.push(modules[idx]);
+		for (const dependent of graph.get(key) || []) {
+			inDegree.set(dependent, (inDegree.get(dependent) || 0) - 1);
+			if ((inDegree.get(dependent) || 0) === 0) queue.push(dependent);
+		}
+	}
+	if (sorted.length < modules.length) {
+		const sortedKeys = new Set(sorted.map((m) => m.key));
+		for (const mod of modules) if (!sortedKeys.has(mod.key)) sorted.push(mod);
+	}
+	return sorted;
+}
+//#endregion
+//#region src/index.ts
+const BUILTIN_CORE_KEYS = /* @__PURE__ */ new Set([
+	"__ubean_core__",
+	"__ubean_vue__",
+	"__ubean_islands__"
+]);
+const MODULE_DEF_KEYS = /* @__PURE__ */ new Set([
+	"vitePlugin",
+	"setup",
+	"hooks",
+	"dependsOn"
+]);
+function isModuleDefinition(obj) {
+	if (!obj || typeof obj !== "object" || Array.isArray(obj)) return false;
+	return Object.keys(obj).some((k) => MODULE_DEF_KEYS.has(k));
+}
+function isVitePlugin(obj) {
+	if (!obj || typeof obj !== "object" || Array.isArray(obj)) return false;
+	return typeof obj.name === "string" && !isModuleDefinition(obj);
+}
+function getModuleKey(mod, index) {
+	if (typeof mod === "string") return mod;
+	if (Array.isArray(mod)) {
+		const [factory] = mod;
+		if (typeof factory === "function") return factory.name || `__factory_${index}__`;
+		return `__tuple_${index}__`;
+	}
+	if (mod && typeof mod === "object") {
+		if (isModuleDefinition(mod)) return mod.name || `__def_${index}__`;
+		const plugin = mod;
+		if (plugin.name) return plugin.name;
+	}
+	return `__module_${index}__`;
+}
+function getModuleName(mod, key) {
+	if (typeof mod === "string") {
+		const parts = mod.split("/");
+		return parts[parts.length - 1] || mod;
+	}
+	if (Array.isArray(mod)) {
+		const [factory] = mod;
+		if (typeof factory === "function") return factory.name || key;
+		return key;
+	}
+	if (mod && typeof mod === "object") {
+		if (isModuleDefinition(mod) && mod.name) return mod.name;
+		const plugin = mod;
+		if (plugin.name) return plugin.name;
+	}
+	return key;
+}
+function extractPlugins(mod) {
+	if (!mod) return [];
+	if (Array.isArray(mod)) return mod.filter(isVitePlugin);
+	if (typeof mod === "object") {
+		if (isModuleDefinition(mod)) {
+			if (mod.vitePlugin) return Array.isArray(mod.vitePlugin) ? mod.vitePlugin.filter(isVitePlugin) : [mod.vitePlugin].filter(isVitePlugin);
+			return [];
+		}
+		if (isVitePlugin(mod)) return [mod];
+	}
+	return [];
+}
+function extractSetup(mod) {
+	if (isModuleDefinition(mod)) return mod.setup;
+}
+function extractHooks(mod) {
+	if (isModuleDefinition(mod)) return mod.hooks;
+}
+function extractDependsOn(mod) {
+	if (isModuleDefinition(mod)) return mod.dependsOn || [];
+	return [];
+}
+function userModulesHasBuiltin(userModules, builtin) {
+	for (const mod of userModules) if (typeof mod === "string") {
+		if (mod === builtin.modulePath || mod.endsWith(builtin.modulePath)) return true;
+	} else if (Array.isArray(mod)) {
+		const [factory] = mod;
+		if (typeof factory === "function") {
+			if (factory.name === `${builtin.pluginName.replace(":", "")}Plugin`) return true;
+		}
+	} else if (mod && typeof mod === "object") {
+		if (isModuleDefinition(mod) && mod.name === builtin.pluginName) return true;
+		if (mod.name === builtin.pluginName) return true;
+	}
+	return false;
+}
+async function loadBuiltinModule(builtin, configValue) {
+	const options = extractBuiltinOptions(configValue);
+	const kit = createModuleKitContext(builtin.pluginName, options);
+	try {
+		const mod = await import(
+			/* @vite-ignore */
+			builtin.modulePath
+);
+		const factory = builtin.factoryExport ? mod[builtin.factoryExport] : mod.default || mod;
+		if (typeof factory === "function") {
+			const result = await factory(options, kit);
+			if (result) {
+				const plugins = extractPlugins(result);
+				const setup = extractSetup(result);
+				const hooks = extractHooks(result);
+				const dependsOn = extractDependsOn(result);
+				plugins.push(...kit._vitePlugins);
+				return {
+					key: builtin.modulePath,
+					name: builtin.pluginName,
+					plugins,
+					setup,
+					hooks,
+					dependsOn,
+					options,
+					kit
+				};
+			}
+		}
+	} catch {}
+	return null;
+}
+async function parseUserModule(mod, index) {
+	const key = getModuleKey(mod, index);
+	const name = getModuleName(mod, key);
+	const options = {};
+	const kit = createModuleKitContext(name, options);
+	let resolvedPlugins = [];
+	let setupFn;
+	let hooks;
+	let dependsOn = [];
+	if (typeof mod === "string") try {
+		const factoryMod = await import(
+			/* @vite-ignore */
+			mod
+);
+		const factoryFn = factoryMod.default || factoryMod;
+		if (typeof factoryFn === "function") {
+			const result = await factoryFn(options, kit);
+			if (result) if (Array.isArray(result)) resolvedPlugins = extractPlugins(result);
+			else {
+				resolvedPlugins = extractPlugins(result);
+				setupFn = extractSetup(result);
+				hooks = extractHooks(result);
+				dependsOn = extractDependsOn(result);
+				if (isModuleDefinition(result) && result.name) kit.moduleName = result.name;
+			}
+		}
+	} catch {
+		return null;
+	}
+	else if (Array.isArray(mod)) {
+		const [factory, factoryOptions] = mod;
+		Object.assign(options, factoryOptions || {});
+		if (typeof factory === "function") try {
+			const result = await factory(factoryOptions, kit);
+			if (result) if (Array.isArray(result)) resolvedPlugins = extractPlugins(result);
+			else {
+				resolvedPlugins = extractPlugins(result);
+				setupFn = extractSetup(result);
+				hooks = extractHooks(result);
+				dependsOn = extractDependsOn(result);
+				if (isModuleDefinition(result) && result.name) kit.moduleName = result.name;
+			}
+		} catch {
+			return null;
+		}
+	} else if (mod && typeof mod === "object") {
+		resolvedPlugins = extractPlugins(mod);
+		setupFn = extractSetup(mod);
+		hooks = extractHooks(mod);
+		dependsOn = extractDependsOn(mod);
+		if (isModuleDefinition(mod) && mod.name) kit.moduleName = mod.name;
+	} else return null;
+	resolvedPlugins.push(...kit._vitePlugins);
+	return {
+		key,
+		name: kit.moduleName || name,
+		plugins: resolvedPlugins,
+		setup: setupFn,
+		hooks,
+		dependsOn,
+		options,
+		kit
+	};
+}
+async function resolveModules(options) {
+	const { config, builtinPlugins } = options;
+	const { modules: userModules = [] } = config;
+	const moduleHooks = createHooks();
+	const parsed = [];
+	const parsedKeys = /* @__PURE__ */ new Set();
+	const plugins = [...builtinPlugins];
+	const serverHandlers = [];
+	const devServerHandlers = [];
+	const devToolsTabs = [];
+	for (const builtin of BUILTIN_MODULES) {
+		const configValue = config[builtin.key];
+		if (isBuiltinDisabled(configValue)) continue;
+		if (userModulesHasBuiltin(userModules, builtin)) continue;
+		const loaded = await loadBuiltinModule(builtin, configValue);
+		if (loaded && !BUILTIN_CORE_KEYS.has(loaded.key) && !parsedKeys.has(loaded.key)) {
+			parsedKeys.add(loaded.key);
+			parsed.push(loaded);
+		}
+	}
+	for (let i = 0; i < userModules.length; i++) {
+		const mod = userModules[i];
+		const key = getModuleKey(mod, i);
+		if (BUILTIN_CORE_KEYS.has(key) || parsedKeys.has(key)) continue;
+		const parsedMod = await parseUserModule(mod, i);
+		if (parsedMod) {
+			parsedKeys.add(parsedMod.key);
+			parsed.push(parsedMod);
+		}
+	}
+	const keyToIndex = /* @__PURE__ */ new Map();
+	for (let i = 0; i < parsed.length; i++) keyToIndex.set(parsed[i].key, i);
+	const sorted = topologicalSort(parsed, keyToIndex);
+	const resolvedModules = [];
+	const coreModule = {
+		name: "ubean-core",
+		key: "__ubean_core__",
+		plugins: builtinPlugins,
+		dependsOn: []
+	};
+	resolvedModules.push(coreModule);
+	for (const mod of sorted) {
+		if (mod.setup) {
+			const setup = mod.setup;
+			const kit = mod.kit;
+			kit.hooks = {
+				hook: ((name, fn) => moduleHooks.hook(name, fn)),
+				callHook: async (name, ...args) => {
+					await moduleHooks.callHook(name, ...args);
+				}
+			};
+			await setup(mod.options, kit);
+		}
+		if (mod.hooks) for (const [hookName, hookFn] of Object.entries(mod.hooks)) moduleHooks.hook(hookName, hookFn);
+		plugins.push(...mod.plugins);
+		plugins.push(...mod.kit._vitePlugins);
+		serverHandlers.push(...mod.kit._serverHandlers);
+		devServerHandlers.push(...mod.kit._devServerHandlers);
+		devToolsTabs.push(...mod.kit._devToolsTabs);
+		resolvedModules.push({
+			name: mod.name,
+			key: mod.key,
+			plugins: [...mod.plugins, ...mod.kit._vitePlugins],
+			options: mod.options,
+			setup: mod.setup,
+			hooks: mod.hooks,
+			dependsOn: mod.dependsOn
+		});
+	}
+	return {
+		plugins,
+		modules: resolvedModules,
+		setupFns: [],
+		hooks: moduleHooks,
+		serverHandlers,
+		devServerHandlers,
+		devToolsTabs
+	};
+}
+function defineModule(def) {
+	return def;
+}
+//#endregion
+export { BUILTIN_MODULES, createModuleKitContext, defineModule, extractBuiltinOptions, getBuiltinModuleByKey, isBuiltinDisabled, isBuiltinModuleConfig, resolveModules, topologicalSort };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/modules",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Module system for ubean (resolveModules, defineModule, BUILTIN_MODULES)",
   "files": [
     "dist"
@@ -17,9 +17,9 @@
   },
   "dependencies": {
     "hookable": "^6.1.1",
-    "@ubean/config": "0.1.1",
-    "@ubean/app": "0.1.1",
-    "@ubean/types": "0.1.1"
+    "@ubean/app": "0.1.3",
+    "@ubean/config": "0.1.3",
+    "@ubean/types": "0.1.3"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",