@powerlines/engine 0.0.25 → 0.9.2

package/dist/context-DrNQXXRC.d.mts

@@ -0,0 +1,149 @@
+import { n as EngineOptions, t as EngineExecutionOptions, u as RpcClient } from "./config-FB8Zqjjz.mjs";
+import { BaseContext, InlineConfig, ParsedUserConfig } from "@powerlines/core";
+import { ConnectionMeta, DevToolsNodeContext } from "devframe/types";
+
+//#region src/types/context.d.ts
+/**
+ * The execution scope state represents the current state of a command, hook, or plugin execution within the Powerlines engine. It includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+type ExecutionScopeType = "command" | "hook" | "plugin";
+/**
+ * The execution state for a command, hook, or plugin execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionScopeState {
+  /**
+   * The timestamp when the command, hook, or plugin execution started
+   */
+  timestamp: number;
+  /**
+   * The name of the command, hook, or plugin being executed
+   */
+  name: string;
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: ExecutionScopeType;
+}
+/**
+ * The execution state for a command execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionCommandScopeState extends ExecutionScopeState {
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "command";
+}
+/**
+ * The execution state for a hook execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionHookScopeState extends ExecutionScopeState {
+  /**
+   * The order of the hook being executed, which can be "pre", "post", or "normal". This indicates whether the hook is being executed
+   */
+  order?: "pre" | "post";
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "hook";
+}
+/**
+ * The execution state for a plugin execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionPluginScopeState extends ExecutionScopeState {
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "plugin";
+}
+/**
+ * The execution state for the Powerlines engine, which includes information about the currently active command, hook, and plugin executions. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionState {
+  /**
+   * The currently active command execution for this execution context
+   */
+  command: ExecutionCommandScopeState | null;
+  /**
+   * The currently active hook execution for this execution context, if any
+   */
+  hook: ExecutionHookScopeState | null;
+  /**
+   * The currently active plugin execution for this execution context, if any
+   */
+  plugin: ExecutionPluginScopeState | null;
+}
+/**
+ * The execution context for a command, hook, or plugin execution within the Powerlines engine. This context includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This context can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface EngineExecutionItem {
+  /**
+   * A unique identifier for the current invocation (a single invocation can include multiple executions).
+   */
+  invocationId: string;
+  /**
+   * The method being executed, which can be one of the supported Powerlines execution API methods such as "build", "docs", or "deploy". This indicates the specific command or action that is being executed within the Powerlines engine.
+   */
+  method: string;
+  /**
+   * The options provided to the Powerlines process for this execution
+   */
+  options: EngineExecutionOptions;
+  /**
+   * The parsed user configuration file provided to the Powerlines process before any resolution or merging
+   */
+  configFile: ParsedUserConfig;
+  /**
+   * An object representing the currently active command, hook, and plugin executions for this execution context
+   */
+  state: ExecutionState;
+}
+/**
+ * The Powerlines engine context.
+ *
+ * @remarks
+ * This context is used during the execution of the Powerlines engine, providing access to the input user configurations.
+ */
+interface EngineContext<TSystemContext = unknown> extends BaseContext<TSystemContext>, Pick<Required<EngineOptions>, "framework"> {
+  /**
+   * The options provided to the Powerlines process
+   */
+  options: EngineOptions;
+  /**
+   * The metadata information for the RPC connection
+   */
+  connection: ConnectionMeta;
+  /**
+   * The [Devframe](https://devtools.vite.dev/devframe/guide/) context for interacting with the DevTools.
+   *
+   * @see https://devtools.vite.dev/devframe/guide/
+   * @see https://github.com/vitejs/devtools/blob/main/devframe
+   */
+  devtools: DevToolsNodeContext;
+  /**
+   * A list of all command executions that will be run during the lifecycle of the engine
+   */
+  executions: EngineExecutionItem[];
+  /**
+   * Initialize the context with the provided configuration options
+   *
+   * @remarks
+   * This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+   */
+  loadExecutions: (method: string, inlineConfig: InlineConfig) => Promise<EngineExecutionItem[]>;
+  /**
+   * Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.
+   *
+   * @param invocationId - The unique identifier for the invocation of the execution to be completed.
+   * @param executionId - The unique identifier for the specific execution to be completed.
+   */
+  completeExecution: (invocationId: string, executionId: string) => void;
+}
+interface EngineSystemContext {
+  /**
+   * The RPC client instance used for communication between the engine and its worker threads, allowing for remote procedure calls to be made between the main thread and worker threads for tasks such as logging, file system operations, and other interactions that require communication between the different execution contexts within the Powerlines engine.
+   */
+  rpc: RpcClient;
+}
+//#endregion
+export { ExecutionHookScopeState as a, ExecutionScopeType as c, ExecutionCommandScopeState as i, ExecutionState as l, EngineExecutionItem as n, ExecutionPluginScopeState as o, EngineSystemContext as r, ExecutionScopeState as s, EngineContext as t };
+//# sourceMappingURL=context-DrNQXXRC.d.mts.map

