tyneq 1.0.0

package/dist/ValidationBuilder.d.ts

@@ -0,0 +1,319 @@
+import { H as HasLength, Q as Optional, R as Factory, Z as Nullable, a as Enumerator, i as Enumerable, q as Maybe } from "./core.js";
+
+//#region src/utility/ArgumentUtility.d.ts
+/**
+ * Facade for all argument validation guards.
+ *
+ * Every method accepts either a single-property object (`{ count }`) - where the
+ * property name becomes the error message's parameter name - or a raw value with
+ * an explicit `paramName` string. Prefer the object form; the name is inferred
+ * automatically via `nameof`.
+ *
+ * @example
+ * ```ts
+ * import { ArgumentUtility } from "tyneq/utility";
+ *
+ * function take(count: number) {
+ *     ArgumentUtility.checkNonNegative({ count });   // throws ArgumentOutOfRangeError if count < 0
+ *     ArgumentUtility.checkInteger({ count });       // throws ArgumentError if count is not an integer
+ * }
+ * ```
+ *
+ * @group Utilities
+ */
+declare class ArgumentUtility {
+  private constructor();
+  static checkNotNull<T>(param: Record<string, Nullable<T>>): asserts param is Record<string, T>;
+  static checkNotNull<T>(param: Nullable<T>, paramName: string): asserts param is T;
+  static checkNotUndefined<T>(param: Record<string, Maybe<T>>): asserts param is Record<string, T>;
+  static checkNotUndefined<T>(param: Maybe<T>, paramName: string): asserts param is T;
+  static checkNotOptional<T>(param: Record<string, Optional<T>>): asserts param is Record<string, T>;
+  static checkNotOptional<T>(param: Optional<T>, paramName: string): asserts param is T;
+  static checkNotNullOrEmpty<T extends HasLength>(param: Record<string, Nullable<T>>): asserts param is Record<string, T>;
+  static checkNotNullOrEmpty<T extends HasLength>(param: Nullable<T>, paramName: string): asserts param is T;
+  static checkNotOptionalOrEmpty<T extends HasLength>(param: Record<string, Optional<T>>): asserts param is Record<string, T>;
+  static checkNotOptionalOrEmpty<T extends HasLength>(param: Optional<T>, paramName: string): asserts param is T;
+  static checkNotNullOrWhiteSpace(param: Record<string, Optional<string>>): asserts param is Record<string, string>;
+  static checkNotNullOrWhiteSpace(param: Optional<string>, paramName: string): asserts param is string;
+  static checkNonNegative(param: Record<string, number>): void;
+  static checkNonNegative(param: number, paramName: string): void;
+  static checkPositive(param: Record<string, number>): void;
+  static checkPositive(param: number, paramName: string): void;
+  static checkNegative(param: Record<string, number>): void;
+  static checkNegative(param: number, paramName: string): void;
+  static checkNonPositive(param: Record<string, number>): void;
+  static checkNonPositive(param: number, paramName: string): void;
+  static checkInRange(param: Record<string, number>, min: number, max: number): void;
+  static checkInRange(param: number, min: number, max: number, paramName: string): void;
+  static checkInteger(param: Record<string, number>): void;
+  static checkInteger(param: number, paramName: string): void;
+  static checkFinite(param: Record<string, number>): void;
+  static checkFinite(param: number, paramName: string): void;
+  static checkNotNaN(param: Record<string, number>): void;
+  static checkNotNaN(param: number, paramName: string): void;
+  static checkSafeInteger(param: Record<string, number>): void;
+  static checkSafeInteger(param: number, paramName: string): void;
+  static checkArrayIndex(param: Record<string, number>, arrayLength?: number): void;
+  static checkArrayIndex(param: number, paramName: string, arrayLength?: number): void;
+  static checkFunction(param: Record<string, unknown>): asserts param is Record<string, Function>;
+  static checkFunction(param: unknown, paramName: string): asserts param is Function;
+  static checkIterable<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Iterable<T>>;
+  static checkIterable<T = unknown>(param: unknown, paramName: string): asserts param is Iterable<T>;
+  static checkIterator<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Iterator<T>>;
+  static checkIterator<T = unknown>(param: unknown, paramName: string): asserts param is Iterator<T>;
+  static checkEnumerable<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Enumerable<T>>;
+  static checkEnumerable<T = unknown>(param: unknown, paramName: string): asserts param is Enumerable<T>;
+  static checkEnumerator<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Enumerator<T>>;
+  static checkEnumerator<T = unknown>(param: unknown, paramName: string): asserts param is Enumerator<T>;
+  static checkInstanceOf<T>(param: Record<string, unknown>, constructor: new (...args: any[]) => T): asserts param is Record<string, T>;
+  static checkInstanceOf<T>(param: unknown, constructor: new (...args: any[]) => T, paramName: string): asserts param is T;
+  static checkHasLength(param: Record<string, unknown>): asserts param is Record<string, HasLength>;
+  static checkHasLength(param: unknown, paramName: string): asserts param is HasLength;
+  static check<T>(param: Record<string, T>, predicate: (v: T) => boolean, message: string): void;
+  static check<T>(param: T, paramName: string, predicate: (v: T) => boolean, message: string): void;
+  private static extractParameter;
+}
+//#endregion
+//#region src/types/reflection.d.ts
+/**
+ * Describes a method (function-valued own property) on a reflected target.
+ *
+ * @group Reflection
+ */
+interface MethodDescriptor {
+  readonly kind: "method";
+  readonly name: string | symbol;
+  /** The raw function value. */
+  readonly value: Function;
+  /** Calls the method with the given `this` context and arguments. */
+  readonly invoke: (thisArg: unknown, ...args: unknown[]) => unknown;
+}
+/**
+ * Describes a data property (non-function own value property) on a reflected target.
+ *
+ * @group Reflection
+ */
+interface DataDescriptor {
+  readonly kind: "data";
+  readonly name: string | symbol;
+  readonly value: unknown;
+  readonly writable: boolean;
+  readonly configurable: boolean;
+  readonly enumerable: boolean;
+}
+/**
+ * Describes an accessor property (get and/or set) on a reflected target.
+ *
+ * @group Reflection
+ */
+interface AccessorDescriptor {
+  readonly kind: "accessor";
+  readonly name: string | symbol;
+  readonly get: Maybe<() => unknown>;
+  readonly set: Maybe<(value: unknown) => void>;
+  readonly configurable: boolean;
+  readonly enumerable: boolean;
+  /** `true` if the accessor defines a getter. */
+  readonly canRead: boolean;
+  /** `true` if the accessor defines a setter. */
+  readonly canWrite: boolean;
+}
+/**
+ * A discriminated union of all member descriptor types returned by {@link ReflectionContext}.
+ *
+ * Use `descriptor.kind` to narrow to the specific descriptor type.
+ *
+ * @group Reflection
+ */
+type MemberDescriptor = MethodDescriptor | DataDescriptor | AccessorDescriptor;
+/**
+ * Options for the {@link reflect} factory.
+ *
+ * @group Reflection
+ */
+interface ReflectOptions {
+  /**
+   * When `true`, walks the full prototype chain and includes inherited members
+   * up to (but not including) `Object.prototype`.
+   *
+   * Equivalent to C# `BindingFlags.FlattenHierarchy`.
+   *
+   * @defaultValue false
+   */
+  readonly inherited?: boolean;
+  /**
+   * When `true`, includes Symbol-keyed members in addition to string-keyed members.
+   *
+   * @defaultValue false
+   */
+  readonly symbols?: boolean;
+}
+//#endregion
+//#region src/utility/reflect.d.ts
+/**
+ * The result of a {@link reflect} call. Provides typed access to the members of
+ * the reflected target.
+ *
+ * @group Reflection
+ */
+declare class ReflectionContext<_T extends object> {
+  private readonly proto;
+  private readonly options;
+  /** @internal */
+  constructor(proto: object, options: ReflectOptions);
+  /**
+   * Returns descriptors for all own (and optionally inherited) members,
+   * excluding `constructor`.
+   */
+  members(): readonly MemberDescriptor[];
+  /**
+   * Returns descriptors for all method members (function-valued own properties),
+   * excluding `constructor`.
+   */
+  methods(): readonly MethodDescriptor[];
+  /**
+   * Returns descriptors for all data members (non-function value properties).
+   */
+  fields(): readonly DataDescriptor[];
+  /**
+   * Returns descriptors for all accessor members (get/set properties).
+   */
+  accessors(): readonly AccessorDescriptor[];
+  /**
+   * Returns the descriptor for the named member, or `undefined` if not found.
+   */
+  get(name: string | symbol): Maybe<MemberDescriptor>;
+  /**
+   * Returns `true` if a member with the given name exists on the target.
+   */
+  has(name: string | symbol): boolean;
+  /**
+   * Returns the method descriptor for `name`, or throws {@link ReflectionError}
+   * if the member does not exist or is not a method.
+   *
+   * @throws {ReflectionError} when the member is absent or is not a method.
+   */
+  getMethod(name: string | symbol): MethodDescriptor;
+  /**
+   * Returns the accessor descriptor for `name`, or throws {@link ReflectionError}
+   * if the member does not exist or is not an accessor.
+   *
+   * @throws {ReflectionError} when the member is absent or is not an accessor.
+   */
+  getAccessor(name: string | symbol): AccessorDescriptor;
+  /**
+   * Returns `true` if a method with the given name exists on the target.
+   *
+   * Unlike {@link has}, this returns `false` if the member exists but is an accessor or data property.
+   */
+  hasMethod(name: string | symbol): boolean;
+  /**
+   * Returns the method descriptor for `name`, or `undefined` if the member does not
+   * exist or is not a method. Never throws.
+   */
+  tryGetMethod(name: string | symbol): Maybe<MethodDescriptor>;
+  private findDescriptor;
+  private collectDescriptors;
+}
+/**
+ * Creates a {@link ReflectionContext} for the given target.
+ *
+ * The `target` can be:
+ * - A **constructor function** - reflects the class prototype (instance members). Preferred form.
+ * - A **prototype object** (`MyClass.prototype`) - reflects it directly.
+ * - Any **object** - reflects the object's own properties directly.
+ *
+ * @example
+ * ```ts
+ * import { reflect } from "tyneq/utility";
+ *
+ * class Service {
+ *     public name = "svc";
+ *     public get label(): string { return this.name; }
+ *     public run(): void { /* ... *\/ }
+ * }
+ *
+ * const ctx = reflect(Service);
+ *
+ * ctx.methods();   // -> [{ kind: "method", name: "run", ... }]
+ * ctx.accessors(); // -> [{ kind: "accessor", name: "label", canRead: true, canWrite: false, ... }]
+ *
+ * const m = ctx.getMethod("run");
+ * m.invoke(new Service()); // calls run()
+ * ```
+ *
+ * Walk the full prototype chain:
+ *
+ * ```ts
+ * const ctx = reflect(DerivedClass, { inherited: true });
+ * ctx.members(); // includes members from base classes too
+ * ```
+ *
+ * @group Reflection
+ */
+declare function reflect<T extends object>(target: (new (...args: any[]) => T) | T, options?: ReflectOptions): ReflectionContext<T>;
+//#endregion
+//#region src/utility/TypeGuardUtility.d.ts
+/**
+ * Type guard predicates for Tyneq's core protocol types.
+ *
+ * @group Utilities
+ */
+declare class TypeGuardUtility {
+  private constructor();
+  static isIterable<T = unknown>(value: unknown): value is Iterable<T>;
+  static isIterator<T = unknown>(value: unknown): value is Iterator<T>;
+  static isIterableIterator<T = unknown>(value: unknown): value is IterableIterator<T>;
+  static isEnumerator<T = unknown>(value: unknown): value is Enumerator<T>;
+  static isEnumerable<T = unknown>(value: unknown): value is Enumerable<T>;
+}
+//#endregion
+//#region src/utility/Lazy.d.ts
+/**
+ * Utility class for lazy initialization of values.
+ *
+ * @group Utilities
+ */
+declare class Lazy<T> {
+  private readonly factory;
+  /** The lazily initialized value, or `undefined` if not yet initialized. */
+  private lazyValue;
+  /** Indicates whether the value has been initialized. */
+  private initialized;
+  constructor(factory: Factory<T, []>);
+  /** Returns the lazily initialized value, initializing it if necessary. */
+  get value(): T;
+}
+//#endregion
+//#region src/utility/ValidationBuilder.d.ts
+/**
+ * Accumulates validation errors and throws a single `ValidationError` containing all of them.
+ *
+ * Use when multiple independent arguments must be validated together so callers see all
+ * failures in one throw rather than one at a time.
+ *
+ * @example
+ * ```ts
+ * new ValidationBuilder()
+ *     .check(() => ArgumentUtility.checkNotOptional({ selector }))
+ *     .check(() => ArgumentUtility.checkPositive({ count }))
+ *     .throwIfAny();
+ * ```
+ *
+ * @group Utilities
+ */
+declare class ValidationBuilder {
+  private readonly errors;
+  /**
+   * Runs `fn` and collects any thrown error message. Returns `this` for chaining.
+   */
+  check(fn: () => void): this;
+  /**
+   * Throws a `ValidationError` with all collected messages if any `check` calls failed.
+   * Does nothing when no errors were collected.
+   */
+  throwIfAny(): void;
+}
+//#endregion
+export { reflect as a, MemberDescriptor as c, ArgumentUtility as d, ReflectionContext as i, MethodDescriptor as l, Lazy as n, AccessorDescriptor as o, TypeGuardUtility as r, DataDescriptor as s, ValidationBuilder as t, ReflectOptions as u };
+//# sourceMappingURL=ValidationBuilder.d.ts.map

