@reliverse/rempts 1.7.44 → 1.7.46

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

@@ -1,534 +0,0 @@
-import { Argument, Command, Option } from "commander";
-const parseUpstreamOptionInfo = (value) => {
-  if (typeof value !== "string" || !value.startsWith("{")) return null;
-  try {
-    const info = JSON.parse(value);
-    if (info.typeName !== "UpstreamOptionInfo") return null;
-    return info;
-  } catch {
-    return null;
-  }
-};
-const parseUpstreamArgumentInfo = (value) => {
-  if (typeof value !== "string" || !value.startsWith("{")) return null;
-  try {
-    const info = JSON.parse(value);
-    if (info.typeName !== "UpstreamArgumentInfo") return null;
-    return info;
-  } catch {
-    return null;
-  }
-};
-const getDefaultSubcommand = (command) => {
-  const defaultChild = /Available subcommands:.* (\S+) \(default\)/.exec(
-    command.description()
-  )?.[1];
-  return defaultChild ? command.commands.find((c) => c.name() === defaultChild) : void 0;
-};
-export const createShadowCommand = (command, onAnalyze) => {
-  const shadow = new Command(command.name());
-  shadow.exitOverride();
-  shadow.configureOutput({
-    writeOut: () => {
-    },
-    writeErr: () => {
-    }
-  });
-  const argumentsMap = /* @__PURE__ */ new Map();
-  const optionsMap = /* @__PURE__ */ new Map();
-  command.options.forEach((original) => {
-    const id = Date.now().toString() + Math.random().toString().slice(1);
-    const shadowOption = new Option(
-      original.flags.replace("<", "[").replace(">", "]"),
-      JSON.stringify([`id=${id}`, original.description])
-    );
-    const upstreamOptionInfo = {
-      typeName: "UpstreamOptionInfo",
-      id,
-      specified: false
-    };
-    shadowOption.default(JSON.stringify(upstreamOptionInfo));
-    shadowOption.argParser(
-      (value) => JSON.stringify({ ...upstreamOptionInfo, specified: true, value })
-    );
-    shadow.addOption(shadowOption);
-    optionsMap.set(id, { shadow: shadowOption, original });
-  });
-  command.registeredArguments.forEach((original) => {
-    const shadowArgument = new Argument(original.name(), original.description);
-    const id = Date.now().toString() + Math.random().toString().slice(1);
-    shadowArgument.argOptional();
-    const upstreamArgumentInfo = {
-      typeName: "UpstreamArgumentInfo",
-      id,
-      specified: false
-    };
-    shadowArgument.default(JSON.stringify(upstreamArgumentInfo));
-    shadowArgument.argParser(
-      (value) => JSON.stringify({ ...upstreamArgumentInfo, specified: true, value })
-    );
-    shadow.addArgument(shadowArgument);
-    argumentsMap.set(id, { shadow: shadowArgument, original });
-  });
-  const analysis = {
-    command: { shadow, original: command },
-    arguments: [],
-    options: []
-  };
-  shadow.action(async (...args) => {
-    const positionalValues = args.slice(0, -2);
-    const options = shadow.opts();
-    if (args.at(-2) !== options) {
-      throw new Error(
-        "Unexpected args format, second last arg is not the options object",
-        { cause: args }
-      );
-    }
-    if (args.at(-1) !== shadow) {
-      throw new Error(
-        "Unexpected args format, last arg is not the Command instance",
-        { cause: args }
-      );
-    }
-    positionalValues.forEach((value) => {
-      const argumentInfo = parseUpstreamArgumentInfo(value);
-      if (argumentInfo) {
-        analysis.arguments.push({
-          ...argumentsMap.get(argumentInfo.id),
-          value: argumentInfo.value,
-          specified: argumentInfo.specified
-        });
-      }
-    });
-    Object.values(options).forEach((value) => {
-      const upstreamOptionInfo = parseUpstreamOptionInfo(value);
-      if (upstreamOptionInfo) {
-        analysis.options.push({
-          ...optionsMap.get(upstreamOptionInfo.id),
-          value: upstreamOptionInfo.value,
-          specified: upstreamOptionInfo.specified
-        });
-      }
-    });
-    await onAnalyze(analysis);
-  });
-  command.commands.forEach((subcommand) => {
-    const shadowSubcommand = createShadowCommand(subcommand, onAnalyze);
-    shadow.addCommand(shadowSubcommand);
-  });
-  return shadow;
-};
-const inquirerPrompter = (prompts) => {
-  return prompts;
-};
-const clackPrompter = (prompts) => {
-  const clack = prompts;
-  class ExitPromptError extends Error {
-  }
-  const throwOnCancel = (value) => {
-    if (clack.isCancel(value)) throw new ExitPromptError();
-    return value;
-  };
-  return {
-    input: async (params) => {
-      return clack.text({
-        message: params.message,
-        initialValue: params.default,
-        defaultValue: params.default,
-        placeholder: params.default,
-        validate: params.validate ? (input) => {
-          const result = params.validate(input);
-          if (result === true) return void 0;
-          if (result === false) return "Invalid input";
-          return result;
-        } : void 0
-      }).then(throwOnCancel);
-    },
-    checkbox: async (params) => {
-      return clack.multiselect({
-        message: params.message,
-        options: params.choices.map((c) => ({
-          label: c.name,
-          value: c.value
-        })),
-        initialValues: params.choices.flatMap(
-          (c) => c.checked ? [c.value] : []
-        )
-      }).then(throwOnCancel);
-    },
-    confirm: async (params) => {
-      return clack.confirm({
-        message: params.message,
-        initialValue: params.default
-      }).then(throwOnCancel);
-    },
-    select: async (params) => {
-      return clack.select({
-        message: params.message,
-        options: params.choices.map((sorc) => {
-          const c = typeof sorc === "string" ? { name: sorc, value: sorc } : sorc;
-          return {
-            label: c.name,
-            value: c.value,
-            hint: c.description
-          };
-        }),
-        initialValue: params.default
-      }).then(throwOnCancel);
-    }
-  };
-};
-const promptsPrompter = (prompts) => {
-  const p = prompts;
-  function x() {
-    return (value) => value.x;
-  }
-  return {
-    input: async (params) => {
-      return p({
-        name: "x",
-        type: "text",
-        message: params.message,
-        validate: params.validate,
-        initial: params.default
-      }).then(x());
-    },
-    confirm: async (params) => {
-      return p({
-        name: "x",
-        type: "confirm",
-        message: params.message,
-        active: params.default ? "yes" : "no"
-      }).then(x());
-    },
-    select: async (params) => {
-      const choicesObjects = params.choices.map(
-        (c) => typeof c === "string" ? { name: c, value: c } : c
-      );
-      return p({
-        name: "x",
-        type: "select",
-        message: params.message,
-        active: params.default,
-        choices: choicesObjects.map((c) => ({
-          title: c.name || c.value,
-          value: c.value
-        })),
-        initial: params.default ? choicesObjects.findIndex((c) => c.value === params.default) : void 0
-      }).then(x());
-    },
-    checkbox: async (params) => {
-      const choicesObjects = params.choices.map(
-        (c) => typeof c === "string" ? { name: c, value: c } : c
-      );
-      return p({
-        name: "x",
-        type: "multiselect",
-        message: params.message,
-        choices: choicesObjects.map((c) => ({
-          title: c.name || c.value,
-          value: c.value,
-          selected: c.checked
-        }))
-      }).then(x());
-    }
-  };
-};
-const enquirerPrompter = (prompts) => {
-  const enquirer = prompts;
-  function x() {
-    return (value) => value.x;
-  }
-  return {
-    input: async (params) => {
-      return enquirer.prompt({
-        type: "input",
-        name: "x",
-        message: params.message,
-        validate: params.validate,
-        initial: params.default
-      }).then(x());
-    },
-    confirm: async (params) => {
-      return enquirer.prompt({
-        type: "confirm",
-        name: "x",
-        message: params.message,
-        validate: params.validate,
-        initial: params.default
-      }).then(x());
-    },
-    select: async (params) => {
-      return enquirer.prompt({
-        type: "select",
-        name: "x",
-        message: params.message,
-        // @ts-expect-error not sure why this is an error, in the IDE it infers the type correctly
-        choices: params.choices.slice(),
-        validate: params.validate,
-        initial: params.default
-      }).then(x());
-    },
-    checkbox: async (params) => {
-      return enquirer.prompt({
-        type: "multiselect",
-        name: "x",
-        message: params.message,
-        // @ts-expect-error not sure why this is an error, in the IDE it infers the type correctly
-        choices: params.choices.slice().map((c) => ({
-          name: c.name,
-          value: c.value
-        })),
-        // validate: params.validate ? v => params.validate!([{value: v}]) : undefined,
-        initial: params.choices.flatMap((c, i) => c.checked ? [i] : [])
-      }).then(x());
-    }
-  };
-};
-export const promptify = (program, prompts) => {
-  let promptsInput = prompts;
-  if (promptsInput?.default) promptsInput = promptsInput.default;
-  let prompter;
-  if (typeof promptsInput === "function" && typeof promptsInput.inject === "function") {
-    prompter = promptsPrompter(promptsInput);
-  } else if (promptsInput?.name === "Enquirer") {
-    prompter = enquirerPrompter(promptsInput);
-  } else if (typeof promptsInput?.rawlist === "function") {
-    prompter = inquirerPrompter(promptsInput);
-  } else if (typeof promptsInput?.intro === "function") {
-    prompter = clackPrompter(promptsInput);
-  } else if (typeof promptsInput === "function") {
-    prompter = promptsInput(program);
-  } else {
-    prompter = promptsInput;
-  }
-  const command = program;
-  const analyseThenParse = async (argv, parseOptions) => {
-    if (parseOptions?.from === "electron") {
-      console.warn(
-        `Warning: using prompts in electron mode is untested. The first two args of $0 are not available in electron mode. Assuming that the first two args of ${JSON.stringify(argv)} are electron-related and not intended for the CLI.`
-      );
-    }
-    if (parseOptions?.from !== "user") {
-      argv = argv.slice(2);
-      parseOptions = { from: "user" };
-    }
-    const f = { command, args: [...argv] };
-    const nextArgv = [...f.args];
-    let analysis;
-    const maxAttempts = 100;
-    for (let i = maxAttempts; i >= 0 && !analysis; i--) {
-      analysis = await new Promise((resolve, reject) => {
-        const shadow = createShadowCommand(f.command, async (an) => {
-          if (an.command.original.commands.length === 0) {
-            resolve(an);
-            return;
-          }
-          const defaultSubcommand = getDefaultSubcommand(an.command.original);
-          if (defaultSubcommand) {
-            resolve(an);
-            return;
-          }
-          const name = await prompter.select(
-            {
-              message: `Select a ${an.command.original.name() || ""} subcommand`.replace(
-                "  ",
-                " "
-              ),
-              choices: an.command.original.commands.map((c) => ({
-                name: c.name(),
-                value: c.name(),
-                description: c.description()
-              }))
-            },
-            {}
-          );
-          nextArgv.push(name);
-          resolve(void 0);
-        });
-        shadow.parseAsync(nextArgv, parseOptions).catch((e) => {
-          if (e?.constructor?.name === "CommanderError") {
-            resolve({
-              command: { shadow: f.command, original: f.command },
-              arguments: [],
-              options: []
-            });
-          } else {
-            reject(e);
-          }
-        });
-      });
-    }
-    if (!analysis) {
-      const message = `Failed to find a subcommand after ${maxAttempts} attempts - failing to avoid an infinite loop. This is probably a bug in @reliverse/rempts.`;
-      throw new Error(message);
-    }
-    const getMessage = (argOrOpt) => {
-      const name = "long" in argOrOpt ? argOrOpt.flags : `[${argOrOpt.name()}]`;
-      const parts = [
-        name,
-        argOrOpt.description,
-        argOrOpt.defaultValue && `(default: ${argOrOpt.defaultValue})`,
-        !argOrOpt.defaultValue && !argOrOpt.required && "(optional)"
-      ];
-      return `${parts.filter(Boolean).join(" ").trim()}:`;
-    };
-    const baseContext = {
-      command: analysis.command.original,
-      inputs: {
-        argv,
-        arguments: analysis.arguments.map((a) => ({
-          name: a.original.name(),
-          specified: a.specified,
-          value: a.value
-        })),
-        options: analysis.options.map((o) => ({
-          name: o.original.name(),
-          specified: o.specified,
-          value: o.value
-        }))
-      }
-    };
-    await prompter.setup?.(baseContext);
-    const promptConfig = "necessary";
-    let shouldPrompt;
-    if (promptConfig === "always") {
-      shouldPrompt = true;
-    } else if (promptConfig === "never") {
-      shouldPrompt = false;
-    } else {
-      promptConfig;
-      const someRequiredArgsUnspecified = analysis.arguments.some(
-        (a) => a.original.required && !a.specified
-      );
-      const someRequiredOptionsUnspecified = analysis.options.some(
-        (o) => o.original.required && !o.specified
-      );
-      shouldPrompt = someRequiredArgsUnspecified || someRequiredOptionsUnspecified;
-    }
-    if (shouldPrompt) {
-      for (const arg of analysis.arguments) {
-        const ctx = { ...baseContext, argument: arg.original };
-        if (!arg.specified) {
-          const parseArg = "parseArg" in arg.original && typeof arg.original.parseArg === "function" ? arg.original.parseArg : void 0;
-          const promptedValue = await prompter.input(
-            {
-              message: getMessage(arg.original),
-              required: arg.original.required,
-              default: arg.value,
-              validate: (input) => {
-                try {
-                  parseArg?.(input);
-                  return true;
-                } catch (e) {
-                  return e?.message || e;
-                }
-              }
-            },
-            ctx
-          );
-          nextArgv.push(promptedValue);
-        }
-      }
-      for (const option of analysis.options) {
-        const ctx = { ...baseContext, option: option.original };
-        if (!option.specified) {
-          const fullFlag = option.original.long || `--${option.original.name()}`;
-          const isBoolean = option.original.isBoolean() || option.original.flags.includes("[boolean]");
-          if (isBoolean) {
-            const promptedValue = await prompter.confirm(
-              {
-                message: getMessage(option.original),
-                default: option.original.defaultValue ?? false
-              },
-              ctx
-            );
-            if (promptedValue) nextArgv.push(fullFlag);
-          } else if (option.original.variadic && option.original.argChoices) {
-            const choices = option.original.argChoices.slice();
-            const results = await prompter.checkbox(
-              {
-                message: getMessage(option.original),
-                choices: choices.map((choice) => ({
-                  value: choice,
-                  name: choice,
-                  checked: true
-                }))
-              },
-              ctx
-            );
-            results.forEach((result) => {
-              if (typeof result === "string") nextArgv.push(fullFlag, result);
-            });
-          } else if (option.original.argChoices) {
-            const choices = option.original.argChoices.slice();
-            const set = new Set(choices);
-            const promptedValue = await prompter.select(
-              {
-                message: getMessage(option.original),
-                choices,
-                default: option.original.defaultValue
-                // required: option.original.required,
-              },
-              ctx
-            );
-            if (set.has(promptedValue)) {
-              nextArgv.push(fullFlag, promptedValue);
-            }
-          } else if (option.original.variadic) {
-            const values = [];
-            do {
-              const promptedValue = await prompter.input(
-                {
-                  message: getMessage(option.original),
-                  default: option.original.defaultValue?.[values.length]
-                },
-                ctx
-              );
-              if (!promptedValue) break;
-              values.push(fullFlag, promptedValue);
-            } while (values);
-            nextArgv.push(...values);
-          } else {
-            const getParsedValue = (input) => {
-              return option.original.parseArg ? option.original.parseArg(
-                input,
-                void 0
-              ) : input;
-            };
-            const promptedValue = await prompter.input(
-              {
-                message: getMessage(option.original),
-                default: option.value,
-                required: option.original.required,
-                validate: (input) => {
-                  const parsed = getParsedValue(input);
-                  if (parsed == null && input != null) return "Invalid value";
-                  return true;
-                }
-              },
-              ctx
-            );
-            if (promptedValue)
-              nextArgv.push(
-                fullFlag,
-                getParsedValue(promptedValue) ?? promptedValue
-              );
-          }
-        }
-      }
-    }
-    await prompter.teardown?.(baseContext);
-    return f.command.parseAsync(nextArgv, parseOptions);
-  };
-  const parseAsync = (args, parseOptions) => analyseThenParse(args, parseOptions).catch((e) => {
-    if (e?.constructor?.name === "ExitPromptError") return;
-    throw e;
-  });
-  return new Proxy(program, {
-    get(target, prop, receiver) {
-      if (prop === "parseAsync") return parseAsync;
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-};

package/bin/libs/launcher/trpc-orpc-support/standard-schema/contract.d.ts

@@ -1,53 +0,0 @@
-/** The Standard Schema interface. */
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard Schema properties. */
-    readonly "~standard": StandardSchemaV1Props<Input, Output>;
-}
-/** The Standard Schema properties interface. */
-export interface StandardSchemaV1Props<Input = unknown, Output = Input> {
-    /** The version number of the standard. */
-    readonly version: 1;
-    /** The vendor name of the schema library. */
-    readonly vendor: string;
-    /** Validates unknown input values. */
-    readonly validate: (value: unknown) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;
-    /** Inferred types associated with the schema. */
-    readonly types?: StandardSchemaV1Types<Input, Output> | undefined;
-}
-/** The result interface of the validate function. */
-export type StandardSchemaV1Result<Output> = StandardSchemaV1SuccessResult<Output> | StandardSchemaV1FailureResult;
-/** The result interface if validation succeeds. */
-export interface StandardSchemaV1SuccessResult<Output> {
-    /** The typed output value. */
-    readonly value: Output;
-    /** The non-existent issues. */
-    readonly issues?: undefined;
-}
-/** The result interface if validation fails. */
-export interface StandardSchemaV1FailureResult {
-    /** The issues of failed validation. */
-    readonly issues: readonly StandardSchemaV1Issue[];
-}
-/** The issue interface of the failure output. */
-export interface StandardSchemaV1Issue {
-    /** The error message of the issue. */
-    readonly message: string;
-    /** The path of the issue, if any. */
-    readonly path?: readonly (PropertyKey | StandardSchemaV1PathSegment)[] | undefined;
-}
-/** The path segment interface of the issue. */
-export interface StandardSchemaV1PathSegment {
-    /** The key representing a path segment. */
-    readonly key: PropertyKey;
-}
-/** The Standard Schema types interface. */
-export interface StandardSchemaV1Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
-}
-/** Infers the input type of a Standard Schema. */
-export type StandardSchemaV1InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-/** Infers the output type of a Standard Schema. */
-export type StandardSchemaV1InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];

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

