@reliverse/rempts 1.7.29 → 1.7.30

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

@@ -0,0 +1,71 @@
+import type { StandardSchemaV1 } from "./standard-schema/contract";
+/**
+ * Type which looks *enough* like a trpc v11(+?) router to infer its types correctly
+ * This is written from scratch to avoid any kind of dependency on @trpc/server v11+
+ */
+export interface Trpc11RouterLike {
+    _def: {
+        _config: {
+            $types: {
+                meta: any;
+                ctx: any;
+            };
+        };
+        procedures: Record<string, Trpc11ProcedureLike | Trpc11ProcedureRecordLike | Record<string, Trpc11ProcedureLike>>;
+    };
+}
+/** Even though you use `t.router({})` to create a sub-router, the actual type is a record of procedures and sub-routers rather than a root-level router */
+export interface Trpc11ProcedureRecordLike {
+    [key: string]: Trpc11ProcedureLike | Trpc11ProcedureRecordLike;
+}
+export interface Trpc11ProcedureLike {
+    _def: {
+        type: "mutation" | "query" | "subscription";
+        _type?: undefined;
+        meta?: any;
+        inputs?: unknown[];
+        $types: {
+            input: any;
+            output: any;
+        };
+    };
+}
+export interface Trpc10RouterLike {
+    _def: {
+        _config: {
+            $types: {
+                meta: any;
+                ctx: any;
+            };
+        };
+        procedures: Record<string, Trpc10ProcedureLike | Trpc10RouterLike>;
+    };
+}
+export interface Trpc10ProcedureLike {
+    _def: {
+        type?: undefined;
+        mutation?: boolean;
+        query?: boolean;
+        subscription?: boolean;
+        meta?: any;
+        inputs: unknown[];
+        _input_in: any;
+        _output_out: any;
+    };
+}
+export interface OrpcProcedureLike<Ctx> {
+    "~orpc": {
+        __initialContext?: (context: Ctx) => unknown;
+        inputSchema?: StandardSchemaV1;
+    };
+}
+export interface OrpcRouterLike<Ctx> {
+    [key: string]: OrpcProcedureLike<Ctx> | OrpcRouterLike<Ctx>;
+}
+export type CreateCallerFactoryLike<Procedures = Record<string, (input: unknown) => unknown>> = (router: any) => (context: any) => Procedures;
+export type AnyRouter = Trpc10RouterLike | Trpc11RouterLike | OrpcRouterLike<any>;
+export type AnyProcedure = Trpc10ProcedureLike | Trpc11ProcedureLike;
+export type inferRouterContext<R extends AnyRouter> = R extends Trpc10RouterLike | Trpc11RouterLike ? R["_def"]["_config"]["$types"]["ctx"] : R extends OrpcRouterLike<infer Ctx> ? Ctx : never;
+export declare const isTrpc11Procedure: (procedure: AnyProcedure) => procedure is Trpc11ProcedureLike;
+export declare const isTrpc11Router: (router: AnyRouter) => router is Trpc11RouterLike;
+export declare const isOrpcRouter: (router: AnyRouter) => router is OrpcRouterLike<any>;

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

@@ -0,0 +1,11 @@
+export const isTrpc11Procedure = (procedure) => {
+  return "type" in procedure._def && typeof procedure._def.type === "string";
+};
+export const isTrpc11Router = (router) => {
+  if (isOrpcRouter(router)) return false;
+  const procedure = Object.values(router._def.procedures)[0];
+  return Boolean(procedure && isTrpc11Procedure(procedure));
+};
+export const isOrpcRouter = (router) => {
+  return !("_def" in router) || router._def && "~orpc" in router._def;
+};

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

