toiljs 0.0.15 → 0.0.19

package/test/io.test.ts

@@ -1,93 +1,117 @@
-import { describe, expect, it } from 'vitest';
-
-import { BinaryReader } from '../src/io/BinaryReader';
-import { BinaryWriter } from '../src/io/BinaryWriter';
-import { FastMap } from '../src/io/FastMap';
-import { FastSet } from '../src/io/FastSet';
-
-describe('BinaryWriter / BinaryReader', () => {
-    it('round-trips fixed-width integers', () => {
-        const w = new BinaryWriter();
-        w.writeU8(255);
-        w.writeU16(65535);
-        w.writeU32(4294967295);
-        w.writeU64(18446744073709551615n);
-        w.writeI8(-128);
-        w.writeI32(-2147483648);
-
-        const r = new BinaryReader(w.getBuffer());
-        expect(r.readU8()).toBe(255);
-        expect(r.readU16()).toBe(65535);
-        expect(r.readU32()).toBe(4294967295);
-        expect(r.readU64()).toBe(18446744073709551615n);
-        expect(r.readI8()).toBe(-128);
-        expect(r.readI32()).toBe(-2147483648);
-    });
-
-    it('round-trips u256 and strings', () => {
-        const big = 123456789012345678901234567890n;
-        const w = new BinaryWriter();
-        w.writeU256(big);
-        w.writeStringWithLength('hello toil 🛠');
-        w.writeBoolean(true);
-
-        const r = new BinaryReader(w.getBuffer());
-        expect(r.readU256()).toBe(big);
-        expect(r.readStringWithLength()).toBe('hello toil 🛠');
-        expect(r.readBoolean()).toBe(true);
-    });
-
-    it('round-trips arrays', () => {
-        const w = new BinaryWriter();
-        w.writeU32Array([1, 2, 3]);
-        w.writeStringArray(['a', 'bb', 'ccc']);
-
-        const r = new BinaryReader(w.getBuffer());
-        expect(r.readU32Array()).toEqual([1, 2, 3]);
-        expect(r.readStringArray()).toEqual(['a', 'bb', 'ccc']);
-    });
-
-    it('rejects out-of-range values', () => {
-        const w = new BinaryWriter();
-        expect(() => w.writeU8(256)).toThrow();
-        expect(() => w.writeI8(128)).toThrow();
-    });
-
-    it('rejects negative / overflowing u256 and u128', () => {
-        const w = new BinaryWriter();
-        expect(() => w.writeU256(-1n)).toThrow();
-        expect(() => w.writeU256(2n ** 256n)).toThrow();
-        expect(() => w.writeU128(-1n)).toThrow();
-        expect(() => w.writeU128(2n ** 128n)).toThrow();
-    });
-
-    it('throws when reading past the end', () => {
-        const r = new BinaryReader(new Uint8Array(2));
-        expect(() => r.readU32()).toThrow();
-    });
-});
-
-describe('FastMap', () => {
-    it('supports bigint keys and basic ops', () => {
-        const m = new FastMap<bigint, string>();
-        m.set(1n, 'one').set(2n, 'two');
-        expect(m.size).toBe(2);
-        expect(m.get(1n)).toBe('one');
-        expect(m.has(2n)).toBe(true);
-        expect(m.delete(1n)).toBe(true);
-        expect(m.has(1n)).toBe(false);
-        expect([...m.entries()]).toEqual([[2n, 'two']]);
-    });
-});
-
-describe('FastSet', () => {
-    it('dedupes and preserves insertion order', () => {
-        const s = new FastSet<bigint>();
-        s.add(2n).add(1n).add(2n);
-        expect(s.size).toBe(2);
-        expect(s.has(1n)).toBe(true);
-        expect([...s.values()]).toEqual([2n, 1n]);
-        expect(s.delete(2n)).toBe(true);
-        expect([...s.values()]).toEqual([1n]);
-    });
-});
+import { describe, expect, it } from 'vitest';
+
+import { DataReader, DataWriter } from '../src/io/codec';
+import { FastMap } from '../src/io/FastMap';
+import { FastSet } from '../src/io/FastSet';
+
+describe('DataWriter / DataReader', () => {
+    it('round-trips fixed-width integers', () => {
+        const w = new DataWriter();
+        w.writeU8(255).writeU16(65535).writeU32(4294967295).writeU64(18446744073709551615n);
+        w.writeI8(-128).writeI16(-32768).writeI32(-2147483648).writeI64(-9223372036854775808n);
+
+        const r = new DataReader(w.toBytes());
+        expect(r.readU8()).toBe(255);
+        expect(r.readU16()).toBe(65535);
+        expect(r.readU32()).toBe(4294967295);
+        expect(r.readU64()).toBe(18446744073709551615n);
+        expect(r.readI8()).toBe(-128);
+        expect(r.readI16()).toBe(-32768);
+        expect(r.readI32()).toBe(-2147483648);
+        expect(r.readI64()).toBe(-9223372036854775808n);
+        expect(r.ok).toBe(true);
+        expect(r.remaining()).toBe(0);
+    });
+
+    it('round-trips floats, bool, bytes and strings', () => {
+        const w = new DataWriter();
+        w.writeF32(0.5).writeF64(3.141592653589793).writeBool(true).writeBool(false);
+        w.writeBytes(new Uint8Array([1, 2, 3, 0, 255]));
+        w.writeString('hello toil 🛠');
+
+        const r = new DataReader(w.toBytes());
+        expect(r.readF32()).toBe(0.5);
+        expect(r.readF64()).toBe(3.141592653589793);
+        expect(r.readBool()).toBe(true);
+        expect(r.readBool()).toBe(false);
+        expect([...r.readBytes()]).toEqual([1, 2, 3, 0, 255]);
+        expect(r.readString()).toBe('hello toil 🛠');
+        expect(r.ok).toBe(true);
+    });
+
+    it('round-trips u128 / i128 / u256 / i256', () => {
+        const u = 123456789012345678901234567890n;
+        const big256 = (2n ** 256n) - 1n;
+        const w = new DataWriter();
+        w.writeU128(u).writeI128(-1234567890123456789n).writeU256(big256).writeI256(-(2n ** 200n));
+
+        const r = new DataReader(w.toBytes());
+        expect(r.readU128()).toBe(u);
+        expect(r.readI128()).toBe(-1234567890123456789n);
+        expect(r.readU256()).toBe(big256);
+        expect(r.readI256()).toBe(-(2n ** 200n));
+    });
+
+    it('grows past the initial capacity without corruption (regression)', () => {
+        // The default buffer is 64 bytes; this forces several reallocations.
+        const w = new DataWriter();
+        const text = 'z'.repeat(500);
+        for (let i = 0; i < 40; i++) w.writeU64(BigInt(i)); // 320 bytes
+        w.writeString(text);
+
+        const r = new DataReader(w.toBytes());
+        for (let i = 0; i < 40; i++) expect(r.readU64()).toBe(BigInt(i));
+        expect(r.readString()).toBe(text);
+        expect(r.ok).toBe(true);
+    });
+
+    it('round-trips big-endian when be is set, and be flips byte order', () => {
+        expect([...new DataWriter().writeU32(0x01020304).toBytes()]).toEqual([4, 3, 2, 1]);
+        expect([...new DataWriter().writeU32(0x01020304, true).toBytes()]).toEqual([1, 2, 3, 4]);
+
+        const w = new DataWriter();
+        w.writeU16(0xabcd, true).writeI32(-2, true).writeU64(0xdeadbeefn, true).writeU128(123456789012345n, true);
+        const r = new DataReader(w.toBytes());
+        expect(r.readU16(true)).toBe(0xabcd);
+        expect(r.readI32(true)).toBe(-2);
+        expect(r.readU64(true)).toBe(0xdeadbeefn);
+        expect(r.readU128(true)).toBe(123456789012345n);
+    });
+
+    it('is little-endian and masks instead of throwing', () => {
+        // u32 1 → 01 00 00 00 (LE); writeU8 masks to a byte, no throw.
+        const bytes = new DataWriter().writeU32(1).writeU8(256).toBytes();
+        expect([...bytes]).toEqual([1, 0, 0, 0, 0]);
+    });
+
+    it('reports ok=false when reading past the end (no throw)', () => {
+        const r = new DataReader(new Uint8Array(2));
+        expect(r.readU32()).toBe(0);
+        expect(r.ok).toBe(false);
+    });
+});
+
+describe('FastMap', () => {
+    it('supports bigint keys and basic ops', () => {
+        const m = new FastMap<bigint, string>();
+        m.set(1n, 'one').set(2n, 'two');
+        expect(m.size).toBe(2);
+        expect(m.get(1n)).toBe('one');
+        expect(m.has(2n)).toBe(true);
+        expect(m.delete(1n)).toBe(true);
+        expect(m.has(1n)).toBe(false);
+        expect([...m.entries()]).toEqual([[2n, 'two']]);
+    });
+});
+
+describe('FastSet', () => {
+    it('dedupes and preserves insertion order', () => {
+        const s = new FastSet<bigint>();
+        s.add(2n).add(1n).add(2n);
+        expect(s.size).toBe(2);
+        expect(s.has(1n)).toBe(true);
+        expect([...s.values()]).toEqual([2n, 1n]);
+        expect(s.delete(2n)).toBe(true);
+        expect([...s.values()]).toEqual([1n]);
+    });
+});