package/dist/context-DrNQXXRC.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-DrNQXXRC.d.mts","names":[],"sources":["../src/types/context.ts"],"mappings":";;;;;;AA0BA;;KAAY,kBAAA;;;AAKZ;UAAiB,mBAAA;;;;EAIf,SAAA;EAUA;;;EALA,IAAA;EAWe;;;EANf,IAAA,EAAM,kBAAA;AAAA;AAgBR;;;AAAA,UAViB,0BAAA,SAAmC,mBAAA;EAUH;;;EAN/C,IAAA;AAAA;AAqBF;;;AAAA,UAfiB,uBAAA,SAAgC,mBAAA;EAmB3C;AAMN;;EArBE,KAAA;EAyBS;;;EApBT,IAAA;AAAA;;;;UAMe,yBAAA,SAAkC,mBAAA;EAwBjD;;;EApBA,IAAA;AAAA;;;;UAMe,cAAA;EA4CR;;;EAxCP,OAAA,EAAS,0BAAA;EAyBT;;;EApBA,IAAA,EAAM,uBAAA;EA8BM;;;EAzBZ,MAAA,EAAQ,yBAAA;AAAA;AAuCV;;;AAAA,UAjCiB,mBAAA;EAoCC;;;EAhChB,YAAA;EAiDU;;;EA5CV,MAAA;EA4DK;;;EAvDL,OAAA,EAAS,sBAAA;EAsBH;;;EAjBN,UAAA,EAAY,gBAAA;EAiBV;;;EAZF,KAAA,EAAO,cAAA;AAAA;;;;;;;UASQ,aAAA,mCAEb,WAAA,CAAY,cAAA,GACZ,IAAA,CAAK,QAAA,CAAS,aAAA;EA+Bd;;;EA3BF,OAAA,EAAS,aAAA;EA6BI;;;EAxBb,UAAA,EAAY,cAAA;EAgCiD;;AAG/D;;;;EA3BE,QAAA,EAAU,mBAAA;;;;EAKV,UAAA,EAAY,mBAAA;;;;;;;EAQZ,cAAA,GACE,MAAA,UACA,YAAA,EAAc,YAAA,KACX,OAAA,CAAQ,mBAAA;;;;;;;EAQb,iBAAA,GAAoB,YAAA,UAAsB,WAAA;AAAA;AAAA,UAG3B,mBAAA;;;;EAIf,GAAA,EAAK,SAAA;AAAA"}

package/dist/context-LQBeYY23.d.cts

