@powerlines/core 0.48.31 → 0.48.33

package/dist/types/hooks.d.mts

@@ -0,0 +1,96 @@
+import { UnpluginBuilderVariant, UnpluginHookFunctions } from "./unplugin.mjs";
+import { BasePlugin, Plugin, PluginHook, PluginHooks } from "./plugin.mjs";
+import { PluginContext, SelectHooksOptions } from "./context.mjs";
+import { StringOrRegExp, UnpluginOptions } from "unplugin";
+import { AnyFunction, MaybePromise } from "@stryke/types/base";
+
+//#region src/types/hooks.d.ts
+type HookListOrders = "preOrdered" | "preEnforced" | "normal" | "postEnforced" | "postOrdered";
+interface HooksListItem<TContext extends PluginContext = PluginContext, TFields extends string = string> {
+  plugin: Plugin<TContext>;
+  handler: InferHookFunction<TContext, TFields>;
+}
+type PluginFilter = (input: string) => boolean;
+type TransformHookFilter = (id: string, code: string) => boolean;
+interface NormalizedStringFilter {
+  include?: StringOrRegExp[];
+  exclude?: StringOrRegExp[];
+}
+type HooksList<TContext extends PluginContext = PluginContext, TFields extends string = string> = { [TKey in HookListOrders]?: HooksListItem<TContext, TFields>[] | undefined };
+type InferPluginFunction<TObject, TKey extends keyof Required<TObject>> = InferPluginFunctionKey<Required<TObject>[TKey]>;
+type InferPluginFunctionKey<TValue> = TValue extends AnyFunction ? TValue : TValue extends PluginHook<infer THookFunction, any> ? THookFunction : never;
+type InferHookFunction<TContext extends PluginContext, TKey extends string> = TKey extends `${infer TVariant}:${infer TField}` ? TVariant extends keyof Required<BasePlugin<TContext>> ? TField extends keyof Required<BasePlugin<TContext>>[TVariant] ? InferPluginFunction<Required<BasePlugin<TContext>>[TVariant], TField> : TVariant extends keyof Required<PluginHooks<TContext>> ? TField extends keyof Required<PluginHooks<TContext>>[TVariant] ? InferPluginFunction<Required<PluginHooks<TContext>>[TVariant], TField> : never : never : TVariant extends UnpluginBuilderVariant ? TField extends keyof Required<UnpluginOptions>[TVariant] ? UnpluginHookFunctions<TContext, TVariant, TField> : never : never : TKey extends keyof Required<BasePlugin<TContext>> ? InferPluginFunction<Required<BasePlugin<TContext>>, TKey> : TKey extends keyof Required<PluginHooks<TContext>> ? InferPluginFunction<Required<PluginHooks<TContext>>, TKey> : never;
+type InferHookReturnType<TContext extends PluginContext, TKey extends string> = ReturnType<InferHookFunction<TContext, TKey>>;
+type InferHookParameters<TContext extends PluginContext, TKey extends string> = Parameters<InferHookFunction<TContext, TKey>>;
+type InferHookThisType<TContext extends PluginContext, TKey extends string> = ThisParameterType<InferHookFunction<TContext, TKey>>;
+type CallHookOptions<TResult = any> = SelectHooksOptions & (({
+  /**
+   * Whether to call the hooks sequentially or in parallel.
+   *
+   * @defaultValue true
+   */
+  sequential?: true;
+} & ({
+  /**
+   * How to handle multiple return values from hooks.
+   * - "merge": Merge all non-undefined return values (if they are objects).
+   * - "first": Return the first non-undefined value.
+   * - "last": Return the last non-undefined value.
+   *
+   * @remarks
+   * Merging only works if the return values are objects.
+   *
+   * @defaultValue "merge"
+   */
+  result: "first";
+} | ({
+  /**
+   * An indicator specifying if the results of the previous hook should be provided as the **first** parameter of the next hook function, or a function to process the result of the previous hook function and pass the returned value as the next hook's **first** parameter
+   */
+  asNextParam?: false | ((previousResult: TResult) => MaybePromise<TResult>);
+} & ({
+  /**
+   * How to handle multiple return values from hooks.
+   * - "merge": Merge all non-undefined return values (if they are objects).
+   * - "first": Return the first non-undefined value.
+   * - "last": Return the last non-undefined value.
+   *
+   * @remarks
+   * Merging only works if the return values are objects.
+   *
+   * @defaultValue "merge"
+   */
+  result?: "merge";
+  /**
+   * A custom function to merge two sets of return values from hooks.
+   *
+   * @remarks
+   * If not provided, the {@link mergeResults} function will be used by default, which merges string results by concatenation and object results by deep merging.
+   *
+   * @param currentResult - The current hook result to merge with the previous results.
+   * @param previousResult - The previous hook result to merge with the current result.
+   * @returns The merged result.
+   */
+  merge?: (currentResult: TResult, previousResult: TResult) => MaybePromise<TResult>;
+} | {
+  /**
+   * How to handle multiple return values from hooks.
+   * - "merge": Merge all non-undefined return values (if they are objects).
+   * - "first": Return the first non-undefined value.
+   * - "last": Return the last non-undefined value.
+   *
+   * @remarks
+   * Merging only works if the return values are objects.
+   *
+   * @defaultValue "merge"
+   */
+  result?: "last";
+})))) | {
+  /**
+   * Whether to call the hooks sequentially or in parallel.
+   */
+  sequential: false;
+});
+//#endregion
+export { CallHookOptions, HookListOrders, HooksList, HooksListItem, InferHookFunction, InferHookParameters, InferHookReturnType, InferHookThisType, NormalizedStringFilter, PluginFilter, TransformHookFilter };
+//# sourceMappingURL=hooks.d.mts.map

