@reliverse/rempts 1.7.29 → 1.7.30

package/bin/{components → libs}/launcher/launcher-types.d.ts

@@ -142,7 +142,7 @@ export type InferArgTypes<A extends ArgDefinitions> = {
         type: "array";
     } ? string[] : never;
 };
-export interface FileBasedCmdsOptions {
+export interface FileBasedOptions {
     enable: boolean;
     cmdsRootPath: string;
 }

package/bin/libs/launcher/trpc-orpc-support/completions.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { OmeletteInstanceLike } from "./types";
+/** uses omelette to add completions to a commander program */
+export declare function addCompletions(program: Command, completion: OmeletteInstanceLike): void;

package/bin/libs/launcher/trpc-orpc-support/completions.js

@@ -0,0 +1,45 @@
+export function addCompletions(program, completion) {
+  const commandSymbol = Symbol("command");
+  const cTree = {};
+  function addCommandCompletions(command, cTreeNode) {
+    command.commands.forEach((c) => {
+      const node = cTreeNode[c.name()] ||= {};
+      Object.defineProperty(node, commandSymbol, {
+        value: c,
+        enumerable: false
+      });
+      addCommandCompletions(c, node);
+    });
+  }
+  addCommandCompletions(program, cTree);
+  completion.on("complete", (fragment, params) => {
+    const segments = params.line.split(/ +/).slice(1, params.fragment);
+    const last = segments.at(-1);
+    let node = cTree;
+    const existingFlags = /* @__PURE__ */ new Set();
+    for (const segment of segments) {
+      if (segment.startsWith("-")) {
+        existingFlags.add(segment);
+        continue;
+      }
+      if (existingFlags.size > 0) continue;
+      node = node[segment];
+      if (!node) return;
+    }
+    const correspondingCommand = node[commandSymbol];
+    if (correspondingCommand?.options?.length) {
+      const suggestions = [];
+      for (const o of correspondingCommand.options) {
+        if (last === o.long || last === o.short) {
+          if (o.argChoices) suggestions.push(...o.argChoices);
+          if (!o.isBoolean()) break;
+        }
+        if (existingFlags.has(o.long)) continue;
+        if (existingFlags.has(o.short)) continue;
+        suggestions.push(o.long);
+      }
+      return params.reply(suggestions);
+    }
+  });
+  completion.tree(cTree).init();
+}

package/bin/libs/launcher/trpc-orpc-support/errors.d.ts

@@ -0,0 +1,11 @@
+/** An error thrown when the trpc procedure results in a bad request */
+export declare class CliValidationError extends Error {
+}
+/** An error which is only thrown when a custom \`process\` parameter is used. Under normal circumstances, this should not be used, even internally. */
+export declare class FailedToExitError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, { exitCode, cause }: {
+        exitCode: number;
+        cause: unknown;
+    });
+}

package/bin/libs/launcher/trpc-orpc-support/errors.js

@@ -0,0 +1,10 @@
+export class CliValidationError extends Error {
+}
+export class FailedToExitError extends Error {
+  exitCode;
+  constructor(message, { exitCode, cause }) {
+    const fullMessage = `${message}. The process was expected to exit with exit code ${exitCode} but did not. This may be because a custom \`process\` parameter was used. The exit reason is in the \`cause\` property.`;
+    super(fullMessage, { cause });
+    this.exitCode = exitCode;
+  }
+}

package/bin/libs/launcher/trpc-orpc-support/index.d.ts

@@ -0,0 +1,34 @@
+import { Command as BaseCommand } from "commander";
+import type { AnyRouter } from "./trpc-compat";
+import type { ParsedProcedure, TrpcCli, TrpcCliMeta, TrpcCliParams } from "./types";
+export * from "./types";
+export { z } from "zod/v4";
+export * as zod from "zod";
+export * as trpcServer from "@trpc/server";
+export declare class TrpcCommand extends BaseCommand {
+    /** @internal track the commands that have been run, so that we can find the `__result` of the last command */
+    __ran: TrpcCommand[];
+    __input?: unknown;
+    /** @internal stash the return value of the underlying procedure on the command so to pass to `FailedToExitError` for use in a pinch */
+    __result?: unknown;
+}
+/**
+ * @internal takes a trpc router and returns an object that you **could** use to build a CLI, or UI, or a bunch of other things with.
+ * Officially, just internal for building a CLI. GLHF.
+ */
+export declare const parseRouter: <R extends AnyRouter>({ router, ...params }: TrpcCliParams<R>) => [string, ProcedureInfo][];
+interface ProcedureInfo {
+    meta: TrpcCliMeta;
+    parsedProcedure: ParsedProcedure;
+    incompatiblePairs: [string, string][];
+    procedure: {};
+}
+/**
+ * Run a trpc router as a CLI.
+ *
+ * @param router A trpc router
+ * @param context The context to use when calling the procedures - needed if your router requires a context
+ * @param trpcServer The trpc server module to use. Only needed if using trpc v10.
+ * @returns A CLI object with a `run` method that can be called to run the CLI. The `run` method will parse the command line arguments, call the appropriate trpc procedure, log the result and exit the process. On error, it will log the error and exit with a non-zero exit code.
+ */
+export declare function createRpcCli<R extends AnyRouter>({ router, ...params }: TrpcCliParams<R>): TrpcCli;