@@ -0,0 +1,149 @@
+import { n as EngineOptions, t as EngineExecutionOptions, u as RpcClient } from "./config-B_E_HMcT.cjs";
+import { BaseContext, InlineConfig, ParsedUserConfig } from "@powerlines/core";
+import { ConnectionMeta, DevToolsNodeContext } from "devframe/types";
+
+//#region src/types/context.d.ts
+/**
+ * The execution scope state represents the current state of a command, hook, or plugin execution within the Powerlines engine. It includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+type ExecutionScopeType = "command" | "hook" | "plugin";
+/**
+ * The execution state for a command, hook, or plugin execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionScopeState {
+  /**
+   * The timestamp when the command, hook, or plugin execution started
+   */
+  timestamp: number;
+  /**
+   * The name of the command, hook, or plugin being executed
+   */
+  name: string;
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: ExecutionScopeType;
+}
+/**
+ * The execution state for a command execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionCommandScopeState extends ExecutionScopeState {
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "command";
+}
+/**
+ * The execution state for a hook execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionHookScopeState extends ExecutionScopeState {
+  /**
+   * The order of the hook being executed, which can be "pre", "post", or "normal". This indicates whether the hook is being executed
+   */
+  order?: "pre" | "post";
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "hook";
+}
+/**
+ * The execution state for a plugin execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionPluginScopeState extends ExecutionScopeState {
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "plugin";
+}
+/**
+ * The execution state for the Powerlines engine, which includes information about the currently active command, hook, and plugin executions. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionState {
+  /**
+   * The currently active command execution for this execution context
+   */
+  command: ExecutionCommandScopeState | null;
+  /**
+   * The currently active hook execution for this execution context, if any
+   */
+  hook: ExecutionHookScopeState | null;
+  /**
+   * The currently active plugin execution for this execution context, if any
+   */
+  plugin: ExecutionPluginScopeState | null;
+}
+/**
+ * The execution context for a command, hook, or plugin execution within the Powerlines engine. This context includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This context can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface EngineExecutionItem {
+  /**
+   * A unique identifier for the current invocation (a single invocation can include multiple executions).
+   */
+  invocationId: string;
+  /**
+   * The method being executed, which can be one of the supported Powerlines execution API methods such as "build", "docs", or "deploy". This indicates the specific command or action that is being executed within the Powerlines engine.
+   */
+  method: string;
+  /**
+   * The options provided to the Powerlines process for this execution
+   */
+  options: EngineExecutionOptions;
+  /**
+   * The parsed user configuration file provided to the Powerlines process before any resolution or merging
+   */
+  configFile: ParsedUserConfig;
+  /**
+   * An object representing the currently active command, hook, and plugin executions for this execution context
+   */
+  state: ExecutionState;
+}
+/**
+ * The Powerlines engine context.
+ *
+ * @remarks
+ * This context is used during the execution of the Powerlines engine, providing access to the input user configurations.
+ */
+interface EngineContext<TSystemContext = unknown> extends BaseContext<TSystemContext>, Pick<Required<EngineOptions>, "framework"> {
+  /**
+   * The options provided to the Powerlines process
+   */
+  options: EngineOptions;
+  /**
+   * The metadata information for the RPC connection
+   */
+  connection: ConnectionMeta;
+  /**
+   * The [Devframe](https://devtools.vite.dev/devframe/guide/) context for interacting with the DevTools.
+   *
+   * @see https://devtools.vite.dev/devframe/guide/
+   * @see https://github.com/vitejs/devtools/blob/main/devframe
+   */
+  devtools: DevToolsNodeContext;
+  /**
+   * A list of all command executions that will be run during the lifecycle of the engine
+   */
+  executions: EngineExecutionItem[];
+  /**
+   * Initialize the context with the provided configuration options
+   *
+   * @remarks
+   * This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+   */
+  loadExecutions: (method: string, inlineConfig: InlineConfig) => Promise<EngineExecutionItem[]>;
+  /**
+   * Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.
+   *
+   * @param invocationId - The unique identifier for the invocation of the execution to be completed.
+   * @param executionId - The unique identifier for the specific execution to be completed.
+   */
+  completeExecution: (invocationId: string, executionId: string) => void;
+}
+interface EngineSystemContext {
+  /**
+   * The RPC client instance used for communication between the engine and its worker threads, allowing for remote procedure calls to be made between the main thread and worker threads for tasks such as logging, file system operations, and other interactions that require communication between the different execution contexts within the Powerlines engine.
+   */
+  rpc: RpcClient;
+}
+//#endregion
+export { ExecutionHookScopeState as a, ExecutionScopeType as c, ExecutionCommandScopeState as i, ExecutionState as l, EngineExecutionItem as n, ExecutionPluginScopeState as o, EngineSystemContext as r, ExecutionScopeState as s, EngineContext as t };
+//# sourceMappingURL=context-LQBeYY23.d.cts.map

