@reliverse/rempts 1.7.44 → 1.7.46

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

@@ -1,168 +0,0 @@
-const capitaliseFromCamelCase = (camel) => {
-  const parts = camel.split(/(?=[A-Z])/);
-  return capitalise(parts.map((p) => p.toLowerCase()).join(" "));
-};
-const capitalise = (s) => s.slice(0, 1).toUpperCase() + s.slice(1);
-export const flattenedProperties = (sch) => {
-  if ("properties" in sch) {
-    return sch.properties;
-  }
-  if ("allOf" in sch) {
-    return Object.fromEntries(
-      sch.allOf.flatMap(
-        (subSchema) => Object.entries(flattenedProperties(subSchema))
-      )
-    );
-  }
-  if ("anyOf" in sch) {
-    const isExcluded = (v) => Object.keys(v).join(",") === "not";
-    const entries = sch.anyOf.flatMap((subSchema) => {
-      const flattened = flattenedProperties(subSchema);
-      const excluded = Object.entries(flattened).flatMap(
-        ([name, propSchema]) => {
-          return isExcluded(propSchema) ? [`--${name}`] : [];
-        }
-      );
-      return Object.entries(flattened).map(([k, v]) => {
-        if (!isExcluded(v) && excluded.length > 0) {
-          return [
-            k,
-            Object.assign({}, v, { "Do not use with": excluded })
-          ];
-        }
-        return [k, v];
-      });
-    });
-    return Object.fromEntries(
-      entries.sort((a, b) => {
-        const scores = [a, b].map(([_k, v]) => isExcluded(v) ? 0 : 1);
-        return scores[0] - scores[1];
-      })
-    );
-  }
-  return {};
-};
-export const incompatiblePropertyPairs = (sch) => {
-  const isUnion = "anyOf" in sch;
-  if (!isUnion) return [];
-  const sets = sch.anyOf.map((subSchema) => {
-    const keys = Object.keys(flattenedProperties(subSchema));
-    return { keys, set: new Set(keys) };
-  });
-  const compatiblityEntries = sets.flatMap(({ keys }) => {
-    return keys.map((key) => {
-      return [
-        key,
-        new Set(
-          sets.filter((other) => other.set.has(key)).flatMap((other) => other.keys)
-        )
-      ];
-    });
-  });
-  const allKeys = sets.flatMap(({ keys }) => keys);
-  return compatiblityEntries.flatMap(([key, compatibleWith]) => {
-    const incompatibleEntries = allKeys.filter((other) => key < other && !compatibleWith.has(other)).map((other) => [key, other]);
-    return incompatibleEntries;
-  });
-};
-export const getDescription = (v, depth = 0) => {
-  if ("items" in v && v.items) {
-    const { items, ...rest } = v;
-    return [
-      getDescription(items, 1),
-      getDescription(rest),
-      "array"
-    ].filter(Boolean).join(" ");
-  }
-  return Object.entries(v).filter(([k, vv]) => {
-    if (k === "default" || k === "additionalProperties" || k === "optional")
-      return false;
-    if (k === "type" && typeof vv === "string") return depth > 0;
-    if (k.startsWith("$")) return false;
-    if (k === "maximum" && vv === Number.MAX_SAFE_INTEGER) return false;
-    if (depth <= 1 && k === "enum" && getEnumChoices(v)?.type === "string_enum")
-      return false;
-    return true;
-  }).sort(([a], [b]) => {
-    const scores = [a, b].map((k) => k === "description" ? 0 : 1);
-    return scores[0] - scores[1];
-  }).map(([k, vv], i) => {
-    if (k === "type" && Array.isArray(vv))
-      return `type: ${vv.join(" or ")}`;
-    if (k === "description" && i === 0) return String(vv);
-    if (k === "properties") return "Object (json formatted)";
-    if (typeof vv === "object")
-      return `${capitaliseFromCamelCase(k)}: ${JSON.stringify(vv)}`;
-    return `${capitaliseFromCamelCase(k)}: ${vv}`;
-  }).join("; ") || "";
-};
-export const getSchemaTypes = (propertyValue) => {
-  const array = [];
-  if ("type" in propertyValue) {
-    array.push(...[propertyValue.type].flat());
-  }
-  if ("enum" in propertyValue && Array.isArray(propertyValue.enum)) {
-    array.push(...propertyValue.enum.flatMap((s) => typeof s));
-  }
-  if ("const" in propertyValue && propertyValue.const === null) {
-    array.push("null");
-  } else if ("const" in propertyValue) {
-    array.push(typeof propertyValue.const);
-  }
-  if ("oneOf" in propertyValue) {
-    array.push(
-      ...propertyValue.oneOf.flatMap(getSchemaTypes)
-    );
-  }
-  if ("anyOf" in propertyValue) {
-    array.push(
-      ...propertyValue.anyOf.flatMap(getSchemaTypes)
-    );
-  }
-  return [...new Set(array)];
-};
-export const getEnumChoices = (propertyValue) => {
-  if (!propertyValue) return null;
-  if (!("enum" in propertyValue && Array.isArray(propertyValue.enum))) {
-    if ("anyOf" in propertyValue && propertyValue.anyOf?.every((subSchema) => {
-      if (subSchema && "const" in subSchema && Object.keys(subSchema).length === 1 && typeof subSchema.const === "string") {
-        return true;
-      }
-      return false;
-    })) {
-      return {
-        type: "string_enum",
-        choices: propertyValue.anyOf.map(
-          (subSchema) => subSchema.const
-        )
-      };
-    }
-    if ("anyOf" in propertyValue && propertyValue.anyOf?.every((subSchema) => {
-      if (subSchema && "const" in subSchema && Object.keys(subSchema).length === 1 && typeof subSchema.const === "number") {
-        return true;
-      }
-      return false;
-    })) {
-      return {
-        type: "number_enum",
-        choices: propertyValue.anyOf.map(
-          (subSchema) => subSchema.const
-        )
-      };
-    }
-    return null;
-  }
-  if (propertyValue.enum.every((s) => typeof s === "string")) {
-    return {
-      type: "string_enum",
-      choices: propertyValue.enum
-    };
-  }
-  if (propertyValue.enum.every((s) => typeof s === "number")) {
-    return {
-      type: "number_enum",
-      choices: propertyValue.enum
-    };
-  }
-  return null;
-};

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