package/test/navlink.test.ts

@@ -1,28 +1,28 @@
-import { describe, expect, it } from 'vitest';
-
-import { matchActive } from '../src/client/navigation/NavLink';
-
-describe('matchActive', () => {
-    it('matches exact paths', () => {
-        expect(matchActive('/about', '/about', false)).toBe(true);
-        expect(matchActive('/about', '/about/', false)).toBe(true);
-        expect(matchActive('/about', '/contact', false)).toBe(false);
-    });
-
-    it('matches sub-paths when not exact (end=false)', () => {
-        expect(matchActive('/blog', '/blog/42', false)).toBe(true);
-        expect(matchActive('/blog', '/blog', false)).toBe(true);
-        expect(matchActive('/blog', '/blogger', false)).toBe(false);
-    });
-
-    it('honors end for exact-only matching', () => {
-        expect(matchActive('/blog', '/blog/42', true)).toBe(false);
-        expect(matchActive('/blog', '/blog', true)).toBe(true);
-    });
-
-    it('treats "/" as active everywhere unless end', () => {
-        expect(matchActive('/', '/anything/deep', false)).toBe(true);
-        expect(matchActive('/', '/anything', true)).toBe(false);
-        expect(matchActive('/', '/', true)).toBe(true);
-    });
-});
+import { describe, expect, it } from 'vitest';
+
+import { matchActive } from '../src/client/navigation/NavLink';
+
+describe('matchActive', () => {
+    it('matches exact paths', () => {
+        expect(matchActive('/about', '/about', false)).toBe(true);
+        expect(matchActive('/about', '/about/', false)).toBe(true);
+        expect(matchActive('/about', '/contact', false)).toBe(false);
+    });
+
+    it('matches sub-paths when not exact (end=false)', () => {
+        expect(matchActive('/blog', '/blog/42', false)).toBe(true);
+        expect(matchActive('/blog', '/blog', false)).toBe(true);
+        expect(matchActive('/blog', '/blogger', false)).toBe(false);
+    });
+
+    it('honors end for exact-only matching', () => {
+        expect(matchActive('/blog', '/blog/42', true)).toBe(false);
+        expect(matchActive('/blog', '/blog', true)).toBe(true);
+    });
+
+    it('treats "/" as active everywhere unless end', () => {
+        expect(matchActive('/', '/anything/deep', false)).toBe(true);
+        expect(matchActive('/', '/anything', true)).toBe(false);
+        expect(matchActive('/', '/', true)).toBe(true);
+    });
+});