package/dist/context-LQBeYY23.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-LQBeYY23.d.cts","names":[],"sources":["../src/types/context.ts"],"mappings":";;;;;;AA0BA;;KAAY,kBAAA;;;AAKZ;UAAiB,mBAAA;;;;EAIf,SAAA;EAUA;;;EALA,IAAA;EAWe;;;EANf,IAAA,EAAM,kBAAA;AAAA;AAgBR;;;AAAA,UAViB,0BAAA,SAAmC,mBAAA;EAUH;;;EAN/C,IAAA;AAAA;AAqBF;;;AAAA,UAfiB,uBAAA,SAAgC,mBAAA;EAmB3C;AAMN;;EArBE,KAAA;EAyBS;;;EApBT,IAAA;AAAA;;;;UAMe,yBAAA,SAAkC,mBAAA;EAwBjD;;;EApBA,IAAA;AAAA;;;;UAMe,cAAA;EA4CR;;;EAxCP,OAAA,EAAS,0BAAA;EAyBT;;;EApBA,IAAA,EAAM,uBAAA;EA8BM;;;EAzBZ,MAAA,EAAQ,yBAAA;AAAA;AAuCV;;;AAAA,UAjCiB,mBAAA;EAoCC;;;EAhChB,YAAA;EAiDU;;;EA5CV,MAAA;EA4DK;;;EAvDL,OAAA,EAAS,sBAAA;EAsBH;;;EAjBN,UAAA,EAAY,gBAAA;EAiBV;;;EAZF,KAAA,EAAO,cAAA;AAAA;;;;;;;UASQ,aAAA,mCAEb,WAAA,CAAY,cAAA,GACZ,IAAA,CAAK,QAAA,CAAS,aAAA;EA+Bd;;;EA3BF,OAAA,EAAS,aAAA;EA6BI;;;EAxBb,UAAA,EAAY,cAAA;EAgCiD;;AAG/D;;;;EA3BE,QAAA,EAAU,mBAAA;;;;EAKV,UAAA,EAAY,mBAAA;;;;;;;EAQZ,cAAA,GACE,MAAA,UACA,YAAA,EAAc,YAAA,KACX,OAAA,CAAQ,mBAAA;;;;;;;EAQb,iBAAA,GAAoB,YAAA,UAAsB,WAAA;AAAA;AAAA,UAG3B,mBAAA;;;;EAIf,GAAA,EAAK,SAAA;AAAA"}

package/dist/engine-context-BBSMtv0b.d.mts

@@ -0,0 +1,54 @@
+import { n as EngineOptions } from "./config-FB8Zqjjz.mjs";
+import { n as EngineExecutionItem, t as EngineContext } from "./context-DrNQXXRC.mjs";
+import { PowerlinesBaseContext } from "@powerlines/core/context/base-context";
+import { EnvPaths } from "@stryke/env/get-env-paths";
+import * as _$_powerlines_core0 from "@powerlines/core";
+import { FrameworkOptions, InlineConfig, LogFn, LoggerOptions } from "@powerlines/core";
+import { ConnectionMeta, DevToolsHost, DevToolsNodeContext } from "devframe/types";
+
+//#region src/context/engine-context.d.ts
+declare class PowerlinesEngineContext<TSystemContext = unknown> extends PowerlinesBaseContext<TSystemContext> implements EngineContext<TSystemContext> {
+  #private;
+  options: EngineOptions;
+  connection: ConnectionMeta;
+  /**
+   * Creates a new instance of the PowerlinesEngineContext class.
+   *
+   * @param options - The options to initialize the context with.
+   * @returns A promise that resolves to an instance of the PowerlinesEngineContext class.
+   */
+  static from<TSystemContext = unknown>(options: EngineOptions, host: DevToolsHost, connection: ConnectionMeta): Promise<PowerlinesEngineContext<TSystemContext>>;
+  createLogger(options?: LoggerOptions, logFn?: LogFn): _$_powerlines_core0.Logger;
+  get executions(): EngineExecutionItem[];
+  get devtools(): DevToolsNodeContext;
+  get envPaths(): EnvPaths;
+  get framework(): FrameworkOptions;
+  get orgId(): string;
+  /**
+   * Creates a new Context instance.
+   *
+   * @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
+   * @param connection - The connection metadata for the dev server.
+   */
+  protected constructor(options: EngineOptions, connection: ConnectionMeta);
+  /**
+   * Initialize the context with the provided configuration options
+   *
+   * @remarks
+   * This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+   *
+   * @param method - The path to the execution configuration to load and run, which can be used to specify different execution configurations for different commands or scenarios.
+   * @param inlineConfig - Additional configuration options provided at runtime, which can override or supplement the options defined in the user configuration file.
+   */
+  loadExecutions(method: string, inlineConfig: InlineConfig): Promise<EngineExecutionItem[]>;
+  /**
+   * Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.
+   *
+   * @param invocationId - The unique identifier for the invocation of the execution to be completed.
+   * @param executionId - The unique identifier for the specific execution to be completed.
+   */
+  completeExecution(invocationId: string, executionId: string): void;
+}
+//#endregion
+export { PowerlinesEngineContext as t };
+//# sourceMappingURL=engine-context-BBSMtv0b.d.mts.map

