@derivation/rpc 0.3.3 → 0.3.5

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);
+    });
+});