+1

src/index.ts

reviewed

··· 29 29 ReadGuard, 30 30 WriteGuard, 31 31 slab, 32 32 + SharedStruct, 32 33 } from './shared/index.ts';

+1

src/shared/index.ts

reviewed

··· 20 20 export { Mutex, MutexGuard } from './mutex.ts'; 21 21 export { RwLock, ReadGuard, WriteGuard } from './rwlock.ts'; 22 22 export { slab } from './slab.ts'; 23 23 + export { SharedStruct } from './shared-struct.ts';

+40

src/shared/shared-struct.ts

reviewed

··· 1 1 + import type { Loadable } from './loadable.ts'; 2 2 + 3 3 + type FieldValues<T extends Record<string, Loadable<any>>> = { 4 4 + [K in keyof T]: T[K] extends Loadable<infer V> ? V : never; 5 5 + }; 6 6 + 7 7 + const SHARED = Symbol.for('moroutine.shared'); 8 8 + 9 9 + export class SharedStruct<T extends Record<string, Loadable<any>>> implements Loadable<FieldValues<T>> { 10 10 + readonly fields: T; 11 11 + 12 12 + constructor(fields: T) { 13 13 + this.fields = fields; 14 14 + } 15 15 + 16 16 + load(): FieldValues<T> { 17 17 + const result = {} as FieldValues<T>; 18 18 + for (const key in this.fields) { 19 19 + (result as any)[key] = this.fields[key].load(); 20 20 + } 21 21 + return result; 22 22 + } 23 23 + 24 24 + store(values: FieldValues<T>): void { 25 25 + for (const key in this.fields) { 26 26 + this.fields[key].store((values as any)[key]); 27 27 + } 28 28 + } 29 29 + 30 30 + [SHARED](): { tag: string; fields: Record<string, unknown> } { 31 31 + const serializedFields: Record<string, unknown> = {}; 32 32 + for (const key in this.fields) { 33 33 + const field = this.fields[key]; 34 34 + if (typeof field === 'object' && field !== null && SHARED in field) { 35 35 + serializedFields[key] = (field as any)[SHARED](); 36 36 + } 37 37 + } 38 38 + return { tag: 'SharedStruct', fields: serializedFields }; 39 39 + } 40 40 + }

+76

test/shared/shared-struct.test.ts

reviewed

··· 1 1 + import { describe, it } from 'node:test'; 2 2 + import assert from 'node:assert/strict'; 3 3 + import { SharedStruct, Int32, Uint8, Bool, slab } from 'moroutine'; 4 4 + 5 5 + describe('SharedStruct', () => { 6 6 + it('load returns all field values', () => { 7 7 + const [x, y] = slab(Int32, Int32); 8 8 + const point = new SharedStruct({ x, y }); 9 9 + assert.deepEqual(point.load(), { x: 0, y: 0 }); 10 10 + }); 11 11 + 12 12 + it('store writes all field values', () => { 13 13 + const [x, y] = slab(Int32, Int32); 14 14 + const point = new SharedStruct({ x, y }); 15 15 + point.store({ x: 10, y: 20 }); 16 16 + assert.deepEqual(point.load(), { x: 10, y: 20 }); 17 17 + }); 18 18 + 19 19 + it('works with mixed types', () => { 20 20 + const [x, y, health, alive] = slab(Int32, Int32, Uint8, Bool); 21 21 + const state = new SharedStruct({ x, y, health, alive }); 22 22 + state.store({ x: 1, y: 2, health: 100, alive: true }); 23 23 + assert.deepEqual(state.load(), { x: 1, y: 2, health: 100, alive: true }); 24 24 + }); 25 25 + 26 26 + it('works with independently created fields', () => { 27 27 + const pos = new SharedStruct({ x: new Int32(), y: new Int32() }); 28 28 + pos.store({ x: 42, y: 99 }); 29 29 + assert.deepEqual(pos.load(), { x: 42, y: 99 }); 30 30 + }); 31 31 + 32 32 + it('supports nested structs', () => { 33 33 + const [sx, sy, sw, sh] = slab(Int32, Int32, Int32, Int32); 34 34 + const position = new SharedStruct({ x: sx, y: sy }); 35 35 + const size = new SharedStruct({ w: sw, h: sh }); 36 36 + const rect = new SharedStruct({ position, size }); 37 37 + 38 38 + rect.store({ position: { x: 1, y: 2 }, size: { w: 100, h: 50 } }); 39 39 + assert.deepEqual(rect.load(), { position: { x: 1, y: 2 }, size: { w: 100, h: 50 } }); 40 40 + }); 41 41 + 42 42 + it('inner struct mutation is visible through outer struct', () => { 43 43 + const [x, y] = slab(Int32, Int32); 44 44 + const pos = new SharedStruct({ x, y }); 45 45 + const entity = new SharedStruct({ pos, alive: new Bool() }); 46 46 + 47 47 + pos.store({ x: 10, y: 20 }); 48 48 + assert.deepEqual(entity.load(), { pos: { x: 10, y: 20 }, alive: false }); 49 49 + }); 50 50 + 51 51 + it('exposes fields for direct access', () => { 52 52 + const [x, y] = slab(Int32, Int32); 53 53 + const point = new SharedStruct({ x, y }); 54 54 + point.fields.x.store(42); 55 55 + assert.equal(point.fields.y.load(), 0); 56 56 + assert.deepEqual(point.load(), { x: 42, y: 0 }); 57 57 + }); 58 58 + 59 59 + it('nested fields accessible via fields property', () => { 60 60 + const [x, y, w, h] = slab(Int32, Int32, Int32, Int32); 61 61 + const pos = new SharedStruct({ x, y }); 62 62 + const rect = new SharedStruct({ pos, w, h }); 63 63 + 64 64 + rect.fields.pos.fields.x.store(99); 65 65 + rect.fields.w.store(200); 66 66 + assert.deepEqual(rect.load(), { pos: { x: 99, y: 0 }, w: 200, h: 0 }); 67 67 + }); 68 68 + 69 69 + it('is itself Loadable (can be nested)', () => { 70 70 + const inner = new SharedStruct({ v: new Int32() }); 71 71 + const outer = new SharedStruct({ inner, flag: new Bool() }); 72 72 + 73 73 + outer.store({ inner: { v: 42 }, flag: true }); 74 74 + assert.deepEqual(outer.load(), { inner: { v: 42 }, flag: true }); 75 75 + }); 76 76 + });