package/dist/types/hooks.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.mts","names":[],"sources":["../../src/types/hooks.ts"],"mappings":";;;;;;;KAwBY,cAAA;AAAA,UAOK,aAAA,kBACE,aAAA,GAAgB,aAAA;EAGjC,MAAA,EAAQ,MAAA,CAAO,QAAA;EACf,OAAA,EAAS,iBAAA,CAAkB,QAAA,EAAU,OAAA;AAAA;AAAA,KAG3B,YAAA,IAAgB,KAAa;AAAA,KAC7B,mBAAA,IAAuB,EAAA,UAAY,IAAY;AAAA,UAE1C,sBAAA;EACf,OAAA,GAAU,cAAA;EACV,OAAA,GAAU,cAAc;AAAA;AAAA,KAGd,SAAA,kBACO,aAAA,GAAgB,aAAA,gDAGxB,cAAA,IAAkB,aAAA,CAAc,QAAA,EAAU,OAAA;AAAA,KAGhD,mBAAA,6BAEgB,QAAA,CAAS,OAAA,KAC1B,sBAAA,CAAuB,QAAA,CAAS,OAAA,EAAS,IAAA;AAAA,KAExC,sBAAA,WAAiC,MAAA,SAAe,WAAA,GACjD,MAAA,GACA,MAAA,SAAe,UAAA,6BACb,aAAA;AAAA,KAGM,iBAAA,kBACO,aAAA,yBAEf,IAAA,+CACA,QAAA,eAAuB,QAAA,CAAS,UAAA,CAAW,QAAA,KACzC,MAAA,eAAqB,QAAA,CAAS,UAAA,CAAW,QAAA,GAAW,QAAA,IAClD,mBAAA,CAAoB,QAAA,CAAS,UAAA,CAAW,QAAA,GAAW,QAAA,GAAW,MAAA,IAC9D,QAAA,eAAuB,QAAA,CAAS,WAAA,CAAY,QAAA,KAC1C,MAAA,eAAqB,QAAA,CAAS,WAAA,CAAY,QAAA,GAAW,QAAA,IACnD,mBAAA,CACE,QAAA,CAAS,WAAA,CAAY,QAAA,GAAW,QAAA,GAChC,MAAA,oBAIR,QAAA,SAAiB,sBAAA,GACf,MAAA,eAAqB,QAAA,CAAS,eAAA,EAAiB,QAAA,IAC7C,qBAAA,CAAsB,QAAA,EAAU,QAAA,EAAU,MAAA,oBAGhD,IAAA,eAAmB,QAAA,CAAS,UAAA,CAAW,QAAA,KACrC,mBAAA,CAAoB,QAAA,CAAS,UAAA,CAAW,QAAA,IAAY,IAAA,IACpD,IAAA,eAAmB,QAAA,CAAS,WAAA,CAAY,QAAA,KACtC,mBAAA,CAAoB,QAAA,CAAS,WAAA,CAAY,QAAA,IAAY,IAAA;AAAA,KAGjD,mBAAA,kBACO,aAAA,yBAEf,UAAA,CAAW,iBAAA,CAAkB,QAAA,EAAU,IAAA;AAAA,KAE/B,mBAAA,kBACO,aAAA,yBAEf,UAAA,CAAW,iBAAA,CAAkB,QAAA,EAAU,IAAA;AAAA,KAE/B,iBAAA,kBACO,aAAA,yBAEf,iBAAA,CAAkB,iBAAA,CAAkB,QAAA,EAAU,IAAA;AAAA,KAEtC,eAAA,kBAAiC,kBAAA;EA1EV;;;;;EAkF3B,UAAA;AAAA;EA9EqB;;;AAAiB;AAG9C;;;;AAAyC;AACzC;;EAwFY,MAAA;AAAA;EAxF+C;AAE3D;;EA4FY,WAAA,aAEM,cAAA,EAAgB,OAAA,KAAY,YAAA,CAAa,OAAA;AAAA;EA7FzD;;;;;AACwB;AAG1B;;;;;EAuGgB,MAAA;EAnG2B;;;;;;;;;;EA+G3B,KAAA,IACE,aAAA,EAAe,OAAA,EACf,cAAA,EAAgB,OAAA,KACb,YAAA,CAAa,OAAA;AAAA;EAlHS;;;AAAiB;AAC1D;;;;;;;EA+Hc,MAAA;AAAA;EA1HU;;;EAkIlB,UAAA;AAAA"}

package/dist/types/index.d.cts

@@ -0,0 +1,9 @@
+import { ResolveOptions, StorageAdapter, StoragePort, StoragePreset, VirtualFile, VirtualFileData, VirtualFileExtension, VirtualFileMetadata, VirtualFileSystemInterface, WriteData, WriteOptions } from "./fs.cjs";
+import { BaseCommandType, BaseExecutionApiMethods, CommandType, Commands, ExecutionApiMethods, SupportedCommands } from "./api.cjs";
+import { BuilderVariant, UnpluginBuilderVariant, UnpluginHookFunctions, UnpluginOptions } from "./unplugin.cjs";
+import { BasePlugin, HookFunctions, Hooks, Plugin, PluginHook, PluginHookFields, PluginHookObject, PluginHooks, PluginNonHookFields, TypesResult } from "./plugin.cjs";
+import { CallHookOptions, HookListOrders, HooksList, HooksListItem, InferHookFunction, InferHookParameters, InferHookReturnType, InferHookThisType, NormalizedStringFilter, PluginFilter, TransformHookFilter } from "./hooks.cjs";
+import { CustomLogger, CustomLoggerMessage, LogCategory, LogFn, LogFnMeta, LogFnOptions, LogLevel, LogLevelResolvedConfig, LogLevelUserConfig, LogMessage, LogMeta, Logger, LoggerMessage, LoggerMeta, LoggerOptions, PowerlinesMessage } from "./logging.cjs";
+import { DeepkitOptions, Level, ParsedTypeScriptConfig, RawReflectionMode, ReflectionMode, TSCompilerOptions, TSConfig } from "./tsconfig.cjs";
+import { BaseContext, BuildPluginContext, Context, EmitEntryOptions, EmitOptions, EnvironmentContext, EnvironmentPlugin, ExecutionContext, FetchOptions, InitContextOptions, MetaInfo, ParseOptions, PluginContext, ResolveResult, Resolver, SelectHookResult, SelectHookResultItem, SelectHooksOptions, SourceFile, TransformResult, UnimportContext, UnresolvedContext, WithUnpluginBuildContext } from "./context.cjs";
+import { BaseExecutionOptions, BuildInlineConfig, CleanInlineConfig, Config, ConfigParams, CopyConfig, CreateInlineConfig, DeployInlineConfig, DocsInlineConfig, EnvironmentConfig, EnvironmentResolvedConfig, ExecutionOptions, FrameworkOptions, InferOverridableConfig, InlineConfig, InlineConfigPaths, LintInlineConfig, Mode, Options, OutputConfig, ParsedUserConfig, PartialPlugin, PartialPluginFactory, PluginConfig, PluginConfigObject, PluginConfigTuple, PluginFactory, PrepareInlineConfig, ProjectType, ResolveConfig, ResolvedAssetGlob, ResolvedConfig, ResolvedCopyConfig, ResolvedEntryFileReference, ResolvedEnvironmentConfig, ResolvedOutputConfig, ResolvedResolveConfig, TestInlineConfig, TypesInlineConfig, UserConfig, UserConfigExport, UserConfigFn, UserConfigFnObject, UserConfigFnPromise, WorkspaceConfig } from "./config.cjs";

