xindex 1.0.0

package/packages/fun/src/concurrency.ts

@@ -0,0 +1,186 @@
+import { Counter, ICounter } from './counter';
+import { Defer, IDefer } from './defer';
+import { IValue, Value } from './value';
+import { waitForCounter, waitForZeroCounter } from './waitForCounter';
+
+export type IStopKeepConcurrency = () => Promise<void>;
+
+export function keepConcurrency(
+  quantity: IValue<number>,
+  fn: () => Promise<any>
+): IStopKeepConcurrency {
+  const desired = Value<number>(quantity);
+
+  const counter = Counter();
+  const unsubscribeCounter = counter.subscribe(handle);
+
+  let stopDefer: undefined | IDefer = undefined;
+  let stopping = false;
+
+  function handle() {
+    if (stopping) {
+      return;
+    }
+
+    if (counter.value() < desired()) {
+      void (async () => {
+        try {
+          counter.increment();
+          await fn();
+        } finally {
+          counter.decrement();
+        }
+      })();
+    }
+  }
+
+  handle();
+
+  return async function stop() {
+    stopping = true;
+
+    if (stopDefer) {
+      await stopDefer.promise;
+      return;
+    }
+
+    stopDefer = stopDefer || Defer();
+
+    if (counter.value() <= 0) {
+      stopDefer?.resolve();
+    } else {
+      const unsubscribe = counter.subscribe(() => {
+        if (counter.value() <= 0) {
+          stopDefer?.resolve();
+          unsubscribe();
+        }
+      });
+    }
+
+    await stopDefer.promise;
+    unsubscribeCounter();
+  };
+}
+
+export type IConcurrencyResultResolver<Output> = () => Promise<Output>;
+export type IPublishToConcurrency<Input, Output> = ((
+  message: Input
+) => Promise<IConcurrencyResultResolver<Output>>) & {
+  finish: () => Promise<void>;
+  counter: ICounter; // concurrency counter
+  quantity: ICounter; // queued quantity
+};
+
+export function Concurrency<T, ReturnType = any>(
+  maxConcurrency: IValue<number>,
+  worker: (message: T) => Promise<ReturnType>
+): IPublishToConcurrency<T, ReturnType> {
+  const max = Value<number>(maxConcurrency);
+  const concurrencyCounter = Counter();
+  const queuedQuantity = Counter();
+
+  let finishing = false;
+
+  function handle(message: T, defer: IDefer<any>) {
+    concurrencyCounter.increment();
+
+    void (async () => {
+      try {
+        defer.resolve(await worker(message));
+      } catch (error) {
+        defer.reject(error);
+      } finally {
+        concurrencyCounter.decrement();
+        queuedQuantity.decrement();
+      }
+    })();
+  }
+
+  const canHandle = () => {
+    const maximum = max();
+
+    if (!maximum) {
+      return true;
+    } else {
+      return concurrencyCounter.value() < maximum;
+    }
+  };
+
+  async function tryToHandle(message: T, defer: IDefer<any>) {
+    if (canHandle()) {
+      handle(message, defer);
+    } else {
+      await waitForCounter(concurrencyCounter, canHandle);
+      void tryToHandle(message, defer);
+    }
+  }
+
+  const publish = async (message: T) => {
+    // if (finishing) {
+    //   throw new Error(`Finishing concurrency, publish is not allowed`);
+    // }
+
+    const defer = Defer<any>();
+    queuedQuantity.increment();
+
+    await tryToHandle(message, defer);
+
+    return async () => defer.promise;
+  };
+
+  publish.counter = concurrencyCounter;
+  publish.quantity = queuedQuantity;
+
+  publish.finish = async () => {
+    finishing = true;
+    await waitForZeroCounter(concurrencyCounter);
+    concurrencyCounter.reset();
+    finishing = false;
+  };
+
+  return publish;
+}
+
+type IKeyType = string | number | undefined;
+type IGetKey<T> = (message: T) => IKeyType | Promise<IKeyType>;
+type IKeyedConcurrencyOptions = {
+  workerConcurrency: IValue<number>;
+};
+
+export function KeyedConcurrency<Input, Output = any>(
+  maxConcurrency: IValue<number>,
+  getKey: IGetKey<Input>,
+  worker: (message: Input) => Promise<Output>,
+  // options
+  { workerConcurrency = 1 }: Partial<IKeyedConcurrencyOptions> = {}
+): IPublishToConcurrency<Input, Output> {
+  const registry: {
+    [key in string | number]: IPublishToConcurrency<Input, Output>;
+  } = {};
+
+  return Concurrency<Input>(maxConcurrency, async (message: Input) => {
+    const key = await getKey(message);
+
+    if (key === undefined) {
+      return worker(message);
+    } else {
+      if (!registry[key]) {
+        const keyedControl = Concurrency<Input>(workerConcurrency, worker);
+        registry[key] = keyedControl;
+
+        const unsubscribe = keyedControl.quantity.subscribe(value => {
+          if (value <= 0) {
+            unsubscribe();
+
+            if (registry[key]) {
+              delete registry[key];
+            }
+          }
+        });
+      }
+
+      const resolver = await registry[key](message);
+      return await resolver();
+    }
+  });
+}

