@powerlines/unplugin 0.0.80 → 0.0.82

package/dist/unloader.d.cts

@@ -1,4 +1,4 @@
-import { r as UnpluginFactory, t as UnpluginExecutionOptions } from "./types-CEaXoKbk.cjs";
+import { UnpluginExecutionOptions, UnpluginFactory } from "./types.cjs";
 import { UnpluginFactoryDecorator, UnpluginFactoryOptions } from "./unplugin.cjs";
 import { ExecutionContext } from "@powerlines/core";
 
@@ -23,7 +23,7 @@ import { ExecutionContext } from "@powerlines/core";
  * @param decorate - A function to decorate the plugin options with additional properties or hooks. This can be used to add custom behavior to the plugin instance, such as additional hooks or configuration options. The function receives the generated plugin options and should return an object containing any additional properties or hooks to be merged into the final plugin options.
  * @returns A function that generates a Unloader plugin instance when called. The generated plugin will invoke the Powerlines API hooks during the build process, allowing you to integrate Powerlines into your Unloader build.
  */
-declare function createUnloaderFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig<import("@powerlines/core").UserConfig, import("@powerlines/core").ExecutionOptions>, any>>;
+declare function createUnloaderFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig, any>>;
 /**
  * An Unloader plugin that will invoke the Powerlines API hooks during processing.
  *

package/dist/unloader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"unloader.d.cts","names":[],"sources":["../src/unloader.ts"],"mappings":";;;;;;;;AA8CA;;;;;;;;;;;;;;;;;iBAAgB,qBAAA,kBAAuC,gBAAA,EACrD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA,4BAAA,UAAA,6BAAA,gBAAA;;;;;;;;;AAAA;AAqBnE;;;;;cAAa,MAAA,GAAM,OAAA,GAAgD,wBAAhD,oCAAA,MAAA,sBAAA,MAAA"}
+{"version":3,"file":"unloader.d.cts","names":[],"sources":["../src/unloader.ts"],"mappings":";;;;;;;;AA8CA;;;;;;;;;;;;;;;;;iBAAgB,qBAAA,kBAAuC,gBAAA,EACrD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA;;;;;;;AAAA;AAqBnE;;;;;;;cAAa,MAAA,GAAM,OAAA,GAAgD,wBAAhD,oCAAA,MAAA,sBAAA,MAAA"}

package/dist/unloader.d.mts

@@ -23,7 +23,7 @@ import { ExecutionContext } from "@powerlines/core";
  * @param decorate - A function to decorate the plugin options with additional properties or hooks. This can be used to add custom behavior to the plugin instance, such as additional hooks or configuration options. The function receives the generated plugin options and should return an object containing any additional properties or hooks to be merged into the final plugin options.
  * @returns A function that generates a Unloader plugin instance when called. The generated plugin will invoke the Powerlines API hooks during the build process, allowing you to integrate Powerlines into your Unloader build.
  */
