@powerlines/plugin-webpack 0.5.132 → 0.5.134

package/dist/powerlines/src/lib/contexts/environment-context.cjs

@@ -0,0 +1,160 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_plugin = require('../../types/plugin.cjs');
+const require_helpers = require('../../plugin-utils/helpers.cjs');
+const require_context = require('./context.cjs');
+const require_plugin_context = require('./plugin-context.cjs');
+let __stryke_fs_resolve = require("@stryke/fs/resolve");
+let __stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+let __stryke_type_checks_is_object = require("@stryke/type-checks/is-object");
+
+//#region ../powerlines/src/lib/contexts/environment-context.ts
+var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends require_context.PowerlinesContext {
+	/**
+	* The hooks registered by plugins in this environment
+	*/
+	#hooks = {};
+	/**
+	* Create a new Storm context from the workspace root and user config.
+	*
+	* @param workspaceConfig - The root directory of the workspace.
+	* @param config - The user configuration options.
+	* @returns A promise that resolves to the new context.
+	*/
+	static async fromConfig(workspaceConfig, config) {
+		const context = new PowerlinesEnvironmentContext(config, workspaceConfig);
+		await context.init();
+		const powerlinesPath = await (0, __stryke_fs_resolve.resolvePackage)("powerlines");
+		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
+		context.powerlinesPath = powerlinesPath;
+		return context;
+	}
+	/**
+	* The resolved environment configuration
+	*/
+	environment;
+	/**
+	* The list of plugins applied to this environment
+	*/
+	plugins = [];
+	/**
+	* The resolved configuration options
+	*/
+	get config() {
+		return super.config;
+	}
+	get hooks() {
+		return this.#hooks;
+	}
+	async addPlugin(plugin) {
+		let resolvedPlugin = plugin;
+		if ((0, __stryke_type_checks_is_function.isFunction)(plugin.applyToEnvironment)) {
+			const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
+			if (!result || (0, __stryke_type_checks_is_object.isObject)(result) && Object.keys(result).length === 0) return;
+			if (require_helpers.isPluginConfig(result)) return this.$$internal.addPlugin(result);
+			resolvedPlugin = require_helpers.isPlugin(result) ? result : plugin;
+		}
+		const context = require_plugin_context.createPluginContext(resolvedPlugin, this);
+		this.plugins.push({
+			plugin: resolvedPlugin,
+			context
+		});
+		this.#hooks = Object.keys(resolvedPlugin).filter((key) => !require_plugin.PLUGIN_NON_HOOK_FIELDS.includes(key)).reduce((ret, key) => {
+			const hook = key;
+			const pluginHook = resolvedPlugin[hook];
+			if (!require_helpers.isPluginHook(pluginHook)) return ret;
+			if (!require_helpers.isHookExternal(hook)) {
+				ret[hook] ??= {};
+				if (resolvedPlugin.enforce) {
+					ret[hook][`${resolvedPlugin.enforce}Enforced`] ??= [];
+					require_helpers.addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${resolvedPlugin.enforce}Enforced`]);
+					return ret;
+				}
+				if ((0, __stryke_type_checks_is_function.isFunction)(pluginHook) || !pluginHook.order) {
+					ret[hook].normal ??= [];
+					require_helpers.addPluginHook(context, resolvedPlugin, pluginHook, ret[hook].normal);
+					return ret;
+				}
+				ret[hook][`${pluginHook.order}Ordered`] ??= [];
+				require_helpers.addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${pluginHook.order}Ordered`]);
+			} else {
+				ret[hook] ??= [];
+				ret[hook].push({
+					plugin: resolvedPlugin,
+					hook: require_helpers.getHookHandler(pluginHook).bind(context)
+				});
+			}
+			return ret;
+		}, this.hooks);
+	}
+	/**
+	* Retrieves the hook handlers for a specific hook name
+	*/
+	selectHooks(hook, options) {
+		const result = [];
+		if (this.hooks[hook]) if (!require_helpers.isHookExternal(hook)) {
+			const hooks = this.hooks[hook];
+			if (options?.order) if (options?.order === "pre") {
+				result.push(...(hooks.preOrdered ?? []).map((h) => {
+					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+					return {
+						handle: h.handler,
+						context: plugin.context
+					};
+				}));
+				result.push(...(hooks.preEnforced ?? []).map((h) => {
+					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+					return {
+						handle: h.handler,
+						context: plugin.context
+					};
+				}));
+			} else if (options?.order === "post") {
+				result.push(...(hooks.postOrdered ?? []).map((h) => {
+					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+					return {
+						handle: h.handler,
+						context: plugin.context
+					};
+				}));
+				result.push(...(hooks.postEnforced ?? []).map((h) => {
+					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+					return {
+						handle: h.handler,
+						context: plugin.context
+					};
+				}));
+			} else result.push(...(hooks.normal ?? []).map((h) => {
+				const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+				if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+				return {
+					handle: h.handler,
+					context: plugin.context
+				};
+			}));
+			else {
+				result.push(...this.selectHooks(hook, { order: "pre" }));
+				result.push(...this.selectHooks(hook, { order: "normal" }));
+				result.push(...this.selectHooks(hook, { order: "post" }));
+			}
+		} else result.push(...this.hooks[hook].map((h) => {
+			const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+			if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+			return {
+				handle: h.handler,
+				context: plugin.context
+			};
+		}));
+		return result;
+	}
+	constructor(config, workspaceConfig) {
+		super(workspaceConfig);
+		this.resolvedConfig = config;
+	}
+};
+
+//#endregion
+exports.PowerlinesEnvironmentContext = PowerlinesEnvironmentContext;

