xindex 1.0.0

package/packages/fun/src/speed-test.ts

@@ -0,0 +1,56 @@
+function uiTime(startedAt: number) {
+  return new Date(startedAt).toISOString();
+}
+
+export function SpeedTest({
+  name = '',
+  every = 1000,
+}: Partial<{ name: string; every: number | null }> = {}) {
+  let counter = 0;
+  let startedAt: number | null = null;
+  let trackedAt: number | null = null;
+
+  const log = (text: string) => console.log(text);
+
+  function textReport(finishedAt: number | null = null) {
+    const started = startedAt ? uiTime(startedAt) : null;
+    const elapsed = startedAt && trackedAt ? trackedAt - startedAt : null;
+
+    const RPM = counter && elapsed ? Math.round(counter / (elapsed / 60_000)) : null;
+
+    const RPS = counter && elapsed ? Math.round(counter / (elapsed / 1000)) : null;
+
+    const finished = finishedAt ? uiTime(finishedAt) : null;
+    const tracked = trackedAt ? uiTime(trackedAt) : null;
+
+    const named = `${name ? `SpeedTest: ${name}; ` : ''}`;
+
+    return `${named}RPS: ${RPS ?? 'N/A'}; RPM: ${RPM ?? 'N/A'}; Counter: ${counter ?? 'N/A'}; Started: ${started ?? 'N/A'}; Elapsed: ${elapsed ?? 'N/A'}; Tracked: ${tracked ?? 'N/A'}; Finished: ${finished ?? 'N/A'}`;
+  }
+
+  const speedTest = {
+    track: (n: number = 1) => {
+      if (!startedAt) {
+        startedAt = Date.now();
+      }
+
+      trackedAt = Date.now();
+
+      counter += n;
+
+      if (every !== null) {
+        if (counter % every === 0) {
+          log(textReport());
+        }
+      }
+    },
+    report: () => {
+      log(textReport(Date.now()));
+    },
+    toString: () => {
+      return textReport(Date.now());
+    },
+  };
+
+  return speedTest;
+}

package/packages/fun/src/tick.ts

@@ -0,0 +1,37 @@
+import { Defer } from './defer';
+
+type ITickSyncRunner = () => any;
+type ITickRunner = () => Promise<any> | any;
+
+export type ITick = (fn: ITickSyncRunner) => void;
+
+function isObject(x: any) {
+  return x instanceof Object;
+}
+
+function isFunction(x: any) {
+  return x instanceof Function;
+}
+
+export function SyncTick(): ITick {
+  return (fn: ITickSyncRunner) => {
+    setTimeout(fn, 0);
+  };
+}
+
+export const syncTick = SyncTick();
+
+export async function tick(fn: ITickRunner) {
+  const defer = Defer();
+
+  syncTick(async () => {
+    try {
+      await fn();
+      defer.resolve();
+    } catch (e) {
+      defer.reject(e);
+    }
+  });
+
+  await defer.promise;
+}

package/packages/fun/src/time-behavior.ts

@@ -0,0 +1,50 @@
+import { IValue, Value } from './value';
+
+export function throttleTrailing<T>(fn: Function, ms: IValue<number>): () => void {
+  let scheduled = false;
+  let calledAfterScheduling = false;
+  const delayMs = Value<number>(ms);
+
+  const aThrottle = () => {
+    if (scheduled) {
+      calledAfterScheduling = true;
+      return;
+    }
+
+    scheduled = true;
+
+    setTimeout(() => {
+      try {
+        fn();
+      } catch {
+      } finally {
+        scheduled = false;
+
+        if (calledAfterScheduling) {
+          calledAfterScheduling = false;
+          aThrottle();
+        }
+      }
+    }, delayMs());
+  };
+
+  return aThrottle;
+}
+
+export function debounceTrailing<T>(fn: () => any, ms: IValue<number>): () => void {
+  const delayMs = Value<number>(ms);
+
+  let timer: any;
+
+  return () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+
+    timer = setTimeout(() => {
+      timer = undefined;
+      fn();
+    }, delayMs());
+  };
+}