@@ -1,9 +0,0 @@
-import type { StandardSchemaV1FailureResult } from "./contract";
-export declare const prettifyStandardSchemaError: (error: unknown) => string | null;
-export declare function toDotPath(path: (string | number | symbol)[]): string;
-export declare class StandardSchemaV1Error extends Error implements StandardSchemaV1FailureResult {
-    issues: StandardSchemaV1FailureResult["issues"];
-    constructor(failure: StandardSchemaV1FailureResult, options?: {
-        cause?: Error;
-    });
-}

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

@@ -1,47 +0,0 @@
-import { looksLikeStandardSchemaFailure } from "./utils.js";
-export const prettifyStandardSchemaError = (error) => {
-  if (!looksLikeStandardSchemaFailure(error)) return null;
-  const issues = [...error.issues].map((issue) => {
-    const path = issue.path || [];
-    const primitivePathSegments = path.map((segment) => {
-      if (typeof segment === "string" || typeof segment === "number" || typeof segment === "symbol")
-        return segment;
-      return segment.key;
-    });
-    const dotPath = toDotPath(primitivePathSegments);
-    return {
-      issue,
-      path,
-      primitivePathSegments,
-      dotPath
-    };
-  }).sort((a, b) => a.path.length - b.path.length);
-  const lines = [];
-  for (const { issue, dotPath } of issues) {
-    let message = `\u2716 ${issue.message}`;
-    if (dotPath) message += ` \u2192 at ${dotPath}`;
-    lines.push(message);
-  }
-  return lines.join("\n");
-};
-export function toDotPath(path) {
-  const segs = [];
-  for (const seg of path) {
-    if (typeof seg === "number") segs.push(`[${seg}]`);
-    else if (typeof seg === "symbol")
-      segs.push(`[${JSON.stringify(String(seg))}]`);
-    else if (/[^\w$]/.test(seg)) segs.push(`[${JSON.stringify(seg)}]`);
-    else {
-      if (segs.length) segs.push(".");
-      segs.push(seg);
-    }
-  }
-  return segs.join("");
-}
-export class StandardSchemaV1Error extends Error {
-  issues;
-  constructor(failure, options) {
-    super("Standard Schema error - details in `issues`.", options);
-    this.issues = failure.issues;
-  }
-}

package/bin/libs/launcher/trpc-orpc-support/standard-schema/utils.d.ts

@@ -1,3 +0,0 @@
-import type { StandardSchemaV1, StandardSchemaV1FailureResult } from "./contract";
-export declare const looksLikeStandardSchemaFailure: (error: unknown) => error is StandardSchemaV1FailureResult;
-export declare const looksLikeStandardSchema: (thing: unknown) => thing is StandardSchemaV1;

package/bin/libs/launcher/trpc-orpc-support/standard-schema/utils.js

@@ -1,6 +0,0 @@
-export const looksLikeStandardSchemaFailure = (error) => {
-  return !!error && typeof error === "object" && "issues" in error && Array.isArray(error.issues);
-};
-export const looksLikeStandardSchema = (thing) => {
-  return !!thing && typeof thing === "object" && "~standard" in thing && typeof thing["~standard"] === "object";
-};