zero-query 1.2.0 → 1.2.2

package/tests/router.test.js

@@ -226,6 +226,21 @@ describe('Router - z-link-params', () => {
     link.click();
     expect(window.location.hash).toBe('#/user/fallback');
   });
+
+  it('rejects z-link-params that parses to an array (must be an object)', () => {
+    document.body.innerHTML += '<a z-link="/user/:id" z-link-params=\'["42"]\'>User</a>';
+    const link = document.querySelector('a[z-link="/user/:id"]');
+    link.click();
+    // Interpolation skipped, raw href preserved
+    expect(window.location.hash).toBe('#/user/:id');
+  });
+
+  it('rejects z-link-params that parses to null', () => {
+    document.body.innerHTML += '<a z-link="/user/:id" z-link-params="null">User</a>';
+    const link = document.querySelector('a[z-link="/user/:id"]');
+    link.click();
+    expect(window.location.hash).toBe('#/user/:id');
+  });
 });
 
 
@@ -2325,3 +2340,84 @@ describe('Router - z-active-route', () => {
     expect(docs.classList.contains('active')).toBe(false);
   });
 });
+
+
+// ---------------------------------------------------------------------------
+// Keep-alive LRU cache
+// ---------------------------------------------------------------------------
+
+describe('Router - keep-alive LRU', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '<div id="app"></div>';
+    window.location.hash = '#/';
+    // Register fresh keep-alive components for each test
+    component('ka-a', { render: () => '<p>a</p>' });
+    component('ka-b', { render: () => '<p>b</p>' });
+    component('ka-c', { render: () => '<p>c</p>' });
+    component('ka-d', { render: () => '<p>d</p>' });
+  });
+
+  it('keepAliveMax evicts oldest cached instance when exceeded', async () => {
+    const router = createRouter({
+      el: '#app',
+      mode: 'hash',
+      keepAliveMax: 2,
+      routes: [
+        { path: '/a', component: 'ka-a', keepAlive: true },
+        { path: '/b', component: 'ka-b', keepAlive: true },
+        { path: '/c', component: 'ka-c', keepAlive: true },
+      ],
+    });
+
+    router.navigate('/a'); await router._resolve();
+    router.navigate('/b'); await router._resolve();
+    expect(router._keepAliveCache.size).toBe(2);
+    expect(router._keepAliveCache.has('ka-a')).toBe(true);
+    expect(router._keepAliveCache.has('ka-b')).toBe(true);
+
+    router.navigate('/c'); await router._resolve();
+    // ka-a (oldest, not current) should be evicted
+    expect(router._keepAliveCache.size).toBe(2);
+    expect(router._keepAliveCache.has('ka-a')).toBe(false);
+    expect(router._keepAliveCache.has('ka-b')).toBe(true);
+    expect(router._keepAliveCache.has('ka-c')).toBe(true);
+  });
+
+  it('keepAliveMax default (unbounded) preserves all entries', async () => {
+    const router = createRouter({
+      el: '#app',
+      mode: 'hash',
+      routes: [
+        { path: '/a', component: 'ka-a', keepAlive: true },
+        { path: '/b', component: 'ka-b', keepAlive: true },
+        { path: '/c', component: 'ka-c', keepAlive: true },
+        { path: '/d', component: 'ka-d', keepAlive: true },
+      ],
+    });
+    router.navigate('/a'); await router._resolve();
+    router.navigate('/b'); await router._resolve();
+    router.navigate('/c'); await router._resolve();
+    router.navigate('/d'); await router._resolve();
+    expect(router._keepAliveCache.size).toBe(4);
+  });
+
+  it('revisiting a cached route refreshes LRU order', async () => {
+    const router = createRouter({
+      el: '#app',
+      mode: 'hash',
+      keepAliveMax: 2,
+      routes: [
+        { path: '/a', component: 'ka-a', keepAlive: true },
+        { path: '/b', component: 'ka-b', keepAlive: true },
+        { path: '/c', component: 'ka-c', keepAlive: true },
+      ],
+    });
+    router.navigate('/a'); await router._resolve();
+    router.navigate('/b'); await router._resolve();
+    router.navigate('/a'); await router._resolve(); // touch a → now b is oldest
+    router.navigate('/c'); await router._resolve(); // should evict b, not a
+    expect(router._keepAliveCache.has('ka-a')).toBe(true);
+    expect(router._keepAliveCache.has('ka-b')).toBe(false);
+    expect(router._keepAliveCache.has('ka-c')).toBe(true);
+  });
+});

package/tests/ssr.test.js

@@ -806,6 +806,52 @@ describe('SSRApp - renderShell', () => {
     expect(html).not.toContain('data-zq-ssr');
   });
 