-declare function createUnloaderFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig<import("@powerlines/core").UserConfig, import("@powerlines/core").ExecutionOptions>, any>>;
+declare function createUnloaderFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig, any>>;
 /**
  * An Unloader plugin that will invoke the Powerlines API hooks during processing.
  *

package/dist/unloader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unloader.d.mts","names":[],"sources":["../src/unloader.ts"],"mappings":";;;;;;;;AA8CA;;;;;;;;;;;;;;;;;iBAAgB,qBAAA,kBAAuC,gBAAA,EACrD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA,4BAAA,UAAA,6BAAA,gBAAA;;;;;;;;;AAAA;AAqBnE;;;;;cAAa,MAAA,GAAM,OAAA,GAAgD,wBAAhD,oCAAA,MAAA,sBAAA,MAAA"}
+{"version":3,"file":"unloader.d.mts","names":[],"sources":["../src/unloader.ts"],"mappings":";;;;;;;;AA8CA;;;;;;;;;;;;;;;;;iBAAgB,qBAAA,kBAAuC,gBAAA,EACrD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA;;;;;;;AAAA;AAqBnE;;;;;;;cAAa,MAAA,GAAM,OAAA,GAAgD,wBAAhD,oCAAA,MAAA,sBAAA,MAAA"}

package/dist/unplugin.cjs

@@ -1,7 +1,237 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_unplugin = require('./unplugin-WjPT9ECw.cjs');
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let _stryke_path_replace = require("@stryke/path/replace");
+let _powerlines_core = require("@powerlines/core");
+let _powerlines_core_constants = require("@powerlines/core/constants");
+let _powerlines_core_context_execution_context = require("@powerlines/core/context/execution-context");
+let _powerlines_core_lib_context_helpers = require("@powerlines/core/lib/context-helpers");
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+let _powerlines_core_lib_utilities_source_file = require("@powerlines/core/lib/utilities/source-file");
+let _powerlines_core_plugin_utils = require("@powerlines/core/plugin-utils");
+let _stryke_convert_to_array = require("@stryke/convert/to-array");
+let _stryke_fs_get_workspace_root = require("@stryke/fs/get-workspace-root");
+let _stryke_fs_helpers = require("@stryke/fs/helpers");
+let _stryke_string_format_kebab_case = require("@stryke/string-format/kebab-case");
+let _stryke_string_format_title_case = require("@stryke/string-format/title-case");
+let _stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+let _stryke_type_checks_is_object = require("@stryke/type-checks/is-object");
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let _stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
 
-exports.createUnpluginFactory = require_unplugin.createUnpluginFactory;
+//#region src/unplugin.ts
+/**
+* Creates a Powerlines unplugin factory that generates a plugin instance.
+*
+* @remarks
+* The factory will handle loading the Powerlines configuration, resolving the plugin configuration, and executing the appropriate hooks during the build process. It also allows for optional customization of logging and framework identification through the provided options.
+*
+* @example
+* ```ts
+* import { createUnpluginFactory } from "@powerlines/unplugin";
+*
+* const factory = createUnpluginFactory({
+*  variant: "vite",
+*  framework: "my-framework",
+*  orgId: "my-org",
+*  customLogger: myCustomLogger
+* });
+*
+* const plugin = createVitePlugin(factory);
+* export default plugin;
+* ```
+*
+* @param options - The options for the unplugin factory, including the build variant and an optional custom logger.
+* @param decorate - An optional function to decorate the unplugin options.
+* @returns The unplugin factory that generates a plugin instance.
+*/
+function createUnpluginFactory(options, decorate = (options) => options) {
+	if (!(0, _powerlines_core.isUnpluginBuilderVariant)(options.variant)) throw new Error(`Invalid unplugin builder variant: ${String(options.variant)}. Expected one of: ${_powerlines_core_constants.UNPLUGIN_BUILDER_VARIANTS.join(", ")}.`);
+	const cwd = (0, _stryke_fs_get_workspace_root.getWorkspaceRoot)(process.cwd());
+	const virtualModulePrefix = options.virtualModulePrefix ?? "\\0";
+	return (params = {}) => {
+		let context;
+		try {
+			const framework = (params.framework?.name ?? options.framework?.name) || "powerlines";
+			const orgId = (params.framework?.orgId ?? options.framework?.orgId) || "storm-software";
+			const root = (0, _powerlines_core.resolveRoot)(cwd, params.root, params.configFile);
+			async function buildStart() {
+				const config = await (0, _powerlines_core.loadParsedConfig)(cwd, root, framework, orgId, {
+					...params,
+					command: "build"
+				});
+				if (!config) throw new Error("Failed to load configuration");
+				const configs = (0, _stryke_convert_to_array.toArray)(config.config);
+				if (params.configIndex !== void 0 && params.configIndex >= configs.length) throw new Error(`Invalid execution index: ${params.configIndex}. The configuration file contains ${configs.length} execution(s).`);
+				const _options = {
+					cwd,
+					root,
+					...params,
+					command: "build",
+					configFile: config.configFile,
+					executionId: (0, _powerlines_core_plugin_utils.formatExecutionId)(config.config.name || root, "build", 0),
+					configIndex: 0
+				};
+				context = await _powerlines_core_context_execution_context.PowerlinesExecutionContext.from({
+					...options,
+					..._options,
+					configFile: config.configFile
+				}, _options);
+				context.logger.info(`Starting ${(0, _stryke_string_format_title_case.titleCase)(framework)} ${(0, _stryke_string_format_title_case.titleCase)(options.variant)} plugin execution`);
+				context.logger.debug({
+					meta: { category: "config" },
+					message: `Invoking ${(0, _stryke_string_format_title_case.titleCase)(framework)} ${(0, _stryke_string_format_title_case.titleCase)(options.variant)} plugin with the following execution parameters: \n --- Execution Options --- \n${(0, _powerlines_core_plugin_utils.formatConfig)(params)}`
+				});
+				await (0, _powerlines_core_lib_context_helpers.resolvePluginConfig)(context);
+				const timer = context.timer("Preparation");
+				await (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+					env.debug(`Initializing the processing options for the Powerlines project.`);
+					await context.callHook("configResolved", {
+						environment: env,
+						order: "pre"
+					});
+					await (0, _powerlines_core.initializeTsconfig)(env);
+					await context.callHook("configResolved", {
+						environment: env,
+						order: "normal"
+					});
+					if (env.entry.length > 0) {
+						const entriesLength = (0, _stryke_type_checks_is_object.isObject)(env.config.input) ? Object.keys(env.config.input).length : (0, _stryke_convert_to_array.toArray)(env.config.input).length;
+						env.debug(`The configuration provided ${entriesLength} entry point${entriesLength !== 1 ? "s" : ""}, Powerlines has found ${env.entry.length} entry file${env.entry.length !== 1 ? "s" : ""} for the ${env.config.title} project${env.entry.length > 0 && env.entry.length < 10 ? `: \n${env.entry.map((entry) => `- ${(0, _stryke_path_replace.replacePath)(entry.file, context.config.root)}${entry.output ? ` -> ${(0, _stryke_path_replace.replacePath)(entry.output, context.config.root)}` : ""}`).join(" \n")}` : ""}`);
+					} else env.warn(`No entry files were found for the ${env.config.title} project. Please ensure this is correct. Powerlines plugins generally require at least one entry point to function properly.`);
+					await (0, _powerlines_core.resolveTsconfig)(env);
+					await (0, _powerlines_core.installDependencies)(env);
+					await context.callHook("configResolved", {
+						environment: env,
+						order: "post"
+					});
+					env.trace({
+						meta: { category: "config" },
+						message: `Powerlines configuration after configResolved hook: \n${(0, _powerlines_core_plugin_utils.formatConfig)(env.config)}`
+					});
+					if (!env.fs.existsSync(env.cachePath)) await (0, _stryke_fs_helpers.createDirectory)(env.cachePath);
+					if (!env.fs.existsSync(env.dataPath)) await (0, _stryke_fs_helpers.createDirectory)(env.dataPath);
+					await context.callHook("prepare", {
+						environment: env,
+						order: "pre"
+					});
+					await context.callHook("prepare", {
+						environment: env,
+						order: "normal"
+					});
+					await context.callHook("prepare", {
+						environment: env,
+						order: "post"
+					});
+					if (env.config.output.types !== false) await (0, _powerlines_core.handleTypes)(context, env);
+					context.debug("Formatting files generated during the prepare step.");
+					await Promise.all([(0, _powerlines_core.formatFolder)(env, env.builtinsPath), (0, _powerlines_core.formatFolder)(env, env.entryPath)]);
+					await (0, _powerlines_core.writeMetaFile)(env);
+					env.persistedMeta = env.meta;
+				});
+				timer();
+			}
+			async function resolveId(id, importer, opts = { isEntry: false }) {
+				const normalizedId = (0, _powerlines_core_plugin_utils.removeVirtualPrefix)(id);
+				const normalizedImporter = importer ? (0, _powerlines_core_plugin_utils.removeVirtualPrefix)(importer) : void 0;
+				let result = await context.callHook("resolveId", {
+					sequential: true,
+					result: "first",
+					order: "pre"
+				}, normalizedId, normalizedImporter, opts);
+				if ((0, _stryke_type_checks_is_set_string.isSetString)(result)) return result;
+				else if ((0, _stryke_type_checks_is_set_object.isSetObject)(result)) return {
+					...result,
+					id: result.virtual && virtualModulePrefix !== false ? (0, _powerlines_core_plugin_utils.addVirtualPrefix)(result.id) : result.id
+				};
+				result = await context.callHook("resolveId", {
+					sequential: true,
+					result: "first",
+					order: "normal"
+				}, normalizedId, normalizedImporter, opts);
+				if ((0, _stryke_type_checks_is_set_string.isSetString)(result)) return result;
+				else if ((0, _stryke_type_checks_is_set_object.isSetObject)(result)) return {
+					...result,
+					id: result.virtual && virtualModulePrefix !== false ? (0, _powerlines_core_plugin_utils.addVirtualPrefix)(result.id) : result.id
+				};
+				result = await context.resolve(normalizedId, normalizedImporter, {
+					isFile: true,
+					...opts
+				});
+				if ((0, _stryke_type_checks_is_set_object.isSetObject)(result)) return {
+					...result,
+					id: result.virtual && virtualModulePrefix !== false ? (0, _powerlines_core_plugin_utils.addVirtualPrefix)(result.id) : result.id
+				};
+				result = await context.callHook("resolveId", {
+					sequential: true,
+					result: "first",
+					order: "post"
+				}, normalizedId, normalizedImporter, opts);
+				if ((0, _stryke_type_checks_is_set_string.isSetString)(result)) return result;
+				else if ((0, _stryke_type_checks_is_set_object.isSetObject)(result)) return {
+					...result,
+					id: result.virtual && virtualModulePrefix !== false ? (0, _powerlines_core_plugin_utils.addVirtualPrefix)(result.id) : result.id
+				};
+				return null;
+			}
+			const load = {
+				filter: virtualModulePrefix !== false ? { id: _powerlines_core_plugin_utils.VIRTUAL_MODULE_PREFIX_REGEX } : void 0,
+				async handler(id) {
+					const normalizedId = (0, _powerlines_core_plugin_utils.removeVirtualPrefix)(id);
+					let result = await context.callHook("load", {
+						sequential: true,
+						result: "first",
+						order: "pre"
+					}, normalizedId);
+					if (result) return result;
+					result = await context.callHook("load", {
+						sequential: true,
+						result: "first",
+						order: "normal"
+					}, normalizedId);
+					if (result) return result;
+					result = await context.load(normalizedId);
+					if (result) return result;
+					return context.callHook("load", {
+						sequential: true,
+						result: "first",
+						order: "post"
+					}, normalizedId);
+				}
+			};
+			async function transform(code, id) {
+				return context.callHook("transform", {
+					environment: await context.getEnvironment(),
+					result: "merge",
+					asNextParam: (previousResult) => (0, _powerlines_core_lib_utilities_source_file.getString)(previousResult)
+				}, (0, _powerlines_core_lib_utilities_source_file.getString)(code), id);
+			}
+			async function writeBundle() {
+				context.logger.debug("Finalizing Powerlines project output...");
+				await context.callHook("writeBundle", { environment: await context.getEnvironment() });
+			}
+			context.logger.debug("Unplugin initialized successfully.");
+			const result = {
+				name: `${(0, _stryke_string_format_kebab_case.kebabCase)(framework)}:${(0, _stryke_string_format_kebab_case.kebabCase)(options.variant)}-plugin`,
+				context,
+				resolveId,
+				load,
+				transform,
+				buildStart,
+				writeBundle
+			};
+			return {
+				...result,
+				...decorate(result)
+			};
+		} catch (error) {
+			if ((0, _stryke_type_checks_is_function.isFunction)(context?.logger?.error)) context.logger.error(error?.message);
+			throw error;
+		}
+	};
+}
+
+//#endregion
+exports.createUnpluginFactory = createUnpluginFactory;
 var _powerlines_core_lib_unplugin = require("@powerlines/core/lib/unplugin");
 Object.keys(_powerlines_core_lib_unplugin).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

