Added types

lib/functional.d.ts

@@ -0,0 +1,48 @@
+
+type Combinations<A extends Array<any>, Acc extends Array<any> = []> =
+  A extends [a: infer A, ...rest: infer Rest]
+  ? [[...Acc, A], ...Combinations<Rest, [...Acc, A]>]
+  : []
+
+type Curried<T extends (...args: any) => any, LeftArgs extends Array<any> = [Parameters<T>[0]]> =
+  T extends (...args: LeftArgs) => any
+  ? T
+  : T extends (...args: [...LeftArgs, ...infer V]) => infer R
+    ? (...args: LeftArgs) => Curried<(...args: V) => R, LeftArgs>
+    : T extends (a: infer A) => infer R
+      ? (arg_last: A) => R
+      : T extends (a: infer A, ...rest: infer V) => infer R
+        ? ((arg_inner: A) => Curried<(...args: V) => R, LeftArgs>)
+        : never
+
+type CurriedVariants<
+    T extends (...args: any) => any,
+    C extends any[][] = Combinations<Parameters<T>>
+> = T extends () => any
+    ? [T]
+    : { [Cn in keyof C]: Curried<T, Extract<C[Cn], C[number]>>};
+
+type Named<QueryKey extends string, Value> = {
+  [key in QueryKey]: Value;
+}
+
+type NamedCurriedVariants<Name extends string, T extends (...args: any) => any, V = CurriedVariants<T>> =
+  { [C in keyof V]: C extends `${number}` ? Named<Name, V[C]> : never };
+
+type UnionToIntersection<U> = 
+  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never
+
+type InterfaceValues<T> = T extends Record<any, infer Inner> ? Inner : never;
+
+type ToFunctional<Func, ExtraArg> = Func extends (...a: infer U) => infer R ? (...a: [...U, ExtraArg]) => R: never;
+
+type Functions = {
+  [x: string]: (...args: any) => any
+};
+
+export type Typify<T> = { [ K in keyof T ]: T[K] };
+
+export type Functionalify<T extends Typify<Functions>, ExtraArg> =
+  UnionToIntersection<InterfaceValues<{
+    [K in keyof T]: UnionToIntersection<NamedCurriedVariants<Extract<K, string>, ToFunctional<T[K], ExtraArg>>[number]>
+}>>

lib/index.d.ts

@@ -0,0 +1,67 @@
+type MapFn<T, R> = (value: T) => R;
+
+type FlatChannel<T, Depth extends number> = {
+  "done": T,
+  "recur": T extends ReadChannel<infer InnerT>
+      ? FlatChannel<InnerT, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]>
+      : T
+}[Depth extends -1 ? "done" : "recur"];
+
+interface CancelablePromise<T> extends Promise<T> {
+  cancel(): void;
+}
+
+interface OrderPromise<C, T> extends CancelablePromise<T> {
+  channel: C;
+  prethen(onFulfilled: (value: C) => void): void;
+}
+type UnwrapOrderPromise<A> = A extends OrderPromise<any, infer T> ? T : never 
+
+export interface ReadChannel<T> {
+  concat<C extends ReadChannel<T>>(...values: (T | C)[]): C;
+  every(callback: (value: T) => boolean, thisArg?: any): Promise<boolean>;
+  filter(callback: (value: T) => boolean, thisArg?: any): ReadWriteChannel<T>;
+  flat<D extends number = 1>(depth?: D): ReadWriteChannel<FlatChannel<T, D>>;
+  flatMap<R>(mapperFunction: MapFn<T, R | R[]>, thisArg?: any): ReadWriteChannel<R>;
+  forEach(callbackfn: (value: T) => void, thisArg?: any): Promise<void>;
+  join(separator?: string): Promise<string>;
+  map<R>(mapperFunction: MapFn<T, R>, thisArg?: any): ReadWriteChannel<R>;
+  readOnly(): ReadChannel<T>;
+  reduce(callbackfn: (prev: any, next: T) => any, initialValue?: any): Promise<any>;
+  shift(): OrderPromise<this, T>;
+  slice(start?: number, end?: number): ReadWriteChannel<T>;
+  some(callbackfn: (value: T) => boolean, thisArg?: any): Promise<boolean>;
+  toString(): string;
+  value(): T;
+  values(): Promise<T[]>;
+}
+
+export interface WriteChannel<T> {
+  close(): void;
+  length(): number;
+  push(value: T): OrderPromise<this, number>;
+  writeOnly(): WriteChannel<T>;
+}
+
+export type ReadWriteChannel<T> = ReadChannel<T> & WriteChannel<T>;
+
+
+import { Functionalify, Typify } from './functional';
+// Ideally these would not be channels of `any`, but I couldn't find a way to pass on the generic arguments
+type FunctionalInterface =
+  Functionalify<Typify<ReadChannel<any>>, ReadChannel<any>> & Functionalify<Typify<WriteChannel<any>>, WriteChannel<any>>
+
+export type ChannelConstructor = {
+  <T>(length?: number): ReadWriteChannel<T>;
+  new <T>(length?: number): ReadWriteChannel<T>;
+  all<T>(...values: T[]): ReadWriteChannel<T>;
+  from<T, R = T>(iterable: Iterable<T>, mapfn?: MapFn<T, R>, thisArg?: any): ReadChannel<R>;
+  from<T>(callback: () => T): ReadChannel<T>;
+  of<T extends unknown[]>(...values: T): ReadChannel<T[number]>;
+  isChannel<T extends ReadChannel<any> | WriteChannel<any>>(channel: T): channel is T;
+  select<T extends OrderPromise<any, any>[]>(promises: T): CancelablePromise<ReadChannel<UnwrapOrderPromise<T[number]>>>;
+} & FunctionalInterface
+
+declare const Channel: ChannelConstructor;
+
+export default Channel;