package/dist/powerlines/src/lib/contexts/environment-context.mjs

@@ -0,0 +1,159 @@
+import { PLUGIN_NON_HOOK_FIELDS } from "../../types/plugin.mjs";
+import { addPluginHook, getHookHandler, isHookExternal, isPlugin, isPluginConfig, isPluginHook } from "../../plugin-utils/helpers.mjs";
+import { PowerlinesContext } from "./context.mjs";
+import { createPluginContext } from "./plugin-context.mjs";
+import { resolvePackage } from "@stryke/fs/resolve";
+import { isFunction } from "@stryke/type-checks/is-function";
+import { isObject } from "@stryke/type-checks/is-object";
+
+//#region ../powerlines/src/lib/contexts/environment-context.ts
+var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends PowerlinesContext {
+	/**
+	* The hooks registered by plugins in this environment
+	*/
+	#hooks = {};
+	/**
+	* Create a new Storm context from the workspace root and user config.
+	*
+	* @param workspaceConfig - The root directory of the workspace.
+	* @param config - The user configuration options.
+	* @returns A promise that resolves to the new context.
+	*/
+	static async fromConfig(workspaceConfig, config) {
+		const context = new PowerlinesEnvironmentContext(config, workspaceConfig);
+		await context.init();
+		const powerlinesPath = await resolvePackage("powerlines");
+		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
+		context.powerlinesPath = powerlinesPath;
+		return context;
+	}
+	/**
+	* The resolved environment configuration
+	*/
+	environment;
+	/**
+	* The list of plugins applied to this environment
+	*/
+	plugins = [];
+	/**
+	* The resolved configuration options
+	*/
+	get config() {
+		return super.config;
+	}
+	get hooks() {
+		return this.#hooks;
+	}
+	async addPlugin(plugin) {
+		let resolvedPlugin = plugin;
+		if (isFunction(plugin.applyToEnvironment)) {
+			const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
+			if (!result || isObject(result) && Object.keys(result).length === 0) return;
+			if (isPluginConfig(result)) return this.$$internal.addPlugin(result);
+			resolvedPlugin = isPlugin(result) ? result : plugin;
+		}
+		const context = createPluginContext(resolvedPlugin, this);
+		this.plugins.push({
+			plugin: resolvedPlugin,
+			context
+		});
+		this.#hooks = Object.keys(resolvedPlugin).filter((key) => !PLUGIN_NON_HOOK_FIELDS.includes(key)).reduce((ret, key) => {
+			const hook = key;
+			const pluginHook = resolvedPlugin[hook];
+			if (!isPluginHook(pluginHook)) return ret;
+			if (!isHookExternal(hook)) {
+				ret[hook] ??= {};
+				if (resolvedPlugin.enforce) {
+					ret[hook][`${resolvedPlugin.enforce}Enforced`] ??= [];
+					addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${resolvedPlugin.enforce}Enforced`]);
+					return ret;
+				}
+				if (isFunction(pluginHook) || !pluginHook.order) {
+					ret[hook].normal ??= [];
+					addPluginHook(context, resolvedPlugin, pluginHook, ret[hook].normal);
+					return ret;
+				}
+				ret[hook][`${pluginHook.order}Ordered`] ??= [];
+				addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${pluginHook.order}Ordered`]);
+			} else {
+				ret[hook] ??= [];
+				ret[hook].push({
+					plugin: resolvedPlugin,
+					hook: getHookHandler(pluginHook).bind(context)
+				});
+			}
+			return ret;
+		}, this.hooks);
+	}
+	/**
+	* Retrieves the hook handlers for a specific hook name
+	*/
+	selectHooks(hook, options) {
+		const result = [];
+		if (this.hooks[hook]) if (!isHookExternal(hook)) {
+			const hooks = this.hooks[hook];
+			if (options?.order) if (options?.order === "pre") {
+				result.push(...(hooks.preOrdered ?? []).map((h) => {
+					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+					return {
+						handle: h.handler,
+						context: plugin.context
+					};
+				}));
+				result.push(...(hooks.preEnforced ?? []).map((h) => {
+					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+					return {
+						handle: h.handler,
+						context: plugin.context
+					};
+				}));
+			} else if (options?.order === "post") {
+				result.push(...(hooks.postOrdered ?? []).map((h) => {
+					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+					return {
+						handle: h.handler,
+						context: plugin.context
+					};
+				}));
+				result.push(...(hooks.postEnforced ?? []).map((h) => {
+					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+					return {
+						handle: h.handler,
+						context: plugin.context
+					};
+				}));
+			} else result.push(...(hooks.normal ?? []).map((h) => {
+				const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+				if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+				return {
+					handle: h.handler,
+					context: plugin.context
+				};
+			}));
+			else {
+				result.push(...this.selectHooks(hook, { order: "pre" }));
+				result.push(...this.selectHooks(hook, { order: "normal" }));
+				result.push(...this.selectHooks(hook, { order: "post" }));
+			}
+		} else result.push(...this.hooks[hook].map((h) => {
+			const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+			if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+			return {
+				handle: h.handler,
+				context: plugin.context
+			};
+		}));
+		return result;
+	}
+	constructor(config, workspaceConfig) {
+		super(workspaceConfig);
+		this.resolvedConfig = config;
+	}
+};
+
+//#endregion
+export { PowerlinesEnvironmentContext };