package/dist/unplugin.d.cts

@@ -1,4 +1,4 @@
-import { a as __reExport, i as __exportAll, r as UnpluginFactory } from "./types-CEaXoKbk.cjs";
+import { UnpluginFactory } from "./types.cjs";
 import { CustomLogger, ExecutionContext, Options, UnpluginBuilderVariant, UnpluginOptions } from "@powerlines/core";
 export * from "@powerlines/core/lib/unplugin";
 

package/dist/unplugin.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"unplugin.d.cts","names":[],"sources":["../src/unplugin.ts"],"mappings":";;;;;;;;UAuEiB,sBAAA,SAA+B,OAAA;EAAR;;;;;;EAOtC,OAAA,EAAS,sBAAA;EAPqC;;;;;EAc9C,mBAAA;EAQ2B;AAAA;AAG7B;;;;EAHE,YAAA,GAAe,YAAA;AAAA;AAAA,KAGL,wBAAA,kBAA0C,gBAAA,KACpD,OAAA,EAAS,eAAA,CAAgB,QAAA,MACtB,OAAA,CAAQ,eAAA,CAAgB,QAAA;;;;;;;;;;;;;;AAAQ;AA2BrC;;;;;;;;;;;iBAAgB,qBAAA,kBACG,gBAAA,GAAmB,gBAAA,EAEpC,OAAA,EAAS,sBAAA,EACT,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAClC,eAAA,CAAgB,QAAA"}
+{"version":3,"file":"unplugin.d.cts","names":[],"sources":["../src/unplugin.ts"],"mappings":";;;;;;;;UAuEiB,sBAAA,SAA+B,OAAA;EAA/B;;;;;;EAOf,OAAA,EAAS,sBAAA;EAP4C;;;;;EAcrD,mBAAA;EAQe;;AAAY;AAG7B;;;EAHE,YAAA,GAAe,YAAA;AAAA;AAAA,KAGL,wBAAA,kBAA0C,gBAAA,KACpD,OAAA,EAAS,eAAA,CAAgB,QAAA,MACtB,OAAA,CAAQ,eAAA,CAAgB,QAAA;;;;;;;;;;;;;;;AAAQ;AA2BrC;;;;;;;;;;iBAAgB,qBAAA,kBACG,gBAAA,GAAmB,gBAAA,EAEpC,OAAA,EAAS,sBAAA,EACT,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAClC,eAAA,CAAgB,QAAA"}