package/dist/engine-context-BBSMtv0b.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-context-BBSMtv0b.d.mts","names":[],"sources":["../src/context/engine-context.ts"],"mappings":";;;;;;;;;cAmDa,uBAAA,mCACH,qBAAA,CAAsB,cAAA,aACnB,aAAA,CAAc,cAAA;EAAA;EAkIP,OAAA,EAAS,aAAA;EAClB,UAAA,EAAY,cAAA;EArIa;;;;;;EAAA,OAgBd,IAAA,0BAAA,CAClB,OAAA,EAAS,aAAA,EACT,IAAA,EAAM,YAAA,EACN,UAAA,EAAY,cAAA,GACX,OAAA,CAAQ,uBAAA,CAAwB,cAAA;EA8DnB,YAAA,CAAa,OAAA,GAAS,aAAA,EAAoB,KAAA,GAAQ,KAAA,GAAK,mBAAA,CAAA,MAAA;EAAA,IAe5D,UAAA,CAAA,GAAc,mBAAA;EAAA,IAId,QAAA,CAAA,GAAY,mBAAA;EAAA,IAIZ,QAAA,CAAA,GAAY,QAAA;EAAA,IAQZ,SAAA,CAAA,GAAa,gBAAA;EAAA,IAQb,KAAA,CAAA;EAvCuD;;;;;;EAAA,UAiDzD,WAAA,CACS,OAAA,EAAS,aAAA,EAClB,UAAA,EAAY,cAAA;EAAA;;;;;;;;;EAcR,cAAA,CACX,MAAA,UACA,YAAA,EAAc,YAAA,GACb,OAAA,CAAQ,mBAAA;EArJmB;;;;;;EAyNvB,iBAAA,CAAkB,YAAA,UAAsB,WAAA;AAAA"}

package/dist/engine-context-C6bNxumd.d.cts

@@ -0,0 +1,54 @@
+import { n as EngineOptions } from "./config-B_E_HMcT.cjs";
+import { n as EngineExecutionItem, t as EngineContext } from "./context-LQBeYY23.cjs";
+import * as _$_powerlines_core0 from "@powerlines/core";
+import { FrameworkOptions, InlineConfig, LogFn, LoggerOptions } from "@powerlines/core";
+import { ConnectionMeta, DevToolsHost, DevToolsNodeContext } from "devframe/types";
+import { PowerlinesBaseContext } from "@powerlines/core/context/base-context";
+import { EnvPaths } from "@stryke/env/get-env-paths";
+
+//#region src/context/engine-context.d.ts
+declare class PowerlinesEngineContext<TSystemContext = unknown> extends PowerlinesBaseContext<TSystemContext> implements EngineContext<TSystemContext> {
+  #private;
+  options: EngineOptions;
+  connection: ConnectionMeta;
+  /**
+   * Creates a new instance of the PowerlinesEngineContext class.
+   *
+   * @param options - The options to initialize the context with.
+   * @returns A promise that resolves to an instance of the PowerlinesEngineContext class.
+   */
+  static from<TSystemContext = unknown>(options: EngineOptions, host: DevToolsHost, connection: ConnectionMeta): Promise<PowerlinesEngineContext<TSystemContext>>;
+  createLogger(options?: LoggerOptions, logFn?: LogFn): _$_powerlines_core0.Logger;
+  get executions(): EngineExecutionItem[];
+  get devtools(): DevToolsNodeContext;
+  get envPaths(): EnvPaths;
+  get framework(): FrameworkOptions;
+  get orgId(): string;
+  /**
+   * Creates a new Context instance.
+   *
+   * @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
+   * @param connection - The connection metadata for the dev server.
+   */
+  protected constructor(options: EngineOptions, connection: ConnectionMeta);
+  /**
+   * Initialize the context with the provided configuration options
+   *
+   * @remarks
+   * This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+   *
+   * @param method - The path to the execution configuration to load and run, which can be used to specify different execution configurations for different commands or scenarios.
+   * @param inlineConfig - Additional configuration options provided at runtime, which can override or supplement the options defined in the user configuration file.
+   */
+  loadExecutions(method: string, inlineConfig: InlineConfig): Promise<EngineExecutionItem[]>;
+  /**
+   * Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.
+   *
+   * @param invocationId - The unique identifier for the invocation of the execution to be completed.
+   * @param executionId - The unique identifier for the specific execution to be completed.
+   */
+  completeExecution(invocationId: string, executionId: string): void;
+}
+//#endregion
+export { PowerlinesEngineContext as t };
+//# sourceMappingURL=engine-context-C6bNxumd.d.cts.map

