@limitlesspc/std 0.20.2

package/dist/iter/index.d.ts

@@ -0,0 +1,226 @@
+import { AnyRecord, uint, Repeat, NonFalsy, int } from '../types.js';
+
+declare const associateBy: {
+    <T extends AnyRecord, K extends keyof T>(first: Iterable<T>, key: K): Map<T[K], T>;
+    <T extends AnyRecord, K extends keyof T>(key: K): (first: Iterable<T>) => Map<T[K], T>;
+};
+
+/**
+ * Runs through all the iterables in order, yielding each value in turn
+ * @param iterables
+ */
+declare function chain<T>(...iterables: Array<Iterable<T>>): Iterator<T>;
+
+/**
+ * Splits an iterable into equally-sized sub arrays
+ * @param iter
+ * @param size the length of each chunk
+ * @returns the chunks
+ */
+declare const chunk: {
+    <T, N extends uint>(first: Iterable<T>, size: N): Generator<Repeat<T, N>>;
+    <T, N extends uint>(size: N): (first: Iterable<T>) => Generator<Repeat<T, N>>;
+};
+
+/**
+ * Collects the items in an iterable into an array
+ * @param iter
+ * @returns an array of the items in the iterable
+ */
+declare function collect<T>(iter: Iterable<T>): T[];
+
+/**
+ * Counts the number of values from an iterable
+ * @param iter
+ */
+declare function count<T>(iter: Iterable<T>): uint;
+
+/**
+ * Loops an iterable infinitely
+ * @param iter
+ */
+declare function cycle<T>(iter: Iterable<T>): Iterator<T>;
+
+declare function enumerate<T>(iter: Iterable<T>): Generator<[number, T]>;
+
+/**
+ * Checks if every item in an iterable passes a `predicate`
+ * @param iter
+ * @param predicate a function to test each item
+ */
+declare const every: {
+    <T>(iter: Iterable<T>, predicate: (item: T) => unknown): boolean;
+    <T>(predicate: (item: T) => unknown): (iter: Iterable<T>) => boolean;
+};
+
+/**
+ * Allows values from an iterable based on a predicate function
+ * @param iter
+ * @param predicate a function that filters based on the truthiness of the return value
+ */
+declare const filter: {
+    <T>(iter: Iterable<T>, predicate: BooleanConstructor): Generator<NonFalsy<T>>;
+    <T>(predicate: BooleanConstructor): (iter: Iterable<T>) => Generator<NonFalsy<T>>;
+    <T, S extends T>(iter: Iterable<T>, predicate: (value: T) => value is S): Generator<S>;
+    <T, S extends T>(predicate: (value: T) => value is S): (iter: Iterable<T>) => Generator<S>;
+    <T>(iter: Iterable<T>, predicate: (value: T) => unknown): Generator<T>;
+    <T>(predicate: (value: T) => unknown): (iter: Iterable<T>) => Generator<T>;
+};
+declare const filterByKey: {
+    <T extends AnyRecord>(iter: Iterable<T>, key: keyof T): Generator<T>;
+    <T extends AnyRecord>(key: keyof T): (iter: Iterable<T>) => Generator<T>;
+};
+
+/**
+ * Returns the first value of an iterable
+ * @param iter
+ */
+declare function first<T>(iter: Iterable<T>): T | undefined;
+
+declare const groupBy: {
+    <T extends AnyRecord, K extends keyof T>(first: Iterable<T>, key: K): Map<T[K], T[]>;
+    <T extends AnyRecord, K extends keyof T>(key: K): (first: Iterable<T>) => Map<T[K], T[]>;
+};
+
+/**
+ * Inserts a `separator` value between each value of the iterable
+ * @param iter
+ * @param separator the value to insert between each value of the iterable
+ */
+declare const intersperse: {
+    <T, U>(first: Iterable<T>, separator: U): Generator<T | U>;
+    <T, U>(separator: U): (first: Iterable<T>) => Generator<T | U>;
+};
+
+/**
+ * Gets the last value of an iterable
+ * @param iter
+ */
+declare function last<T>(iter: Iterable<T>): T | undefined;
+
+declare const map: {
+    <T, U>(iter: Iterable<T>, fn: (value: T) => U): Generator<U>;
+    <T, U>(fn: (value: T) => U): (iter: Iterable<T>) => Generator<U>;
+};
+
+/**
+ * Gets a certain value from an iterable based on sequence number
+ * @param iter
+ * @param n a zero-based index
+ */
+declare const nth: {
+    <T>(iter: Iterable<T>, n: uint): T;
+    <T>(n: uint): (iter: Iterable<T>) => T;
+};
+
+/**
+ * Splits an iterable into two halves based on a condition
+ * @param iter
+ * @param predicate a function to test each item
+ * @returns a tuple with items that either pass or fail the `predicate`
+ */
+declare const partition: {
+    <T>(iter: Iterable<T>, predicate: BooleanConstructor): [pass: Array<NonFalsy<T>>, fail: T[]];
+    <T>(predicate: BooleanConstructor): (iter: Iterable<T>) => [pass: Array<NonFalsy<T>>, fail: T[]];
+    <T, S extends T>(iter: Iterable<T>, predicate: (value: T) => value is S): [pass: S[], fail: T[]];
+    <T, S extends T>(predicate: (value: T) => value is S): (iter: Iterable<T>) => [pass: S[], fail: T[]];
+    <T>(iter: Iterable<T>, predicate: (value: T) => unknown): [pass: T[], fail: T[]];
+    <T>(predicate: (value: T) => unknown): (iter: Iterable<T>) => [pass: T[], fail: T[]];
+};
+
+/**
+ * Using an iterable of objects, extract part of each object
+ * @param iter
+ * @param keys an array of keys in each object or a single key
+ * @returns the iterator of object only containing the keys specified
+ */
+declare const pick: {
+    <T extends AnyRecord, K extends keyof T>(iter: Iterable<T>, key: K): Generator<T[K]>;
+    <T extends AnyRecord, K extends keyof T>(key: K): (iter: Iterable<T>) => Generator<T[K]>;
+    <T extends AnyRecord, K extends keyof T>(iter: Iterable<T>, keys: K[]): Generator<Pick<T, K>>;
+    <T extends AnyRecord, K extends keyof T>(keys: K[]): (iter: Iterable<T>) => Generator<Pick<T, K>>;
+};
+
+declare function range(max: int): Generator<int>;
+declare function range(min: number, max: number, step?: number): Generator<number>;
+
+/**
+ * Skips over the first `n` values of an iterable
+ * @param iter
+ * @param n number of values to skip over
+ */
+declare const skip: {
+    <T>(iter: Iterable<T>, n: uint): Generator<T>;
+    <T>(n: uint): (iter: Iterable<T>) => Generator<T>;
+};
+
+declare const slidingWindow: {
+    <T>(iter: Iterable<T>, { size, partial }: {
+        size: uint;
+        partial?: boolean;
+    }): Generator<T[]>;
+    <T>({ size, partial, }: {
+        size: uint;
+        partial?: boolean;
+    }): (iter: Iterable<T>) => Generator<T[]>;
+};
+
+/**
+ * Checks if one of the items in an iterable passes a `predicate`
+ * @param iter
+ * @param predicate a function to test each item
+ */
+declare const some: {
+    <T>(iter: Iterable<T>, predicate: (item: T) => unknown): boolean;
+    <T>(predicate: (item: T) => unknown): (iter: Iterable<T>) => boolean;
+};
+
+/**
+ * Take the first n values from an iterable
+ * @param iter
+ * @param n number of values to take
+ */
+declare const take: {
+    <T>(iter: Iterable<T>, n: uint): Generator<T>;
+    <T>(n: uint): (iter: Iterable<T>) => Generator<T>;
+};
+
+/**
+ * Calls a function on each value of an iterable without modifying
+ * @param iter
+ * @param fn a function to call on each value
+ */
+declare const tap: {
+    <T>(iter: Iterable<T>, fn: (value: T) => unknown): Generator<T>;
+    <T>(fn: (value: T) => unknown): (iter: Iterable<T>) => Generator<T>;
+};
+
+/**
+ * Returns a tuple of iterables, which all yield the same items as the original iterable
+ * @param iter
+ */
+declare const tee: {
+    <T, N extends number = 2>(first: Iterable<T>, n?: N): Repeat<IterableIterator<T>, N>;
+    <T, N extends number = 2>(n?: N): (first: Iterable<T>) => Repeat<IterableIterator<T>, N>;
+};
+
+declare const unique: {
+    <T>(iter: Iterable<T>): Generator<T>;
+    <T>(): (iter: Iterable<T>) => Generator<T>;
+};
+declare const uniqueBy: {
+    <T, U>(iter: Iterable<T>, keyFn: (value: T) => U): Generator<T>;
+    <T, U>(keyFn: (value: T) => U): (iter: Iterable<T>) => Generator<T>;
+};
+
+declare const unzip: {
+    <T, U>(iterable: Iterable<readonly [T, U]>): [T[], U[]];
+    <T, U>(): (iterable: Iterable<readonly [T, U]>) => [T[], U[]];
+};
+
+declare const zip: {
+    <T, U>(iterable1: Iterable<T>, iterable2: Iterable<U>): Generator<[T, U]>;
+    <T, U>(iterable2: Iterable<U>): (iterable1: Iterable<T>) => Generator<[T, U]>;
+};
+
+export { associateBy, chain, chunk, collect, count, cycle, enumerate, every, filter, filterByKey, first, groupBy, intersperse, last, map, nth, partition, pick, range, skip, slidingWindow, some, take, tap, tee, unique, uniqueBy, unzip, zip };

package/dist/iter/index.js

@@ -0,0 +1,65 @@
+import {
+  associateBy,
+  chain,
+  chunk,
+  collect,
+  count,
+  cycle,
+  enumerate,
+  every,
+  filter,
+  filterByKey,
+  first,
+  groupBy,
+  intersperse,
+  last,
+  map,
+  nth,
+  partition,
+  pick,
+  range,
+  skip,
+  slidingWindow,
+  some,
+  take,
+  tap,
+  tee,
+  unique,
+  uniqueBy,
+  unzip,
+  zip
+} from "../chunk-WBSY6KRH.js";
+import "../chunk-MG5VQSTV.js";
+import "../chunk-6F4PWJZI.js";
+import "../chunk-LJSF3QBT.js";
+export {
+  associateBy,
+  chain,
+  chunk,
+  collect,
+  count,
+  cycle,
+  enumerate,
+  every,
+  filter,
+  filterByKey,
+  first,
+  groupBy,
+  intersperse,
+  last,
+  map,
+  nth,
+  partition,
+  pick,
+  range,
+  skip,
+  slidingWindow,
+  some,
+  take,
+  tap,
+  tee,
+  unique,
+  uniqueBy,
+  unzip,
+  zip
+};