package/test/placeholder.test.ts

@@ -1,9 +1,9 @@
-import { describe, expect, it } from 'vitest';
-
-import { FRAMEWORK_NAME } from '../src/shared/index';
-
-describe('toiljs scaffold', () => {
-    it('exposes the framework name', () => {
-        expect(FRAMEWORK_NAME).toBe('toiljs');
-    });
-});
+import { describe, expect, it } from 'vitest';
+
+import { FRAMEWORK_NAME } from '../src/shared/index';
+
+describe('toiljs scaffold', () => {
+    it('exposes the framework name', () => {
+        expect(FRAMEWORK_NAME).toBe('toiljs');
+    });
+});

package/test/prettier-plugin.test.ts

@@ -0,0 +1,46 @@
+import prettier from 'prettier';
+import { describe, expect, it } from 'vitest';
+
+import * as plugin from '../presets/prettier-plugin.js';
+
+function fmt(src: string): Promise<string> {
+    return prettier.format(src, {
+        parser: 'typescript',
+        plugins: [plugin],
+        tabWidth: 4,
+        singleQuote: true,
+        semi: true,
+    });
+}
+
+// The plugin lets prettier format toilscript server code, whose native decorators on free
+// functions (@main, @remote function) are not valid JS/TS grammar (so stock prettier throws).
+describe('toiljs prettier-plugin', () => {
+    it('formats a free @remote function and keeps the decorator', async () => {
+        const out = await fmt('@remote\nfunction ping(n:i32):i32{return n+1}\n');
+        expect(out).toContain('@remote');
+        expect(out).toContain('function ping(n: i32): i32 {');
+        expect(out).not.toContain('toil-decorator'); // marker fully restored
+    });
+
+    it('formats @main', async () => {
+        const out = await fmt('@main\nfunction run():i32{return 42}\n');
+        expect(out).toMatch(/@main\nfunction run\(\): i32 \{/);
+    });
+
+    it('handles @remote export function', async () => {
+        const out = await fmt('@remote\nexport function pong():void{}\n');
+        expect(out).toContain('@remote\nexport function pong(): void {}');
+    });
+
+    it('leaves class/method decorators untouched', async () => {
+        const out = await fmt('@data\nclass A{ x:i32=0 }\n');
+        expect(out).toContain('@data');
+        expect(out).toContain('class A {');
+    });
+
+    it('is idempotent', async () => {
+        const once = await fmt('@remote\nfunction f():void{}\n@main\nfunction g():void{}\n');
+        expect(await fmt(once)).toBe(once);
+    });
+});

package/test/routes.test.ts

@@ -1,76 +1,76 @@
-import { describe, expect, it } from 'vitest';
-
-import { matchRoute } from '../src/client/routing/match';
-import { filePathToRoute, interceptTarget } from '../src/compiler/routes';
-
-describe('filePathToRoute', () => {
-    it('maps index, static, nested, and dynamic files to patterns', () => {
-        expect(filePathToRoute('index.tsx')).toBe('/');
-        expect(filePathToRoute('about.tsx')).toBe('/about');
-        expect(filePathToRoute('blog/index.tsx')).toBe('/blog');
-        expect(filePathToRoute('blog/[id].tsx')).toBe('/blog/:id');
-        expect(filePathToRoute('docs/guide/intro.jsx')).toBe('/docs/guide/intro');
-        expect(filePathToRoute('docs/[...slug].tsx')).toBe('/docs/*slug');
-    });
-
-    it('maps optional catch-all and strips route groups', () => {
-        expect(filePathToRoute('docs/[[...slug]].tsx')).toBe('/docs/**slug');
-        expect(filePathToRoute('[[...slug]].tsx')).toBe('/**slug');
-        expect(filePathToRoute('(marketing)/about.tsx')).toBe('/about');
-        expect(filePathToRoute('(shop)/index.tsx')).toBe('/');
-        expect(filePathToRoute('(a)/(b)/deep.tsx')).toBe('/deep');
-    });
-
-    it('strips parallel-slot (@slot) segments from the URL', () => {
-        expect(filePathToRoute('@modal/photo/[id].tsx')).toBe('/photo/:id');
-        expect(filePathToRoute('@sidebar/index.tsx')).toBe('/');
-        expect(filePathToRoute('dashboard/@chart/views.tsx')).toBe('/dashboard/views');
-    });
-});
-
-describe('interceptTarget', () => {
-    it('resolves (.)/(..)/(...) marker targets', () => {
-        expect(interceptTarget('@modal/(.)photo/[id].tsx')).toBe('/photo/:id');
-        expect(interceptTarget('feed/@modal/(..)photo/[id].tsx')).toBe('/photo/:id');
-        expect(interceptTarget('a/b/@m/(...)login.tsx')).toBe('/login');
-    });
-
-    it('returns null for routes with no interception marker', () => {
-        expect(interceptTarget('photo/[id].tsx')).toBeNull();
-        expect(interceptTarget('@modal/settings.tsx')).toBeNull();
-    });
-});
-
-describe('matchRoute', () => {
-    it('matches static routes', () => {
-        expect(matchRoute('/', '/')).toEqual({});
-        expect(matchRoute('/about', '/about')).toEqual({});
-    });
-
-    it('rejects non-matches', () => {
-        expect(matchRoute('/about', '/x')).toBeNull();
-        expect(matchRoute('/blog/:id', '/blog')).toBeNull();
-        expect(matchRoute('/', '/about')).toBeNull();
-    });
-
-    it('extracts dynamic params', () => {
-        expect(matchRoute('/blog/:id', '/blog/42')).toEqual({ id: '42' });
-        expect(matchRoute('/u/:user/p/:post', '/u/ann/p/7')).toEqual({ user: 'ann', post: '7' });
-        expect(matchRoute('/blog/:id', '/blog/a%20b')).toEqual({ id: 'a b' });
-    });
-
-    it('captures the tail with catch-all routes', () => {
-        expect(matchRoute('/docs/*slug', '/docs/a/b/c')).toEqual({ slug: 'a/b/c' });
-        expect(matchRoute('/docs/*slug', '/docs/intro')).toEqual({ slug: 'intro' });
-        expect(matchRoute('/files/*path', '/files/a%20b/c')).toEqual({ path: 'a b/c' });
-        // catch-all needs at least one trailing segment
-        expect(matchRoute('/docs/*slug', '/docs')).toBeNull();
-    });
-
-    it('matches optional catch-all with zero or more segments', () => {
-        expect(matchRoute('/docs/**slug', '/docs')).toEqual({ slug: '' });
-        expect(matchRoute('/docs/**slug', '/docs/a/b')).toEqual({ slug: 'a/b' });
-        expect(matchRoute('/**slug', '/')).toEqual({ slug: '' });
-        expect(matchRoute('/**slug', '/x/y')).toEqual({ slug: 'x/y' });
-    });
-});
+import { describe, expect, it } from 'vitest';
+
+import { matchRoute } from '../src/client/routing/match';
+import { filePathToRoute, interceptTarget } from '../src/compiler/routes';
+
+describe('filePathToRoute', () => {
+    it('maps index, static, nested, and dynamic files to patterns', () => {
+        expect(filePathToRoute('index.tsx')).toBe('/');
+        expect(filePathToRoute('about.tsx')).toBe('/about');
+        expect(filePathToRoute('blog/index.tsx')).toBe('/blog');
+        expect(filePathToRoute('blog/[id].tsx')).toBe('/blog/:id');
+        expect(filePathToRoute('docs/guide/intro.jsx')).toBe('/docs/guide/intro');
+        expect(filePathToRoute('docs/[...slug].tsx')).toBe('/docs/*slug');
+    });
+
+    it('maps optional catch-all and strips route groups', () => {
+        expect(filePathToRoute('docs/[[...slug]].tsx')).toBe('/docs/**slug');
+        expect(filePathToRoute('[[...slug]].tsx')).toBe('/**slug');
+        expect(filePathToRoute('(marketing)/about.tsx')).toBe('/about');
+        expect(filePathToRoute('(shop)/index.tsx')).toBe('/');
+        expect(filePathToRoute('(a)/(b)/deep.tsx')).toBe('/deep');
+    });
+
+    it('strips parallel-slot (@slot) segments from the URL', () => {
+        expect(filePathToRoute('@modal/photo/[id].tsx')).toBe('/photo/:id');
+        expect(filePathToRoute('@sidebar/index.tsx')).toBe('/');
+        expect(filePathToRoute('dashboard/@chart/views.tsx')).toBe('/dashboard/views');
+    });
+});
+
+describe('interceptTarget', () => {
+    it('resolves (.)/(..)/(...) marker targets', () => {
+        expect(interceptTarget('@modal/(.)photo/[id].tsx')).toBe('/photo/:id');
+        expect(interceptTarget('feed/@modal/(..)photo/[id].tsx')).toBe('/photo/:id');
+        expect(interceptTarget('a/b/@m/(...)login.tsx')).toBe('/login');
+    });
+
+    it('returns null for routes with no interception marker', () => {
+        expect(interceptTarget('photo/[id].tsx')).toBeNull();
+        expect(interceptTarget('@modal/settings.tsx')).toBeNull();
+    });
+});
+
+describe('matchRoute', () => {
+    it('matches static routes', () => {
+        expect(matchRoute('/', '/')).toEqual({});
+        expect(matchRoute('/about', '/about')).toEqual({});
+    });
+
+    it('rejects non-matches', () => {
+        expect(matchRoute('/about', '/x')).toBeNull();
+        expect(matchRoute('/blog/:id', '/blog')).toBeNull();
+        expect(matchRoute('/', '/about')).toBeNull();
+    });
+
+    it('extracts dynamic params', () => {
+        expect(matchRoute('/blog/:id', '/blog/42')).toEqual({ id: '42' });
+        expect(matchRoute('/u/:user/p/:post', '/u/ann/p/7')).toEqual({ user: 'ann', post: '7' });
+        expect(matchRoute('/blog/:id', '/blog/a%20b')).toEqual({ id: 'a b' });
+    });
+
+    it('captures the tail with catch-all routes', () => {
+        expect(matchRoute('/docs/*slug', '/docs/a/b/c')).toEqual({ slug: 'a/b/c' });
+        expect(matchRoute('/docs/*slug', '/docs/intro')).toEqual({ slug: 'intro' });
+        expect(matchRoute('/files/*path', '/files/a%20b/c')).toEqual({ path: 'a b/c' });
+        // catch-all needs at least one trailing segment
+        expect(matchRoute('/docs/*slug', '/docs')).toBeNull();
+    });
+
+    it('matches optional catch-all with zero or more segments', () => {
+        expect(matchRoute('/docs/**slug', '/docs')).toEqual({ slug: '' });
+        expect(matchRoute('/docs/**slug', '/docs/a/b')).toEqual({ slug: 'a/b' });
+        expect(matchRoute('/**slug', '/')).toEqual({ slug: '' });
+        expect(matchRoute('/**slug', '/x/y')).toEqual({ slug: 'x/y' });
+    });
+});

package/test/rpc.test.ts

@@ -0,0 +1,50 @@
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { Server } from '../src/client/rpc';
+
+// `Server` is the runtime behind the generated typed surface. Until the transport
+// is wired, it is a recursive proxy that throws on call.
+describe('Server RPC stub', () => {
+    it('throws on a direct call, naming the path', () => {
+        const s = Server as { ping: () => unknown };
+        expect(() => s.ping()).toThrow(/Server\.ping\(\)/);
+    });
+
+    it('throws on a nested service.method call', () => {
+        const s = Server as { accounts: { getUser: () => unknown } };
+        expect(() => s.accounts.getUser()).toThrow(/Server\.accounts\.getUser\(\)/);
+        expect(() => s.accounts.getUser()).toThrow(/not available yet/);
+    });
+
+    it('is not thenable (so it is not mistaken for a promise)', () => {
+        const s = Server as Record<string, unknown>;
+        expect(s.then).toBeUndefined();
+    });
+
+    it('ignores symbol probes without throwing', () => {
+        const s = Server as Record<PropertyKey, unknown>;
+        expect(s[Symbol.iterator]).toBeUndefined();
+    });
+});
+
+// `Server.REST` surfaces the working fetch client that the generated `shared/server.ts`
+// attaches to `globalThis.__toilRest` on import.
+describe('Server.REST surface', () => {
+    afterEach(() => {
+        delete (globalThis as { __toilRest?: unknown }).__toilRest;
+    });
+
+    it('returns the attached REST client when shared/server has loaded', () => {
+        const fake = { todos: { getTodo: async () => 'ok' } };
+        (globalThis as { __toilRest?: unknown }).__toilRest = fake;
+        const s = Server as { REST: typeof fake };
+        expect(s.REST).toBe(fake);
+        expect(s.REST.todos.getTodo).toBeTypeOf('function');
+    });
+
+    it('throws a helpful "not loaded" error when the REST client is absent', () => {
+        const s = Server as { REST: { todos: { getTodo: () => unknown } } };
+        expect(() => s.REST.todos.getTodo()).toThrow(/Server\.REST\.todos\.getTodo\(\)/);
+        expect(() => s.REST.todos.getTodo()).toThrow(/has not loaded/);
+    });
+});