package/dist/types/index.d.mts

@@ -0,0 +1,9 @@
+import { ResolveOptions, StorageAdapter, StoragePort, StoragePreset, VirtualFile, VirtualFileData, VirtualFileExtension, VirtualFileMetadata, VirtualFileSystemInterface, WriteData, WriteOptions } from "./fs.mjs";
+import { BaseCommandType, BaseExecutionApiMethods, CommandType, Commands, ExecutionApiMethods, SupportedCommands } from "./api.mjs";
+import { BuilderVariant, UnpluginBuilderVariant, UnpluginHookFunctions, UnpluginOptions } from "./unplugin.mjs";
+import { BasePlugin, HookFunctions, Hooks, Plugin, PluginHook, PluginHookFields, PluginHookObject, PluginHooks, PluginNonHookFields, TypesResult } from "./plugin.mjs";
+import { CallHookOptions, HookListOrders, HooksList, HooksListItem, InferHookFunction, InferHookParameters, InferHookReturnType, InferHookThisType, NormalizedStringFilter, PluginFilter, TransformHookFilter } from "./hooks.mjs";
+import { CustomLogger, CustomLoggerMessage, LogCategory, LogFn, LogFnMeta, LogFnOptions, LogLevel, LogLevelResolvedConfig, LogLevelUserConfig, LogMessage, LogMeta, Logger, LoggerMessage, LoggerMeta, LoggerOptions, PowerlinesMessage } from "./logging.mjs";
+import { DeepkitOptions, Level, ParsedTypeScriptConfig, RawReflectionMode, ReflectionMode, TSCompilerOptions, TSConfig } from "./tsconfig.mjs";
+import { BaseContext, BuildPluginContext, Context, EmitEntryOptions, EmitOptions, EnvironmentContext, EnvironmentPlugin, ExecutionContext, FetchOptions, InitContextOptions, MetaInfo, ParseOptions, PluginContext, ResolveResult, Resolver, SelectHookResult, SelectHookResultItem, SelectHooksOptions, SourceFile, TransformResult, UnimportContext, UnresolvedContext, WithUnpluginBuildContext } from "./context.mjs";
+import { BaseExecutionOptions, BuildInlineConfig, CleanInlineConfig, Config, ConfigParams, CopyConfig, CreateInlineConfig, DeployInlineConfig, DocsInlineConfig, EnvironmentConfig, EnvironmentResolvedConfig, ExecutionOptions, FrameworkOptions, InferOverridableConfig, InlineConfig, InlineConfigPaths, LintInlineConfig, Mode, Options, OutputConfig, ParsedUserConfig, PartialPlugin, PartialPluginFactory, PluginConfig, PluginConfigObject, PluginConfigTuple, PluginFactory, PrepareInlineConfig, ProjectType, ResolveConfig, ResolvedAssetGlob, ResolvedConfig, ResolvedCopyConfig, ResolvedEntryFileReference, ResolvedEnvironmentConfig, ResolvedOutputConfig, ResolvedResolveConfig, TestInlineConfig, TypesInlineConfig, UserConfig, UserConfigExport, UserConfigFn, UserConfigFnObject, UserConfigFnPromise, WorkspaceConfig } from "./config.mjs";

package/dist/types/logging.d.cts