package/dist/powerlines/src/lib/contexts/plugin-context.cjs

@@ -0,0 +1,75 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+let __storm_software_config_tools_types = require("@storm-software/config-tools/types");
+let __stryke_type_checks_is_string = require("@stryke/type-checks/is-string");
+
+//#region ../powerlines/src/lib/contexts/plugin-context.ts
+/**
+* Create a Proxy-based PluginContext
+*
+* @param plugin - The plugin instance
+* @param environment - The environment context
+* @returns The proxied plugin context
+*/
+function createPluginContext(plugin, environment) {
+	const normalizeMessage = (message) => {
+		return (0, __stryke_type_checks_is_string.isString)(message) ? message : message.message;
+	};
+	const log = environment.extendLog(plugin.name.replaceAll(":", " - "));
+	const callHookFn = async (hook, options, ...args) => {
+		return environment.$$internal.api.callHook(hook, {
+			sequential: true,
+			result: "merge",
+			...options,
+			environment
+		}, ...args);
+	};
+	return new Proxy({}, {
+		get(_, prop) {
+			if (prop === "$$internal") return {
+				...environment.$$internal,
+				environment,
+				callHook: callHookFn
+			};
+			if (prop === "log" || prop === "logger") return log;
+			if (prop === "error") return (message) => {
+				log(__storm_software_config_tools_types.LogLevelLabel.ERROR, normalizeMessage(message));
+			};
+			if (prop === "warn") return (message) => {
+				log(__storm_software_config_tools_types.LogLevelLabel.WARN, normalizeMessage(message));
+			};
+			if (prop === "info") return (message) => {
+				log(__storm_software_config_tools_types.LogLevelLabel.INFO, normalizeMessage(message));
+			};
+			if (prop === "debug") return (message) => {
+				log(__storm_software_config_tools_types.LogLevelLabel.DEBUG, normalizeMessage(message));
+			};
+			if (prop === "trace") return (message) => {
+				log(__storm_software_config_tools_types.LogLevelLabel.TRACE, normalizeMessage(message));
+			};
+			return environment[prop];
+		},
+		set(_, prop, value) {
+			if ([
+				"$$internal",
+				"environment",
+				"config",
+				"log",
+				"logger",
+				"error",
+				"warn",
+				"plugins",
+				"hooks",
+				"addPlugin",
+				"selectHooks"
+			].includes(prop)) {
+				log(__storm_software_config_tools_types.LogLevelLabel.WARN, `Cannot set read-only property "${String(prop)}"`);
+				return false;
+			}
+			environment[prop] = value;
+			return true;
+		}
+	});
+}
+
+//#endregion
+exports.createPluginContext = createPluginContext;

