alepha 0.7.6 → 0.8.0

package/command.d.ts

@@ -0,0 +1,154 @@
+import { Alepha, AlephaError, Async, HookDescriptor, KIND, Logger, Module, OPTIONS, Static, TObject, TProperties, TSchema, TString } from "alepha";
+import * as fs from "node:fs/promises";
+import { glob } from "node:fs/promises";
+
+//#region src/helpers/Runner.d.ts
+type Task = {
+  name: string;
+  handler: () => any;
+};
+interface Timer {
+  name: string;
+  duration: string;
+}
+interface RunnerMethod {
+  (cmd: string | Array<string | Task>, fn?: () => any): Promise<string>;
+  rm: (glob: string | string[]) => Promise<string>;
+}
+declare class Runner {
+  protected readonly log: Logger;
+  protected readonly timers: Timer[];
+  protected readonly startTime: number;
+  readonly run: RunnerMethod;
+  constructor(log: Logger);
+  protected exec(cmd: string): Promise<string>;
+  /**
+  * Executes one or more tasks.
+  *
+  * @param task - A single task or an array of tasks to run in parallel.
+  */
+  protected execute(task: Task | Task[]): Promise<string>;
+  /**
+  * Prints a summary of all executed tasks and their durations.
+  */
+  summary(): void;
+  protected executeTask(task: Task): Promise<string>;
+  protected renderTable(data: string[][]): void;
+}
+//#endregion
+//#region src/descriptors/$command.d.ts
+declare const KEY = "COMMAND";
+interface CommandDescriptorOptions<T extends TObject> {
+  /**
+  * The handler function to execute when the command is matched.
+  */
+  handler: (args: {
+    flags: Static<T>;
+    run: RunnerMethod;
+    glob: typeof glob;
+    fs: typeof fs;
+  }) => Async<void>;
+  /**
+  * The name of the command. If omitted, the property key is used.
+  *
+  * An empty string "" denotes the root command.
+  */
+  name?: string;
+  /**
+  * A short description of the command, shown in the help message.
+  */
+  description?: string;
+  /**
+  * An array of alternative names for the command.
+  */
+  aliases?: string[];
+  /**
+  * A TypeBox object schema defining the flags for the command.
+  */
+  flags?: T;
+}
+interface CommandDescriptor<T extends TObject> {
+  [KIND]: typeof KEY;
+  [OPTIONS]: CommandDescriptorOptions<T>;
+  /**
+  * Executes the command. This is a placeholder and will be replaced by the provider.
+  */
+  (flags: Static<T>): Promise<void>;
+}
+/**
+* Declares a CLI command.
+*
+* This descriptor allows you to define a command, its flags, and its handler
+* within your Alepha application structure.
+*/
+declare const $command: {
+  <T extends TObject>(options: CommandDescriptorOptions<T>): CommandDescriptor<T>;
+  [KIND]: string;
+};
+//#endregion
+//#region src/errors/CommandError.d.ts
+declare class CommandError extends AlephaError {}
+//#endregion
+//#region src/providers/CommandDescriptorProvider.d.ts
+interface Command {
+  key: string;
+  name: string;
+  description?: string;
+  aliases: string[];
+  flags: TObject<TProperties>;
+  handler: (flags: any) => Promise<void>;
+}
+declare const envSchema: TObject<{
+  CLI_NAME: TString;
+  CLI_DESCRIPTION: TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+declare class CommandDescriptorProvider {
+  protected readonly env: Static<typeof envSchema>;
+  protected readonly alepha: Alepha;
+  protected readonly log: Logger;
+  protected commands: Command[];
+  options: {
+    name: string;
+    description: string;
+    argv: string[];
+  };
+  protected readonly globalFlags: Record<string, {
+    aliases: string[];
+    description: string;
+    schema: TSchema;
+  }>;
+  protected readonly onConfigure: HookDescriptor<"configure">;
+  protected readonly onReady: HookDescriptor<"ready">;
+  private findCommand;
+  protected parseCommandFlags(argv: string[], schema: TObject): Record<string, any>;
+  protected parseFlags(argv: string[], flagDefs: {
+    key: string;
+    aliases: string[];
+    schema: TSchema;
+  }[]): Record<string, any>;
+  private printHelp;
+  private getMaxCmdLength;
+  private getMaxFlagLength;
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+/**
+* Alepha Command Module
+*
+* This module provides a powerful way to build command-line interfaces
+* directly within your Alepha application, using declarative descriptors.
+*
+* @see {@link $command}
+* @module alepha.command
+*/
+declare class AlephaCommand implements Module {
+  readonly name = "alepha.command";
+  readonly $services: (alepha: Alepha) => Alepha;
+}
+//#endregion
+export { $command, AlephaCommand, CommandDescriptor, CommandDescriptorOptions, CommandDescriptorProvider, CommandError, Runner, RunnerMethod, Task };
+//# sourceMappingURL=index.d.ts.map

package/command.js

@@ -0,0 +1 @@
+export * from '@alepha/command'