package/dist/ValidationBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationBuilder.d.ts","names":[],"sources":["../src/utility/ArgumentUtility.ts","../src/types/reflection.ts","../src/utility/reflect.ts","../src/utility/TypeGuardUtility.ts","../src/utility/Lazy.ts","../src/utility/ValidationBuilder.ts"],"mappings":"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"}

package/dist/ValidationBuilder.js

@@ -0,0 +1,69 @@
+import { u as ArgumentError } from "./Lazy.js";
+//#region src/core/errors/argument/ValidationError.ts
+/**
+* Thrown when multiple argument validations fail simultaneously.
+*
+* @remarks
+* `errors` contains one message per failed validation.
+* Thrown by `ValidationBuilder.throwIfAny()` when at least one check failed.
+*
+* @example
+* ```ts
+* try { seq.someOperator(badArg1, badArg2); }
+* catch (e) { if (e instanceof ValidationError) { console.log(e.errors); } }
+* ```
+*
+* @see {@link ArgumentError}
+* @group Errors
+*/
+var ValidationError = class extends ArgumentError {
+	/** The individual validation failure messages. */
+	errors;
+	constructor(errors) {
+		super(`${errors.length} validation error(s):\n${errors.map((e, i) => `  ${i + 1}. ${e}`).join("\n")}`);
+		this.errors = errors;
+	}
+};
+//#endregion
+//#region src/utility/ValidationBuilder.ts
+/**
+* Accumulates validation errors and throws a single `ValidationError` containing all of them.
+*
+* Use when multiple independent arguments must be validated together so callers see all
+* failures in one throw rather than one at a time.
+*
+* @example
+* ```ts
+* new ValidationBuilder()
+*     .check(() => ArgumentUtility.checkNotOptional({ selector }))
+*     .check(() => ArgumentUtility.checkPositive({ count }))
+*     .throwIfAny();
+* ```
+*
+* @group Utilities
+*/
+var ValidationBuilder = class {
+	errors = [];
+	/**
+	* Runs `fn` and collects any thrown error message. Returns `this` for chaining.
+	*/
+	check(fn) {
+		try {
+			fn();
+		} catch (e) {
+			this.errors.push(e instanceof Error ? e.message : String(e));
+		}
+		return this;
+	}
+	/**
+	* Throws a `ValidationError` with all collected messages if any `check` calls failed.
+	* Does nothing when no errors were collected.
+	*/
+	throwIfAny() {
+		if (this.errors.length > 0) throw new ValidationError(this.errors);
+	}
+};
+//#endregion
+export { ValidationError as n, ValidationBuilder as t };
+
+//# sourceMappingURL=ValidationBuilder.js.map

