@derivation/rpc 0.3.0 → 0.3.5

package/dist/tests/reactive-set-adapter.test.js

@@ -0,0 +1,157 @@
+import { describe, it, expect } from 'vitest';
+import { Graph } from 'derivation';
+import { ZSet, Reactive, ZSetOperations, ZSetChangeInput } from '@derivation/composable';
+import { ReactiveSetSourceAdapter, ReactiveSetSinkAdapter, sink } from '../reactive-set-adapter.js';
+import * as iso from '../iso.js';
+describe('ReactiveSetSourceAdapter', () => {
+    it('should provide snapshot as array of [item, weight] tuples', () => {
+        const graph = new Graph();
+        let zset = new ZSet();
+        zset = zset.add('a', 1).add('b', 2);
+        const reactiveSet = Reactive.create(graph, new ZSetOperations(), new ZSetChangeInput(graph), zset);
+        const adapter = new ReactiveSetSourceAdapter(reactiveSet, iso.id());
+        const snapshot = adapter.Snapshot;
+        expect(snapshot).toEqual([['a', 1], ['b', 2]]);
+    });
+    it('should transform elements using isomorphism', () => {
+        const graph = new Graph();
+        let zset = new ZSet();
+        zset = zset.add(1, 2).add(3, 4);
+        const reactiveSet = Reactive.create(graph, new ZSetOperations(), new ZSetChangeInput(graph), zset);
+        const numToString = {
+            to: (n) => n.toString(),
+            from: (s) => parseInt(s, 10),
+        };
+        const adapter = new ReactiveSetSourceAdapter(reactiveSet, numToString);
+        const snapshot = adapter.Snapshot;
+        expect(snapshot).toEqual([['1', 2], ['3', 4]]);
+    });
+    it('should provide last change after modifications', () => {
+        const graph = new Graph();
+        const input = new ZSetChangeInput(graph);
+        const reactiveSet = Reactive.create(graph, new ZSetOperations(), input, new ZSet());
+        const adapter = new ReactiveSetSourceAdapter(reactiveSet, iso.id());
+        // Push a change
+        let zset = new ZSet();
+        zset = zset.add('x', 1);
+        input.push(zset);
+        graph.step();
+        const lastChange = adapter.LastChange;
+        expect(lastChange).toEqual([['x', 1]]);
+    });
+    it('should return the underlying reactive set', () => {
+        const graph = new Graph();
+        const reactiveSet = Reactive.create(graph, new ZSetOperations(), new ZSetChangeInput(graph), new ZSet());
+        const adapter = new ReactiveSetSourceAdapter(reactiveSet, iso.id());
+        expect(adapter.Stream).toBe(reactiveSet);
+    });
+    it('should handle empty sets', () => {
+        const graph = new Graph();
+        const reactiveSet = Reactive.create(graph, new ZSetOperations(), new ZSetChangeInput(graph), new ZSet());
+        const adapter = new ReactiveSetSourceAdapter(reactiveSet, iso.id());
+        expect(adapter.Snapshot).toEqual([]);
+    });
+});
+describe('ReactiveSetSinkAdapter', () => {
+    it('should build a reactive set source', () => {
+        const graph = new Graph();
+        const adapter = new ReactiveSetSinkAdapter(graph, iso.compose(iso.zset(iso.id()), iso.zsetToArray()), []);
+        const { stream: source } = adapter.build();
+        expect(source).toBeDefined();
+        expect([...source.snapshot.getEntries()]).toEqual([]);
+    });
+    it('should apply changes to a reactive set', () => {
+        const graph = new Graph();
+        const isoComposed = iso.compose(iso.zset(iso.id()), iso.zsetToArray());
+        const adapter = new ReactiveSetSinkAdapter(graph, isoComposed, []);
+        const { stream: source, input } = adapter.build();
+        // Apply a change to add items
+        const change = [['a', 1], ['b', 2]];
+        adapter.apply(change, input);
+        graph.step();
+        // Check snapshot after change
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries).toContainEqual(['a', 1]);
+        expect(entries).toContainEqual(['b', 2]);
+    });
+    it('should transform elements using isomorphism', () => {
+        const graph = new Graph();
+        const numToString = {
+            to: (n) => n.toString(),
+            from: (s) => parseInt(s, 10),
+        };
+        const isoComposed = iso.compose(iso.zset(numToString), iso.zsetToArray());
+        const adapter = new ReactiveSetSinkAdapter(graph, isoComposed, []);
+        const { stream: source, input } = adapter.build();
+        // Apply change with string values
+        const change = [['5', 1], ['10', 2]];
+        adapter.apply(change, input);
+        graph.step();
+        // Should be converted to numbers
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries).toContainEqual([5, 1]);
+        expect(entries).toContainEqual([10, 2]);
+    });
+});
+describe('sink function', () => {
+    it('should create a sink initialized with snapshot', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id());
+        const snapshot = [['item1', 1], ['item2', 2]];
+        const sinkAdapter = sinkFn(snapshot);
+        const { stream: source } = sinkAdapter.build();
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries).toContainEqual(['item1', 1]);
+        expect(entries).toContainEqual(['item2', 2]);
+    });
+    it('should allow applying changes after initialization', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id());
+        const snapshot = [['a', 1]];
+        const sinkAdapter = sinkFn(snapshot);
+        const { stream: source, input } = sinkAdapter.build();
+        // Apply a change
+        const change = [['b', 2], ['c', 3]];
+        sinkAdapter.apply(change, input);
+        graph.step();
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries.length).toBeGreaterThan(1);
+        expect(entries).toContainEqual(['b', 2]);
+        expect(entries).toContainEqual(['c', 3]);
+    });
+    it('should transform snapshot using isomorphism', () => {
+        const graph = new Graph();
+        const stringToNum = {
+            to: (n) => n.toString(),
+            from: (s) => parseInt(s, 10),
+        };
+        const sinkFn = sink(graph, stringToNum);
+        // Snapshot with string values
+        const snapshot = [['42', 1], ['99', 2]];
+        const sinkAdapter = sinkFn(snapshot);
+        const { stream: source } = sinkAdapter.build();
+        // Should be converted to numbers
+        const entries = [...source.snapshot.getEntries()];
+        expect(entries).toContainEqual([42, 1]);
+        expect(entries).toContainEqual([99, 2]);
+    });
+    it('should handle empty snapshot', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id());
+        const sinkAdapter = sinkFn([]);
+        const { stream: source } = sinkAdapter.build();
+        expect([...source.snapshot.getEntries()]).toEqual([]);
+    });
+    it('should create new source instances on each build call', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id());
+        const sinkAdapter = sinkFn([['test', 1]]);
+        const { stream: source1 } = sinkAdapter.build();
+        const { stream: source2 } = sinkAdapter.build();
+        // Each build creates a new instance - use strict equality to avoid vitest's deep comparison
+        expect(source1 === source2).toBe(false);
+        // But both have the same initial snapshot
+        expect([...source1.snapshot.getEntries()]).toEqual([['test', 1]]);
+        expect([...source2.snapshot.getEntries()]).toEqual([['test', 1]]);
+    });
+});