@@ -0,0 +1,276 @@
+import type { JSONSchema7 } from "json-schema";
+import type { JsonSchema7Type } from "zod-to-json-schema";
+import type { CommandJSON } from "./json";
+import type { AnyRouter, CreateCallerFactoryLike, inferRouterContext } from "./trpc-compat";
+export interface TrpcCliParams<R extends AnyRouter> extends Dependencies {
+    /** A tRPC router. Procedures will become CLI commands. */
+    router: R;
+    name?: string;
+    version?: string;
+    description?: string;
+    usage?: string | string[];
+    /** Context to be supplied when invoking the router. */
+    context?: inferRouterContext<R>;
+    /** @deprecated this is actually **removed** not deprecated; use `aliases` on each procedure `meta` instead */
+    alias?: never;
+    /** @deprecated this is actually **removed** not deprecated; set `default: true` on the procedure `meta` instead */
+    _default?: never;
+    /** The `@trpc/server` module to use for calling procedures. Required when using trpc v10. */
+    trpcServer?: TrpcServerModuleLike | Promise<TrpcServerModuleLike>;
+}
+/** Rough shape of the `@trpc/server` (v10) module. Needed to pass in to `createRpcCli` when using trpc v10. */
+export interface TrpcServerModuleLike {
+    initTRPC: {
+        create: () => {
+            createCallerFactory: CreateCallerFactoryLike<{}>;
+        };
+    };
+}
+/**
+ * Optional interface for describing procedures via meta - if your router conforms to this meta shape, it will contribute to the CLI help text.
+ */
+export interface TrpcCliMeta {
+    /** Version of the script displayed in `--help` output. Use to avoid enabling `--version` option. */
+    version?: string;
+    /** Description of the script or command to display in `--help` output. */
+    description?: string;
+    /** Usage code examples to display in `--help` output. */
+    usage?: false | string | string[];
+    /** Example code snippets to display in `--help` output. */
+    examples?: string | string[];
+    /** If true, this command will be run if no command is specified. */
+    default?: boolean;
+    aliases?: {
+        /** Aliases for the command. Note: take care to avoid conflicts with other commands. */
+        command?: string[];
+        /** Aliases for the options. Note: take care to avoid conflicts with other options. An error will be thrown if an alias is defined for a non-existent option. */
+        options?: Record<string, string>;
+    };
+    /** If true, will use a single CLI option expect the entire input to be parsed in as JSON, e.g. `--input '{"foo": "bar"}`. Can be useful to opt out of the default mapping of input schemas to CLI options. */
+    jsonInput?: boolean;
+    /** Sub-property for the CLI meta. If present, will take precedence over the top-level meta, to avoid conflicts with other tools. */
+    cliMeta?: TrpcCliMeta;
+}
+export interface ParsedProcedure {
+    positionalParameters: {
+        name: string;
+        description: string;
+        type: "string" | "number" | "boolean" | (string & {});
+        required: boolean;
+        array: boolean;
+    }[];
+    /** JSON Schema type describing the flags for the procedure */
+    optionsJsonSchema: JsonSchema7Type;
+    /**
+     * Function for taking parsed argv output and transforming it so it can be passed into the procedure.
+     * Needed because this function is where inspect the input schema(s) and determine how to map the argv to the input
+     */
+    getPojoInput: (argv: {
+        positionalValues: (string | string[])[];
+        options: Record<string, unknown>;
+    }) => unknown;
+}
+export type Result<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: string;
+};
+/** A function that logs any inputs. e.g. `console.info` */
+export type Log = (...args: unknown[]) => void;
+/**
+ * A struct which has `info` and `error` functions for logging. Easiest example: `console`
+ * But most loggers like pino, winston etc. have a similar interface.
+ */
+export interface Logger {
+    info?: Log;
+    error?: Log;
+}
+/**
+ * Slim reconstruction of an `omelette` instance. Hand-written here to avoid a hard dependency on `omelette` or its types.
+ * Usually you will just pass in an `omelette` instance by doing something like
+ *
+ * ```ts
+ * import omelette from 'omelette'
+ * import {createRpcCli} from '@reliverse/rempts'
+ *
+ * const cli = createRpcCli({
+ *   router: myRouter,
+ *   completion: omelette('myprogram'),
+ * })
+ * ```
+ *
+ * Or it also accepts an async function that resolves to an `omelette` instance, so you can use dynamic import:
+ *
+ * ```ts
+ * import {createRpcCli} from '@reliverse/rempts'
+ *
+ * const cli = await createRpcCli({
+ *   router: myRouter,
+ *   completion: () => import('omelette').then(omelette => omelette.default('myprogram')),
+ * })
+ * ```
+ */
+export interface OmeletteInstanceLike {
+    on: (event: "complete", callback: (fragment: string, params: {
+        line: string;
+        fragment: number;
+        reply: (suggestions: string[]) => void;
+    }) => void) => void;
+    init: () => void;
+    setupShellInitFile: () => void;
+    cleanupShellInitFile: () => void;
+    tree: (value: any) => this;
+}
+export interface InquirerPromptOptions {
+    message: string;
+    required?: boolean;
+    validate?: (input: string) => boolean | string;
+    default?: any;
+}
+/** looks like the `@inquirer/prompts` package */
+export interface InquirerPromptsLike {
+    input: (params: InquirerPromptOptions) => Promise<string>;
+    confirm: (params: InquirerPromptOptions) => Promise<boolean>;
+}
+/** looks like the `prompts` package */
+export interface PromptsLike {
+    prompt: Function;
+    inject: Function;
+}
+/** looks like the `enquirer` package */
+export interface EnquirerLike {
+    prompt: <T>(params: {
+        type: "input";
+        name: string;
+        message: string;
+        validate?: (input: string) => boolean | string;
+        initial?: unknown;
+    }) => Promise<T>;
+}
+export interface ClackPromptsLike {
+    intro: (title: string) => void;
+    outro: (title: string) => void;
+}
+export type Promptable = InquirerPromptsLike | EnquirerLike | PromptsLike | Prompter | ClackPromptsLike | ((command: CommanderProgramLike) => Prompter);
+export interface TrpcCliRunParams {
+    argv?: string[];
+    logger?: Logger;
+    completion?: OmeletteInstanceLike | (() => Promise<OmeletteInstanceLike>);
+    prompts?: Promptable;
+    /** Format an error thrown by the root procedure before logging to `logger.error` */
+    formatError?: (error: unknown) => string;
+    process?: {
+        exit: (code: number) => never;
+    };
+}
+/**
+ * Type that looks like a `commander` Command instance, but doesn't require a dependency on `commander` to avoid awkward typescript errors.
+ * If you need to use it as a `Command` instance, just cast it with `as` to `import('commander').Command`.
+ */
+export interface CommanderProgramLike {
+    name: () => string;
+    parseAsync: (args: string[], options?: {
+        from: "user" | "node" | "electron";
+    }) => Promise<unknown>;
+    helpInformation: () => string;
+}
+export interface TrpcCli {
+    /** run the CLI - gets args from `process.argv` by default */
+    run: (params?: TrpcCliRunParams, program?: CommanderProgramLike) => Promise<void>;
+    /**
+     * Build a `Commander` program from the CLI - you can use this to manually customise the program before passing it to `.run(...)`.
+     * Note that you will need to cast the return value to `import('commander').Command` to use it as a `Command` instance.
+     */
+    buildProgram: (params?: TrpcCliRunParams) => CommanderProgramLike;
+    /**
+     * @experimental
+     * Get a JSON representation of the CLI - useful for generating documentation etc. This function returns basic information about the CLI
+     * and each command - to get any extra details you will need to use the `buildProgram` function and walk the tree of commands yourself.
+     */
+    toJSON: (program?: CommanderProgramLike) => CommandJSON;
+}
+export interface Dependencies {
+    "@valibot/to-json-schema"?: {
+        toJsonSchema: (input: unknown, options?: {
+            errorMode?: "throw" | "ignore" | "warn";
+        }) => JSONSchema7;
+    };
+    effect?: {
+        Schema: {
+            isSchema: (input: unknown) => input is "JSONSchemaMakeable";
+        };
+        JSONSchema: {
+            make: (input: "JSONSchemaMakeable") => JSONSchema7;
+        };
+    };
+}
+export interface PromptContext {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    clearPromptOnDone?: boolean;
+    signal?: AbortSignal;
+    /** The command that is being prompted for. Cast this to a `commander.Command` to access the command's name, description, options etc. */
+    command: {
+        name: () => string;
+    };
+    /** The original inputs the user provided - if they passed some but not all arguments/options, this will contain the values they did pass. */
+    inputs: {
+        argv: string[];
+        arguments: {
+            name: string;
+            specified: boolean;
+            value: unknown;
+        }[];
+        options: {
+            name: string;
+            specified: boolean;
+            value: unknown;
+        }[];
+    };
+    /** If set, this is the argument that is being prompted for. Cast to a `commander.Argument`. */
+    argument?: {
+        name: () => string;
+    };
+    /** If set, this is the option that is being prompted for. Cast to a `commander.Option`. */
+    option?: {
+        name: () => string;
+    };
+}
+export interface Prompter {
+    setup?: (context: PromptContext) => Promise<void>;
+    teardown?: (context: PromptContext) => Promise<void>;
+    input: (params: {
+        message: string;
+        validate?: (input: string) => boolean | string;
+        required?: boolean;
+        default?: string;
+    }, context: PromptContext) => Promise<string>;
+    select: (params: {
+        message: string;
+        choices: string[] | {
+            name: string;
+            value: string;
+            description?: string;
+        }[];
+        required?: boolean;
+        default?: string;
+        validate?: (input: string) => boolean | string;
+    }, context: PromptContext) => Promise<string>;
+    confirm: (params: {
+        message: string;
+        default?: boolean;
+        validate?: (input: string) => boolean | string;
+    }, context: PromptContext) => Promise<boolean>;
+    checkbox: (params: {
+        message: string;
+        choices: {
+            name: string;
+            value: string;
+            checked?: boolean;
+        }[];
+        required?: boolean;
+        default?: string[];
+    }, context: PromptContext) => Promise<string[]>;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Pretty much like the `instanceof` operator, but should work across different realms. Necessary for zod because some installations
+ * might result in this library using the commonjs zod export, while the user's code uses the esm export.
+ * https://github.com/mmkal/trpc-cli/issues/7
+ *
+ * Tradeoff: It's possible that this function will return false positives if the target class has the same name as an unrelated class in the current realm.
+ * So, only use it for classes that are unlikely to have name conflicts like `ZodAbc` or `TRPCDef`.
+ */
+export declare const looksLikeInstanceof: <T>(value: unknown, target: string | (new (...args: any[]) => T)) => value is T;

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

@@ -0,0 +1,9 @@
+export const looksLikeInstanceof = (value, target) => {
+  let current = value?.constructor;
+  while (current?.name) {
+    if (current?.name === (typeof target === "string" ? target : target.name))
+      return true;
+    current = Object.getPrototypeOf(current);
+  }
+  return false;
+};

package/bin/{components → libs}/msg-fmt/logger.js

@@ -1,4 +1,4 @@
-import { streamText, streamTextWithSpinner } from "../../utils/stream-text.js";
+import { streamText, streamTextWithSpinner } from "../utils/stream-text.js";
 import { toSolidColor } from "./colors.js";
 import { msg } from "./messages.js";
 const verboseLogging = false;

package/bin/libs/multiselect/multiselect-alias.d.ts

@@ -0,0 +1 @@
+export declare const multiselect: any;

package/bin/libs/multiselect/multiselect-alias.js

@@ -0,0 +1,2 @@
+import { multiselectPrompt } from "./multiselect-prompt.js";
+export const multiselect = multiselectPrompt;

package/bin/{components/select → libs/multiselect}/multiselect-prompt.js

@@ -4,7 +4,7 @@ import { stdin as input, stdout as output } from "node:process";
 import readline from "node:readline";
 import { msg, symbols } from "../msg-fmt/messages.js";
 import { deleteLastLine } from "../msg-fmt/terminal.js";
-import { completePrompt } from "../../utils/prompt-end.js";
+import { completePrompt } from "../utils/prompt-end.js";
 function isSelectOption(option) {
   return !("separator" in option);
 }

package/bin/{components → libs}/number/number-mod.js

@@ -1,10 +1,7 @@
 import { stdin as input, stdout as output } from "node:process";
 import readline from "node:readline/promises";
 import { bar, msg } from "../msg-fmt/messages.js";
-import {
-  deleteLastLine,
-  deleteLastLines
-} from "../msg-fmt/terminal.js";
+import { deleteLastLine, deleteLastLines } from "../msg-fmt/terminal.js";
 function renderPromptUI(params) {
   const {
     title,

package/bin/libs/outro/outro-alias.d.ts

@@ -0,0 +1,2 @@
+export declare const endPrompt: any;
+export declare const outro: any;

package/bin/libs/outro/outro-alias.js

@@ -0,0 +1,3 @@
+import { outroPrompt } from "./outro-mod.js";
+export const endPrompt = outroPrompt;
+export const outro = outroPrompt;

package/bin/{components/outro/outro-end.js → libs/outro/outro-mod.js}

@@ -1,7 +1,7 @@
-import { animateText } from "../animate/animate.js";
-import { createAsciiArt } from "../ascii-art/ascii-art.js";
+import { animateText } from "../animate/animate-mod.js";
 import { msg } from "../msg-fmt/messages.js";
 import { getExactTerminalWidth } from "../msg-fmt/terminal.js";
+import { createAsciiArt } from "../visual/visual-mod.js";
 export async function outroPrompt(optionsOrTitle) {
   const options = typeof optionsOrTitle === "string" ? { title: optionsOrTitle } : optionsOrTitle;
   const {

package/bin/libs/select/aliases-alias.d.ts

@@ -0,0 +1 @@
+export declare const select: any;

package/bin/libs/select/aliases-alias.js

@@ -0,0 +1,2 @@
+import { selectPrompt } from "./select-prompt.js";
+export const select = selectPrompt;

package/bin/{components → libs}/select/select-prompt.js

@@ -4,8 +4,8 @@ import { stdin as input, stdout as output } from "node:process";
 import readline from "node:readline";
 import { msg, symbols } from "../msg-fmt/messages.js";
 import { deleteLastLine } from "../msg-fmt/terminal.js";
-import { completePrompt } from "../../utils/prompt-end.js";
-import { streamText } from "../../utils/stream-text.js";
+import { completePrompt } from "../utils/prompt-end.js";
+import { streamText } from "../utils/stream-text.js";
 function isSelectOption(option) {
   return !("separator" in option);
 }

package/bin/{components → libs}/select/toggle-prompt.js

@@ -4,7 +4,7 @@ import { stdin as input, stdout as output } from "node:process";
 import readline from "node:readline";
 import { msg } from "../msg-fmt/messages.js";
 import { deleteLastLine } from "../msg-fmt/terminal.js";
-import { completePrompt } from "../../utils/prompt-end.js";
+import { completePrompt } from "../utils/prompt-end.js";
 function renderTogglePrompt(params) {
   const {
     title,

package/bin/libs/spinner/spinner-alias.d.ts

@@ -0,0 +1 @@
+export declare const spinner: any;

package/bin/libs/spinner/spinner-alias.js

@@ -0,0 +1,2 @@
+import { useSpinner } from "./spinner-mod.js";
+export const spinner = useSpinner;

package/bin/{components → libs}/spinner/spinner-mod.js

@@ -109,7 +109,9 @@ export function useSpinner(options) {
         }
         clearPrevMessage();
         state.prevMessage = state.text;
-        const frame = re.magenta((options.frames ?? defaultFrames)[frameIndex]);
+        const frame = re.magenta(
+          (options.frames ?? defaultFrames)[frameIndex] ?? ""
+        );
         if (process.env.CI) {
           process.stdout.write(`${frame}  ${state.text}...`);
         } else if (options.indicator === "timer") {

package/bin/{components → libs}/task/task-spin.js

@@ -65,7 +65,7 @@ export async function taskSpinPrompt(options) {
         process.stdin.on("data", handleInput);
       }
       interval = setInterval(() => {
-        const frame = re.magenta(frames[frameIndex]);
+        const frame = re.magenta(frames[frameIndex] ?? "");
         process.stdout.write(
           `${cursor.move(-999, 0)}${erase.line}${frame} ${re.cyan(message)}`
         );

package/bin/{utils → libs/utils}/colorize.d.ts

@@ -1,2 +1,2 @@
-import type { ColorName, TypographyName } from "../types.js";
+import type { ColorName, TypographyName } from "../../types.js";
 export declare function colorize(text: string, colorName?: ColorName, typography?: TypographyName): string;

package/bin/{utils → libs/utils}/prevent.d.ts

@@ -1,4 +1,4 @@
-import type { PreventWrongTerminalSizeOptions } from "../types.js";
+import type { PreventWrongTerminalSizeOptions } from "../../types.js";
 export declare function preventUnsupportedTTY(): void;
 /**
  * Prevents EISDIR errors when trying to read Windows home directory as a file

package/bin/{utils → libs/utils}/prevent.js

@@ -2,11 +2,11 @@ import { re } from "@reliverse/relico";
 import { relinka } from "@reliverse/relinka";
 import { homedir } from "node:os";
 import terminalSize from "terminal-size";
-import { msg } from "../components/msg-fmt/messages.js";
+import { msg } from "../msg-fmt/messages.js";
 import {
   getExactTerminalWidth,
   getTerminalWidth
-} from "../components/msg-fmt/terminal.js";
+} from "../msg-fmt/terminal.js";
 export function preventUnsupportedTTY() {
   if (!process.stdout.isTTY) {
     relinka(

package/bin/{utils → libs/utils}/prompt-end.d.ts

@@ -1,4 +1,4 @@
-import type { BorderColorName, ColorName, TypographyName, VariantName } from "../types.js";
+import type { BorderColorName, ColorName, TypographyName, VariantName } from "../../types.js";
 /**
  * Ends the prompt by optionally displaying an end message and running the action if confirmed.
  * Preserves the last prompt state unless there's an endTitle.

package/bin/{utils → libs/utils}/prompt-end.js

@@ -1,7 +1,7 @@
 import { re } from "@reliverse/relico";
 import { relinka } from "@reliverse/relinka";
-import { msg, symbols } from "../components/msg-fmt/messages.js";
-import { getExactTerminalWidth } from "../components/msg-fmt/terminal.js";
+import { msg, symbols } from "../msg-fmt/messages.js";
+import { getExactTerminalWidth } from "../msg-fmt/terminal.js";
 export async function completePrompt(prompt, isCtrlC, _endTitle = "", _endTitleColor = "dim", _titleTypography = "none", _titleVariant = void 0, _border = true, borderColor = "dim", action, value) {
   if (action && value) {
     await action();

package/bin/{utils → libs/utils}/stream-text.d.ts

@@ -1,4 +1,4 @@
-import type { BorderColorName, StreamTextOptions } from "../types.js";
+import type { BorderColorName, StreamTextOptions } from "../../types.js";
 /**
  * Simulates streaming text output in the console, character by character
  */

package/bin/{utils → libs/utils}/stream-text.js

@@ -4,8 +4,8 @@ import ora from "ora";
 import { cursor } from "sisteransi";
 import terminalSize from "terminal-size";
 import wrapAnsi from "wrap-ansi";
-import { toBaseColor } from "../components/msg-fmt/colors.js";
-import { msg } from "../components/msg-fmt/messages.js";
+import { toBaseColor } from "../msg-fmt/colors.js";
+import { msg } from "../msg-fmt/messages.js";
 function getTerminalWidth() {
   return terminalSize().columns;
 }