@@ -0,0 +1,145 @@
+import { LOG_CATEGORIES, LOG_LEVELS } from "../constants/log-level.cjs";
+import { Mode } from "./config.cjs";
+import { PartialKeys, RequiredKeys } from "@stryke/types/base";
+import { UnpluginMessage } from "unplugin";
+
+//#region src/types/logging.d.ts
+type LogLevel = (typeof LOG_LEVELS)[number];
+type LogCategory = (typeof LOG_CATEGORIES)[number];
+interface LogMeta {
+  /**
+   * A unique identifier for the log message, which can be used to correlate related log entries across different parts of the system or different executions.
+   */
+  logId: string;
+  /**
+   * The log level of the message, which indicates the severity or importance of the log entry. The log level can be used to filter log messages based on their importance, allowing users to focus on critical issues or relevant information while ignoring less important messages.
+   */
+  type: LogLevel;
+  /**
+   * The category of the log message, which can be used to classify and filter log entries based on their purpose or origin.
+   */
+  category: LogCategory;
+  /**
+   * The timestamp when the RPC message was created, represented as the number of milliseconds since the Unix epoch.
+   */
+  timestamp: number;
+  /**
+   * The name of the project or package associated with the log message, which can be used to identify the source of the log entry and provide context for the message.
+   */
+  name?: string;
+  /**
+   * A unique identifier for the current execution instance, which can be used for logging and other purposes to distinguish between different executions in the same process.
+   */
+  executionId?: string;
+  /**
+   * The zero-based index of the current execution within the sequence of executions in the same process.
+   */
+  configIndex?: number;
+  /**
+   * Optional command identifier to specify the command or task associated with the log message, which can be used to provide additional context about the operation being performed when the log entry was generated.
+   */
+  command?: string;
+  /**
+   * Optional hook name to specify the plugin hook associated with the log message, which can be used to provide additional context about the specific plugin hook being executed when the log entry was generated.
+   */
+  hook?: string;
+  /**
+   * Optional environment identifier to specify the context or environment in which the message is being processed.
+   */
+  environment?: string;
+  /**
+   * Optional plugin name to specify the source plugin of the log message.
+   */
+  plugin?: string;
+  /**
+   * The name of the logger or source of the log message, which can be used to identify the origin of the log entry.
+   */
+  source?: string;
+  /**
+   * Indicates whether the log message is related to inter-process communication (IPC).
+   *
+   * @internal
+   */
+  $$ipc?: boolean;
+}
+type LogFnOptions = Omit<Partial<LogMeta>, "logId" | "timestamp" | "name" | "type"> & {
+  mode?: Mode;
+  logLevel?: LogLevelUserConfig;
+};
+type LogFnMeta = LogLevel | PartialKeys<LogMeta, "logId" | "timestamp" | "name" | "category">;
+type LogFn = (meta: LogFnMeta, message: string) => void;
+type LoggerMeta = PartialKeys<Omit<LogMeta, "type">, "logId" | "timestamp" | "name" | "category">;
+type LoggerOptions = Omit<LoggerMeta, "logId" | "timestamp" | "type"> & {
+  mode?: Mode;
+  logLevel?: LogLevelUserConfig;
+};
+interface PowerlinesMessage<TMeta> extends UnpluginMessage {
+  meta: TMeta;
+  error?: Error;
+}
+type LogMessage = PowerlinesMessage<Partial<LogMeta>>;
+/**
+ * A type representing a log message that can be passed to the logging methods defined in the {@link Logger} interface, which includes the log metadata and message content. This type is used as the parameter for the logging methods defined in the {@link Logger} interface, allowing users to log messages with rich metadata that can be used for filtering, formatting, or other purposes in the logging implementation.
+ */
+type LoggerMessage = PowerlinesMessage<LoggerMeta>;
+/**
+ * An internal interface representing a logger instance used within Powerlines for logging messages at various log levels, including "error", "warn", "info", "debug", and "trace". This interface defines methods for logging messages at each log level, which accept a message parameter that can be either a string or an object containing the log metadata and message content. The logger instance also includes an options property that contains the configuration options used for the logger, such as the source, command, environment, plugin, log level, and other relevant metadata. This interface is intended for internal use within Powerlines and is not meant to be implemented by users directly; instead, users can provide a custom logger that implements the {@link CustomLogger} interface to integrate with Powerlines' logging system.
+ */
+interface Logger {
+  options: LoggerOptions;
+  error: (message: string | LoggerMessage | Error) => void;
+  warn: (message: string | LoggerMessage) => void;
+  info: (message: string | LoggerMessage) => void;
+  debug: (message: string | LoggerMessage) => void;
+  trace: (message: string | LoggerMessage) => void;
+  log: (type: LogLevel, message: string | LoggerMessage) => void;
+}
+/**
+ * A type representing a log message that can be passed to a custom logger, which includes the log metadata and message content. This type is used as the parameter for the logging methods defined in the {@link CustomLogger} interface, allowing users to log messages with rich metadata that can be used for filtering, formatting, or other purposes in their custom logging implementation.
+ */
+type CustomLoggerMessage = PowerlinesMessage<Omit<LogMeta, "type">>;
+/**
+ * An interface representing a custom logger that can be provided by the user to override the default logging behavior of Powerlines. This interface defines methods for logging messages at different log levels, including "error", "warn", "info", "debug", and "trace". Each method accepts a message parameter, which can be either a string or an object containing the log metadata and message content. By implementing this interface, users can integrate their own logging system with Powerlines or customize the logging behavior to suit their specific needs.
+ */
+interface CustomLogger {
+  /**
+   * A function to log messages at the "error" level, which indicates a serious issue that has caused a failure in the build process or a critical problem that needs immediate attention.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the error being reported.
+   * @returns void
+   */
+  error?: (message: CustomLoggerMessage) => void;
+  /**
+   * A function to log messages at the "warn" level, which indicates a potential issue or a situation that may require attention but does not necessarily cause a failure in the build process.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the warning being reported.
+   * @returns void
+   */
+  warn?: (message: CustomLoggerMessage) => void;
+  /**
+   * A function to log messages at the "info" level, which indicates general informational messages about the build process, such as the start and completion of tasks, configuration details, or other relevant information that may be useful for monitoring the build process.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the informational message being reported.
+   * @returns void
+   */
+  info?: (message: CustomLoggerMessage) => void;
+  /**
+   * A function to log messages at the "debug" level, which indicates detailed debugging information that may be useful for diagnosing issues during development or troubleshooting problems in the build process.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the debug information being reported.
+   * @returns void
+   */
+  debug?: (message: CustomLoggerMessage) => void;
+  /**
+   * A function to log messages at the "trace" level, which indicates very detailed tracing information that may be useful for in-depth analysis of the build process or for tracking the flow of execution through various stages of the build.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the trace information being reported.
+   * @returns void
+   */
+  trace?: (message: CustomLoggerMessage) => void;
+}
+type LogLevelUserConfig = LogLevel | RequiredKeys<Partial<Record<LogCategory, LogLevel | boolean | undefined>>, "general">;
+type LogLevelResolvedConfig = Record<LogCategory, LogLevel>;
+//#endregion
+export { CustomLogger, CustomLoggerMessage, LogCategory, LogFn, LogFnMeta, LogFnOptions, LogLevel, LogLevelResolvedConfig, LogLevelUserConfig, LogMessage, LogMeta, Logger, LoggerMessage, LoggerMeta, LoggerOptions, PowerlinesMessage };
+//# sourceMappingURL=logging.d.cts.map