package/packages/fun/src/time.ts

@@ -0,0 +1,22 @@
+export function UTCDate() {
+  const date = new Date();
+
+  const utc = Date.UTC(
+    date.getUTCFullYear(),
+    date.getUTCMonth(),
+    date.getUTCDate(),
+    date.getUTCHours(),
+    date.getUTCMinutes(),
+    date.getUTCSeconds()
+  );
+
+  return new Date(utc);
+}
+
+export function UTCTime() {
+  return UTCDate().getTime();
+}
+
+export function offsetDate(now: Date, offsetMs: number): Date {
+  return new Date(now.getTime() + offsetMs);
+}

package/packages/fun/src/timedFallback.ts

@@ -0,0 +1,37 @@
+import { Defer } from './defer';
+
+export type MayBeAsync<Type = any> = Type | Promise<Type>;
+
+type ITimedFallback<Target = any, Fallback = any> = (
+  resolver: () => MayBeAsync<Target>
+) => Promise<Target | Fallback>;
+
+export function TimedFallback<Target, Fallback = Target>(
+  timeout: number,
+  fallback: () => MayBeAsync<Fallback>
+): ITimedFallback<Target, Fallback> {
+  return async (resolver: () => MayBeAsync<Target>) => {
+    const defer = Defer<Target | Fallback>();
+
+    const timerRef = setTimeout(async function () {
+      try {
+        defer.resolve(await fallback());
+      } catch (error) {
+        defer.reject(error);
+      }
+    }, timeout);
+
+    setTimeout(async () => {
+      try {
+        const result = await resolver();
+        clearTimeout(timerRef);
+        defer.resolve(result);
+      } catch (error) {
+        clearTimeout(timerRef);
+        defer.reject(error);
+      }
+    }, 0);
+
+    return defer.promise;
+  };
+}

package/packages/fun/src/timer.ts

@@ -0,0 +1,30 @@
+export type ITimerInterface = {
+  start(fn: () => any): void;
+  stop(): void;
+};
+
+export function Timer(timeout: number | undefined | null): ITimerInterface {
+  let ref: any;
+
+  function start(fn: () => any) {
+    if (ref) {
+      stop();
+    }
+
+    if (Number.isInteger(timeout)) {
+      ref = setTimeout(fn, timeout!);
+    }
+  }
+
+  function stop() {
+    if (ref) {
+      clearTimeout(ref);
+    }
+    ref = null;
+  }
+
+  return {
+    start,
+    stop,
+  };
+}

package/packages/fun/src/value.ts

@@ -0,0 +1,33 @@
+import { ISyncPubSub, SyncPubSub } from './pubsub';
+
+const ValueSymbol = Symbol('ValueSymbol');
+type IValueSymbol = typeof ValueSymbol;
+
+export type IValueInstance<T> = ((value?: T | IValueSymbol) => T) & {
+  subscribe: ISyncPubSub<T>['subscribe'];
+};
+
+export type IValue<T> = T | IValueInstance<T>;
+
+export function Value<T>(defaults: T | Function | IValueInstance<T>): IValueInstance<T> {
+  if (defaults instanceof Function) {
+    return defaults as IValueInstance<T>;
+  }
+
+  let value: T = defaults as T;
+
+  const topic = SyncPubSub<T>();
+
+  const valueInstance = (_value: T | IValueSymbol = ValueSymbol) => {
+    if (_value !== ValueSymbol) {
+      value = _value;
+      topic.publish(value);
+    }
+
+    return value;
+  };
+
+  valueInstance.subscribe = topic.subscribe;
+
+  return valueInstance;
+}

package/packages/fun/src/waitForCounter.ts