package/dist/powerlines/src/lib/contexts/plugin-context.mjs

@@ -0,0 +1,74 @@
+import { LogLevelLabel } from "@storm-software/config-tools/types";
+import { isString } from "@stryke/type-checks/is-string";
+
+//#region ../powerlines/src/lib/contexts/plugin-context.ts
+/**
+* Create a Proxy-based PluginContext
+*
+* @param plugin - The plugin instance
+* @param environment - The environment context
+* @returns The proxied plugin context
+*/
+function createPluginContext(plugin, environment) {
+	const normalizeMessage = (message) => {
+		return isString(message) ? message : message.message;
+	};
+	const log = environment.extendLog(plugin.name.replaceAll(":", " - "));
+	const callHookFn = async (hook, options, ...args) => {
+		return environment.$$internal.api.callHook(hook, {
+			sequential: true,
+			result: "merge",
+			...options,
+			environment
+		}, ...args);
+	};
+	return new Proxy({}, {
+		get(_, prop) {
+			if (prop === "$$internal") return {
+				...environment.$$internal,
+				environment,
+				callHook: callHookFn
+			};
+			if (prop === "log" || prop === "logger") return log;
+			if (prop === "error") return (message) => {
+				log(LogLevelLabel.ERROR, normalizeMessage(message));
+			};
+			if (prop === "warn") return (message) => {
+				log(LogLevelLabel.WARN, normalizeMessage(message));
+			};
+			if (prop === "info") return (message) => {
+				log(LogLevelLabel.INFO, normalizeMessage(message));
+			};
+			if (prop === "debug") return (message) => {
+				log(LogLevelLabel.DEBUG, normalizeMessage(message));
+			};
+			if (prop === "trace") return (message) => {
+				log(LogLevelLabel.TRACE, normalizeMessage(message));
+			};
+			return environment[prop];
+		},
+		set(_, prop, value) {
+			if ([
+				"$$internal",
+				"environment",
+				"config",
+				"log",
+				"logger",
+				"error",
+				"warn",
+				"plugins",
+				"hooks",
+				"addPlugin",
+				"selectHooks"
+			].includes(prop)) {
+				log(LogLevelLabel.WARN, `Cannot set read-only property "${String(prop)}"`);
+				return false;
+			}
+			environment[prop] = value;
+			return true;
+		}
+	});
+}
+
+//#endregion
+export { createPluginContext };