package/dist/types/logging.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.cts","names":[],"sources":["../../src/types/logging.ts"],"mappings":";;;;;;KAuBY,QAAA,WAAmB,UAAU;AAAA,KAE7B,WAAA,WAAsB,cAAc;AAAA,UAE/B,OAAA;EAJG;;;EAQlB,KAAA;EANU;;;EAUV,IAAA,EAAM,QAAA;EAVwC;AAEhD;;EAYE,QAAA,EAAU,WAAW;EAAA;;;EAIrB,SAAA;EAJA;;;EAQA,IAAA;EAIA;;;EAAA,WAAA;EAgBA;;;EAZA,WAAA;EA0BK;AAAA;AAGP;EAzBE,OAAA;;;;EAIA,IAAA;EAyBO;;;EArBP,WAAA;EAiByB;;;EAbzB,MAAA;EAiBO;;;EAbP,MAAA;EAc6B;AAG/B;;;;EAXE,KAAA;AAAA;AAAA,KAGU,YAAA,GAAe,IAAA,CACzB,OAAA,CAAQ,OAAA;EAGR,IAAA,GAAO,IAAA;EACP,QAAA,GAAW,kBAAA;AAAA;AAAA,KAGD,SAAA,GACR,QAAA,GACA,WAAA,CAAY,OAAA;AAAA,KAEJ,KAAA,IAAS,IAAA,EAAM,SAAS,EAAE,OAAA;AAAA,KAE1B,UAAA,GAAa,WAAA,CACvB,IAAA,CAAK,OAAA;AAAA,KAIK,aAAA,GAAgB,IAAA,CAAK,UAAA;EAC/B,IAAA,GAAO,IAAA;EACP,QAAA,GAAW,kBAAA;AAAA;AAAA,UAGI,iBAAA,gBAAiC,eAAA;EAChD,IAAA,EAAM,KAAA;EACN,KAAA,GAAQ,KAAA;AAAA;AAAA,KAGE,UAAA,GAAa,iBAAA,CAAkB,OAAA,CAAQ,OAAA;AAfnD;;;AAAA,KAoBY,aAAA,GAAgB,iBAAiB,CAAC,UAAA;;;;UAK7B,MAAA;EACf,OAAA,EAAS,aAAA;EACT,KAAA,GAAQ,OAAA,WAAkB,aAAA,GAAgB,KAAA;EAC1C,IAAA,GAAO,OAAA,WAAkB,aAAA;EACzB,IAAA,GAAO,OAAA,WAAkB,aAAA;EACzB,KAAA,GAAQ,OAAA,WAAkB,aAAA;EAC1B,KAAA,GAAQ,OAAA,WAAkB,aAAA;EAC1B,GAAA,GAAM,IAAA,EAAM,QAAA,EAAU,OAAA,WAAkB,aAAA;AAAA;;;;KAM9B,mBAAA,GAAsB,iBAAA,CAAkB,IAAA,CAAK,OAAA;;;;UAKxC,YAAA;EArCf;;;;;AAC6B;EA2C7B,KAAA,IAAS,OAAA,EAAS,mBAAA;EAxCc;;;;;;EA+ChC,IAAA,IAAQ,OAAA,EAAS,mBAAA;EA/CgB;;;;;;EAsDjC,IAAA,IAAQ,OAAA,EAAS,mBAAA;EApDJ;AAGf;;;;;EAwDE,KAAA,IAAS,OAAA,EAAS,mBAAA;EAxDsB;;;;;;EA+DxC,KAAA,IAAS,OAAA,EAAS,mBAAA;AAAA;AAAA,KAGR,kBAAA,GACR,QAAA,GACA,YAAA,CACE,OAAA,CAAQ,MAAA,CAAO,WAAA,EAAa,QAAA;AAAA,KAItB,sBAAA,GAAyB,MAAA,CAAO,WAAA,EAAa,QAAA"}

package/dist/types/logging.d.mts