@@ -0,0 +1,15 @@
+import { ICounter } from './counter';
+import { waitForMessage } from './pubsub';
+
+export async function waitForCounter(
+  counter: ICounter,
+  isTrue: (counter: ICounter) => boolean
+): Promise<void> {
+  if (!isTrue(counter)) {
+    await waitForMessage(counter.subscribe, () => isTrue(counter));
+  }
+}
+
+export async function waitForZeroCounter(counter: ICounter) {
+  return waitForCounter(counter, counter => counter.value() <= 0);
+}

package/packages/streamx/src/batch.ts

@@ -0,0 +1,23 @@
+import { StreamX, StreamXMapper } from './index';
+
+export function batch<Input>(size: number): StreamXMapper<Input, Input[]> {
+  let batched: Input[] = [];
+  return inputStream =>
+    (async function* batchedStream(): StreamX<Input[]> {
+      for await (const record of inputStream) {
+        batched.push(record);
+
+        if (batched.length >= size) {
+          const toEmit = batched;
+          batched = [];
+          yield toEmit;
+        }
+      }
+
+      if (batched.length) {
+        const toEmit = batched;
+        batched = [];
+        yield toEmit;
+      }
+    })();
+}

package/packages/streamx/src/batchTimed.ts

@@ -0,0 +1,113 @@
+import { StreamXMapper } from './index';
+import { IRead, read } from './reader';
+import { IWriter, Writer } from './writer';
+import { syncTick } from '@handy/fun/tick';
+import { clearTimeout } from 'timers';
+
+type Milliseconds = number;
+
+export function batchTimed<Input>(
+  size: number,
+  maxTimeout: Milliseconds
+): StreamXMapper<Input, Input[]> {
+  let outputBuffer: IWriter<Input[]>;
+  let readInput: IRead<Input>;
+  let readOutput: IRead<Input[]>;
+  let _error: Error | undefined = undefined;
+  let batch: Input[] = [];
+  let flushTimeout: any;
+
+  async function finish() {
+    await flush();
+    if (outputBuffer) {
+      await outputBuffer.finish();
+    }
+  }
+
+  async function flush() {
+    if (outputBuffer) {
+      if (batch.length) {
+        const currentBatch: Input[] = [...batch];
+        batch = [];
+        await outputBuffer.write(currentBatch);
+      }
+    }
+  }
+
+  function clearFlushTimeout() {
+    if (flushTimeout) {
+      clearTimeout(flushTimeout);
+      flushTimeout = null;
+    }
+  }
+
+  return inputStream => {
+    return {
+      [Symbol.asyncIterator](): AsyncIterator<Input[]> {
+        return {
+          async next(): Promise<IteratorResult<Input[]>> {
+            if (_error) {
+              throw _error;
+            }
+
+            if (!readInput) {
+              readInput = read<Input>(inputStream);
+            }
+
+            if (!outputBuffer) {
+              outputBuffer = Writer<Input[]>();
+              syncTick(async () => {
+                while (true) {
+                  try {
+                    const inputValue = await readInput();
+                    if (inputValue === read.DONE) {
+                      // process finished
+                      await finish();
+                      break;
+                    } else {
+                      // new incoming data
+                      batch.push(inputValue);
+
+                      clearFlushTimeout();
+
+                      flushTimeout = setTimeout(async () => {
+                        try {
+                          await flush();
+                        } catch (error) {
+                          _error = error as Error;
+                        }
+                      }, maxTimeout);
+
+                      if (batch.length >= size) {
+                        await flush();
+                      }
+                    }
+                  } catch (error) {
+                    _error = error as Error;
+                    await finish();
+                  }
+                }
+              });
+            }
+
+            if (!readOutput) {
+              readOutput = read<Input[]>(outputBuffer.stream);
+            }
+
+            const output = await readOutput();
+
+            if (_error) {
+              throw _error;
+            }
+
+            if (output === read.DONE) {
+              return { done: true, value: undefined };
+            } else {
+              return { done: false, value: output };
+            }
+          },
+        };
+      },
+    };
+  };
+}

package/packages/streamx/src/buffer.ts