package/dist/ValidationBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationBuilder.js","names":[],"sources":["../src/core/errors/argument/ValidationError.ts","../src/utility/ValidationBuilder.ts"],"sourcesContent":["import { ArgumentError } from \"./ArgumentError\";\r\n\r\n/**\r\n * Thrown when multiple argument validations fail simultaneously.\r\n *\r\n * @remarks\r\n * `errors` contains one message per failed validation.\r\n * Thrown by `ValidationBuilder.throwIfAny()` when at least one check failed.\r\n *\r\n * @example\r\n * ```ts\r\n * try { seq.someOperator(badArg1, badArg2); }\r\n * catch (e) { if (e instanceof ValidationError) { console.log(e.errors); } }\r\n * ```\r\n *\r\n * @see {@link ArgumentError}\r\n * @group Errors\r\n */\r\nexport class ValidationError extends ArgumentError {\r\n    /** The individual validation failure messages. */\r\n    public readonly errors: readonly string[];\r\n\r\n    public constructor(errors: readonly string[]) {\r\n        super(\r\n            `${errors.length} validation error(s):\\n${errors.map((e, i) => `  ${i + 1}. ${e}`).join(\"\\n\")}`\r\n        );\r\n        this.errors = errors;\r\n    }\r\n}\r\n","import { ValidationError } from \"../core/errors/argument/ValidationError\";\r\n\r\n/**\r\n * Accumulates validation errors and throws a single `ValidationError` containing all of them.\r\n *\r\n * Use when multiple independent arguments must be validated together so callers see all\r\n * failures in one throw rather than one at a time.\r\n *\r\n * @example\r\n * ```ts\r\n * new ValidationBuilder()\r\n *     .check(() => ArgumentUtility.checkNotOptional({ selector }))\r\n *     .check(() => ArgumentUtility.checkPositive({ count }))\r\n *     .throwIfAny();\r\n * ```\r\n *\r\n * @group Utilities\r\n */\r\nexport class ValidationBuilder {\r\n    private readonly errors: string[] = [];\r\n\r\n    /**\r\n     * Runs `fn` and collects any thrown error message. Returns `this` for chaining.\r\n     */\r\n    public check(fn: () => void): this {\r\n        try {\r\n            fn();\r\n        } catch (e) {\r\n            this.errors.push(e instanceof Error ? e.message : String(e));\r\n        }\r\n        \r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Throws a `ValidationError` with all collected messages if any `check` calls failed.\r\n     * Does nothing when no errors were collected.\r\n     */\r\n    public throwIfAny(): void {\r\n        if (this.errors.length > 0) {\r\n            throw new ValidationError(this.errors);\r\n        }\r\n    }\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,IAAa,kBAAb,cAAqC,cAAc;;CAE/C;CAEA,YAAmB,QAA2B;AAC1C,QACI,GAAG,OAAO,OAAO,yBAAyB,OAAO,KAAK,GAAG,MAAM,KAAK,IAAI,EAAE,IAAI,IAAI,CAAC,KAAK,KAAK,GAChG;AACD,OAAK,SAAS;;;;;;;;;;;;;;;;;;;;;ACRtB,IAAa,oBAAb,MAA+B;CAC3B,SAAoC,EAAE;;;;CAKtC,MAAa,IAAsB;AAC/B,MAAI;AACA,OAAI;WACC,GAAG;AACR,QAAK,OAAO,KAAK,aAAa,QAAQ,EAAE,UAAU,OAAO,EAAE,CAAC;;AAGhE,SAAO;;;;;;CAOX,aAA0B;AACtB,MAAI,KAAK,OAAO,SAAS,EACrB,OAAM,IAAI,gBAAgB,KAAK,OAAO"}