@@ -0,0 +1,145 @@
+import { LOG_CATEGORIES, LOG_LEVELS } from "../constants/log-level.mjs";
+import { Mode } from "./config.mjs";
+import { UnpluginMessage } from "unplugin";
+import { PartialKeys, RequiredKeys } from "@stryke/types/base";
+
+//#region src/types/logging.d.ts
+type LogLevel = (typeof LOG_LEVELS)[number];
+type LogCategory = (typeof LOG_CATEGORIES)[number];
+interface LogMeta {
+  /**
+   * A unique identifier for the log message, which can be used to correlate related log entries across different parts of the system or different executions.
+   */
+  logId: string;
+  /**
+   * The log level of the message, which indicates the severity or importance of the log entry. The log level can be used to filter log messages based on their importance, allowing users to focus on critical issues or relevant information while ignoring less important messages.
+   */
+  type: LogLevel;
+  /**
+   * The category of the log message, which can be used to classify and filter log entries based on their purpose or origin.
+   */
+  category: LogCategory;
+  /**
+   * The timestamp when the RPC message was created, represented as the number of milliseconds since the Unix epoch.
+   */
+  timestamp: number;
+  /**
+   * The name of the project or package associated with the log message, which can be used to identify the source of the log entry and provide context for the message.
+   */
+  name?: string;
+  /**
+   * A unique identifier for the current execution instance, which can be used for logging and other purposes to distinguish between different executions in the same process.
+   */
+  executionId?: string;
+  /**
+   * The zero-based index of the current execution within the sequence of executions in the same process.
+   */
+  configIndex?: number;
+  /**
+   * Optional command identifier to specify the command or task associated with the log message, which can be used to provide additional context about the operation being performed when the log entry was generated.
+   */
+  command?: string;
+  /**
+   * Optional hook name to specify the plugin hook associated with the log message, which can be used to provide additional context about the specific plugin hook being executed when the log entry was generated.
+   */
+  hook?: string;
+  /**
+   * Optional environment identifier to specify the context or environment in which the message is being processed.
+   */
+  environment?: string;
+  /**
+   * Optional plugin name to specify the source plugin of the log message.
+   */
+  plugin?: string;
+  /**
+   * The name of the logger or source of the log message, which can be used to identify the origin of the log entry.
+   */
+  source?: string;
+  /**
+   * Indicates whether the log message is related to inter-process communication (IPC).
+   *
+   * @internal
+   */
+  $$ipc?: boolean;
+}
+type LogFnOptions = Omit<Partial<LogMeta>, "logId" | "timestamp" | "name" | "type"> & {
+  mode?: Mode;
+  logLevel?: LogLevelUserConfig;
+};
+type LogFnMeta = LogLevel | PartialKeys<LogMeta, "logId" | "timestamp" | "name" | "category">;
+type LogFn = (meta: LogFnMeta, message: string) => void;
+type LoggerMeta = PartialKeys<Omit<LogMeta, "type">, "logId" | "timestamp" | "name" | "category">;
+type LoggerOptions = Omit<LoggerMeta, "logId" | "timestamp" | "type"> & {
+  mode?: Mode;
+  logLevel?: LogLevelUserConfig;
+};
+interface PowerlinesMessage<TMeta> extends UnpluginMessage {
+  meta: TMeta;
+  error?: Error;
+}
+type LogMessage = PowerlinesMessage<Partial<LogMeta>>;
+/**
+ * A type representing a log message that can be passed to the logging methods defined in the {@link Logger} interface, which includes the log metadata and message content. This type is used as the parameter for the logging methods defined in the {@link Logger} interface, allowing users to log messages with rich metadata that can be used for filtering, formatting, or other purposes in the logging implementation.
+ */
+type LoggerMessage = PowerlinesMessage<LoggerMeta>;
+/**
+ * An internal interface representing a logger instance used within Powerlines for logging messages at various log levels, including "error", "warn", "info", "debug", and "trace". This interface defines methods for logging messages at each log level, which accept a message parameter that can be either a string or an object containing the log metadata and message content. The logger instance also includes an options property that contains the configuration options used for the logger, such as the source, command, environment, plugin, log level, and other relevant metadata. This interface is intended for internal use within Powerlines and is not meant to be implemented by users directly; instead, users can provide a custom logger that implements the {@link CustomLogger} interface to integrate with Powerlines' logging system.
+ */
+interface Logger {
+  options: LoggerOptions;
+  error: (message: string | LoggerMessage | Error) => void;
+  warn: (message: string | LoggerMessage) => void;
+  info: (message: string | LoggerMessage) => void;
+  debug: (message: string | LoggerMessage) => void;
+  trace: (message: string | LoggerMessage) => void;
+  log: (type: LogLevel, message: string | LoggerMessage) => void;
+}
+/**
+ * A type representing a log message that can be passed to a custom logger, which includes the log metadata and message content. This type is used as the parameter for the logging methods defined in the {@link CustomLogger} interface, allowing users to log messages with rich metadata that can be used for filtering, formatting, or other purposes in their custom logging implementation.
+ */
+type CustomLoggerMessage = PowerlinesMessage<Omit<LogMeta, "type">>;
+/**
+ * An interface representing a custom logger that can be provided by the user to override the default logging behavior of Powerlines. This interface defines methods for logging messages at different log levels, including "error", "warn", "info", "debug", and "trace". Each method accepts a message parameter, which can be either a string or an object containing the log metadata and message content. By implementing this interface, users can integrate their own logging system with Powerlines or customize the logging behavior to suit their specific needs.
+ */
+interface CustomLogger {
+  /**
+   * A function to log messages at the "error" level, which indicates a serious issue that has caused a failure in the build process or a critical problem that needs immediate attention.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the error being reported.
+   * @returns void
+   */
+  error?: (message: CustomLoggerMessage) => void;
+  /**
+   * A function to log messages at the "warn" level, which indicates a potential issue or a situation that may require attention but does not necessarily cause a failure in the build process.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the warning being reported.
+   * @returns void
+   */
+  warn?: (message: CustomLoggerMessage) => void;
+  /**
+   * A function to log messages at the "info" level, which indicates general informational messages about the build process, such as the start and completion of tasks, configuration details, or other relevant information that may be useful for monitoring the build process.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the informational message being reported.
+   * @returns void
+   */
+  info?: (message: CustomLoggerMessage) => void;
+  /**
+   * A function to log messages at the "debug" level, which indicates detailed debugging information that may be useful for diagnosing issues during development or troubleshooting problems in the build process.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the debug information being reported.
+   * @returns void
+   */
+  debug?: (message: CustomLoggerMessage) => void;
+  /**
+   * A function to log messages at the "trace" level, which indicates very detailed tracing information that may be useful for in-depth analysis of the build process or for tracking the flow of execution through various stages of the build.
+   *
+   * @param message - The log message to be recorded, which can be a string or an object containing the log metadata and message content. The log message should provide sufficient information to understand the context and nature of the trace information being reported.
+   * @returns void
+   */
+  trace?: (message: CustomLoggerMessage) => void;
+}
+type LogLevelUserConfig = LogLevel | RequiredKeys<Partial<Record<LogCategory, LogLevel | boolean | undefined>>, "general">;
+type LogLevelResolvedConfig = Record<LogCategory, LogLevel>;
+//#endregion
+export { CustomLogger, CustomLoggerMessage, LogCategory, LogFn, LogFnMeta, LogFnOptions, LogLevel, LogLevelResolvedConfig, LogLevelUserConfig, LogMessage, LogMeta, Logger, LoggerMessage, LoggerMeta, LoggerOptions, PowerlinesMessage };
+//# sourceMappingURL=logging.d.mts.map

package/dist/types/logging.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.mts","names":[],"sources":["../../src/types/logging.ts"],"mappings":";;;;;;KAuBY,QAAA,WAAmB,UAAU;AAAA,KAE7B,WAAA,WAAsB,cAAc;AAAA,UAE/B,OAAA;EAJG;;;EAQlB,KAAA;EANU;;;EAUV,IAAA,EAAM,QAAA;EAVwC;AAEhD;;EAYE,QAAA,EAAU,WAAW;EAAA;;;EAIrB,SAAA;EAJA;;;EAQA,IAAA;EAIA;;;EAAA,WAAA;EAgBA;;;EAZA,WAAA;EA0BK;AAAA;AAGP;EAzBE,OAAA;;;;EAIA,IAAA;EAyBO;;;EArBP,WAAA;EAiByB;;;EAbzB,MAAA;EAiBO;;;EAbP,MAAA;EAc6B;AAG/B;;;;EAXE,KAAA;AAAA;AAAA,KAGU,YAAA,GAAe,IAAA,CACzB,OAAA,CAAQ,OAAA;EAGR,IAAA,GAAO,IAAA;EACP,QAAA,GAAW,kBAAA;AAAA;AAAA,KAGD,SAAA,GACR,QAAA,GACA,WAAA,CAAY,OAAA;AAAA,KAEJ,KAAA,IAAS,IAAA,EAAM,SAAS,EAAE,OAAA;AAAA,KAE1B,UAAA,GAAa,WAAA,CACvB,IAAA,CAAK,OAAA;AAAA,KAIK,aAAA,GAAgB,IAAA,CAAK,UAAA;EAC/B,IAAA,GAAO,IAAA;EACP,QAAA,GAAW,kBAAA;AAAA;AAAA,UAGI,iBAAA,gBAAiC,eAAA;EAChD,IAAA,EAAM,KAAA;EACN,KAAA,GAAQ,KAAA;AAAA;AAAA,KAGE,UAAA,GAAa,iBAAA,CAAkB,OAAA,CAAQ,OAAA;AAfnD;;;AAAA,KAoBY,aAAA,GAAgB,iBAAiB,CAAC,UAAA;;;;UAK7B,MAAA;EACf,OAAA,EAAS,aAAA;EACT,KAAA,GAAQ,OAAA,WAAkB,aAAA,GAAgB,KAAA;EAC1C,IAAA,GAAO,OAAA,WAAkB,aAAA;EACzB,IAAA,GAAO,OAAA,WAAkB,aAAA;EACzB,KAAA,GAAQ,OAAA,WAAkB,aAAA;EAC1B,KAAA,GAAQ,OAAA,WAAkB,aAAA;EAC1B,GAAA,GAAM,IAAA,EAAM,QAAA,EAAU,OAAA,WAAkB,aAAA;AAAA;;;;KAM9B,mBAAA,GAAsB,iBAAA,CAAkB,IAAA,CAAK,OAAA;;;;UAKxC,YAAA;EArCf;;;;;AAC6B;EA2C7B,KAAA,IAAS,OAAA,EAAS,mBAAA;EAxCc;;;;;;EA+ChC,IAAA,IAAQ,OAAA,EAAS,mBAAA;EA/CgB;;;;;;EAsDjC,IAAA,IAAQ,OAAA,EAAS,mBAAA;EApDJ;AAGf;;;;;EAwDE,KAAA,IAAS,OAAA,EAAS,mBAAA;EAxDsB;;;;;;EA+DxC,KAAA,IAAS,OAAA,EAAS,mBAAA;AAAA;AAAA,KAGR,kBAAA,GACR,QAAA,GACA,YAAA,CACE,OAAA,CAAQ,MAAA,CAAO,WAAA,EAAa,QAAA;AAAA,KAItB,sBAAA,GAAyB,MAAA,CAAO,WAAA,EAAa,QAAA"}