package/packages/fun/src/container.ts

@@ -0,0 +1,86 @@
+export const ContainerDefinitionSymbol = Symbol('ContainerDefinitionSymbol');
+
+const TYPE_SERVICE = 'service';
+const TYPE_FACTORY = 'factory';
+
+export type IContainerServiceDefinition<Shape, ReturnType = void> = {
+  type: typeof TYPE_SERVICE;
+  factory: (box: Shape) => ReturnType;
+  [ContainerDefinitionSymbol]: true;
+};
+export type IContainerFactoryDefinition<Shape, ReturnType = void> = {
+  type: typeof TYPE_FACTORY;
+  factory: (box: Shape) => ReturnType;
+  [ContainerDefinitionSymbol]: true;
+};
+
+export type IContainerDefinition<Shape, ReturnType> =
+  | IContainerServiceDefinition<Shape, ReturnType>
+  | IContainerFactoryDefinition<Shape, ReturnType>;
+
+export type IContainerSpecDefinition<Shape, ReturnType> =
+  | ReturnType
+  | IContainerDefinition<Shape, ReturnType>;
+
+export type IContainerSpec<Shape extends object> = {
+  [P in keyof Shape]: IContainerSpecDefinition<Shape, Shape[P]>;
+};
+
+export function isContainerDefinition(definition: IContainerSpecDefinition<any, any>): boolean {
+  return definition instanceof Object && definition[ContainerDefinitionSymbol];
+}
+
+export function ContainerService<Shape = any, ReturnType = void>(
+  creator: (box: Shape) => ReturnType
+): IContainerServiceDefinition<Shape, ReturnType> {
+  let called = false;
+  let cachedValue: any = undefined;
+
+  return {
+    type: TYPE_SERVICE,
+
+    factory: box => {
+      if (called) {
+        return cachedValue;
+      }
+
+      called = true;
+      cachedValue = creator(box);
+
+      return cachedValue;
+    },
+
+    [ContainerDefinitionSymbol]: true,
+  };
+}
+
+export function ContainerFactory<Shape = any, ReturnType = void>(
+  creator: (box: Shape) => ReturnType
+): IContainerFactoryDefinition<Shape, ReturnType> {
+  return {
+    type: TYPE_FACTORY,
+    factory: creator,
+    [ContainerDefinitionSymbol]: true,
+  };
+}
+
+export function Container<Shape extends object>(containerSpec: IContainerSpec<Shape>): Shape {
+  const box: any = new Proxy<IContainerSpec<Shape>>(containerSpec, {
+    get: (target, prop) => {
+      if (prop in target) {
+        // @ts-ignore
+        const value: any = target[prop];
+
+        if (isContainerDefinition(value)) {
+          return (value as IContainerDefinition<any, any>).factory(box);
+        } else {
+          return value;
+        }
+      } else {
+        throw new Error(`No value: "${String(prop)}"`);
+      }
+    },
+  });
+
+  return box as Shape;
+}

package/packages/fun/src/counter.ts

