xindex 1.0.0

package/packages/fun/src/isIterable.ts

@@ -0,0 +1,3 @@
+export function isIterable(input: any): input is Iterable<any> {
+  return input != null && typeof (input as any)[Symbol.iterator] === 'function';
+}

package/packages/fun/src/mailbox.ts

@@ -0,0 +1,13 @@
+import { IPubSub, PubSub } from './pubsub';
+
+export type IMailbox<Inbox, Outbox = never> = Readonly<{
+  inbox: IPubSub<Inbox>;
+  outbox: IPubSub<Outbox>;
+}>;
+
+export function Mailbox<Inbox = never, Outbox = never>(): IMailbox<Inbox, Outbox> {
+  return {
+    inbox: PubSub<Inbox>(),
+    outbox: PubSub<Outbox>(),
+  };
+}

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

@@ -0,0 +1,19 @@
+export const mapRecord = <TKey extends keyof TIn, TIn extends Record<any, any>, TOut>(
+  record: TIn,
+  mapper: (value: TIn[TKey], key: TKey) => TOut
+): Record<TKey, TOut> => {
+  const entries = Object.entries(record) as [TKey, TIn[TKey]][];
+  const results = entries.map(([key, value]) => [key as TKey, mapper(value, key as TKey)]);
+  return Object.fromEntries(results) as Record<TKey, TOut>;
+};
+
+export const mapRecordAsync = async <TKey extends keyof TIn, TIn extends Record<any, any>, TOut>(
+  record: TIn,
+  mapper: (value: TIn[TKey], key: TKey) => Promise<TOut>
+): Promise<Record<TKey, TOut>> => {
+  const entries = Object.entries(record) as [TKey, TIn[TKey]][];
+  const results = await Promise.all(
+    entries.map<Promise<[TKey, TOut]>>(async ([key, value]) => [key, await mapper(value, key)])
+  );
+  return Object.fromEntries(results) as Record<TKey, TOut>;
+};

package/packages/fun/src/match-collections.ts

@@ -0,0 +1,57 @@
+export type Identifier<Item> = (previousItem: Item, nextItem: Item) => boolean;
+
+export type IsEqual<Item = any> = (previousItem: Item, nextItem: Item) => boolean;
+
+export type IMatchCollectionsOutput<Item> = {
+  created: Item[];
+  matched: {
+    previous: Item;
+    next: Item;
+  }[];
+  deleted: Item[];
+};
+
+export type IMatchCollections<Item = any> = (
+  previousCollection: Item[],
+  nextCollection: Item[]
+) => IMatchCollectionsOutput<Item>;
+
+export function MatchCollections<Item>(identifier: Identifier<Item>): IMatchCollections<Item> {
+  return function (prevItems, nextItems) {
+    const createdItems: Item[] = nextItems.filter(
+      nextItem => !prevItems.find(prevItem => identifier(nextItem, prevItem))
+    );
+
+    const deletedItems: Item[] = prevItems.filter(
+      prevItem => !nextItems.find(nextItem => identifier(nextItem, prevItem))
+    );
+
+    const map = nextItems.map(nextItem => {
+      const prevItemFound = prevItems.find(prevItem => identifier(prevItem, nextItem));
+
+      const isMatched = !!prevItemFound;
+
+      return {
+        prevItem: prevItemFound,
+        nextItem,
+        isMatched,
+      };
+    });
+
+    const matchedItems = map
+      .filter(({ isMatched }) => isMatched)
+      .map(({ prevItem, nextItem }) => ({
+        previous: prevItem!,
+        next: nextItem!,
+      }));
+
+    return {
+      created: createdItems,
+      matched: matchedItems,
+      deleted: deletedItems,
+    };
+  };
+}
+
+export const identifyById = <T extends { id: any }>(item1: T, item2: T) =>
+  String(item1.id) === String(item2.id);

package/packages/fun/src/match-left-and-right-arrays.ts