package/dist/tests/stream-adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/stream-adapter.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import { Graph, inputValue } from 'derivation';
+import { StreamSourceAdapter, StreamSinkAdapter, sink } from '../stream-adapter.js';
+import * as iso from '../iso.js';
+describe('StreamSourceAdapter', () => {
+    it('should provide snapshot of the stream value', () => {
+        const graph = new Graph();
+        const stream = inputValue(graph, { x: 10, y: 20 });
+        const adapter = new StreamSourceAdapter(stream, iso.id());
+        expect(adapter.Snapshot).toEqual({ x: 10, y: 20 });
+    });
+    it('should transform snapshot using isomorphism', () => {
+        const graph = new Graph();
+        const stream = inputValue(graph, { count: 42 });
+        const countToString = {
+            to: (obj) => ({ count: obj.count.toString() }),
+            from: (obj) => ({ count: parseInt(obj.count, 10) }),
+        };
+        const adapter = new StreamSourceAdapter(stream, countToString);
+        expect(adapter.Snapshot).toEqual({ count: '42' });
+    });
+    it('should provide last change as the current value', () => {
+        const graph = new Graph();
+        const stream = inputValue(graph, { a: 1 });
+        const adapter = new StreamSourceAdapter(stream, iso.id());
+        expect(adapter.LastChange).toEqual({ a: 1 });
+        stream.push({ a: 2 });
+        graph.step();
+        expect(adapter.LastChange).toEqual({ a: 2 });
+    });
+    it('should return the underlying stream', () => {
+        const graph = new Graph();
+        const stream = inputValue(graph, { test: true });
+        const adapter = new StreamSourceAdapter(stream, iso.id());
+        expect(adapter.Stream).toBe(stream);
+    });
+});
+describe('StreamSinkAdapter', () => {
+    it('should apply changes to a stream', () => {
+        const graph = new Graph();
+        const adapter = new StreamSinkAdapter(graph, iso.id(), { x: 0 });
+        const { stream, input } = adapter.build();
+        adapter.apply({ x: 5 }, input);
+        graph.step();
+        expect(stream.value).toEqual({ x: 5 });
+        adapter.apply({ x: 10 }, input);
+        graph.step();
+        expect(stream.value).toEqual({ x: 10 });
+    });
+    it('should transform changes using isomorphism', () => {
+        const graph = new Graph();
+        const stringToNum = {
+            to: (obj) => ({ val: obj.val.toString() }),
+            from: (obj) => ({ val: parseInt(obj.val, 10) }),
+        };
+        const adapter = new StreamSinkAdapter(graph, stringToNum, { val: '0' });
+        const { stream, input } = adapter.build();
+        // Apply change with string, should be converted to number
+        adapter.apply({ val: '42' }, input);
+        graph.step();
+        expect(stream.value).toEqual({ val: 42 });
+    });
+    it('should build a new input stream each time', () => {
+        const graph = new Graph();
+        const adapter = new StreamSinkAdapter(graph, iso.id(), { id: 'test' });
+        const { stream: stream1 } = adapter.build();
+        const { stream: stream2 } = adapter.build();
+        expect(stream1).toBeDefined();
+        expect(stream2).toBeDefined();
+        expect(stream1).not.toBe(stream2);
+    });
+});
+describe('sink function', () => {
+    it('should create a sink that initializes with snapshot', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id());
+        const snapshot = { name: 'initial' };
+        const sinkAdapter = sinkFn(snapshot);
+        const { stream } = sinkAdapter.build();
+        expect(stream.value).toEqual({ name: 'initial' });
+    });
+    it('should allow applying changes after initialization', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id());
+        const sinkAdapter = sinkFn({ count: 0 });
+        const { stream, input } = sinkAdapter.build();
+        expect(stream.value).toEqual({ count: 0 });
+        sinkAdapter.apply({ count: 5 }, input);
+        graph.step();
+        expect(stream.value).toEqual({ count: 5 });
+        sinkAdapter.apply({ count: 10 }, input);
+        graph.step();
+        expect(stream.value).toEqual({ count: 10 });
+    });
+    it('should transform snapshot using isomorphism', () => {
+        const graph = new Graph();
+        const strToNum = {
+            to: (obj) => ({ value: obj.value.toString() }),
+            from: (obj) => ({ value: parseInt(obj.value, 10) }),
+        };
+        const sinkFn = sink(graph, strToNum);
+        const sinkAdapter = sinkFn({ value: '99' });
+        const { stream } = sinkAdapter.build();
+        // Should be converted from string to number
+        expect(stream.value).toEqual({ value: 99 });
+    });
+    it('should create new stream instances on each build call', () => {
+        const graph = new Graph();
+        const sinkFn = sink(graph, iso.id());
+        const sinkAdapter = sinkFn({ data: 'test' });
+        const { stream: stream1 } = sinkAdapter.build();
+        const { stream: stream2 } = sinkAdapter.build();
+        // Each build creates a new instance
+        expect(stream1).not.toBe(stream2);
+        // But both have the same initial value
+        expect(stream1.value).toEqual({ data: 'test' });
+        expect(stream2.value).toEqual({ data: 'test' });
+    });
+});