@@ -0,0 +1,45 @@
+import { IPubSubSubscribe, SyncPubSub } from './pubsub';
+
+export type ICounter = {
+  increment: (n?: number) => number;
+  decrement: (n?: number) => number;
+  value: () => number;
+  subscribe: IPubSubSubscribe<number>;
+  reset: () => void;
+};
+
+export function Counter(): ICounter {
+  const topic = SyncPubSub<number>();
+  const { subscribe, publish } = topic;
+
+  let counter = 0;
+
+  function increment(n = 1) {
+    counter += n;
+    publish(counter);
+    return counter;
+  }
+
+  function decrement(n = 1) {
+    counter -= n;
+    publish(counter);
+    return counter;
+  }
+
+  function value() {
+    return counter;
+  }
+
+  function reset() {
+    counter = 0;
+    publish(0);
+  }
+
+  return {
+    increment,
+    decrement,
+    value,
+    subscribe,
+    reset,
+  };
+}

package/packages/fun/src/create-map.ts

@@ -0,0 +1,2 @@
+export const createMap = <Key, Item>(items: Item[], selector: (item: Item) => Key) =>
+  new Map(items.map(item => [selector(item), item]));

package/packages/fun/src/dedupe.ts

@@ -0,0 +1,2 @@
+export const dedupeValues = <T>(values: T[]): T[] =>
+  Array.from(new Set(values.map((v: T) => JSON.stringify(v)))).map((s: string) => JSON.parse(s));

package/packages/fun/src/defer.ts

@@ -0,0 +1,55 @@
+export type IDefer<ResultType = void> = {
+  promise: Promise<ResultType>;
+  resolved: boolean;
+  rejected: boolean;
+  pending: boolean;
+  resolve(value: ResultType | PromiseLike<ResultType>): void;
+  reject(reason?: unknown): void;
+};
+
+export function Defer<ResultType = void>(): IDefer<ResultType> {
+  const deferred = {
+    rejected: false,
+    resolved: false,
+    pending: true,
+  } as IDefer<ResultType>;
+
+  deferred.promise = new Promise<ResultType>((resolve, reject) => {
+    deferred.resolve = (data: any) => {
+      if (deferred.resolved || deferred.rejected) {
+        return;
+      }
+
+      deferred.pending = false;
+      deferred.resolved = true;
+      resolve(data);
+    };
+
+    deferred.reject = (error: any) => {
+      if (deferred.resolved || deferred.rejected) {
+        return;
+      }
+
+      deferred.pending = false;
+      deferred.rejected = true;
+      reject(error);
+    };
+  });
+
+  return deferred;
+}
+
+export type IDataDefer<DataType = any, ResultType = void> = IDefer<ResultType> & {
+  data: DataType;
+};
+
+export function DeferData<DataType = void, ResultType = void>(
+  data: DataType
+): IDataDefer<DataType, ResultType> {
+  const deferred = Defer<ResultType>();
+
+  return {
+    ...deferred,
+    data,
+  };
+}

package/packages/fun/src/delay.ts

@@ -0,0 +1,5 @@
+export function delay(ms: number): Promise<void> {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => resolve(), ms);
+  });
+}

package/packages/fun/src/discriminate.ts

@@ -0,0 +1,34 @@
+export function discriminate<K extends PropertyKey, V extends string | number | boolean>(
+  discriminantKey: K,
+  discriminantValue: V | V[]
+) {
+  return <T extends Record<K, any>>(
+    obj: T & Record<K, V extends T[K] ? T[K] : V>
+  ): obj is Extract<T, Record<K, V>> =>
+    Array.isArray(discriminantValue)
+      ? discriminantValue.includes(obj[discriminantKey])
+      : obj[discriminantKey] === discriminantValue;
+}
+
+export function discriminateAndFilter<
+  T extends Record<K, any>,
+  K extends PropertyKey,
+  V extends string | number | boolean,
+>(
+  discriminantKey: K,
+  discriminantValue: V | V[],
+  predicate: (item: Extract<T, Record<K, V>>) => boolean
+) {
+  return (obj: T & Record<K, V extends T[K] ? T[K] : V>): obj is Extract<T, Record<K, V>> =>
+    (Array.isArray(discriminantValue)
+      ? discriminantValue.includes(obj[discriminantKey])
+      : obj[discriminantKey] === discriminantValue) && predicate(obj as any);
+}
+
+type A = { type: 'a'; a: string };
+type B = { type: 'b'; b: string };
+type X = A | B;
+
+function test(x: X[]) {
+  const result = x.find(discriminateAndFilter('type', 'b', z => z.b === 'toto'));
+}

