@reliverse/rempts-core 1.6.1 → 2.3.2

package/src/utils/type-helpers.ts

@@ -0,0 +1,151 @@
+/**
+ * Type utilities inspired by TanStack Router for advanced type manipulation
+ */
+
+// Union to intersection conversion
+export type UnionToIntersection<T> = (T extends any ? (arg: T) => any : never) extends (
+  arg: infer T
+) => any
+  ? T
+  : never;
+
+// Constrain types with fallback
+export type Constrain<T, TConstraint, TDefault = TConstraint> =
+  | (T extends TConstraint ? T : never)
+  | TDefault;
+
+// Pick required properties
+export type PickRequired<T> = {
+  [K in keyof T as undefined extends T[K] ? never : K]: T[K];
+};
+
+// Pick optional properties
+export type PickOptional<T> = {
+  [K in keyof T as undefined extends T[K] ? K : never]: T[K];
+};
+
+// Extract primitive types from union
+export type ExtractPrimitives<TUnion> = TUnion extends MergeAllPrimitive
+  ? TUnion
+  : TUnion extends object
+    ? never
+    : TUnion;
+
+// Merge all primitive types
+export type MergeAllPrimitive =
+  | readonly any[]
+  | number
+  | string
+  | bigint
+  | boolean
+  | symbol
+  | undefined
+  | null;
+
+// Extract objects from union
+export type ExtractObjects<TUnion> = TUnion extends MergeAllPrimitive ? never : TUnion;
+
+// Partial merge all objects
+export type PartialMergeAllObject<TUnion> =
+  ExtractObjects<TUnion> extends infer TObj
+    ? [TObj] extends [never]
+      ? never
+      : {
+          [TKey in TObj extends any ? keyof TObj : never]?: TObj extends any
+            ? TKey extends keyof TObj
+              ? TObj[TKey]
+              : never
+            : never;
+        }
+    : never;
+
+// Partial merge all
+export type PartialMergeAll<TUnion> = ExtractPrimitives<TUnion> | PartialMergeAllObject<TUnion>;
+
+// Merge all objects in union
+export type MergeAllObjects<TUnion, TIntersected = UnionToIntersection<ExtractObjects<TUnion>>> = [
+  keyof TIntersected,
+] extends [never]
+  ? never
+  : {
+      [TKey in keyof TIntersected]: TUnion extends any ? TUnion[TKey & keyof TUnion] : never;
+    };
+
+// Merge all types in union
+export type MergeAll<TUnion> = MergeAllObjects<TUnion> | ExtractPrimitives<TUnion>;
+
+// No inference utility
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+
+// Check if type is any
+export type IsAny<TValue, TYesResult, TNoResult = TValue> = 1 extends 0 & TValue
+  ? TYesResult
+  : TNoResult;
+
+// Pick as required
+export type PickAsRequired<TValue, TKey extends keyof TValue> = Omit<TValue, TKey> &
+  Required<Pick<TValue, TKey>>;
+
+// Without empty objects
+export type WithoutEmpty<T> = T extends any ? ({} extends T ? never : T) : never;
+
+// Expand type for better IntelliSense
+export type Expand<T> = T extends object
+  ? T extends infer O
+    ? O extends Function
+      ? O
+      : { [K in keyof O]: O[K] }
+    : never
+  : T;
+
+// Deep partial
+export type DeepPartial<T> = T extends object
+  ? {
+      [P in keyof T]?: DeepPartial<T[P]>;
+    }
+  : T;
+
+// Make difference optional
+export type MakeDifferenceOptional<TLeft, TRight> = keyof TLeft & keyof TRight extends never
+  ? TRight
+  : Omit<TRight, keyof TLeft & keyof TRight> & {
+      [K in keyof TLeft & keyof TRight]?: TRight[K];
+    };
+
+// Check if type is union
+export type IsUnion<T, U extends T = T> = (
+  T extends any
+    ? U extends T
+      ? false
+      : true
+    : never
+) extends false
+  ? false
+  : true;
+
+// Check if type is non-empty object
+export type IsNonEmptyObject<T> = T extends object ? (keyof T extends never ? false : true) : false;
+
+// Assign types
+export type Assign<TLeft, TRight> = TLeft extends any
+  ? TRight extends any
+    ? IsNonEmptyObject<TLeft> extends false
+      ? TRight
+      : IsNonEmptyObject<TRight> extends false
+        ? TLeft
+        : keyof TLeft & keyof TRight extends never
+          ? TLeft & TRight
+          : Omit<TLeft, keyof TRight> & TRight
+    : never
+  : never;
+
+// Intersect assign
+export type IntersectAssign<TLeft, TRight> = TLeft extends any
+  ? TRight extends any
+    ? IsNonEmptyObject<TLeft> extends false
+      ? TRight
+      : IsNonEmptyObject<TRight> extends false
+        ? TLeft
+        : TRight & TLeft
+    : never
+  : never;