package/dist/tests/weak-list.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/weak-list.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import WeakList from '../weak-list.js';
+describe('WeakList', () => {
+    it('should store and iterate over objects', () => {
+        const list = new WeakList();
+        const obj1 = { id: 1 };
+        const obj2 = { id: 2 };
+        const obj3 = { id: 3 };
+        list.add(obj1);
+        list.add(obj2);
+        list.add(obj3);
+        const items = [...list];
+        expect(items).toHaveLength(3);
+        expect(items).toContain(obj1);
+        expect(items).toContain(obj2);
+        expect(items).toContain(obj3);
+    });
+    it('should automatically clean up collected references', () => {
+        const list = new WeakList();
+        // Add objects in a scope
+        {
+            const obj1 = { id: 1 };
+            const obj2 = { id: 2 };
+            list.add(obj1);
+            list.add(obj2);
+        }
+        // Keep one object alive
+        const obj3 = { id: 3 };
+        list.add(obj3);
+        // Force garbage collection if available
+        if (global.gc) {
+            global.gc();
+        }
+        // Iterate - this should clean up dead references
+        const items = [...list];
+        // obj3 should still be present
+        expect(items).toContain(obj3);
+        // Note: We can't reliably test that obj1 and obj2 are gone
+        // because GC timing is non-deterministic
+    });
+    it('should handle empty list', () => {
+        const list = new WeakList();
+        const items = [...list];
+        expect(items).toHaveLength(0);
+    });
+    it('should allow multiple iterations', () => {
+        const list = new WeakList();
+        const obj1 = { id: 1 };
+        const obj2 = { id: 2 };
+        list.add(obj1);
+        list.add(obj2);
+        const items1 = [...list];
+        expect(items1).toHaveLength(2);
+        const items2 = [...list];
+        expect(items2).toHaveLength(2);
+        expect(items2).toEqual(items1);
+    });
+    it('should work with different object types', () => {
+        class MyClass {
+            constructor(value) {
+                this.value = value;
+            }
+        }
+        const list = new WeakList();
+        const obj1 = new MyClass('test1');
+        const obj2 = new MyClass('test2');
+        list.add(obj1);
+        list.add(obj2);
+        const items = [...list];
+        expect(items).toHaveLength(2);
+        expect(items[0]).toBeInstanceOf(MyClass);
+        expect(items[1]).toBeInstanceOf(MyClass);
+    });
+    it('should maintain insertion order for live objects', () => {
+        const list = new WeakList();
+        const obj1 = { id: 1 };
+        const obj2 = { id: 2 };
+        const obj3 = { id: 3 };
+        list.add(obj1);
+        list.add(obj2);
+        list.add(obj3);
+        const items = [...list];
+        expect(items[0]).toBe(obj1);
+        expect(items[1]).toBe(obj2);
+        expect(items[2]).toBe(obj3);
+    });
+    it('should handle adding the same object multiple times', () => {
+        const list = new WeakList();
+        const obj1 = { id: 1 };
+        list.add(obj1);
+        list.add(obj1);
+        list.add(obj1);
+        const items = [...list];
+        // Should have 3 references to the same object
+        expect(items).toHaveLength(3);
+        expect(items[0]).toBe(obj1);
+        expect(items[1]).toBe(obj1);
+        expect(items[2]).toBe(obj1);
+    });
+});