granular topics

Author: devagrawal09

Diff for: index.spec.ts

@@ -6,6 +6,7 @@ import {
   createMutationListener,
   createPartition,
   createSyncListener,
+  createTopic,
   halt,
 } from ".";
 import { setTimeout } from "timers/promises";
@@ -263,3 +264,69 @@ describe(`createSyncListener`, () => {
     d();
   });
 });
+
+describe(`createTopic`, () => {
+  test(`emits to multiple listeners`, () => {
+    const messages = [] as number[];
+
+    const d = createRoot((d) => {
+      const [onTopic, emitTopic] = createTopic<{ a: number; b: number }>();
+
+      onTopic(`a`, (p) => messages.push(p));
+      onTopic(`b`, (p) => messages.push(p + 1));
+
+      emitTopic(`a`, 1);
+      emitTopic(`b`, 2);
+      return d;
+    });
+
+    expect(messages).toEqual([1, 3]);
+    d();
+  });
+
+  test(`emits to nested listeners`, () => {
+    const messages = [] as number[];
+
+    const d = createRoot((d) => {
+      const [onTopic, emitTopic] = createTopic<{
+        a: number;
+        b: { c: number };
+      }>();
+
+      onTopic(`a`, (p) => messages.push(p));
+      onTopic(`b`, (p) => messages.push(p.c));
+      onTopic(`b`, `c`, (p) => messages.push(p));
+
+      emitTopic(`a`, 1);
+      emitTopic(`b`, { c: 2 });
+      emitTopic(`b`, `c`, 3);
+      emitTopic({ a: 4, b: { c: 5 } });
+
+      return d;
+    });
+
+    expect(messages).toEqual([1, 2, 2, 3, 3, 4, 5, 5]);
+    d();
+  });
+
+  test(`transforms into new topic handlers`, () => {
+    const messages = [] as number[];
+
+    const d = createRoot((d) => {
+      const [onTopic, emitTopic] = createTopic<{ a: { b: number } }>();
+
+      const onB = onTopic(`a`, (p) => p.b);
+      const onTopicA = onTopic(`a`);
+
+      onB((p) => messages.push(p));
+      onTopicA(`b`, (p) => messages.push(p));
+
+      emitTopic(`a`, { b: 1 });
+      emitTopic(`a`, `b`, 2);
+      return d;
+    });
+
+    expect(messages).toEqual([1, 1, 2, 2]);
+    d();
+  });
+});

Diff for: index.ts

@@ -56,7 +56,10 @@ function makeHandler<E>($: Observable<Promise<E | HaltError> | E>): Handler<E> {
 
 export function createEvent<E = any>(): [Handler<E>, Emitter<E>] {
   const $ = new Subject<E>();
-  return [makeHandler($), (e) => ($.next(e), flushQueues())] as const;
+  return [
+    makeHandler($),
+    (e) => (pureQueue.push(() => $.next(e)), flushQueues()),
+  ] as const;
 }
 
 export function createSubject<T>(
@@ -233,3 +236,106 @@ export function introspectQueues() {
     listenerQueue.length
   );
 }
+
+export type TopicHandler<T extends Record<string, any>> = {
+  <K extends keyof T, O>(
+    key: K,
+    transform: (e: T[K]) => Promise<O> | O
+  ): Handler<O>;
+  <K extends keyof T>(key: K): TopicHandler<T[K]>;
+
+  <K1 extends keyof T, K2 extends keyof T[K1], O>(
+    key1: K1,
+    key2: K2,
+    transform: (e: T[K1][K2]) => Promise<O> | O
+  ): Handler<O>;
+  <K1 extends keyof T, K2 extends keyof T[K1]>(
+    key1: K1,
+    key2: K2
+  ): TopicHandler<T[K1][K2]>;
+
+  <K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], O>(
+    key1: K1,
+    key2: K2,
+    key3: K3,
+    transform: (e: T[K1][K2][K3]) => Promise<O> | O
+  ): Handler<O>;
+  <K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(
+    key1: K1,
+    key2: K2,
+    key3: K3
+  ): TopicHandler<T[K1][K2][K3]>;
+};
+export type TopicEmitter<T extends Record<string, any>> = {
+  (e: T): void;
+  <K extends keyof T>(key: K, e: T[K]): void;
+  <K1 extends keyof T, K2 extends keyof T[K1]>(
+    key1: K1,
+    key2: K2,
+    e: T[K1][K2]
+  ): void;
+  <K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(
+    key1: K1,
+    key2: K2,
+    key3: K3,
+    e: T[K1][K2][K3]
+  ): void;
+};
+
+const $EVENT = Symbol("event");
+type TopicNode = {
+  [$EVENT]?: [Handler<any>, Emitter<any>];
+  [key: string]: TopicNode;
+};
+
+export function createTopic<T extends Record<string, any>>() {
+  const topicTree: TopicNode = {};
+
+  // @ts-expect-error
+  const on: TopicHandler<T> = (...key: (string | ((e: any) => any))[]) => {
+    const transform = key.pop()!;
+
+    if (typeof transform !== "function") {
+      // @ts-expect-error
+      return (...args: any[]) => on(...key, transform, ...args);
+    }
+
+    const node = (key as string[]).reduce((node, k) => {
+      if (!node[k]) node[k] = {};
+      return node[k];
+    }, topicTree);
+
+    if (!node[$EVENT]) {
+      node[$EVENT] = createEvent();
+    }
+
+    return node[$EVENT][0](transform);
+  };
+
+  const emit: TopicEmitter<T> = (...key: (string | any)[]) => {
+    const payload = key.pop()! as any;
+
+    if (typeof payload === "object") {
+      Object.keys(payload).forEach((k) => {
+        // @ts-expect-error
+        emit(...key, k, payload[k]);
+      });
+      return;
+    }
+
+    for (let i = 0; i <= key.length; i++) {
+      let p = payload;
+      key
+        .slice(i)
+        .toReversed()
+        .forEach((k) => {
+          p = { [k]: p };
+        });
+
+      const node = key.slice(0, i).reduce((node, k) => node[k], topicTree);
+      node[$EVENT]?.[1](p);
+    }
+  };
+
+  return [on, emit] as const;
+}

Diff for: package.json

@@ -3,6 +3,7 @@
   "version": "0.0.5",
   "description": "Declarative event composition and state derivation primitives for Solidjs",
   "main": "index.ts",
+  "type": "module",
   "scripts": {
     "test": "vitest"
   },

Diff for: tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES6",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ESNext"],
+    "moduleResolution": "nodenext",
+    "module": "NodeNext"
+  },
+  "include": ["./index.ts"],
+  "exclude": ["node_modules", "**/*.spec.ts"]
+}