@@ -0,0 +1,78 @@
+import { sortObject } from './sort-object';
+
+export type IMatchLeftAndRightArraysResult<Left, Right> = {
+  matched: { left: Left; right: Right }[];
+  unmatched: { left: Left[]; right: Right[] };
+};
+
+export function matchLeftAndRightArrays<Left, Right, ID>(
+  left: Left[] | ReadonlyArray<Left>,
+  right: Right[] | ReadonlyArray<Right>,
+  leftToId: (left: Left) => ID,
+  rightToId: (left: Right) => ID
+): IMatchLeftAndRightArraysResult<Left, Right> {
+  const matched: { left: Left; right: Right }[] = [];
+
+  const leftSet = new Set<Left>();
+  const rightSet = new Set<Right>();
+
+  if (!left.length) {
+    right.forEach(rightItem => {
+      rightSet.add(rightItem);
+    });
+  }
+
+  if (!right.length) {
+    left.forEach(leftItem => {
+      leftSet.add(leftItem);
+    });
+  }
+
+  const serializeId = (id: ID): string => {
+    if (id instanceof Object) {
+      return JSON.stringify(sortObject(id));
+    } else {
+      return String(id);
+    }
+  };
+
+  const leftMap = new Map<string, Left>();
+  const rightMap = new Map<string, Right>();
+
+  left.forEach(leftItem => {
+    const id = serializeId(leftToId(leftItem));
+    leftMap.set(id, leftItem);
+  });
+
+  right.forEach(rightItem => {
+    const id = serializeId(rightToId(rightItem));
+    rightMap.set(id, rightItem);
+  });
+
+  // @ts-ignore
+  const ids = new Set<string>([...leftMap.keys(), ...rightMap.keys()]);
+
+  ids.forEach(id => {
+    if (leftMap.has(id) && rightMap.has(id)) {
+      matched.push({ left: leftMap.get(id)!, right: rightMap.get(id)! });
+    } else {
+      if (leftMap.has(id)) {
+        leftSet.add(leftMap.get(id)!);
+      }
+
+      if (rightMap.has(id)) {
+        rightSet.add(rightMap.get(id)!);
+      }
+    }
+  });
+
+  return {
+    matched,
+    unmatched: {
+      // @ts-ignore
+      left: [...leftSet],
+      // @ts-ignore
+      right: [...rightSet],
+    },
+  };
+}

package/packages/fun/src/mem.ts

@@ -0,0 +1,26 @@
+export type IMem<T> = (() => T) & {
+  reset: () => void;
+};
+
+export function mem<T>(fn: () => T): IMem<T> {
+  let value: any = undefined;
+  let called = false;
+
+  const iMem = () => {
+    if (called) {
+      return value;
+    }
+
+    value = fn();
+    called = true;
+
+    return value;
+  };
+
+  iMem.reset = () => {
+    value = undefined;
+    called = false;
+  };
+
+  return iMem;
+}

package/packages/fun/src/memos.ts

@@ -0,0 +1,28 @@
+import { IMem, mem } from './mem';
+
+export type IMemos<Input, Output> = ((value: Input) => Output) & {
+  reset: () => void;
+};
+
+export function memos<Input, Output>(
+  toKey: (value: Input) => string | number,
+  toValue: (value: Input) => Output
+): IMemos<Input, Output> {
+  let cache: { [P in string | number]: IMem<Output> } = {};
+
+  const iMemos = (value: Input) => {
+    const key = toKey(value);
+    if (!(key in cache)) {
+      cache[key] = mem<Output>(() => toValue(value));
+    }
+
+    return cache[key]!();
+  };
+
+  iMemos.reset = () => {
+    Object.values(cache).forEach(mem => mem.reset());
+    cache = {};
+  };
+
+  return iMemos;
+}

package/packages/fun/src/normalizeError.ts

@@ -0,0 +1,25 @@
+export function normalizeError<Type extends Error>(error: Type): Type {
+  if (!error) {
+    return error;
+  }
+
+  if(!(error instanceof Object)) {
+    return error as Type;
+  }
+
+  return {
+    ...error,
+    name: error.name,
+    message: error.message,
+    stack: error.stack,
+
+    // @ts-ignore
+    type: error.type,
+
+    // @ts-ignore
+    data: error.data,
+
+    // @ts-ignore
+    origin: error.origin,
+  };
+}

package/packages/fun/src/nothing.ts