package/dist/powerlines/src/lib/entry.cjs

@@ -0,0 +1,69 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_paths = require('../plugin-utils/paths.cjs');
+let __stryke_path_join_paths = require("@stryke/path/join-paths");
+let __stryke_convert_to_array = require("@stryke/convert/to-array");
+let __stryke_fs_list_files = require("@stryke/fs/list-files");
+let __stryke_path_append = require("@stryke/path/append");
+let __stryke_path_replace = require("@stryke/path/replace");
+let __stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let __stryke_type_checks_is_string = require("@stryke/type-checks/is-string");
+let __stryke_hash_murmurhash = require("@stryke/hash/murmurhash");
+let __stryke_helpers_get_unique = require("@stryke/helpers/get-unique");
+let __stryke_convert_parse_type_definition = require("@stryke/convert/parse-type-definition");
+let __stryke_fs_is_file = require("@stryke/fs/is-file");
+
+//#region ../powerlines/src/lib/entry.ts
+function resolveEntryInputFile(context, typeDefinition) {
+	return (0, __stryke_path_replace.replacePath)(typeDefinition.file, (0, __stryke_path_join_paths.joinPaths)(context.workspaceConfig.workspaceRoot, context.config.projectRoot));
+}
+function resolveEntryInput(context, typeDefinition) {
+	return {
+		file: resolveEntryInputFile(context, typeDefinition),
+		name: typeDefinition.name
+	};
+}
+function resolveEntryOutput(context, typeDefinition) {
+	return (0, __stryke_path_replace.replaceExtension)((0, __stryke_path_replace.replacePath)((0, __stryke_path_replace.replacePath)((0, __stryke_path_replace.replacePath)((0, __stryke_path_replace.replacePath)((0, __stryke_path_replace.replacePath)(typeDefinition.file, (0, __stryke_path_join_paths.joinPaths)(context.workspaceConfig.workspaceRoot, context.config.sourceRoot)), (0, __stryke_path_join_paths.joinPaths)(context.workspaceConfig.workspaceRoot, context.config.projectRoot)), context.config.sourceRoot), context.config.projectRoot), (0, __stryke_path_replace.replacePath)(context.config.sourceRoot, context.config.projectRoot)));
+}
+function resolveEntry(context, typeDefinition) {
+	const input = resolveEntryInput(context, typeDefinition);
+	return {
+		...input,
+		input,
+		output: resolveEntryOutput(context, typeDefinition)
+	};
+}
+/**
+* Resolves multiple type definitions into their corresponding resolved entry type definitions.
+*
+* @param context - The current context
+* @param typeDefinitions - The type definitions to resolve.
+* @returns A promise that resolves to an array of resolved entry type definitions.
+*/
+function resolveEntriesSync(context, typeDefinitions) {
+	return typeDefinitions.map((entry) => (0, __stryke_type_checks_is_string.isString)(entry) ? require_paths.replacePathTokens(context, entry) : require_paths.replacePathTokens(context, entry.file)).map((typeDefinition) => {
+		const parsed = (0, __stryke_convert_parse_type_definition.parseTypeDefinition)(typeDefinition);
+		const filePath = (0, __stryke_path_append.appendPath)(parsed.file, context.config.projectRoot);
+		if ((0, __stryke_fs_is_file.isFile)(filePath)) return resolveEntry(context, {
+			file: (0, __stryke_path_replace.replacePath)(filePath, context.config.projectRoot),
+			name: parsed.name
+		});
+		return (0, __stryke_fs_list_files.listFilesSync)(filePath).map((file) => resolveEntry(context, {
+			file,
+			name: parsed.name
+		}));
+	}).flat().filter(Boolean);
+}
+/**
+* Get unique entries from the provided list.
+*
+* @param entries - The entries to process.
+* @returns An array of unique entries (by file path or content hash).
+*/
+function getUniqueEntries(entries = []) {
+	return (0, __stryke_helpers_get_unique.getUniqueBy)((0, __stryke_convert_to_array.toArray)(entries), (item) => (0, __stryke_type_checks_is_set_string.isSetString)(item) ? item : (0, __stryke_hash_murmurhash.murmurhash)(item ?? {}, { maxLength: 24 }));
+}
+
+//#endregion
+exports.getUniqueEntries = getUniqueEntries;
+exports.resolveEntriesSync = resolveEntriesSync;

