@statedelta-libs/operators 0.0.2 → 0.1.1

package/dist/index.d.cts

@@ -1,152 +1,3 @@
-/**
- * Returns its argument unchanged.
- *
- * The identity function is useful as a default transformation,
- * placeholder in pipelines, or when a function is required but
- * no transformation is needed.
- *
- * @param x - The value to return
- * @returns The same value
- *
- * @example
- * ```ts
- * identity(5);              // 5
- * identity({ a: 1 });       // { a: 1 }
- * identity([1, 2, 3]);      // [1, 2, 3]
- *
- * // Useful as default in pipelines
- * const transform = condition ? someTransform : identity;
- * pipe(data, transform, process);
- *
- * // Useful as filter predicate (keeps truthy values)
- * [1, 0, 2, null, 3].filter(identity); // [1, 2, 3]
- * ```
- */
-declare function identity<T>(x: T): T;
-
-/**
- * Creates a function that always returns the same value.
- *
- * Useful for providing constant values in places that expect functions,
- * like in `cond`, `ifElse`, or as default transformations.
- *
- * @param x - The value to always return
- * @returns A function that ignores its arguments and returns x
- *
- * @example
- * ```ts
- * const alwaysFive = always(5);
- * alwaysFive();        // 5
- * alwaysFive(100);     // 5
- * alwaysFive('any');   // 5
- *
- * // Useful in conditionals
- * const getDiscount = cond([
- *   [propEq('tier', 'gold'), always(0.3)],
- *   [propEq('tier', 'silver'), always(0.2)],
- *   [T, always(0)]  // default
- * ]);
- *
- * // Useful in ifElse
- * const discount = ifElse(
- *   propEq('vip', true),
- *   always(0.2),
- *   always(0)
- * );
- * ```
- */
-declare function always<T>(x: T): () => T;
-
-/**
- * Constant functions that return true or false.
- *
- * These are useful as default predicates in conditional functions
- * like `cond`, `filter`, or as terminal cases in pattern matching.
- */
-/**
- * A function that always returns true.
- *
- * Useful as a default case or catch-all predicate.
- *
- * @returns Always true
- *
- * @example
- * ```ts
- * T();  // true
- *
- * // Default case in cond
- * const classify = cond([
- *   [propEq('type', 'admin'), always('full')],
- *   [propEq('type', 'user'), always('limited')],
- *   [T, always('none')]  // default case - always matches
- * ]);
- *
- * // Always include
- * filter(T, [1, 2, 3]);  // [1, 2, 3]
- * ```
- */
-declare function T$1(): true;
-/**
- * A function that always returns false.
- *
- * Useful as a never-matching predicate or to explicitly exclude.
- *
- * @returns Always false
- *
- * @example
- * ```ts
- * F();  // false
- *
- * // Never match
- * filter(F, [1, 2, 3]);  // []
- *
- * // Explicit disable
- * const shouldProcess = isEnabled ? checkCondition : F;
- * ```
- */
-declare function F(): false;
-
-/**
- * Executes a side-effect function and returns the original value.
- *
- * `tap` is invaluable for debugging pipelines, logging intermediate
- * values, or performing side-effects without breaking the data flow.
- * The side-effect function's return value is ignored.
- *
- * @param fn - The side-effect function to execute
- * @param x - The value to pass through
- * @returns The original value x, unchanged
- *
- * @example
- * ```ts
- * // Debugging a pipeline
- * pipe(
- *   [1, 2, 3, 4, 5],
- *   filter(x => x > 2),
- *   tap(console.log),        // logs: [3, 4, 5]
- *   map(x => x * 2),
- *   tap(console.log),        // logs: [6, 8, 10]
- *   sum
- * );  // 24
- *
- * // Curried usage
- * const log = tap(console.log);
- * log('hello');  // logs 'hello', returns 'hello'
- *
- * // Side-effects in transformations
- * const users = pipe(
- *   fetchUsers(),
- *   tap(users => analytics.track('users_fetched', { count: users.length })),
- *   filter(user => user.active)
- * );
- * ```
- */
-interface TapFn {
-    <T>(fn: (x: T) => void, x: T): T;
-    <T>(fn: (x: T) => void): (x: T) => T;
-}
-declare const tap: TapFn;
-
 /**
  * @statedelta-libs/operators - Type Definitions
  *
@@ -353,6 +204,155 @@ type Reducer<T, U> = (accumulator: U, value: T, index: number, array: readonly T
  */
 type Comparator<T> = (a: T, b: T) => number;
 