package/dist/unplugin.mjs

@@ -1,4 +1,4 @@
-import { n as __reExport, t as __exportAll } from "./chunk-BUUfjzRC.mjs";
+import { __exportAll, __reExport } from "./_virtual/_rolldown/runtime.mjs";
 import { replacePath } from "@stryke/path/replace";
 import { formatFolder, handleTypes, initializeTsconfig, installDependencies, isUnpluginBuilderVariant, loadParsedConfig, resolveRoot, resolveTsconfig, writeMetaFile } from "@powerlines/core";
 import { UNPLUGIN_BUILDER_VARIANTS } from "@powerlines/core/constants";

package/dist/vite.cjs

@@ -1,5 +1,6 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-const require_unplugin = require('./unplugin-WjPT9ECw.cjs');
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_unplugin = require('./unplugin.cjs');
 const require_esbuild = require('./esbuild.cjs');
 const require_rolldown = require('./rolldown.cjs');
 let _stryke_env_environment_checks = require("@stryke/env/environment-checks");
@@ -7,7 +8,7 @@ let _stryke_path_append = require("@stryke/path/append");
 let _stryke_path_file_path_fns = require("@stryke/path/file-path-fns");
 let _stryke_path_join_paths = require("@stryke/path/join-paths");
 let defu = require("defu");