package/dist/engine-context-C6bNxumd.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-context-C6bNxumd.d.cts","names":[],"sources":["../src/context/engine-context.ts"],"mappings":";;;;;;;;;cAmDa,uBAAA,mCACH,qBAAA,CAAsB,cAAA,aACnB,aAAA,CAAc,cAAA;EAAA;EAkIP,OAAA,EAAS,aAAA;EAClB,UAAA,EAAY,cAAA;EArIa;;;;;;EAAA,OAgBd,IAAA,0BAAA,CAClB,OAAA,EAAS,aAAA,EACT,IAAA,EAAM,YAAA,EACN,UAAA,EAAY,cAAA,GACX,OAAA,CAAQ,uBAAA,CAAwB,cAAA;EA8DnB,YAAA,CAAa,OAAA,GAAS,aAAA,EAAoB,KAAA,GAAQ,KAAA,GAAK,mBAAA,CAAA,MAAA;EAAA,IAe5D,UAAA,CAAA,GAAc,mBAAA;EAAA,IAId,QAAA,CAAA,GAAY,mBAAA;EAAA,IAIZ,QAAA,CAAA,GAAY,QAAA;EAAA,IAQZ,SAAA,CAAA,GAAa,gBAAA;EAAA,IAQb,KAAA,CAAA;EAvCuD;;;;;;EAAA,UAiDzD,WAAA,CACS,OAAA,EAAS,aAAA,EAClB,UAAA,EAAY,cAAA;EAAA;;;;;;;;;EAcR,cAAA,CACX,MAAA,UACA,YAAA,EAAc,YAAA,GACb,OAAA,CAAQ,mBAAA;EArJmB;;;;;;EAyNvB,iBAAA,CAAkB,YAAA,UAAsB,WAAA;AAAA"}

package/dist/engine-context-SEzTm1aq.cjs