+  it('replaces meta description regardless of attribute spacing, order, or quoting', async () => {
+    const variantShell = `<!DOCTYPE html>
+<html><head>
+  <title>T</title>
+  <meta   name="description"   content="orig multi-space">
+</head><body><z-outlet></z-outlet></body></html>`;
+    const html = await app.renderShell(variantShell, { component: 'test-page', description: 'New' });
+    expect(html).toContain('<meta name="description" content="New">');
+    expect(html).not.toContain('orig multi-space');
+
+    const reversedShell = `<!DOCTYPE html>
+<html><head>
+  <title>T</title>
+  <meta content="orig reversed" name="description">
+</head><body><z-outlet></z-outlet></body></html>`;
+    const html2 = await app.renderShell(reversedShell, { component: 'test-page', description: 'New2' });
+    expect(html2).toContain('<meta name="description" content="New2">');
+    expect(html2).not.toContain('orig reversed');
+
+    const selfClosingShell = `<!DOCTYPE html>
+<html><head>
+  <title>T</title>
+  <meta name='description' content='orig single quoted' />
+</head><body><z-outlet></z-outlet></body></html>`;
+    const html3 = await app.renderShell(selfClosingShell, { component: 'test-page', description: 'New3' });
+    expect(html3).toContain('<meta name="description" content="New3">');
+    expect(html3).not.toContain('orig single quoted');
+  });
+
+  it('replaces og:* meta tags regardless of attribute order / quoting', async () => {
+    const variantShell = `<!DOCTYPE html>
+<html><head>
+  <title>T</title>
+  <meta content="orig og title" property="og:title">
+  <meta  property='og:type'  content='website' />
+</head><body><z-outlet></z-outlet></body></html>`;
+    const html = await app.renderShell(variantShell, {
+      component: 'test-page',
+      og: { title: 'New OG', type: 'article' },
+    });
+    expect(html).toContain('<meta property="og:title" content="New OG">');
+    expect(html).toContain('<meta property="og:type" content="article">');
+    expect(html).not.toContain('orig og title');
+    expect(html).not.toContain("content='website'");
+  });
+
   it('handles a missing component gracefully', async () => {
     const html = await app.renderShell(shell, { component: 'nonexistent' });
     expect(html).toContain('<!-- SSR error:');

package/tests/store.test.js

@@ -232,6 +232,16 @@ describe('Store - snapshot & replaceState', () => {
     expect(store.state.a).toBe(1); // original unchanged
   });
 
+  it('snapshot({ clone: false }) skips the deep copy (read-only fast path)', () => {
+    const store = createStore('snap-noclone', { state: { a: 1, nested: { b: 2 } } });
+    const snap = store.snapshot({ clone: false });
+    // Same reference to the underlying nested object (no cloning happened)
+    expect(snap.nested).toBe((store.state.__raw || store.state).nested);
+    // Default still clones
+    const cloned = store.snapshot();
+    expect(cloned.nested).not.toBe((store.state.__raw || store.state).nested);
+  });
+
   it('replaceState replaces entire state', () => {
     const store = createStore('replace-1', { state: { x: 1, y: 2 } });
     store.replaceState({ x: 10, z: 30 });

package/tests/utils.test.js

@@ -62,6 +62,27 @@ describe('debounce', () => {
     vi.advanceTimersByTime(20);
     expect(fn).toHaveBeenCalledOnce();
   });
+
+  it('cancels pending invocation when AbortSignal aborts', () => {
+    const fn = vi.fn();
+    const ctrl = new AbortController();
+    const debounced = debounce(fn, 100, { signal: ctrl.signal });
+    debounced('x');
+    vi.advanceTimersByTime(50);
+    ctrl.abort();
+    vi.advanceTimersByTime(200);
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it('ignores calls after AbortSignal aborts', () => {
+    const fn = vi.fn();
+    const ctrl = new AbortController();
+    const debounced = debounce(fn, 100, { signal: ctrl.signal });
+    ctrl.abort();
+    debounced('x');
+    vi.advanceTimersByTime(200);
+    expect(fn).not.toHaveBeenCalled();
+  });
 });
 
 
@@ -594,6 +615,19 @@ describe('bus (EventBus)', () => {
 // ===========================================================================
 
 describe('throttle - edge cases', () => {
+  it('cancels trailing call when AbortSignal aborts', () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const ctrl = new AbortController();
+    const throttled = throttle(fn, 100, { signal: ctrl.signal });
+    throttled('a');
+    expect(fn).toHaveBeenCalledTimes(1);
+    throttled('b');
+    ctrl.abort();
+    vi.advanceTimersByTime(200);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
   it('fires trailing call after wait period', async () => {
     vi.useFakeTimers();
     const fn = vi.fn();

package/cli/scaffold/webrtc/app/lib/room.js

@@ -1,252 +0,0 @@
-// lib/room.js - Backend-less WebRTC room built on BroadcastChannel.
-//
-// Why no backend?
-//   WebRTC needs a signaling channel to swap SDP + ICE between peers. We use
-//   BroadcastChannel, which lets every same-origin tab on the same browser
-//   talk to every other tab for free. Open the demo in 2+ tabs (or windows)
-//   and you have a working mesh room with audio, video, screen share, and
-//   text chat - zero servers required.
-//
-// Caveats:
-//   - BroadcastChannel is same-origin / same-browser only. To connect across
-//     machines, plug in any real signaling transport (WebSocket, SSE, etc.)
-//     in place of BroadcastChannel and the rest of this file keeps working.
-//   - Mesh topology: every peer has an RTCPeerConnection with every other
-//     peer. Works great up to ~6 peers; beyond that, use an SFU.
-
-const SIGNAL_VERSION = 1;
-
-/**
- * Wrap a BroadcastChannel as a "SignalingClient" that $.Peer can consume.
- * The Peer class expects `.send(type, payload)` and `.on(type, cb)`.
- */
-function makeSignaling(channel, myId) {
-    return {
-        send(type, payload) {
-            channel.postMessage({ v: SIGNAL_VERSION, type, from: myId, ...payload });
-        },
-        on(type, cb) {
-            const handler = (ev) => {
-                const msg = ev.data;
-                if (!msg || msg.v !== SIGNAL_VERSION) return;
-                if (msg.type !== type) return;
-                if (msg.from === myId) return;                       // ignore self
-                if (msg.to !== undefined && msg.to !== myId) return; // not addressed to us
-                cb(msg);
-            };
-            channel.addEventListener('message', handler);
-            return () => channel.removeEventListener('message', handler);
-        },
-    };
-}
-
-/**
- * Backend-less mesh room.
- *
- * Events (subscribe via `.on(type, cb)`):
- *   - 'peers'     payload: Map<id, PeerInfo>     - roster changed
- *   - 'chat'      payload: { from, name, text, t }
- *   - 'status'    payload: string                - human-readable status line
- *   - 'error'     payload: Error
- *
- * PeerInfo: { id, name, stream: MediaStream|null, peer: $.Peer, chat: RTCDataChannel|null }
- */
-export class LocalRoom {
-    constructor(name, { id, displayName, iceServers = [] } = {}) {
-        this.name        = name;
-        this.id          = id          || ('p-' + Math.random().toString(36).slice(2, 10));
-        this.displayName = displayName || ('User-' + this.id.slice(-4));
-        this.iceServers  = iceServers;
-
-        this._channel    = null;
-        this._signaling  = null;
-        this._peers      = new Map();          // id -> PeerInfo
-        this._localStream = null;
-        this._videoSenders = new Map();        // peerId -> RTCRtpSender (current video sender)
-        this._listeners  = new Map();
-        this._heartbeat  = null;
-        this._unsubHello = null;
-        this._unsubBye   = null;
-        this.closed      = false;
-    }
-
-    // ---- Pub/sub ---------------------------------------------------------
-
-    on(type, cb) {
-        if (typeof cb !== 'function') return () => {};
-        let set = this._listeners.get(type);
-        if (!set) { set = new Set(); this._listeners.set(type, set); }
-        set.add(cb);
-        return () => set.delete(cb);
-    }
-
-    _emit(type, payload) {
-        const set = this._listeners.get(type);
-        if (!set) return;
-        for (const cb of [...set]) { try { cb(payload); } catch (_) {} }
-    }
-
-    get peers() { return this._peers; }
-
-    // ---- Lifecycle -------------------------------------------------------
-
-    /**
-     * Open the BroadcastChannel, announce presence, and start accepting peers.
-     * `localStream` is optional - join as a viewer if you have no camera/mic.
-     */
-    join(localStream = null) {
-        if (this.closed) throw new Error('LocalRoom already closed');
-        this._localStream = localStream;
-
-        this._channel   = new BroadcastChannel('zquery-room::' + this.name);
-        this._signaling = makeSignaling(this._channel, this.id);
-
-        // Listen for newcomers' hellos and respond with our own hello so the
-        // newcomer learns about us too. Net effect: every pair exchanges
-        // hellos exactly once and both sides bring up a peer connection.
-        this._unsubHello = this._signaling.on('hello', (m) => {
-            // Ignore if we already track this peer.
-            if (this._peers.has(m.from)) return;
-            this._addPeer(m.from, m.name || 'User');
-            // Reply directly so the newcomer adds us.
-            this._signaling.send('hello', { to: m.from, name: this.displayName });
-        });
-
-        this._unsubBye = this._signaling.on('bye', (m) => {
-            this._removePeer(m.from);
-        });
-
-        // Broadcast hello to the whole room (no `to` field = everyone).
-        this._signaling.send('hello', { name: this.displayName });
-        this._emit('status', 'Looking for peers in room "' + this.name + '"...');
-
-        // Periodic hello so late-comers refresh the roster even if they miss
-        // the first broadcast (e.g. tab woken from background).
-        this._heartbeat = setInterval(() => {
-            if (this.closed) return;
-            this._signaling.send('hello', { name: this.displayName });
-        }, 5000);
-
-        return this;
-    }
-
-    leave() {
-        if (this.closed) return;
-        this.closed = true;
-
-        if (this._heartbeat)  { clearInterval(this._heartbeat); this._heartbeat = null; }
-        if (this._unsubHello) { this._unsubHello(); this._unsubHello = null; }
-        if (this._unsubBye)   { this._unsubBye();   this._unsubBye   = null; }
-
-        try { this._signaling && this._signaling.send('bye', {}); } catch (_) {}
-
-        for (const info of this._peers.values()) {
-            try { info.peer.close(); } catch (_) {}
-        }
-        this._peers.clear();
-        this._videoSenders.clear();
-        this._emit('peers', this._peers);
-
-        if (this._channel) {
-            try { this._channel.close(); } catch (_) {}
-            this._channel = null;
-        }
-    }
-
-    // ---- Media control ---------------------------------------------------
-
-    /**
-     * Replace our outgoing video track on every peer (used for screen share).
-     * Pass `null` to remove video entirely (camera-off).
-     */
-    async replaceVideoTrack(newTrack) {
-        for (const [id, sender] of this._videoSenders) {
-            try { await sender.replaceTrack(newTrack); }
-            catch (err) { this._emit('error', err); }
-        }
-    }
-
-    /** Broadcast a chat message over every peer's data channel. */
-    sendChat(text) {
-        const msg = { from: this.id, name: this.displayName, text, t: Date.now() };
-        const payload = JSON.stringify(msg);
-        for (const info of this._peers.values()) {
-            const dc = info.chat;
-            if (dc && dc.readyState === 'open') {
-                try { dc.send(payload); } catch (_) {}
-            }
-        }
-        // Echo locally so the sender sees their own message.
-        this._emit('chat', msg);
-    }
-
-    // ---- Peer plumbing ---------------------------------------------------
-
-    _addPeer(remoteId, remoteName) {
-        // Perfect-negotiation politeness: the peer with the larger id is polite.
-        const polite = this.id > remoteId;
-        const peer = new window.$.Peer(remoteId, this._signaling, {
-            polite,
-            iceServers: this.iceServers,
-        });
-
-        /** @type {PeerInfo} */
-        const info = { id: remoteId, name: remoteName, stream: null, peer, chat: null };
-        this._peers.set(remoteId, info);
-
-        // Collect remote tracks into a single MediaStream per peer.
-        peer.on('track', (ev) => {
-            const stream = ev.streams && ev.streams[0]
-                ? ev.streams[0]
-                : (info.stream || new MediaStream([ev.track]));
-            info.stream = stream;
-            this._emit('peers', this._peers);
-        });
-
-        // The peer with the smaller id opens the chat channel so we only get
-        // one per pair. The other side picks it up via 'datachannel'.
-        if (this.id < remoteId) {
-            const dc = peer.createDataChannel('chat');
-            this._wireChat(info, dc);
-        } else {
-            peer.on('datachannel', (ev) => this._wireChat(info, ev.channel));
-        }
-
-        peer.on('connectionstatechange', (state) => {
-            if (state === 'failed' || state === 'closed') this._removePeer(remoteId);
-        });
-
-        peer.on('error', (err) => this._emit('error', err));
-
-        // Publish local tracks (camera + mic) so the negotiation fires.
-        if (this._localStream) {
-            for (const track of this._localStream.getTracks()) {
-                const sender = peer.addTrack(track, this._localStream);
-                if (track.kind === 'video') this._videoSenders.set(remoteId, sender);
-            }
-        }
-
-        this._emit('peers', this._peers);
-        this._emit('status', 'Peer joined: ' + remoteName);
-    }
-
-    _wireChat(info, dc) {
-        info.chat = dc;
-        dc.onmessage = (ev) => {
-            try { this._emit('chat', JSON.parse(ev.data)); }
-            catch (_) { /* ignore malformed */ }
-        };
-        dc.onopen  = () => this._emit('status', info.name + ' is now connected.');
-        dc.onclose = () => { if (info.chat === dc) info.chat = null; };
-    }
-
-    _removePeer(remoteId) {
-        const info = this._peers.get(remoteId);
-        if (!info) return;
-        try { info.peer.close(); } catch (_) {}
-        this._peers.delete(remoteId);
-        this._videoSenders.delete(remoteId);
-        this._emit('peers', this._peers);
-        this._emit('status', 'Peer left: ' + info.name);
-    }
-}