package/packages/fun/src/enum-values.ts

@@ -0,0 +1,12 @@
+export const getEnumValues = <T>(enumType: Record<string, T>) => {
+  const values = Object.values(enumType);
+  if (values.some(isNumber)) {
+    // Number-based enum
+    return values.filter(isNumber);
+  } else {
+    // String-based enum
+    return values;
+  }
+};
+
+const isNumber = (value: any) => !isNaN(Number(value));

package/packages/fun/src/exponential-backoff.ts

@@ -0,0 +1,20 @@
+import { assert } from 'console';
+
+// From https://www.tylercrosse.com/ideas/exponential-backoff/
+export function exponentialBackoff({
+  attempt,
+  baseDelay = 100,
+  maxDelay,
+}: {
+  attempt: number;
+  baseDelay: number;
+  maxDelay?: number;
+}) {
+  assert(attempt >= 1, `attempt must be greater than or equal to 1`);
+  assert(baseDelay >= 1, `baseDelay must be greater than or equal to 1`);
+  assert(maxDelay === undefined || maxDelay >= 1, `baseDelay must be greater than or equal to 1`);
+
+  const exponential = Math.pow(2, attempt) * baseDelay;
+  const delay = maxDelay ? Math.min(exponential, maxDelay) : exponential;
+  return Math.floor(Math.random() * delay);
+}

package/packages/fun/src/flatten.ts

@@ -0,0 +1,11 @@
+import { isIterable } from './isIterable';
+
+export function flatten<T>(items: T | T[] | Iterable<T>): T[] {
+  if (Array.isArray(items) || isIterable(items)) {
+    return [...items].reduce((acc, item) => {
+      return [...acc, ...flatten(item)];
+    }, [] as T[]);
+  } else {
+    return [items];
+  }
+}

package/packages/fun/src/hash.ts

@@ -0,0 +1,67 @@
+// TODO @@@@slava tests
+export function hashCodeNative(input: string): number {
+  let hash = 0;
+  let i;
+  let charCode;
+
+  for (i = 0; i < input.length; i++) {
+    charCode = input.charCodeAt(i);
+    hash = (hash << 5) - hash + charCode;
+    hash |= 0;
+  }
+
+  return hash;
+}
+
+export function hashCode(input: string): number {
+  return Math.abs(hashCodeNative(input));
+}
+
+export function hashHex(value: string, bits = 64): string {
+  const radix = 16; // hex
+  const size = Math.ceil(bits / 8) * 2;
+
+  let result = '';
+  let idx = 0;
+  let prevHash = '';
+
+  while (result.length < size) {
+    prevHash = hashCode(`${idx++}${prevHash}${value}`).toString(radix);
+    result += prevHash;
+  }
+
+  return result.slice(0, size);
+}
+
+export function HashBalance(hash: (input: string) => number = hashCode) {
+  return function balance(value: string, members: number): number {
+    if (members <= 0) {
+      return 0;
+    } else {
+      return hash(value) % members;
+    }
+  };
+}
+
+export function hexToNumber(hex: string): number {
+  if (hex.length % 2 != 0) {
+    hex = '0' + hex;
+  }
+
+  let num = parseInt(hex, 16);
+  const maxVal = Math.pow(2, (hex.length / 2) * 8);
+
+  if (num > maxVal / 2 - 1) {
+    num = num - maxVal;
+  }
+
+  return num;
+}
+
+export function HashToNumber(Hash: (value: string) => Promise<string> = async v => hashHex(v, 32)) {
+  return async (value: string) => {
+    const hex8bytes = (await Hash(value)).slice(0, 8);
+    return hexToNumber(hex8bytes);
+  };
+}
+

package/packages/fun/src/hash128.ts

@@ -0,0 +1,6 @@
+import { hashHex } from './hash';
+import { sortObject } from './sort-object';
+
+export function hash128(input: any) {
+  return hashHex(JSON.stringify(sortObject(input)), 128);
+}

package/packages/fun/src/hash256.ts

@@ -0,0 +1,6 @@
+import { hashHex } from './hash';
+import { sortObject } from './sort-object';
+
+export function hash256(input: any) {
+  return hashHex(JSON.stringify(sortObject(input)), 256);
+}