-defu = require_unplugin.__toESM(defu, 1);
+defu = require_runtime.__toESM(defu, 1);
 let unplugin = require("unplugin");
 
 //#region src/vite.ts

package/dist/vite.d.cts

@@ -1,4 +1,4 @@
-import { r as UnpluginFactory, t as UnpluginExecutionOptions } from "./types-CEaXoKbk.cjs";
+import { UnpluginExecutionOptions, UnpluginFactory } from "./types.cjs";
 import { UnpluginFactoryDecorator, UnpluginFactoryOptions } from "./unplugin.cjs";
 import { ExecutionContext, UnresolvedContext } from "@powerlines/core";
 import { UserConfig as UserConfig$1 } from "vite";
@@ -34,7 +34,7 @@ declare function resolveOptions<TContext extends UnresolvedContext>(context: TCo
  * @param decorate - A function to decorate the plugin options with additional properties or hooks. This can be used to add custom behavior to the plugin instance, such as additional hooks or configuration options. The function receives the generated plugin options and should return an object containing any additional properties or hooks to be merged into the final plugin options.
  * @returns A function that generates a Vite plugin instance when called. The generated plugin will invoke the Powerlines API hooks during the build process, allowing you to integrate Powerlines into your Vite build.
  */
-declare function createViteFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig<import("@powerlines/core").UserConfig, import("@powerlines/core").ExecutionOptions>, any>>;
+declare function createViteFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig, any>>;
 /**
  * A Vite plugin that will invoke the Powerlines API hooks during the build process.
  *

package/dist/vite.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"vite.d.cts","names":[],"sources":["../src/vite.ts"],"mappings":";;;;;;cAsCa,eAAA,EAAiB,OAAO,CAAC,YAAA;;;AAAtC;;;;iBAiBgB,cAAA,kBAAgC,iBAAA,EAC9C,OAAA,EAAS,QAAA,GACR,YAAA;AAFH;;;;;;;;;;;;;;AAEa;AAuFb;;;;;;;AAzFA,iBAyFgB,iBAAA,kBAAmC,gBAAA,EACjD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA,4BAAA,UAAA,6BAAA,gBAAA;;;;;;;;;;;;;;;;;cAqGtD,MAAA,GAAM,OAAA,GAAwC,wBAAxC,gCAAA,MAAA,uBAAA,MAAA"}
+{"version":3,"file":"vite.d.cts","names":[],"sources":["../src/vite.ts"],"mappings":";;;;;;cAsCa,eAAA,EAAiB,OAAO,CAAC,YAAA;;;AAAtC;;;;iBAiBgB,cAAA,kBAAgC,iBAAA,EAC9C,OAAA,EAAS,QAAA,GACR,YAAA;AAFH;;;;;;;;;;;;;;AAEa;AAuFb;;;;;;;AAzFA,iBAyFgB,iBAAA,kBAAmC,gBAAA,EACjD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA;;;;;;;;;;;;;;;;;cAqGtD,MAAA,GAAM,OAAA,GAAwC,wBAAxC,gCAAA,MAAA,uBAAA,MAAA"}

package/dist/vite.d.mts

@@ -34,7 +34,7 @@ declare function resolveOptions<TContext extends UnresolvedContext>(context: TCo
  * @param decorate - A function to decorate the plugin options with additional properties or hooks. This can be used to add custom behavior to the plugin instance, such as additional hooks or configuration options. The function receives the generated plugin options and should return an object containing any additional properties or hooks to be merged into the final plugin options.
  * @returns A function that generates a Vite plugin instance when called. The generated plugin will invoke the Powerlines API hooks during the build process, allowing you to integrate Powerlines into your Vite build.
  */
-declare function createViteFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig<import("@powerlines/core").UserConfig, import("@powerlines/core").ExecutionOptions>, any>>;
+declare function createViteFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig, any>>;
 /**
  * A Vite plugin that will invoke the Powerlines API hooks during the build process.
  *

package/dist/vite.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"vite.d.mts","names":[],"sources":["../src/vite.ts"],"mappings":";;;;;;cAsCa,eAAA,EAAiB,OAAO,CAAC,YAAA;;;AAAtC;;;;iBAiBgB,cAAA,kBAAgC,iBAAA,EAC9C,OAAA,EAAS,QAAA,GACR,YAAA;AAFH;;;;;;;;;;;;;;AAEa;AAuFb;;;;;;;AAzFA,iBAyFgB,iBAAA,kBAAmC,gBAAA,EACjD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA,4BAAA,UAAA,6BAAA,gBAAA;;;;;;;;;;;;;;;;;cAqGtD,MAAA,GAAM,OAAA,GAAwC,wBAAxC,gCAAA,MAAA,uBAAA,MAAA"}
+{"version":3,"file":"vite.d.mts","names":[],"sources":["../src/vite.ts"],"mappings":";;;;;;cAsCa,eAAA,EAAiB,OAAO,CAAC,YAAA;;;AAAtC;;;;iBAiBgB,cAAA,kBAAgC,iBAAA,EAC9C,OAAA,EAAS,QAAA,GACR,YAAA;AAFH;;;;;;;;;;;;;;AAEa;AAuFb;;;;;;;AAzFA,iBAyFgB,iBAAA,kBAAmC,gBAAA,EACjD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA;;;;;;;;;;;;;;;;;cAqGtD,MAAA,GAAM,OAAA,GAAwC,wBAAxC,gCAAA,MAAA,uBAAA,MAAA"}

package/dist/webpack.cjs

@@ -1,8 +1,9 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-const require_unplugin = require('./unplugin-WjPT9ECw.cjs');
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_unplugin = require('./unplugin.cjs');
 let _stryke_path_join_paths = require("@stryke/path/join-paths");
 let defu = require("defu");
-defu = require_unplugin.__toESM(defu, 1);
+defu = require_runtime.__toESM(defu, 1);
 let unplugin = require("unplugin");
 
 //#region src/webpack.ts

package/dist/webpack.d.cts

@@ -1,4 +1,4 @@
-import { r as UnpluginFactory, t as UnpluginExecutionOptions } from "./types-CEaXoKbk.cjs";
+import { UnpluginExecutionOptions, UnpluginFactory } from "./types.cjs";
 import { UnpluginFactoryDecorator, UnpluginFactoryOptions } from "./unplugin.cjs";
 import { Context, ExecutionContext } from "@powerlines/core";
 import { DeepPartial } from "@stryke/types/base";
@@ -34,7 +34,7 @@ declare function resolveOptions(context: Context): DeepPartial<WebpackOptionsNor
  * @param decorate - A function to decorate the plugin options with additional properties or hooks. This can be used to add custom behavior to the plugin instance, such as additional hooks or configuration options. The function receives the generated plugin options and should return an object containing any additional properties or hooks to be merged into the final plugin options.
  * @returns A function that generates a Webpack plugin instance when called. The generated plugin will invoke the Powerlines API hooks during the build process, allowing you to integrate Powerlines into your Webpack build.
  */
-declare function createWebpackFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig<import("@powerlines/core").UserConfig, import("@powerlines/core").ExecutionOptions>, any>>;
+declare function createWebpackFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig, any>>;
 /**
  * An Webpack plugin that will invoke the Powerlines API hooks during the build process.
  *

package/dist/webpack.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"webpack.d.cts","names":[],"sources":["../src/webpack.ts"],"mappings":";;;;;;;;;;AAqCA;;;iBAAgB,cAAA,CACd,OAAA,EAAS,OAAA,GACR,WAAA,CAAY,wBAAA;;;;;;;;;;AAAwB;AAiEvC;;;;;;;;;;;;iBAAgB,oBAAA,kBAAsC,gBAAA,EACpD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA,4BAAA,UAAA,6BAAA,gBAAA;;;;;;;;;;;;;;AAAA;AAgCnE;cAAa,MAAA,GAAM,OAAA,GAA8C,wBAA9C,mCAAA,qBAAA"}
+{"version":3,"file":"webpack.d.cts","names":[],"sources":["../src/webpack.ts"],"mappings":";;;;;;;;;;AAqCA;;;iBAAgB,cAAA,CACd,OAAA,EAAS,OAAA,GACR,WAAA,CAAY,wBAAA;;;;;;;;;;AAAwB;AAiEvC;;;;;;;;;;;;iBAAgB,oBAAA,kBAAsC,gBAAA,EACpD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA;;;;;;;;;;;;AAAA;AAgCnE;;;cAAa,MAAA,GAAM,OAAA,GAA8C,wBAA9C,mCAAA,qBAAA"}

package/dist/webpack.d.mts

@@ -34,7 +34,7 @@ declare function resolveOptions(context: Context): DeepPartial<WebpackOptionsNor
  * @param decorate - A function to decorate the plugin options with additional properties or hooks. This can be used to add custom behavior to the plugin instance, such as additional hooks or configuration options. The function receives the generated plugin options and should return an object containing any additional properties or hooks to be merged into the final plugin options.
  * @returns A function that generates a Webpack plugin instance when called. The generated plugin will invoke the Powerlines API hooks during the build process, allowing you to integrate Powerlines into your Webpack build.
  */
-declare function createWebpackFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig<import("@powerlines/core").UserConfig, import("@powerlines/core").ExecutionOptions>, any>>;
+declare function createWebpackFactory<TContext extends ExecutionContext>(options?: Omit<UnpluginFactoryOptions, "variant">, decorate?: UnpluginFactoryDecorator<TContext>): UnpluginFactory<ExecutionContext<import("@powerlines/core").ResolvedConfig, any>>;
 /**
  * An Webpack plugin that will invoke the Powerlines API hooks during the build process.
  *

package/dist/webpack.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"webpack.d.mts","names":[],"sources":["../src/webpack.ts"],"mappings":";;;;;;;;;;AAqCA;;;iBAAgB,cAAA,CACd,OAAA,EAAS,OAAA,GACR,WAAA,CAAY,wBAAA;;;;;;;;;;AAAwB;AAiEvC;;;;;;;;;;;;iBAAgB,oBAAA,kBAAsC,gBAAA,EACpD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA,4BAAA,UAAA,6BAAA,gBAAA;;;;;;;;;;;;;;AAAA;AAgCnE;cAAa,MAAA,GAAM,OAAA,GAA8C,wBAA9C,mCAAA,qBAAA"}
+{"version":3,"file":"webpack.d.mts","names":[],"sources":["../src/webpack.ts"],"mappings":";;;;;;;;;;AAqCA;;;iBAAgB,cAAA,CACd,OAAA,EAAS,OAAA,GACR,WAAA,CAAY,wBAAA;;;;;;;;;;AAAwB;AAiEvC;;;;;;;;;;;;iBAAgB,oBAAA,kBAAsC,gBAAA,EACpD,OAAA,GAAS,IAAA,CAAK,sBAAA,cACd,QAAA,GAAU,wBAAA,CAAyB,QAAA,IAA8B,eAAA,CAAA,gBAAA,4BAAA,cAAA;;;;;;;;;;;;AAAA;AAgCnE;;;cAAa,MAAA,GAAM,OAAA,GAA8C,wBAA9C,mCAAA,qBAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerlines/unplugin",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "private": false,
   "description": "A package containing a Powerlines plugin to assist in developing other Powerlines plugins.",
   "keywords": [
@@ -105,20 +105,20 @@
   "typings": "dist/index.d.mts",
   "files": ["dist"],
   "dependencies": {
-    "@powerlines/core": "^0.48.32",
+    "@powerlines/core": "^0.48.34",
     "@rollup/plugin-alias": "^6.0.0",
     "@rollup/plugin-inject": "^5.0.5",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-replace": "^6.0.3",
     "@stryke/convert": "^0.7.13",
-    "@stryke/fs": "^0.33.82",
+    "@stryke/fs": "^0.33.83",
     "@stryke/helpers": "^0.10.22",
     "@stryke/json": "^0.15.6",
     "@stryke/path": "^0.29.9",
     "@stryke/string-format": "^0.17.24",
     "@stryke/type-checks": "^0.6.15",
     "@stryke/types": "^0.12.10",
-    "@stryke/unique-id": "^0.3.93",
+    "@stryke/unique-id": "^0.3.94",
     "defu": "^6.1.7",
     "glob": "^13.0.6",
     "jiti": "^2.7.0",
@@ -167,5 +167,5 @@
     "webpack": { "optional": true }
   },
   "publishConfig": { "access": "public" },
-  "gitHead": "796932c328e29c623584c8c58fc0ae421674ba4e"
+  "gitHead": "64a604fd5da7312baeeb58dfcef0fd3ace15174e"
 }

package/dist/nuxt-DnPulowA.mjs

@@ -1,48 +0,0 @@
-import plugin$1 from "./vite.mjs";
-import plugin$2 from "./webpack.mjs";
-import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
-
-//#region package.json
-var name = "@powerlines/unplugin";
-var version = "0.0.79";
-
-//#endregion
-//#region src/nuxt.ts
-/**
-* A Nuxt plugin that will invoke the Powerlines API hooks during the build process.
-*
-* @see https://nuxt.com/docs/guide/directory-structure/modules
-*
-* @example
-* ```ts
-* // nuxt.config.ts
-* import { defineNuxtConfig } from "@nuxt/kit";
-*
-* export default defineNuxtConfig({
-*  modules: [
-*    [
-*      "@powerlines/unplugin/nuxt",
-*      { name: "example-app", ... }
-*    ],
-*  ],
-* });
-*
-* ```
-*/
-const plugin = defineNuxtModule({
-	meta: {
-		name,
-		version,
-		configKey: "powerlines",
-		compatibility: { builder: { vite: "^8.0.0" } }
-	},
-	defaults: {},
-	setup(options) {
-		addVitePlugin(() => plugin$1(options));
-		addWebpackPlugin(() => plugin$2(options));
-	}
-});
-
-//#endregion
-export { plugin as t };
-//# sourceMappingURL=nuxt-DnPulowA.mjs.map

package/dist/nuxt-DnPulowA.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"nuxt-DnPulowA.mjs","names":["vite","webpack"],"sources":["../package.json","../src/nuxt.ts"],"sourcesContent":["","/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { addVitePlugin, addWebpackPlugin, defineNuxtModule } from \"@nuxt/kit\";\nimport type { UserConfig } from \"@powerlines/core\";\nimport { name, version } from \"../package.json\";\nimport vite from \"./vite\";\nimport webpack from \"./webpack\";\n\n/**\n * A Nuxt plugin that will invoke the Powerlines API hooks during the build process.\n *\n * @see https://nuxt.com/docs/guide/directory-structure/modules\n *\n * @example\n * ```ts\n * // nuxt.config.ts\n * import { defineNuxtConfig } from \"@nuxt/kit\";\n *\n * export default defineNuxtConfig({\n *  modules: [\n *    [\n *      \"@powerlines/unplugin/nuxt\",\n *      { name: \"example-app\", ... }\n *    ],\n *  ],\n * });\n *\n * ```\n */\nconst plugin = defineNuxtModule<UserConfig>({\n  meta: {\n    name,\n    version,\n    configKey: \"powerlines\",\n    compatibility: {\n      builder: {\n        vite: \"^8.0.0\"\n      }\n    }\n  },\n  defaults: {},\n  setup(options) {\n    addVitePlugin(() => vite(options));\n    addWebpackPlugin(() => webpack(options));\n  }\n});\n\nexport default plugin;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC6CA,MAAM,SAAS,iBAA6B;CAC1C,MAAM;EACJ;EACA;EACA,WAAW;EACX,eAAe,EACb,SAAS,EACP,MAAM,SACR,EACF;CACF;CACA,UAAU,CAAC;CACX,MAAM,SAAS;EACb,oBAAoBA,SAAK,OAAO,CAAC;EACjC,uBAAuBC,SAAQ,OAAO,CAAC;CACzC;AACF,CAAC"}

package/dist/nuxt-p97pkRJZ.cjs

@@ -1,52 +0,0 @@
-const require_vite = require('./vite.cjs');
-const require_webpack = require('./webpack.cjs');
-let _nuxt_kit = require("@nuxt/kit");
-
-//#region package.json
-var name = "@powerlines/unplugin";
-var version = "0.0.79";
-
-//#endregion
-//#region src/nuxt.ts
-/**
-* A Nuxt plugin that will invoke the Powerlines API hooks during the build process.
-*
-* @see https://nuxt.com/docs/guide/directory-structure/modules
-*
-* @example
-* ```ts
-* // nuxt.config.ts
-* import { defineNuxtConfig } from "@nuxt/kit";
-*
-* export default defineNuxtConfig({
-*  modules: [
-*    [
-*      "@powerlines/unplugin/nuxt",
-*      { name: "example-app", ... }
-*    ],
-*  ],
-* });
-*
-* ```
-*/
-const plugin = (0, _nuxt_kit.defineNuxtModule)({
-	meta: {
-		name,
-		version,
-		configKey: "powerlines",
-		compatibility: { builder: { vite: "^8.0.0" } }
-	},
-	defaults: {},
-	setup(options) {
-		(0, _nuxt_kit.addVitePlugin)(() => require_vite.default(options));
-		(0, _nuxt_kit.addWebpackPlugin)(() => require_webpack.default(options));
-	}
-});
-
-//#endregion
-Object.defineProperty(exports, 'plugin', {
-  enumerable: true,
-  get: function () {
-    return plugin;
-  }
-});

package/dist/types-CEaXoKbk.d.cts

@@ -1,13 +0,0 @@
-import { BuildInlineConfig, ExecutionContext, ExecutionOptions, UnpluginOptions } from "@powerlines/core";
-import { PartialKeys } from "@stryke/types/base";
-import { UnpluginContextMeta } from "unplugin";
-
-//#region \0rolldown/runtime.js
-//#endregion
-//#region src/types.d.ts
-type UnpluginExecutionOptionsBase = Omit<PartialKeys<ExecutionOptions, "cwd" | "configFile" | "framework" | "root" | "configIndex">, "executionId">;
-type UnpluginExecutionOptions = Omit<BuildInlineConfig, "command"> & UnpluginExecutionOptionsBase;
-type UnpluginFactory<TContext extends ExecutionContext> = (options: UnpluginExecutionOptions | undefined, meta: UnpluginContextMeta) => UnpluginOptions<TContext>;
-//#endregion
-export { __reExport as a, __exportAll as i, UnpluginExecutionOptionsBase as n, UnpluginFactory as r, UnpluginExecutionOptions as t };
-//# sourceMappingURL=types-CEaXoKbk.d.cts.map

package/dist/types-CEaXoKbk.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-CEaXoKbk.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;KA6BY,4BAAA,GAA+B,IAAA,CACzC,WAAA,CACE,gBAAA;AAAA,KAMQ,wBAAA,GAA2B,IAAA,CAAK,iBAAA,eAC1C,4BAAA;AAAA,KAEU,eAAA,kBAAiC,gBAAA,KAC3C,OAAA,EAAS,wBAAA,cACT,IAAA,EAAM,mBAAA,KACH,eAAA,CAAgB,QAAA"}