package/dist/types/plugin.d.cts

@@ -0,0 +1,207 @@
+import { PLUGIN_NON_HOOK_FIELDS } from "../constants/plugin.cjs";
+import { BaseCommandType } from "./api.cjs";
+import { UnpluginBuilderVariant, UnpluginOptions as UnpluginOptions$1 } from "./unplugin.cjs";
+import { BuildPluginContext, PluginContext, ResolveResult, UnresolvedContext } from "./context.cjs";
+import { EnvironmentConfig, PluginConfig, ResolvedEnvironmentConfig } from "./config.cjs";
+import { AnyFunction, MaybePromise } from "@stryke/types/base";
+import { HookFilter, TransformResult } from "unplugin";
+import { ArrayValues } from "@stryke/types/array";
+import { LoadResult } from "rollup";
+
+//#region src/types/plugin.d.ts
+interface PluginHookObject<THookFunction extends AnyFunction, TFilter extends keyof HookFilter = never> {
+  /**
+   * The order in which the plugin should be applied.
+   */
+  order?: "pre" | "post" | null | undefined;
+  /**
+   * A filter to determine when the hook should be called.
+   */
+  filter?: Pick<HookFilter, TFilter>;
+  /**
+   * The hook function to be called.
+   */
+  handler: THookFunction;
+}
+type PluginHook<THookFunction extends AnyFunction, TFilter extends keyof HookFilter = never> = THookFunction | PluginHookObject<THookFunction, TFilter>;
+/**
+ * A result returned by the plugin from the `types` hook that describes the declaration types output file.
+ */
+interface TypesResult {
+  directives?: string[];
+  code: string;
+}
+interface Hooks<TContext extends PluginContext> {
+  /**
+   * A function that returns configuration options to be merged with the build context's options.
+   *
+   * @remarks
+   * Modify config before it's resolved. The hook can either mutate {@link Context.config} on the passed-in context directly, or return a partial config object that will be deeply merged into existing config.
+   *
+   * @warning User plugins are resolved before running this hook so injecting other plugins inside the config hook will have no effect.
+   *
+   * @see https://vitejs.dev/guide/api-plugin#config
+   *
+   * @param this - The build context.
+   * @param config - The partial configuration object to be modified.
+   * @returns A promise that resolves to a partial configuration object.
+   */
+  config: (this: UnresolvedContext<TContext["config"]>) => MaybePromise<DeepPartial$1<TContext["config"]> & Record<string, any>>;
+  /**
+   * Modify environment configs before it's resolved. The hook can either mutate the passed-in environment config directly, or return a partial config object that will be deeply merged into existing config.
+   *
+   * @remarks
+   * This hook is called for each environment with a partially resolved environment config that already accounts for the default environment config values set at the root level. If plugins need to modify the config of a given environment, they should do it in this hook instead of the config hook. Leaving the config hook only for modifying the root default environment config.
+   *
+   * @see https://vitejs.dev/guide/api-plugin#configenvironment
+   *
+   * @param this - The build context.
+   * @param name - The name of the environment being configured.
+   * @param environment - The Vite-like environment object containing information about the current build environment.
+   * @returns A promise that resolves when the hook is complete.
+   */
+  configEnvironment: (this: TContext, name: string, environment: EnvironmentConfig) => MaybePromise<Partial<ResolvedEnvironmentConfig> | undefined | null>;
+  /**
+   * A hook that is called when the plugin is resolved.
+   *
+   * @see https://vitejs.dev/guide/api-plugin#configresolved
+   *
+   * @param this - The build context.
+   * @returns A promise that resolves when the hook is complete.
+   */
+  configResolved: (this: TContext) => MaybePromise<void>;
+  /**
+   * A hook that is called to overwrite the generated declaration types file (.d.ts). The generated type definitions should describe the built-in modules/logic added during the `prepare` task.
+   *
+   * @param this - The build context.
+   * @param code - The source code to generate types for.
+   * @returns A promise that resolves when the hook is complete.
+   */
+  types: (this: TContext, code: string) => MaybePromise<TypesResult | string | undefined | null>;
+  /**
+   * A hook that is called at the start of the build process.
+   *
+   * @param this - The build context and unplugin build context.
+   * @returns A promise that resolves when the hook is complete.
+   */
+  buildStart: (this: BuildPluginContext<TContext["config"]> & TContext) => MaybePromise<void>;
+  /**
+   * A hook that is called at the end of the build process.
+   *
+   * @param this - The build context and unplugin build context.
+   * @returns A promise that resolves when the hook is complete.
+   */
+  buildEnd: (this: BuildPluginContext<TContext["config"]> & TContext) => MaybePromise<void>;
+  /**
+   * A hook that is called to transform the source code.
+   *
+   * @param this - The build context, unplugin build context, and unplugin context.
+   * @param code - The source code to transform.
+   * @param id - The identifier of the source code.
+   * @returns A promise that resolves when the hook is complete.
+   */
+  transform: (this: BuildPluginContext<TContext["config"]> & TContext, code: string, id: string) => MaybePromise<TransformResult>;
+  /**
+   * A hook that is called to load the source code.
+   *
+   * @param this - The build context, unplugin build context, and unplugin context.
+   * @param id - The identifier of the source code.
+   * @returns A promise that resolves when the hook is complete.
+   */
+  load: (this: BuildPluginContext<TContext["config"]> & TContext, id: string) => MaybePromise<LoadResult>;
+  /**
+   * A hook that is called to resolve the identifier of the source code.
+   *
+   * @param this - The build context, unplugin build context, and unplugin context.
+   * @param id - The identifier of the source code.
+   * @param importer - The importer of the source code.
+   * @param options - The options for resolving the identifier.
+   * @returns A promise that resolves when the hook is complete.
+   */
+  resolveId: (this: BuildPluginContext<TContext["config"]> & TContext, id: string, importer: string | undefined, options: {
+    isEntry: boolean;
+  }) => MaybePromise<string | ResolveResult | null | undefined>;
+  /**
+   * A hook that is called to write the bundle to disk.
+   *
+   * @param this - The build context.
+   * @returns A promise that resolves when the hook is complete.
+   */
+  writeBundle: (this: TContext) => MaybePromise<void>;
+}
+type HookFunctions<TContext extends PluginContext> = { [TCommandType in BaseCommandType]: (this: TContext) => MaybePromise<void> } & Hooks<TContext>;
+type DeepPartial$1<T> = { [K in keyof T]?: DeepPartial$1<T[K]> };
+type InferPluginHookFunction<TContext extends PluginContext, TKey extends string> = TKey extends keyof HookFunctions<TContext> ? HookFunctions<TContext>[TKey] extends AnyFunction ? PluginHook<HookFunctions<TContext>[TKey], TKey & keyof HookFilter> : HookFunctions<TContext>[TKey] extends object ? { [K in keyof HookFunctions<TContext>[TKey]]?: InferPluginHookFunction<TContext, `${TKey}:${K & string}`> } : never : never;
+type PluginHooks<TContext extends PluginContext> = { [TKey in keyof HookFunctions<TContext>]?: InferPluginHookFunction<TContext, TKey> } & {
+  types?: PluginHook<HookFunctions<TContext>["types"], never>;
+  transform?: PluginHook<HookFunctions<TContext>["transform"], "code" | "id">;
+  load?: PluginHook<HookFunctions<TContext>["load"], "id">;
+  resolveId?: PluginHook<HookFunctions<TContext>["resolveId"], "id">;
+};
+interface BasePlugin<TContext extends PluginContext> {
+  /**
+   * The name of the plugin, for use in deduplication, error messages and logs.
+   */
+  name: string;
+  /**
+   * An API object that can be used for inter-plugin communication.
+   *
+   * @see https://rollupjs.org/plugin-development/#direct-plugin-communication
+   */
+  api?: Record<string, any>;
+  /**
+   * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering is still subject to the `order` property in the hook object.
+   *
+   * @remarks
+   * The Plugin invocation order is as follows:
+   * - `enforce: 'pre'` plugins
+   * - `order: 'pre'` plugin hooks
+   * - any other plugins (normal)
+   * - `order: 'post'` plugin hooks
+   * - `enforce: 'post'` plugins
+   *
+   * @see https://vitejs.dev/guide/api-plugin.html#plugin-ordering
+   * @see https://rollupjs.org/plugin-development/#build-hooks
+   * @see https://webpack.js.org/concepts/loaders/#enforce---pre-and-post
+   * @see https://esbuild.github.io/plugins/#concepts
+   */
+  enforce?: "pre" | "post";
+  /**
+   * A function to determine if two plugins are the same and can be de-duplicated.
+   *
+   * @remarks
+   * If this is not provided, plugins are de-duplicated by comparing their names.
+   *
+   * @param other - The other plugin to compare against.
+   * @returns `true` if the two plugins are the same, `false` otherwise.
+   */
+  dedupe?: false | ((other: Plugin<any>) => boolean);
+  /**
+   * Define environments where this plugin should be active. By default, the plugin is active in all environments.
+   *
+   * @param environment - The environment to check.
+   * @returns `true` if the plugin should be active in the specified environment, `false` otherwise.
+   */
+  applyToEnvironment?: (environment: ResolvedEnvironmentConfig) => boolean | PluginConfig<any>;
+  /**
+   * A function that returns configuration options to be merged with the build context's options.
+   *
+   * @remarks
+   * Modify config before it's resolved. The hook can either mutate {@link Context.config} on the passed-in context directly, or return a partial config object that will be deeply merged into existing config.
+   *
+   * @warning User plugins are resolved before running this hook so injecting other plugins inside the config hook will have no effect. If you want to add plugins, consider doing so in the {@link Plugin.dependsOn} property instead.
+   *
+   * @see https://vitejs.dev/guide/api-plugin#config
+   *
+   * @param this - The build context.
+   * @param config - The partial configuration object to be modified.
+   * @returns A promise that resolves to a partial configuration object.
+   */
+  config?: PluginHook<(this: UnresolvedContext<TContext["config"], TContext["system"]>) => MaybePromise<DeepPartial$1<TContext["config"]> & Record<string, any>>> | (DeepPartial$1<TContext["config"]> & Record<string, any>);
+}
+type Plugin<TContext extends PluginContext> = Partial<PluginHooks<TContext>> & BasePlugin<TContext> & Pick<UnpluginOptions$1<TContext>, UnpluginBuilderVariant>;
+type PluginNonHookFields = ArrayValues<typeof PLUGIN_NON_HOOK_FIELDS>;
+type PluginHookFields<TContext extends PluginContext = PluginContext, TKey extends string = string> = TKey extends ArrayValues<typeof PLUGIN_NON_HOOK_FIELDS> ? never : TKey extends keyof HookFunctions<TContext> ? HookFunctions<TContext>[TKey] extends AnyFunction ? TKey : HookFunctions<TContext>[TKey] extends object ? { [K in keyof HookFunctions<TContext>[TKey]]?: `${TKey}:${K & string}` }[keyof HookFunctions<TContext>[TKey]] : never : never;
+//#endregion
+export { BasePlugin, HookFunctions, Hooks, Plugin, PluginHook, PluginHookFields, PluginHookObject, PluginHooks, PluginNonHookFields, TypesResult };
+//# sourceMappingURL=plugin.d.cts.map