package/dist/powerlines/src/lib/entry.mjs

@@ -0,0 +1,67 @@
+import { replacePathTokens } from "../plugin-utils/paths.mjs";
+import { joinPaths } from "@stryke/path/join-paths";
+import { toArray } from "@stryke/convert/to-array";
+import { listFiles, listFilesSync } from "@stryke/fs/list-files";
+import { appendPath } from "@stryke/path/append";
+import { replaceExtension, replacePath } from "@stryke/path/replace";
+import { isSetString } from "@stryke/type-checks/is-set-string";
+import { isString } from "@stryke/type-checks/is-string";
+import { murmurhash } from "@stryke/hash/murmurhash";
+import { getUniqueBy } from "@stryke/helpers/get-unique";
+import { parseTypeDefinition } from "@stryke/convert/parse-type-definition";
+import { isFile } from "@stryke/fs/is-file";
+
+//#region ../powerlines/src/lib/entry.ts
+function resolveEntryInputFile(context, typeDefinition) {
+	return replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot));
+}
+function resolveEntryInput(context, typeDefinition) {
+	return {
+		file: resolveEntryInputFile(context, typeDefinition),
+		name: typeDefinition.name
+	};
+}
+function resolveEntryOutput(context, typeDefinition) {
+	return replaceExtension(replacePath(replacePath(replacePath(replacePath(replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.sourceRoot)), joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot)), context.config.sourceRoot), context.config.projectRoot), replacePath(context.config.sourceRoot, context.config.projectRoot)));
+}
+function resolveEntry(context, typeDefinition) {
+	const input = resolveEntryInput(context, typeDefinition);
+	return {
+		...input,
+		input,
+		output: resolveEntryOutput(context, typeDefinition)
+	};
+}
+/**
+* Resolves multiple type definitions into their corresponding resolved entry type definitions.
+*
+* @param context - The current context
+* @param typeDefinitions - The type definitions to resolve.
+* @returns A promise that resolves to an array of resolved entry type definitions.
+*/
+function resolveEntriesSync(context, typeDefinitions) {
+	return typeDefinitions.map((entry) => isString(entry) ? replacePathTokens(context, entry) : replacePathTokens(context, entry.file)).map((typeDefinition) => {
+		const parsed = parseTypeDefinition(typeDefinition);
+		const filePath = appendPath(parsed.file, context.config.projectRoot);
+		if (isFile(filePath)) return resolveEntry(context, {
+			file: replacePath(filePath, context.config.projectRoot),
+			name: parsed.name
+		});
+		return listFilesSync(filePath).map((file) => resolveEntry(context, {
+			file,
+			name: parsed.name
+		}));
+	}).flat().filter(Boolean);
+}
+/**
+* Get unique entries from the provided list.
+*
+* @param entries - The entries to process.
+* @returns An array of unique entries (by file path or content hash).
+*/
+function getUniqueEntries(entries = []) {
+	return getUniqueBy(toArray(entries), (item) => isSetString(item) ? item : murmurhash(item ?? {}, { maxLength: 24 }));
+}
+
+//#endregion
+export { getUniqueEntries, resolveEntriesSync };