@@ -0,0 +1,179 @@
+const require_chunk = require('./chunk-C0xms8kb.cjs');
+let devframe_node = require("devframe/node");
+let _powerlines_core_context_base_context = require("@powerlines/core/context/base-context");
+let _powerlines_core_lib_config = require("@powerlines/core/lib/config");
+let _powerlines_core_plugin_utils = require("@powerlines/core/plugin-utils");
+let _stryke_convert_to_array = require("@stryke/convert/to-array");
+let _stryke_env_get_env_paths = require("@stryke/env/get-env-paths");
+let _stryke_string_format_kebab_case = require("@stryke/string-format/kebab-case");
+let _stryke_unique_id_uuid = require("@stryke/unique-id/uuid");
+let valibot = require("valibot");
+valibot = require_chunk.__toESM(valibot, 1);
+
+//#region src/context/engine-context.ts
+var PowerlinesEngineContext = class PowerlinesEngineContext extends _powerlines_core_context_base_context.PowerlinesBaseContext {
+	#executions = [];
+	#devtools;
+	#logLevel;
+	/**
+	* Creates a new instance of the PowerlinesEngineContext class.
+	*
+	* @param options - The options to initialize the context with.
+	* @returns A promise that resolves to an instance of the PowerlinesEngineContext class.
+	*/
+	static async from(options, host, connection) {
+		const context = new PowerlinesEngineContext(options, connection);
+		context.#devtools = await (0, devframe_node.createHostContext)({
+			cwd: context.cwd,
+			mode: "dev",
+			host
+		});
+		await options.setup?.(context.#devtools);
+		context.#devtools.rpc.register({
+			name: "powerlines:log",
+			type: "event",
+			args: [valibot.object({
+				meta: valibot.object({
+					category: valibot.string(),
+					name: valibot.string(),
+					command: valibot.string(),
+					hook: valibot.string(),
+					plugin: valibot.string(),
+					source: valibot.string()
+				}),
+				message: valibot.string()
+			})],
+			setup: (_) => ({ handler: (payload) => {
+				switch (payload.meta.type) {
+					case "error":
+						context.error(payload);
+						break;
+					case "warn":
+						context.warn(payload);
+						break;
+					case "info":
+						context.info(payload);
+						break;
+					case "debug":
+						context.debug(payload);
+						break;
+					case "trace":
+						context.trace(payload);
+						break;
+					default:
+						context.info(payload);
+						break;
+				}
+			} })
+		});
+		context.#logLevel = options.logLevel ? (0, _powerlines_core_plugin_utils.resolveLogLevel)(options.logLevel) : await (0, _powerlines_core_lib_config.getDefaultLogLevel)(context.cwd);
+		return context;
+	}
+	createLogger(options = {}, logFn) {
+		let logger = (0, _powerlines_core_plugin_utils.createLogger)("engine", {
+			logLevel: this.#logLevel,
+			...options
+		}, logFn);
+		if (this.options.customLogger) logger = (0, _powerlines_core_plugin_utils.withCustomLogger)(logger, this.options.customLogger);
+		return logger;
+	}
+	get executions() {
+		return this.#executions;
+	}
+	get devtools() {
+		return this.#devtools;
+	}
+	get envPaths() {
+		return (0, _stryke_env_get_env_paths.getEnvPaths)({
+			orgId: (0, _stryke_string_format_kebab_case.kebabCase)(this.orgId),
+			appId: (0, _stryke_string_format_kebab_case.kebabCase)(this.framework.name),
+			workspaceRoot: this.cwd
+		});
+	}
+	get framework() {
+		return {
+			name: "powerlines",
+			orgId: "storm-software",
+			...this.options.framework
+		};
+	}
+	get orgId() {
+		return this.framework.orgId;
+	}
+	/**
+	* Creates a new Context instance.
+	*
+	* @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
+	* @param connection - The connection metadata for the dev server.
+	*/
+	constructor(options, connection) {
+		super(options);
+		this.options = options;
+		this.connection = connection;
+	}
+	/**
+	* Initialize the context with the provided configuration options
+	*
+	* @remarks
+	* This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+	*
+	* @param method - The path to the execution configuration to load and run, which can be used to specify different execution configurations for different commands or scenarios.
+	* @param inlineConfig - Additional configuration options provided at runtime, which can override or supplement the options defined in the user configuration file.
+	*/
+	async loadExecutions(method, inlineConfig) {
+		const root = (0, _powerlines_core_lib_config.resolveRoot)(this.cwd, inlineConfig.root, inlineConfig.configFile);
+		const config = await (0, _powerlines_core_lib_config.loadParsedConfig)(this.cwd, root, this.framework?.name, this.orgId, inlineConfig);
+		if (!config) throw new Error("Failed to load configuration");
+		const invocationId = (0, _stryke_unique_id_uuid.uuid)();
+		const executions = await Promise.all((0, _stryke_convert_to_array.toArray)(config.config).map(async (_, configIndex) => {
+			const executionId = (0, _stryke_unique_id_uuid.uuid)();
+			const options = {
+				cwd: this.cwd,
+				root,
+				framework: this.framework,
+				orgId: this.orgId,
+				...this.options,
+				command: method,
+				baseURL: this.#devtools.host.resolveOrigin(),
+				connection: this.connection,
+				configFile: config.configFile,
+				executionId,
+				configIndex
+			};
+			this.logger.debug({
+				meta: { category: "config" },
+				message: `Invoking ${method} with the following execution parameters: \n --- Options --- \n${(0, _powerlines_core_plugin_utils.formatConfig)(options)}\n --- Inline Config --- \n${(0, _powerlines_core_plugin_utils.formatConfig)(inlineConfig)}`
+			});
+			return {
+				invocationId,
+				method,
+				configFile: config,
+				options,
+				state: {
+					command: null,
+					hook: null,
+					plugin: null
+				}
+			};
+		}));
+		this.#executions = this.#executions.concat(executions);
+		return executions;
+	}
+	/**
+	* Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.
+	*
+	* @param invocationId - The unique identifier for the invocation of the execution to be completed.
+	* @param executionId - The unique identifier for the specific execution to be completed.
+	*/
+	completeExecution(invocationId, executionId) {
+		this.#executions = this.#executions.filter((execution) => execution.options.executionId !== executionId || execution.invocationId !== invocationId);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'PowerlinesEngineContext', {
+  enumerable: true,
+  get: function () {
+    return PowerlinesEngineContext;
+  }
+});