package/packages/fun/src/hub.ts

@@ -0,0 +1,53 @@
+import { IPubSub, IPubSubSubscriber, IPubSubUnsubscribe, PubSub } from './pubsub';
+
+export type IHubTopicName = string | any;
+
+export type IHubUnsubscribe = IPubSubUnsubscribe;
+
+export type IHubSubscriber<DataType = any> = IPubSubSubscriber<DataType>;
+
+export type IHub = {
+  subscribe: <DataType = any>(
+    topic: IHubTopicName,
+    subscriber: IHubSubscriber<DataType>
+  ) => IHubUnsubscribe;
+
+  publish: <DataType = any>(topic: IHubTopicName, data: DataType) => void | Promise<void>;
+
+  close: () => void;
+};
+
+export function Hub(): IHub {
+  let topics: { [topic in IHubTopicName]: IPubSub<any> } = {};
+
+  let unSubscribers: IHubUnsubscribe[] = [];
+
+  return {
+    publish<DataType = any>(topic: IHubTopicName, data: DataType): Promise<void> | void {
+      topics[topic] = topics[topic] || PubSub();
+      return topics[topic].publish(data);
+    },
+
+    close(): void {
+      unSubscribers.forEach(un => un());
+      unSubscribers = [];
+      topics = {};
+    },
+
+    subscribe<DataType = any>(
+      topic: IHubTopicName,
+      subscriber: IHubSubscriber<DataType>
+    ): IHubUnsubscribe {
+      topics[topic] = topics[topic] || PubSub();
+
+      const unsubscribeTopic = topics[topic].subscribe(subscriber);
+
+      unSubscribers.push(unsubscribeTopic);
+
+      return () => {
+        unsubscribeTopic();
+        unSubscribers = unSubscribers.filter(un => un !== unsubscribeTopic);
+      };
+    },
+  };
+}

package/packages/fun/src/id.ts

@@ -0,0 +1,10 @@
+import { v4 as uuid } from 'uuid';
+
+export const generateRandomId = () => uuid().toString();
+
+export const generateSafeRandomId = () => uuid().toString().replace(/-/g, '');
+
+const UUID_PATTERN =
+  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+
+export const checkFormatOfUUID = (value: string): boolean => UUID_PATTERN.test(value);

package/packages/fun/src/interval.ts

@@ -0,0 +1,76 @@
+import { Defer, IDefer } from './defer';
+
+export type IFinishInterval = () => Promise<void>;
+
+export function Interval(
+  fn: () => any | Promise<any>,
+  timeWindow: number,
+  startImmediately = false
+): IFinishInterval {
+  let finishing = false;
+  let finished = false;
+  let finishingDefer: IDefer<void> | undefined = undefined;
+  let delayDefer: IDefer<void> = Defer<void>();
+  let timer: any;
+
+  function clearTimerIfExists() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+  }
+
+  async function execute() {
+    if (!finishing) {
+      await fn();
+    }
+
+    if (finishingDefer) {
+      finishingDefer.resolve();
+    }
+
+    clearTimerIfExists();
+
+    if (finishing) {
+      finished = true;
+    }
+  }
+
+  void (async () => {
+    if (startImmediately) {
+      await execute();
+    }
+
+    while (!finishing) {
+      // delay
+      delayDefer.resolve();
+      delayDefer = Defer<void>();
+
+      timer = setTimeout(() => delayDefer.resolve(), timeWindow);
+      await delayDefer.promise;
+
+      // execution
+      await execute();
+    }
+  })();
+
+  return async () => {
+    finishing = true;
+
+    if (!finishingDefer) {
+      finishingDefer = Defer<void>();
+    }
+
+    if (finished) {
+      finishingDefer.resolve();
+    }
+
+    if (delayDefer) {
+      delayDefer.resolve();
+    }
+
+    clearTimerIfExists();
+
+    await finishingDefer.promise;
+  };
+}

package/packages/fun/src/is-non-nullable.ts

@@ -0,0 +1,2 @@
+export const isNotNullable = <T>(x: T | null | undefined): x is NonNullable<T> =>
+  x !== null && typeof x !== 'undefined';