@@ -1,44 +0,0 @@
-import type { Command } from "commander";
-/**
- * JSON representation of a commander `Command` instance
- * Note: this is not necessarily a _complete_ representation of the command - it aims to be a big enough subset to be useful for generating documentation etc.
- */
-export interface CommandJSON {
-    name?: string;
-    version?: string;
-    description?: string;
-    usage?: string;
-    commands?: CommandJSON[];
-    arguments?: {
-        name: string;
-        description?: string;
-        required: boolean;
-        defaultValue?: {};
-        defaultValueDescription?: string;
-        variadic: boolean;
-        choices?: string[];
-    }[];
-    options?: {
-        name: string;
-        description?: string;
-        required: boolean;
-        defaultValue?: {};
-        defaultValueDescription?: string;
-        variadic: boolean;
-        attributeName?: string;
-        flags?: string;
-        short?: string;
-        negate: boolean;
-        optional: boolean;
-        choices?: string[];
-    }[];
-}
-/**
- * Convert a commander `Command` instance to a JSON object.
- *
- * Note: in theory you could use this with any `Command` instance, it doesn't have
- * to be one built by `@reliverse/rempts`. Implementing here because it's pretty simple to do and `commander` doesn't seem to provide a way to do it.
- *
- * Note: falsy values for strings are replaced with `undefined` in the output - e.g. if there's an empty description, it will be `undefined` in the output.
- */
-export declare const commandToJSON: (command: Command) => CommandJSON;

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

@@ -1,41 +0,0 @@
-export const commandToJSON = (command) => {
-  const json = {};
-  const name = command.name();
-  if (name) json.name = name;
-  const version = command.version();
-  if (version) json.version = version;
-  const description = command.description();
-  if (description) json.description = description;
-  const usage = command.usage();
-  if (usage) json.usage = usage;
-  json.arguments = command.registeredArguments.map((arg) => {
-    const result = { name: arg.name() };
-    result.variadic = arg.variadic;
-    result.required = arg.required;
-    if (arg.description) result.description = arg.description;
-    if (arg.defaultValue) result.defaultValue = arg.defaultValue;
-    if (arg.defaultValueDescription)
-      result.defaultValueDescription = arg.defaultValueDescription;
-    if (arg.argChoices) result.choices = arg.argChoices;
-    return result;
-  });
-  json.options = command.options.map((o) => {
-    const result = { name: o.name() };
-    result.required = o.required;
-    result.optional = o.optional;
-    result.negate = o.negate;
-    result.variadic = o.variadic;
-    if (o.flags) result.flags = o.flags;
-    if (o.short) result.short = o.short;
-    if (o.description) result.description = o.description;
-    if (o.argChoices) result.choices = o.argChoices;
-    const attributeName = o.attributeName();
-    if (attributeName) result.attributeName = attributeName;
-    if (o.defaultValue) result.defaultValue = o.defaultValue;
-    if (o.defaultValueDescription)
-      result.defaultValueDescription = o.defaultValueDescription;
-    return result;
-  });
-  json.commands = command.commands.map((c) => commandToJSON(c));
-  return json;
-};

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

@@ -1,11 +0,0 @@
-import type { Logger } from "./types";
-export declare const lineByLineLogger: (logger: Logger) => Logger;
-/**
- * A logger which uses `console.log` and `console.error` to log in the following way:
- * - Primitives are logged directly
- * - Arrays are logged item-by-item
- * - Objects are logged as JSON
- *
- * This is useful for logging structured data in a human-readable way, and for piping logs to other tools.
- */
-export declare const lineByLineConsoleLogger: Logger;

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

@@ -1,26 +0,0 @@
-export const lineByLineLogger = getLoggerTransformer((log) => {
-  const wrapper = (args, depth) => {
-    if (args.length === 1 && Array.isArray(args[0]) && depth === 0) {
-      args[0].forEach((item) => wrapper([item], 1));
-    } else if (args.every(isPrimitive)) {
-      log(...args);
-    } else if (args.length === 1) {
-      log(JSON.stringify(args[0], null, 2));
-    } else {
-      log(JSON.stringify(args, null, 2));
-    }
-  };
-  return (...args) => wrapper(args, 0);
-});
-const isPrimitive = (value) => {
-  const type = typeof value;
-  return type === "string" || type === "number" || type === "boolean";
-};
-function getLoggerTransformer(transform) {
-  return (logger) => {
-    const info = logger.info && transform(logger.info);
-    const error = logger.error && transform(logger.error);
-    return { info, error };
-  };
-}
-export const lineByLineConsoleLogger = lineByLineLogger(console);

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

@@ -1,2 +0,0 @@
-import type { Dependencies, ParsedProcedure, Result } from "./types";
-export declare function parseProcedureInputs(inputs: unknown[], dependencies: Dependencies): Result<ParsedProcedure>;