@@ -0,0 +1,72 @@
+import { StreamX, StreamXMapper } from './index';
+import { IRead, read } from './reader';
+import { IWriter, Writer } from './writer';
+import { syncTick } from '@handy/fun/tick';
+
+export function buffer<Input>(size: number): StreamXMapper<Input, Input> {
+  let outputBuffer: IWriter<Input>;
+  let readInput: IRead<Input>;
+  let readOutput: IRead<Input>;
+  let _error: Error | undefined = undefined;
+
+  async function finish() {
+    if (outputBuffer) {
+      await outputBuffer.finish();
+    }
+  }
+
+  return (inputStream: StreamX<Input>) => {
+    return {
+      [Symbol.asyncIterator](): AsyncIterator<Input> {
+        return {
+          async next(): Promise<IteratorResult<Input>> {
+            if (_error) {
+              throw _error;
+            }
+
+            if (!readInput) {
+              readInput = read<Input>(inputStream);
+            }
+
+            if (!outputBuffer) {
+              outputBuffer = Writer<Input>(size);
+
+              syncTick(async () => {
+                while (true) {
+                  try {
+                    const inputValue = await readInput();
+                    if (inputValue === read.DONE) {
+                      await finish();
+                      break;
+                    } else {
+                      await outputBuffer.write(inputValue);
+                    }
+                  } catch (error) {
+                    _error = error as Error;
+                    await finish();
+                  }
+                }
+              });
+            }
+
+            if (!readOutput) {
+              readOutput = read<Input>(outputBuffer.stream);
+            }
+
+            const output = await readOutput();
+
+            if (_error) {
+              throw _error;
+            }
+
+            if (output === read.DONE) {
+              return { done: true, value: undefined };
+            } else {
+              return { done: false, value: output };
+            }
+          },
+        };
+      },
+    };
+  };
+}

package/packages/streamx/src/concatenate.ts

@@ -0,0 +1,33 @@
+import { StreamX } from './index';
+
+export function concatenate<T>(...streams: StreamX<T>[]): StreamX<T>;
+
+export function concatenate<T1, T2, T3, T4, T5>(
+  stream1: StreamX<T1>,
+  stream2: StreamX<T2>,
+  stream3: StreamX<T3>,
+  stream4: StreamX<T4>,
+  stream5: StreamX<T5>
+): StreamX<T1 | T2 | T3 | T4 | T5>;
+export function concatenate<T1, T2, T3, T4>(
+  stream1: StreamX<T1>,
+  stream2: StreamX<T2>,
+  stream3: StreamX<T3>,
+  stream4: StreamX<T4>
+): StreamX<T1 | T2 | T3 | T4>;
+export function concatenate<T1, T2, T3>(
+  stream1: StreamX<T1>,
+  stream2: StreamX<T2>,
+  stream3: StreamX<T3>
+): StreamX<T1 | T2 | T3>;
+export function concatenate<T1, T2>(
+  stream1: StreamX<T1>,
+  stream2: StreamX<T2>
+): StreamX<T1 | T2>;
+export function concatenate<T>(...streams: StreamX<any>[]): StreamX<T> {
+  return (async function* concatenateStreams(): StreamX<T> {
+    for await (const stream of streams) {
+      yield* stream;
+    }
+  })();
+}

package/packages/streamx/src/filter.ts

@@ -0,0 +1,14 @@
+import { Promised, StreamX, StreamXMapper } from './index';
+
+export function filter<Input>(
+  condition: (input: Input) => Promised<boolean | undefined | null>
+): StreamXMapper<Input, Input> {
+  return inputStream =>
+    (async function* filtered(): StreamX<Input> {
+      for await (const record of inputStream) {
+        if (await condition(record)) {
+          yield record;
+        }
+      }
+    })();
+}

package/packages/streamx/src/flat.ts

@@ -0,0 +1,19 @@
+import { StreamX, StreamXLike, StreamXMapper } from './index';
+
+export function flat<Type>(): StreamXMapper<Type | StreamXLike<Type>, Type> {
+  return inputStream =>
+    (async function* flatStream(): StreamX<Type> {
+      for await (const record of inputStream) {
+        if (
+          record instanceof Object &&
+          (Array.isArray(record) || Symbol.iterator in record || Symbol.asyncIterator in record)
+        ) {
+          for await (const element of record) {
+            yield element;
+          }
+        } else {
+          yield record;
+        }
+      }
+    })();
+}