@@ -0,0 +1,3 @@
+export function Nothing(...args: any[]): any {
+  return null as any;
+}

package/packages/fun/src/pipe.ts

@@ -0,0 +1,18 @@
+// TODO @@@@slava specs
+type IMapper = (x: any) => any;
+
+export function syncPipe<Input = void, Output = any>(...mappers: IMapper[]) {
+  return function (input: Input): Output {
+    // @ts-ignore
+    return mappers.reduce((current, mapper) => mapper(current), input) as Output;
+  };
+}
+
+export function pipe<Input = void, Output = any>(...mappers: IMapper[]) {
+  return async function (input: Input): Promise<Output> {
+    return (await mappers.reduce(
+      async (current, mapper) => mapper(await current),
+      (async () => input)()
+    )) as Output;
+  };
+}

package/packages/fun/src/prettyJson.ts

@@ -0,0 +1,3 @@
+export function prettyJson(value: any) {
+  return JSON.stringify(value, null, 2);
+}

package/packages/fun/src/project.ts

@@ -0,0 +1,8 @@
+export const projectObject = (record: Record<string, any>, fields: string[]): Record<string, any> =>
+  fields.reduce(
+    (outputData: Record<string, any>, field: string) => ({
+      ...outputData,
+      [field]: record[field],
+    }),
+    {} as Record<string, any>
+  );

package/packages/fun/src/promise.ts

@@ -0,0 +1,27 @@
+type IUnoPromise<T> = (() => Promise<T>) & {
+  reset: () => Promise<void>;
+};
+
+export function UnoPromise<T>(fn: () => Promise<T>): IUnoPromise<T> {
+  let promise: undefined | Promise<T> = undefined;
+
+  const unoPromise = async () => {
+    const hadPromise = !!promise;
+
+    try {
+      promise = promise || fn();
+      return promise as Promise<T>;
+    } finally {
+      if (!hadPromise) {
+        promise = undefined;
+      }
+    }
+  };
+
+  unoPromise.reset = async () => {
+    await promise;
+    promise = undefined;
+  };
+
+  return unoPromise;
+}

package/packages/fun/src/pubsub.ts

@@ -0,0 +1,128 @@
+import { Defer } from "./defer";
+import { IType, IUseType } from "./IType";
+
+export type ISyncPubSub<T> = {
+  publish: (message: T) => void;
+  subscribe: IPubSubSubscribe<T>;
+  unsubscribeAll: () => void;
+};
+
+export type IPubSubSubscribe<T> = (
+  subscriber: IPubSubSubscriber<T>,
+) => IPubSubUnsubscribe;
+export type IPubSubPublish<T> = (message: T) => Promise<void>;
+
+export type IPubSub<T> = {
+  publish: IPubSubPublish<T>;
+  subscribe: IPubSubSubscribe<T>;
+  unsubscribeAll: () => void;
+};
+
+export type IPubSubSubscriber<T> = (message: T) => any | Promise<any>;
+export type IPubSubUnsubscribe = () => void | any;
+
+export function SyncPubSub<T>(): ISyncPubSub<T> {
+  let subscribers: IPubSubSubscriber<T>[] = [];
+
+  function subscribe(subscriber: (value: T) => void) {
+    subscribers.push(subscriber);
+    return () => unsubscribe(subscriber);
+  }
+
+  function unsubscribe(subscriber: IPubSubSubscriber<T>) {
+    subscribers = subscribers.filter((sub) => sub !== subscriber);
+  }
+
+  function publish(value: T) {
+    subscribers.map((sub) => sub(value));
+  }
+
+  function unsubscribeAll() {
+    subscribers = [];
+  }
+
+  return {
+    publish,
+    subscribe,
+    unsubscribeAll,
+  };
+}
+
+export class PubSubAggregateError extends Error {
+  constructor(
+    public errors: Error[],
+    message?: string,
+  ) {
+    super(message);
+
+    const error = errors[0] || ({} as any);
+
+    this.message = message || error.message || "";
+    this.stack = error.stack || "";
+  }
+}
+
+export function PubSub<T>(): IPubSub<T> {
+  let subscribers: IPubSubSubscriber<T>[] = [];
+
+  function subscribe(subscriber: (value: T) => void) {
+    subscribers.push(subscriber);
+    return () => unsubscribe(subscriber);
+  }
+
+  function unsubscribe(subscriber: IPubSubSubscriber<T>) {
+    subscribers = subscribers.filter((sub) => sub !== subscriber);
+  }
+
+  async function publish(message: T) {
+    await Promise.all(subscribers.map((sub) => sub(message)));
+  }
+
+  function unsubscribeAll() {
+    subscribers = [];
+  }
+
+  return {
+    publish,
+    subscribe,
+    unsubscribeAll,
+  };
+}
+
+export async function waitForMessage<T>(
+  subscribe: IPubSubSubscribe<T> | IPubSub<T>,
+  isAcceptable: (message: T) => boolean | Promise<boolean>,
+): Promise<T> {
+  const defer = Defer<T>();
+  if ("subscribe" in subscribe) {
+    subscribe = subscribe.subscribe;
+  }
+
+  const unsubscribe = subscribe(async (message: T) => {
+    try {
+      if (await isAcceptable(message)) {
+        unsubscribe();
+        defer.resolve(message);
+      }
+    } catch (error) {
+      unsubscribe();
+      defer.reject(error);
+    }
+  });
+
+  return defer.promise;
+}
+
+export function ScopedSubscribe<Type extends IType, Scope extends Type["type"]>(
+  subscribe: IPubSubSubscribe<Type>,
+  scope: ReadonlyArray<Scope>,
+): IPubSubSubscribe<IUseType<Type, Scope>> {
+  const set = new Set(scope);
+  return (subscriber) => {
+    return subscribe((message) => {
+      if (set.has(message.type as Scope)) {
+        return subscriber(message as IUseType<Type, Scope>);
+      }
+    });
+  };
+}