package/src/validation.ts

@@ -0,0 +1,177 @@
+/**
+ * Runtime validation utilities for Rempts
+ */
+
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { RemptsValidationError } from "./types";
+
+/**
+ * Validate a value against a schema at runtime
+ */
+export async function validateValue(
+  value: unknown,
+  schema: StandardSchemaV1,
+  context: {
+    option: string;
+    command: string;
+  }
+): Promise<unknown> {
+  try {
+    const result = await schema["~standard"].validate(value);
+
+    if (result.issues && result.issues.length > 0) {
+      const issue = result.issues[0];
+      if (!issue) {
+        return value;
+      }
+
+      const expectedType = extractSchemaType(schema);
+      const hint = generateHint(schema, value);
+
+      throw new RemptsValidationError(`Invalid option '${context.option}': ${issue.message}`, {
+        option: context.option,
+        value,
+        command: context.command,
+        expectedType,
+        hint,
+      });
+    }
+
+    return "value" in result ? result.value : value;
+  } catch (error) {
+    if (error instanceof RemptsValidationError) {
+      throw error;
+    }
+
+    // Wrap other errors
+    throw new RemptsValidationError(`Validation failed for option '${context.option}': ${error}`, {
+      option: context.option,
+      value,
+      command: context.command,
+      expectedType: "unknown",
+      hint: "Check the value format and try again",
+    });
+  }
+}
+
+/**
+ * Validate multiple values against their schemas
+ */
+export async function validateValues(
+  values: Record<string, unknown>,
+  schemas: Record<string, StandardSchemaV1>,
+  command: string
+): Promise<Record<string, unknown>> {
+  const results: Record<string, unknown> = {};
+  const errors: string[] = [];
+
+  for (const [key, value] of Object.entries(values)) {
+    const schema = schemas[key];
+    if (!schema) {
+      results[key] = value;
+      continue;
+    }
+
+    try {
+      results[key] = await validateValue(value, schema, {
+        option: key,
+        command,
+      });
+    } catch (error) {
+      if (error instanceof RemptsValidationError) {
+        errors.push(error.toString());
+      } else {
+        errors.push(`Validation error for ${key}: ${error}`);
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Validation failed:\n${errors.join("\n")}`);
+  }
+
+  return results;
+}
+
+/**
+ * Check if a value matches a schema type
+ */
+export function isValueOfType(value: unknown, expectedType: string): boolean {
+  switch (expectedType) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return false;
+  }
+}
+
+/**
+ * Extract a human-readable type description from a schema
+ */
+function extractSchemaType(schema: StandardSchemaV1): string {
+  if ("type" in schema && typeof schema.type === "string") {
+    return schema.type;
+  }
+
+  if ("enum" in schema) {
+    return "enum";
+  }
+  if ("items" in schema) {
+    return "array";
+  }
+  if ("properties" in schema) {
+    return "object";
+  }
+  if ("format" in schema) {
+    return "string";
+  }
+
+  return "unknown";
+}
+
+/**
+ * Generate a helpful hint based on the schema and value
+ */
+function generateHint(schema: StandardSchemaV1, value: unknown): string {
+  const type = extractSchemaType(schema);
+
+  if (type === "boolean" && typeof value === "string") {
+    return "Use --flag or --no-flag for boolean options";
+  }
+  if (type === "number" && typeof value === "string") {
+    return "Provide a numeric value";
+  }
+  if (type === "array" && !Array.isArray(value)) {
+    return "Provide a comma-separated list of values";
+  }
+  if (type === "enum" && typeof value === "string") {
+    return "Choose from the available options";
+  }
+  return "";
+}
+
+/**
+ * Create a validator function from a schema
+ */
+export function createValidator(schema: StandardSchemaV1) {
+  return async (value: unknown, context: { option: string; command: string }) => {
+    return validateValue(value, schema, context);
+  };
+}
+
+/**
+ * Batch validate multiple values
+ */
+export function createBatchValidator(schemas: Record<string, StandardSchemaV1>) {
+  return async (values: Record<string, unknown>, command: string) => {
+    return validateValues(values, schemas, command);
+  };
+}

package/LICENSE

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2025 blefnk Nazar Kornienko
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/bin/core-impl/anykey/anykey-mod.d.ts

@@ -1,12 +0,0 @@
-import type { ColorName } from "../../core-types.js";
-type Options = {
-    ctrlC?: number | false | "reject";
-    preserveLog?: boolean;
-    hideMessage?: boolean;
-    shouldStream?: boolean;
-    streamDelay?: number;
-    color?: ColorName;
-    placeholderColor?: ColorName;
-};
-export declare function anykeyPrompt(message?: string, options?: Options): Promise<void>;
-export {};

package/bin/core-impl/anykey/anykey-mod.js

@@ -1,125 +0,0 @@
-import logUpdate from "log-update";
-import { cursor } from "sisteransi";
-import { fmt } from "../msg-fmt/messages.js";
-import { endPrompt } from "../st-end/end.js";
-import { streamText } from "../utils/stream-text.js";
-const DEFAULT_MESSAGE = "Press any key to continue...";
-const CTRL_C_CODE = 3;
-const terminal = {
-  /**
-   * Move cursor to start of line
-   */
-  moveToStart: () => process.stdout.write("\r"),
-  /**
-   * Clear current line and move cursor up
-   */
-  clearLineAndMoveUp: () => process.stdout.write("\x1B[1A\x1B[2K"),
-  /**
-   * Clear multiple lines above current position
-   */
-  clearLines: (count) => {
-    terminal.moveToStart();
-    process.stdout.write("\x1B[2K");
-    for (let i = 0; i < count; i++) {
-      terminal.clearLineAndMoveUp();
-    }
-  }
-};
-export async function anykeyPrompt(message = DEFAULT_MESSAGE, options = {}) {
-  const {
-    ctrlC = 1,
-    preserveLog = false,
-    hideMessage = false,
-    shouldStream = false,
-    streamDelay = 20,
-    color = "dim",
-    placeholderColor = "gray"
-  } = options;
-  if (message) {
-    if (!shouldStream) {
-      const { text } = fmt({
-        hintPlaceholderColor: placeholderColor,
-        type: "M_GENERAL",
-        title: message,
-        titleColor: color,
-        dontRemoveBar: true
-      });
-      message = text;
-    }
-  }
-  if (message && !hideMessage) {
-    if (shouldStream) {
-      await streamText({
-        text: `\u25C6  ${message}`,
-        delay: streamDelay,
-        newline: false,
-        clearLine: true,
-        color
-      });
-      const lineCount = message.split("\n").length;
-      terminal.clearLines(lineCount);
-      const { text } = fmt({
-        hintPlaceholderColor: placeholderColor,
-        type: "M_GENERAL",
-        title: message,
-        titleColor: color,
-        dontRemoveBar: true
-      });
-      terminal.moveToStart();
-      logUpdate(text);
-    } else {
-      logUpdate(message);
-    }
-  }
-  return new Promise((resolve, reject) => {
-    const cleanup = () => {
-      process.stdin.removeListener("data", handler);
-      if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
-        process.stdin.setRawMode(false);
-      }
-      process.stdin.pause();
-      process.stdout.write(cursor.show);
-    };
-    const handleCtrlC = () => {
-      cleanup();
-      void endPrompt({
-        title: "\u270B User pressed Ctrl+C, exiting...",
-        titleAnimation: "pulse",
-        titleColor: "redBright",
-        titleTypography: "bold",
-        endTitleColor: "redBright",
-        titleAnimationDelay: 400
-      }).then(() => {
-        if (ctrlC === "reject") {
-          reject(new Error("User pressed CTRL+C"));
-        } else if (ctrlC === false) {
-          resolve();
-        } else if (typeof ctrlC === "number") {
-          process.exit(0);
-        } else {
-          throw new TypeError("Invalid ctrlC option");
-        }
-      }).catch(reject);
-    };
-    const handler = (buffer) => {
-      cleanup();
-      if (message && !preserveLog) {
-        logUpdate.clear();
-      } else {
-        logUpdate.done();
-        process.stdout.write("\n");
-      }
-      const [firstByte] = buffer;
-      if (firstByte === CTRL_C_CODE) {
-        handleCtrlC();
-      } else {
-        resolve();
-      }
-    };
-    process.stdin.resume();
-    if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.once("data", handler);
-  });
-}

package/bin/core-impl/date/date.d.ts

@@ -1,2 +0,0 @@
-import type { DatePromptOptions } from "../../core-types.js";
-export declare function datePrompt(opts: DatePromptOptions): Promise<string>;