+/**
+ * Executes a side-effect function and returns the original value.
+ *
+ * `tap` is invaluable for debugging pipelines, logging intermediate
+ * values, or performing side-effects without breaking the data flow.
+ * The side-effect function's return value is ignored.
+ *
+ * @param fn - The side-effect function to execute
+ * @param x - The value to pass through
+ * @returns The original value x, unchanged
+ *
+ * @example
+ * ```ts
+ * // Debugging a pipeline
+ * pipe(
+ *   [1, 2, 3, 4, 5],
+ *   filter(x => x > 2),
+ *   tap(console.log),        // logs: [3, 4, 5]
+ *   map(x => x * 2),
+ *   tap(console.log),        // logs: [6, 8, 10]
+ *   sum
+ * );  // 24
+ *
+ * // Curried usage
+ * const log = tap(console.log);
+ * log('hello');  // logs 'hello', returns 'hello'
+ *
+ * // Side-effects in transformations
+ * const users = pipe(
+ *   fetchUsers(),
+ *   tap(users => analytics.track('users_fetched', { count: users.length })),
+ *   filter(user => user.active)
+ * );
+ * ```
+ */
+interface TapFn {
+    <T>(fn: (x: T) => void, x: T): T;
+    <T>(fn: (x: T) => void): (x: T) => T;
+}
+declare const tap: TapFn;
+
+/**
+ * Returns its argument unchanged.
+ *
+ * The identity function is useful as a default transformation,
+ * placeholder in pipelines, or when a function is required but
+ * no transformation is needed.
+ *
+ * @param x - The value to return
+ * @returns The same value
+ *
+ * @example
+ * ```ts
+ * identity(5);              // 5
+ * identity({ a: 1 });       // { a: 1 }
+ * identity([1, 2, 3]);      // [1, 2, 3]
+ *
+ * // Useful as default in pipelines
+ * const transform = condition ? someTransform : identity;
+ * pipe(data, transform, process);
+ *
+ * // Useful as filter predicate (keeps truthy values)
+ * [1, 0, 2, null, 3].filter(identity); // [1, 2, 3]
+ * ```
+ */
+declare function identity<T>(x: T): T;
+
+/**
+ * Creates a function that always returns the same value.
+ *
+ * Useful for providing constant values in places that expect functions,
+ * like in `cond`, `ifElse`, or as default transformations.
+ *
+ * @param x - The value to always return
+ * @returns A function that ignores its arguments and returns x
+ *
+ * @example
+ * ```ts
+ * const alwaysFive = always(5);
+ * alwaysFive();        // 5
+ * alwaysFive(100);     // 5
+ * alwaysFive('any');   // 5
+ *
+ * // Useful in conditionals
+ * const getDiscount = cond([
+ *   [propEq('tier', 'gold'), always(0.3)],
+ *   [propEq('tier', 'silver'), always(0.2)],
+ *   [T, always(0)]  // default
+ * ]);
+ *
+ * // Useful in ifElse
+ * const discount = ifElse(
+ *   propEq('vip', true),
+ *   always(0.2),
+ *   always(0)
+ * );
+ * ```
+ */
+declare function always<T>(x: T): () => T;
+
+/**
+ * Constant functions that return true or false.
+ *
+ * These are useful as default predicates in conditional functions
+ * like `cond`, `filter`, or as terminal cases in pattern matching.
+ */
+/**
+ * A function that always returns true.
+ *
+ * Useful as a default case or catch-all predicate.
+ *
+ * @returns Always true
+ *
+ * @example
+ * ```ts
+ * T();  // true
+ *
+ * // Default case in cond
+ * const classify = cond([
+ *   [propEq('type', 'admin'), always('full')],
+ *   [propEq('type', 'user'), always('limited')],
+ *   [T, always('none')]  // default case - always matches
+ * ]);
+ *
+ * // Always include
+ * filter(T, [1, 2, 3]);  // [1, 2, 3]
+ * ```
+ */
+declare function T$1(): true;
+/**
+ * A function that always returns false.
+ *
+ * Useful as a never-matching predicate or to explicitly exclude.
+ *
+ * @returns Always false
+ *
+ * @example
+ * ```ts
+ * F();  // false
+ *
+ * // Never match
+ * filter(F, [1, 2, 3]);  // []
+ *
+ * // Explicit disable
+ * const shouldProcess = isEnabled ? checkCondition : F;
+ * ```
+ */
+declare function F(): false;
+
 /**
  * Transforms a function into a curried version.
  *
@@ -2156,6 +2156,8 @@ declare function divide(a: number): (b: number) => number;
 declare function divide(a: number, b: number): number;
 declare function modulo(a: number): (b: number) => number;
 declare function modulo(a: number, b: number): number;
+declare function mathMod(a: number): (b: number) => number;
+declare function mathMod(a: number, b: number): number;
 declare function negate(n: number): number;
 declare function inc(n: number): number;
 declare function dec(n: number): number;
@@ -2350,4 +2352,208 @@ declare function transduce<A, B, Acc>(transducer: Transducer<A, B>, transformer:
 declare function into<A, B>(transducer: Transducer<A, B>): (collection: readonly A[]) => B[];
 declare function into<A, B>(transducer: Transducer<A, B>, collection: readonly A[]): B[];
 
-export { type BinaryFn, type Comparator, type ComposeBuilderFn, type Curry1, type Curry2, type Curry3, type DeepReadonly, F, type Fn, type Head, type Last, type Lens, type Mapper, type Nullable, type ParamsOf, type PipeBuilderFn, type PipeFn, type PipeTransformer, type Placeholder, type Predicate, type Reducer, type ReturnOf, T$1 as T, type Tail, type TernaryFn, type Transducer, type Transformer, type UnaryFn, type VariadicFn, placeholder as __, abs, add, allPass, always, and, anyPass, append, applySpec, assoc, assocPath, both, ceil, chain, clamp, coalesce, complement, compose, composeAsync, composeK, composeT, concat, concatStr, cond, countBy, curry, curryN, dec, defaultTo, dissoc, dissocPath, divide, drop, dropLast, dropT, dropWhile, either, endsWith, entries, equals, every, evolve, extend, filter, filterAsync, filterT, find, findIndex, findLast, flatten, floor, fromEntries, groupBy, gt, gte, head, identical, identity, ifElse, inc, includes, indexBy, indexOf, init, into, is, isEmpty, isNil, isNotEmpty, isNotNil, isPlaceholder, join, keys, last, length, lens, lensIndex, lensPath, lensProp, letIn, lt, lte, map, mapAsync, mapSerial, mapT, match, max, mean, median, merge, mergeDeep, min, modulo, multiply, negate, none, not, nth, omit, or, over, padEnd, padStart, partial, partialRight, partition, path, pathEq, pathOr, pathSatisfies, pick, pipe, pipeAsync, pipeBuilder, pipeK, pipeWith, pluck, pow, prepend, product, prop, propEq, propOr, propSatisfies, props, range, reduce, reduceAsync, reduceRight, reject, replace, reverse, round, set, slice, some, sort, sortBy, split, splitEvery, startsWith, substring, subtract, sum, tail, take, takeLast, takeT, takeWhile, tap, test, toArray, toBoolean, toLower, toNumber, toObject, toString, toUpper, transduce, trim, tryCatch, type, uniq, uniqBy, unless, unnest, values, view, when, where, whereEq, zip, zipObj, zipWith };
+declare const scope: {
+    readonly identity: typeof identity;
+    readonly always: typeof always;
+    readonly T: typeof T$1;
+    readonly F: typeof F;
+    readonly tap: TapFn;
+    readonly curry: typeof curry;
+    readonly curryN: typeof curryN;
+    readonly partial: typeof partial;
+    readonly partialRight: typeof partialRight;
+    readonly pipe: PipeFn;
+    readonly pipeBuilder: PipeBuilderFn;
+    readonly compose: ComposeBuilderFn;
+    readonly pipeWith: typeof pipeWith;
+    readonly pipeAsync: typeof pipeAsync;
+    readonly composeAsync: typeof composeAsync;
+    readonly pipeK: typeof pipeK;
+    readonly composeK: typeof composeK;
+    readonly letIn: typeof letIn;
+    readonly map: {
+        <T, U>(fn: (value: T, index: number, array: readonly T[]) => U, arr: readonly T[]): U[];
+        <T, U>(fn: (value: T, index: number, array: readonly T[]) => U): (arr: readonly T[]) => U[];
+    };
+    readonly filter: {
+        <T, S extends T>(pred: (value: T, index: number, array: readonly T[]) => value is S, arr: readonly T[]): S[];
+        <T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): T[];
+        <T, S extends T>(pred: (value: T, index: number, array: readonly T[]) => value is S): (arr: readonly T[]) => S[];
+        <T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T[];
+    };
+    readonly reject: {
+        <T>(pred: (value: T, index: number, array: readonly T[]) => boolean, arr: readonly T[]): T[];
+        <T>(pred: (value: T, index: number, array: readonly T[]) => boolean): (arr: readonly T[]) => T[];
+    };
+    readonly reduce: {
+        <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U, init: U, arr: readonly T[]): U;
+        <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U, init: U): (arr: readonly T[]) => U;
+        <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U): {
+            (init: U, arr: readonly T[]): U;
+            (init: U): (arr: readonly T[]) => U;
+        };
+    };
+    readonly reduceRight: {
+        <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U, init: U, arr: readonly T[]): U;
+        <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U, init: U): (arr: readonly T[]) => U;
+        <T, U>(fn: (accumulator: U, value: T, index: number, array: readonly T[]) => U): {
+            (init: U, arr: readonly T[]): U;
+            (init: U): (arr: readonly T[]) => U;
+        };
+    };
+    readonly head: typeof head;
+    readonly tail: typeof tail;
+    readonly last: typeof last;
+    readonly init: typeof init;
+    readonly nth: typeof nth;
+    readonly take: typeof take;
+    readonly takeLast: typeof takeLast;
+    readonly takeWhile: typeof takeWhile;
+    readonly drop: typeof drop;
+    readonly dropLast: typeof dropLast;
+    readonly dropWhile: typeof dropWhile;
+    readonly slice: typeof slice;
+    readonly find: typeof find;
+    readonly findIndex: typeof findIndex;
+    readonly findLast: typeof findLast;
+    readonly indexOf: typeof indexOf;
+    readonly includes: typeof includes;
+    readonly flatten: typeof flatten;
+    readonly unnest: typeof flatten;
+    readonly chain: typeof chain;
+    readonly uniq: typeof uniq;
+    readonly uniqBy: typeof uniqBy;
+    readonly sort: typeof sort;
+    readonly sortBy: typeof sortBy;
+    readonly reverse: typeof reverse;
+    readonly groupBy: typeof groupBy;
+    readonly concat: typeof concat;
+    readonly append: typeof append;
+    readonly prepend: typeof prepend;
+    readonly zip: typeof zip;
+    readonly zipWith: typeof zipWith;
+    readonly zipObj: typeof zipObj;
+    readonly some: typeof some;
+    readonly every: typeof every;
+    readonly none: typeof none;
+    readonly length: typeof length;
+    readonly sum: typeof sum;
+    readonly product: typeof product;
+    readonly mean: typeof mean;
+    readonly median: typeof median;
+    readonly min: typeof min;
+    readonly max: typeof max;
+    readonly countBy: typeof countBy;
+    readonly range: typeof range;
+    readonly partition: typeof partition;
+    readonly splitEvery: typeof splitEvery;
+    readonly indexBy: typeof indexBy;
+    readonly prop: typeof prop;
+    readonly path: typeof path;
+    readonly propOr: typeof propOr;
+    readonly pathOr: typeof pathOr;
+    readonly props: typeof props;
+    readonly pluck: typeof pluck;
+    readonly assoc: typeof assoc;
+    readonly assocPath: typeof assocPath;
+    readonly dissoc: typeof dissoc;
+    readonly dissocPath: typeof dissocPath;
+    readonly pick: typeof pick;
+    readonly omit: typeof omit;
+    readonly merge: typeof merge;
+    readonly mergeDeep: typeof mergeDeep;
+    readonly evolve: typeof evolve;
+    readonly applySpec: typeof applySpec;
+    readonly extend: typeof extend;
+    readonly keys: typeof keys;
+    readonly values: typeof values;
+    readonly entries: typeof entries;
+    readonly fromEntries: typeof fromEntries;
+    readonly equals: typeof equals;
+    readonly identical: typeof identical;
+    readonly gt: typeof gt;
+    readonly gte: typeof gte;
+    readonly lt: typeof lt;
+    readonly lte: typeof lte;
+    readonly not: typeof not;
+    readonly and: typeof and;
+    readonly or: typeof or;
+    readonly both: typeof both;
+    readonly either: typeof either;
+    readonly complement: typeof complement;
+    readonly allPass: typeof allPass;
+    readonly anyPass: typeof anyPass;
+    readonly ifElse: typeof ifElse;
+    readonly when: typeof when;
+    readonly unless: typeof unless;
+    readonly cond: typeof cond;
+    readonly tryCatch: typeof tryCatch;
+    readonly propEq: typeof propEq;
+    readonly propSatisfies: typeof propSatisfies;
+    readonly pathEq: typeof pathEq;
+    readonly pathSatisfies: typeof pathSatisfies;
+    readonly where: typeof where;
+    readonly whereEq: typeof whereEq;
+    readonly is: typeof is;
+    readonly isNil: typeof isNil;
+    readonly isEmpty: typeof isEmpty;
+    readonly isNotNil: typeof isNotNil;
+    readonly isNotEmpty: typeof isNotEmpty;
+    readonly defaultTo: typeof defaultTo;
+    readonly coalesce: typeof coalesce;
+    readonly add: typeof add;
+    readonly subtract: typeof subtract;
+    readonly multiply: typeof multiply;
+    readonly divide: typeof divide;
+    readonly modulo: typeof modulo;
+    readonly mathMod: typeof mathMod;
+    readonly negate: typeof negate;
+    readonly inc: typeof inc;
+    readonly dec: typeof dec;
+    readonly clamp: typeof clamp;
+    readonly abs: typeof abs;
+    readonly round: typeof round;
+    readonly floor: typeof floor;
+    readonly ceil: typeof ceil;
+    readonly pow: typeof pow;
+    readonly toUpper: typeof toUpper;
+    readonly toLower: typeof toLower;
+    readonly trim: typeof trim;
+    readonly split: typeof split;
+    readonly join: typeof join;
+    readonly replace: typeof replace;
+    readonly startsWith: typeof startsWith;
+    readonly endsWith: typeof endsWith;
+    readonly test: typeof test;
+    readonly match: typeof match;
+    readonly substring: typeof substring;
+    readonly padStart: typeof padStart;
+    readonly padEnd: typeof padEnd;
+    readonly concatStr: typeof concatStr;
+    readonly toString: typeof toString;
+    readonly toNumber: typeof toNumber;
+    readonly toBoolean: typeof toBoolean;
+    readonly toArray: typeof toArray;
+    readonly toObject: typeof toObject;
+    readonly type: typeof type;
+    readonly lens: typeof lens;
+    readonly lensProp: typeof lensProp;
+    readonly lensPath: typeof lensPath;
+    readonly lensIndex: typeof lensIndex;
+    readonly view: typeof view;
+    readonly set: typeof set;
+    readonly over: typeof over;
+    readonly mapAsync: typeof mapAsync;
+    readonly mapSerial: typeof mapSerial;
+    readonly filterAsync: typeof filterAsync;
+    readonly reduceAsync: typeof reduceAsync;
+    readonly mapT: typeof mapT;
+    readonly filterT: typeof filterT;
+    readonly takeT: typeof takeT;
+    readonly dropT: typeof dropT;
+    readonly composeT: typeof composeT;
+    readonly transduce: typeof transduce;
+    readonly into: typeof into;
+};
+
+export { type BinaryFn, type Comparator, type ComposeBuilderFn, type Curry1, type Curry2, type Curry3, type DeepReadonly, F, type Fn, type Head, type Last, type Lens, type Mapper, type Nullable, type ParamsOf, type PipeBuilderFn, type PipeFn, type PipeTransformer, type Placeholder, type Predicate, type Reducer, type ReturnOf, T$1 as T, type Tail, type TapFn, type TernaryFn, type Transducer, type Transformer, type UnaryFn, type VariadicFn, placeholder as __, abs, add, allPass, always, and, anyPass, append, applySpec, assoc, assocPath, both, ceil, chain, clamp, coalesce, complement, compose, composeAsync, composeK, composeT, concat, concatStr, cond, countBy, curry, curryN, dec, defaultTo, dissoc, dissocPath, divide, drop, dropLast, dropT, dropWhile, either, endsWith, entries, equals, every, evolve, extend, filter, filterAsync, filterT, find, findIndex, findLast, flatten, floor, fromEntries, groupBy, gt, gte, head, identical, identity, ifElse, inc, includes, indexBy, indexOf, init, into, is, isEmpty, isNil, isNotEmpty, isNotNil, isPlaceholder, join, keys, last, length, lens, lensIndex, lensPath, lensProp, letIn, lt, lte, map, mapAsync, mapSerial, mapT, match, mathMod, max, mean, median, merge, mergeDeep, min, modulo, multiply, negate, none, not, nth, omit, or, over, padEnd, padStart, partial, partialRight, partition, path, pathEq, pathOr, pathSatisfies, pick, pipe, pipeAsync, pipeBuilder, pipeK, pipeWith, pluck, pow, prepend, product, prop, propEq, propOr, propSatisfies, props, range, reduce, reduceAsync, reduceRight, reject, replace, reverse, round, scope, set, slice, some, sort, sortBy, split, splitEvery, startsWith, substring, subtract, sum, tail, take, takeLast, takeT, takeWhile, tap, test, toArray, toBoolean, toLower, toNumber, toObject, toString, toUpper, transduce, trim, tryCatch, type, uniq, uniqBy, unless, unnest, values, view, when, where, whereEq, zip, zipObj, zipWith };