package/packages/fun/src/randomId.ts

@@ -0,0 +1,14 @@
+export function RandomId(bits = 128): () => string {
+  const radix = 16; // hex
+  const size = Math.ceil(bits / 8) * 2;
+
+  return () => {
+    let result = "";
+
+    while (result.length < size) {
+      result += Math.random().toString(radix).slice(2);
+    }
+
+    return result.slice(0, size);
+  };
+}

package/packages/fun/src/regexp-escape.ts

@@ -0,0 +1,13 @@
+// https://stackoverflow.com/a/9310752
+export const regExpEscape = (value: string) => value.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&');
+
+// copy of https://www.npmjs.com/package/escape-string-regexp
+export function escapeStringRegexp(string: string) {
+  if (typeof string !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+
+  // Escape characters with special meaning either inside or outside character sets.
+  // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+}

package/packages/fun/src/retry.ts

@@ -0,0 +1,15 @@
+export async function retry<Result>(
+  fn: (attempt: number) => Result,
+  { attempts }: { attempts: number }
+) {
+  let lastError: any;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw lastError;
+}

package/packages/fun/src/serial.test.ts

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { Serial } from "./serial.js";
+
+function delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Thunk-runner: Serial parameterized to accept `() => Promise<T>` inputs.
+// Lets tests exercise Serial with arbitrary per-call work.
+function ThunkSerial() {
+    return Serial<() => Promise<any>, any>((fn) => fn());
+}
+
+describe("Serial", () => {
+    it("runs tasks sequentially — no overlap when two tasks start together", async () => {
+        const serial = ThunkSerial();
+        const events: string[] = [];
+
+        const p1 = serial(async () => {
+            events.push("a:start");
+            await delay(15);
+            events.push("a:end");
+            return "a";
+        });
+        const p2 = serial(async () => {
+            events.push("b:start");
+            await delay(15);
+            events.push("b:end");
+            return "b";
+        });
+
+        await Promise.all([p1, p2]);
+
+        assert.deepEqual(events, ["a:start", "a:end", "b:start", "b:end"]);
+    });
+
+    it("returns the task's resolved value to the caller", async () => {
+        const serial = ThunkSerial();
+        const v = await serial(() => Promise.resolve(42));
+        assert.equal(v, 42);
+    });
+
+    it("propagates task rejection to the caller", async () => {
+        const serial = ThunkSerial();
+        const err = new Error("boom");
+        await assert.rejects(serial(() => Promise.reject(err)), (e: unknown) => e === err);
+    });
+
+    it("does not poison the chain when a task rejects — later tasks still resolve", async () => {
+        const serial = ThunkSerial();
+        const first = new Error("first");
+        await assert.rejects(serial(() => Promise.reject(first)), (e: unknown) => e === first);
+        const v = await serial(() => Promise.resolve("after"));
+        assert.equal(v, "after");
+    });
+
+    it("flush resolves after all pending tasks settle (success and failure)", async () => {
+        const serial = ThunkSerial();
+        let rejectedDone = false;
+        let okDone = false;
+
+        void serial(async () => {
+            await delay(20);
+            throw new Error("planned");
+        }).catch(() => { rejectedDone = true; });
+
+        void serial(async () => {
+            await delay(15);
+            okDone = true;
+        });
+
+        assert.equal(rejectedDone, false);
+        assert.equal(okDone, false);
+
+        await serial.flush();
+
+        assert.equal(rejectedDone, true);
+        assert.equal(okDone, true);
+    });
+
+    it("preserves FIFO order across many concurrent enqueues", async () => {
+        const serial = ThunkSerial();
+        const order: number[] = [];
+        const tasks = Array.from({ length: 10 }, (_, i) =>
+            serial(async () => {
+                order.push(i);
+                return i;
+            }),
+        );
+        await Promise.all(tasks);
+        assert.deepEqual(order, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    });
+
+    it("typed worker: dispatches inputs to the configured worker", async () => {
+        type Msg = { kind: "add"; n: number } | { kind: "reset" };
+        let sum = 0;
+        const run = Serial<Msg, number>(async (m) => {
+            if (m.kind === "reset") sum = 0;
+            else sum += m.n;
+            return sum;
+        });
+        assert.equal(await run({ kind: "add", n: 2 }), 2);
+        assert.equal(await run({ kind: "add", n: 3 }), 5);
+        assert.equal(await run({ kind: "reset" }), 0);
+    });
+});

package/packages/fun/src/serial.ts

@@ -0,0 +1,17 @@
+export type ISerial<In, Out> = {
+    (input: In): Promise<Out>;
+    flush: () => Promise<void>;
+};
+
+export function Serial<In, Out>(worker: (input: In) => Promise<Out>): ISerial<In, Out> {
+    let tail: Promise<unknown> = Promise.resolve();
+
+    const publish = ((input: In) => {
+        const next = tail.then(() => worker(input));
+        tail = next.catch(() => {});
+        return next;
+    }) as ISerial<In, Out>;
+
+    publish.flush = () => tail.then(() => {});
+    return publish;
+}

package/packages/fun/src/sleep.ts

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

package/packages/fun/src/sort-object.ts

@@ -0,0 +1,46 @@
+// TODO @@@@slava move to fun lib
+
+const jsonStringify = (x: any): string => JSON.stringify(x);
+const stringSorter = (a: string, b: string): number => a.localeCompare(b);
+
+export function SortObject({
+  sortIterable = true,
+  stringify = jsonStringify,
+  sorter = stringSorter,
+} = {}) {
+  return function sortObject(input: any): any {
+    if (Array.isArray(input) || (input instanceof Object && input[Symbol.iterator])) {
+      if (sortIterable) {
+        return [...input]
+          .map(sortObject)
+          .map(item => ({ item, value: stringify(item) }))
+          .sort((a, b) => sorter(a.value, b.value))
+          .map(({ item }) => item);
+      } else {
+        return [...input].map(sortObject);
+      }
+    }
+
+    if (input instanceof Object) {
+      const result: any = {};
+
+      Object.keys(input)
+        .sort(sorter)
+        .forEach(key => (result[key] = sortObject(input[key])));
+
+      return result;
+    }
+
+    return input;
+  };
+}
+
+export const sortObject = SortObject();
+
+export function DeepEqual({ sort = sortObject, stringify = jsonStringify } = {}) {
+  return function (a: any, b: any) {
+    return stringify(sort(a)) === stringify(sort(b));
+  };
+}
+
+export const deepEqual = DeepEqual();