package/packages/streamx/src/flatMap.ts

@@ -0,0 +1,9 @@
+import { flat } from './flat';
+import { map } from './map';
+import { pipe, Promised, StreamXLike, StreamXMapper } from './index';
+
+export function flatMap<Input, Output>(
+  mapper: (input: Input) => Promised<Output | StreamXLike<Output>>
+): StreamXMapper<Input, Output> {
+  return pipe(map(mapper)).pipe(flat());
+}

package/packages/streamx/src/from.ts

@@ -0,0 +1,30 @@
+import { of, StreamX, StreamXLike, StreamXOf } from './index';
+
+export function isStreamXLike(stream: any): stream is StreamXLike<any> {
+  return (
+    stream != null &&
+    ((stream instanceof Object && Symbol.asyncIterator in stream) ||
+      (stream instanceof Object && Symbol.iterator in stream))
+  );
+}
+
+export function toStreamX<Input>(stream: StreamXLike<Input>): StreamX<Input> {
+  if (stream instanceof Object && Symbol.asyncIterator in stream) {
+    return stream;
+  } else if (stream instanceof Object && Symbol.iterator in stream) {
+    return {
+      [Symbol.asyncIterator]: () => {
+        const syncIterator = stream[Symbol.iterator]();
+        return {
+          next: async () => syncIterator.next(),
+        };
+      },
+    };
+  } else {
+    throw new Error(`${typeof stream}, is not iterable`);
+  }
+}
+
+export function from<Input>(streamLike: StreamXLike<Input>): StreamXOf<Input> {
+  return of(toStreamX<Input>(streamLike));
+}

package/packages/streamx/src/index.ts

@@ -0,0 +1,49 @@
+// types
+
+export type StreamX<Type> = AsyncIterable<Type>;
+export type StreamXOf<Input> = StreamX<Input> & {
+  pipe<Output>(mapper: StreamXMapper<Input, Output>): StreamXOf<Output>;
+};
+export type StreamXLike<Type> = AsyncIterable<Type> | Iterable<Type> | Type[];
+export type StreamXMapper<Input, Output> = (
+  stream: StreamX<Input>
+) => StreamX<Output>;
+export type Promised<Type> = Type | Promise<Type>;
+
+export type StreamXPlumber<In, Out> = StreamXMapper<In, Out> & {
+  pipe<Output>(mapper: StreamXMapper<Out, Output>): StreamXPlumber<In, Output>;
+};
+
+// of
+export function of<Input>(inputStream: StreamX<Input>): StreamXOf<Input> {
+  return {
+    [Symbol.asyncIterator]: () => inputStream[Symbol.asyncIterator](),
+    pipe<Output>(mapper: StreamXMapper<Input, Output>): StreamXOf<Output> {
+      return of(mapper(inputStream));
+    },
+  };
+}
+
+export function pipe<In, Out>(mapper: StreamXMapper<In, Out>): StreamXPlumber<In, Out> {
+  const streamMapper: StreamXMapper<In, Out> = (input: StreamX<In>) => mapper(input);
+
+  // @ts-ignore
+  streamMapper.pipe = <Output>(mapper: StreamXMapper<Out, Output>) => {
+    return pipe<In, Output>((input: StreamX<In>) => {
+      const nextStream = streamMapper(input);
+      return mapper(nextStream);
+    });
+  };
+  return streamMapper as StreamXPlumber<In, Out>;
+}
+
+export async function run<Type, Default = undefined>(
+  stream: StreamX<Type>,
+  defaultValue = undefined as Default
+): Promise<Type | Default> {
+  let value: Type | Default = defaultValue;
+  for await (const record of stream) {
+    value = record;
+  }
+  return value;
+}