@loadbare/app 0.5.6 → 0.7.0

package/dist/tests/lb-rows.test.js

@@ -1,336 +0,0 @@
-/**
- * The row machinery — see docs/testing.md, tier 3.
- *
- * This is the most intricate code in the framework and the most likely to
- * break in ways nobody notices, because what it gets wrong is a row in the
- * wrong place rather than an exception.
- *
- * The last describe holds the two properties. Reconciliation's contract is
- * convergence, and two properties state it better than twenty examples.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { applyRows } from "../hub/lb-rows";
-import { body } from "./helpers/dom";
-import { captured } from "./helpers/console";
-/**
- * A list widget's subtree: the template a page author wrote, and nothing
- * else. The default `place` puts rows in front of the template, so the
- * template staying put is part of what is under test.
- */
-function list(template = `<template lb-key="id"><p><span lb-cell="name"></span></p></template>`) {
-    return body(`<lb-list>${template}</lb-list>`).firstElementChild;
-}
-/** The keys of the rows showing, in document order. */
-function keys(scope) {
-    return [...scope.querySelectorAll(`[lb-key]`)]
-        .filter((el) => el.localName !== "template")
-        .map((el) => el.getAttribute("lb-key"));
-}
-/** What each row is showing, in document order. */
-function shown(scope) {
-    return [...scope.querySelectorAll(`[lb-key]`)]
-        .filter((el) => el.localName !== "template")
-        .map((el) => el.textContent.trim());
-}
-const rows = (list) => ({ op: "rows", rows: list });
-const patch = (change) => ({ op: "patch", ...change });
-// --- The whole set -------------------------------------------------------
-describe("a rows result", () => {
-    it("clones the template once per tuple and fills it", () => {
-        const scope = list();
-        applyRows(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        assert.deepEqual(keys(scope), ["1", "2"]);
-        assert.deepEqual(shown(scope), ["Ada", "Bab"]);
-    });
-    it("carries the key value on the live row", () => {
-        // lb-key names the key column on the template and carries the key value
-        // on a row. One name in two positions, never ambiguous, because a
-        // template is not a row.
-        const scope = list();
-        applyRows(scope, rows([{ id: "7", name: "Ada" }]));
-        const row = scope.querySelector("p");
-        assert.equal(row.getAttribute("lb-key"), "7");
-    });
-    it("leaves the template where it was, after the rows", () => {
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]));
-        assert.equal(scope.lastElementChild.localName, "template");
-    });
-    it("decides membership: a key that did not arrive is gone", () => {
-        const scope = list();
-        applyRows(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        applyRows(scope, rows([{ id: "2", name: "Bab" }]));
-        assert.deepEqual(keys(scope), ["2"]);
-    });
-    it("decides order: a row that already exists is placed again", () => {
-        const scope = list();
-        applyRows(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        applyRows(scope, rows([
-            { id: "2", name: "Bab" },
-            { id: "1", name: "Ada" },
-        ]));
-        assert.deepEqual(keys(scope), ["2", "1"]);
-    });
-    it("updates a row it keeps rather than replacing it", () => {
-        // The row is the same element, so anything a widget put on it survives.
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]));
-        const before = scope.querySelector("p");
-        applyRows(scope, rows([{ id: "1", name: "Grace" }]));
-        assert.equal(scope.querySelector("p"), before, "same element");
-        assert.deepEqual(shown(scope), ["Grace"]);
-    });
-    it("empties the list when the set is empty", () => {
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]));
-        applyRows(scope, rows([]));
-        assert.deepEqual(keys(scope), []);
-        assert.equal(scope.querySelector("template"), scope.firstElementChild);
-    });
-});
-// --- Only what changed ---------------------------------------------------
-describe("a patch result", () => {
-    it("adds a row it names", () => {
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]));
-        applyRows(scope, patch({ rows: [{ id: "2", name: "Bab" }] }));
-        assert.deepEqual(keys(scope), ["1", "2"]);
-    });
-    it("updates a row it names", () => {
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]));
-        applyRows(scope, patch({ rows: [{ id: "1", name: "Grace" }] }));
-        assert.deepEqual(shown(scope), ["Grace"]);
-    });
-    it("drops a row it names", () => {
-        const scope = list();
-        applyRows(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        applyRows(scope, patch({ drop: ["1"] }));
-        assert.deepEqual(keys(scope), ["2"]);
-    });
-    it("leaves a row it did not name, in contents and in place", () => {
-        const scope = list();
-        applyRows(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-            { id: "3", name: "Cai" },
-        ]));
-        applyRows(scope, patch({ rows: [{ id: "2", name: "Grace" }] }));
-        assert.deepEqual(keys(scope), ["1", "2", "3"]);
-        assert.deepEqual(shown(scope), ["Ada", "Grace", "Cai"]);
-    });
-    it("does not re-place a row that already exists", () => {
-        // Today's behavior, and exactly the gap NEEDED-FOR-1.0 names: a row whose
-        // sort column changed stays where it was. This test states what is true
-        // now, and is the one that flips when that item closes.
-        const placed = [];
-        const place = (row, _tuple, template) => {
-            placed.push(row.getAttribute("lb-key"));
-            template.parentElement.insertBefore(row, template);
-        };
-        const scope = list();
-        applyRows(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]), place);
-        placed.length = 0;
-        applyRows(scope, patch({ rows: [{ id: "1", name: "Grace" }] }), place);
-        assert.deepEqual(placed, [], "an existing row is filled, never placed");
-    });
-    it("places a row it has not seen before", () => {
-        const placed = [];
-        const place = (row, _tuple, template) => {
-            placed.push(row.getAttribute("lb-key"));
-            template.parentElement.insertBefore(row, template);
-        };
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]), place);
-        placed.length = 0;
-        applyRows(scope, patch({ rows: [{ id: "2", name: "Bab" }] }), place);
-        assert.deepEqual(placed, ["2"]);
-    });
-    it("ignores a drop for a row that is not showing", () => {
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]));
-        assert.doesNotThrow(() => applyRows(scope, patch({ drop: ["9"] })));
-        assert.deepEqual(keys(scope), ["1"]);
-    });
-    it("naming nothing changes nothing", () => {
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]));
-        const before = scope.innerHTML;
-        applyRows(scope, patch({}));
-        assert.equal(scope.innerHTML, before);
-    });
-});
-// --- Placement -----------------------------------------------------------
-describe("placement", () => {
-    it("hands the widget the row, the tuple and the template", () => {
-        const seen = [];
-        const place = (row, tuple, template) => {
-            seen.push([row.localName, tuple, template.localName]);
-            template.parentElement.insertBefore(row, template);
-        };
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]), place);
-        assert.deepEqual(seen, [["p", { id: "1", name: "Ada" }, "template"]]);
-    });
-    it("fills the row before the widget places it", () => {
-        // The attributes are already there when the row upgrades, which is the
-        // same thing that makes hydration and refresh one operation everywhere
-        // else. A widget that reads a cell to decide where the row goes — every
-        // sorting or grouping widget — depends on this ordering.
-        let atPlacement = "";
-        const place = (row, _tuple, template) => {
-            atPlacement = row.textContent.trim();
-            template.parentElement.insertBefore(row, template);
-        };
-        applyRows(list(), rows([{ id: "1", name: "Ada" }]), place);
-        assert.equal(atPlacement, "Ada");
-    });
-    it("hands the widget a row that is not yet in the document", () => {
-        let connected = true;
-        const place = (row, _tuple, template) => {
-            connected = row.parentElement !== null;
-            template.parentElement.insertBefore(row, template);
-        };
-        applyRows(list(), rows([{ id: "1", name: "Ada" }]), place);
-        assert.equal(connected, false, "the row arrives detached");
-    });
-});
-// --- How many are showing ------------------------------------------------
-describe("the row count", () => {
-    it("is stamped on the widget", () => {
-        // The one conditional a page cannot be sent: the server answers with rows
-        // and says nothing about how many survived reconciliation. It is here so
-        // that "no members yet" is a stylesheet rule rather than code in every
-        // list widget.
-        const scope = list();
-        applyRows(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        assert.equal(scope.getAttribute("data-rows"), "2");
-    });
-    it("is zero for an empty set", () => {
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]));
-        applyRows(scope, rows([]));
-        assert.equal(scope.getAttribute("data-rows"), "0");
-    });
-    it("reports the same fact the same way after a set and after a patch", () => {
-        const viaRows = list();
-        applyRows(viaRows, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        const viaPatch = list();
-        applyRows(viaPatch, rows([
-            { id: "1", name: "Ada" },
-            { id: "3", name: "Cai" },
-        ]));
-        applyRows(viaPatch, patch({ rows: [{ id: "2", name: "Bab" }], drop: ["3"] }));
-        assert.equal(viaPatch.getAttribute("data-rows"), viaRows.getAttribute("data-rows"));
-    });
-});
-// --- What it refuses to guess at ----------------------------------------
-describe("applyRows reports and stops", () => {
-    it("when the widget has no template to clone", async () => {
-        const scope = body(`<lb-list></lb-list>`).firstElementChild;
-        const { error } = await captured(() => applyRows(scope, rows([{ id: "1" }])));
-        assert.match(error.join("\n"), /<lb-list> has no <template> to clone/);
-        assert.equal(scope.children.length, 0, "nothing was invented");
-    });
-    it("when the template does not name the key column", async () => {
-        const scope = list(`<template><p></p></template>`);
-        const { error } = await captured(() => applyRows(scope, rows([{ id: "1" }])));
-        assert.match(error.join("\n"), /has no lb-key naming the column that identifies a row/);
-        assert.deepEqual(keys(scope), []);
-    });
-    it("does not stamp a count it could not compute", async () => {
-        const scope = body(`<lb-list></lb-list>`).firstElementChild;
-        await captured(() => applyRows(scope, rows([{ id: "1" }])));
-        assert.equal(scope.hasAttribute("data-rows"), false);
-    });
-    it("when a tuple has no key cell, and lands its siblings anyway", async () => {
-        const scope = list();
-        const { error } = await captured(() => applyRows(scope, rows([
-            { id: "1", name: "Ada" },
-            { name: "nameless" },
-            { id: "2", name: "Bab" },
-        ])));
-        assert.match(error.join("\n"), /a tuple for <lb-list> has no 'id' cell/);
-        assert.deepEqual(keys(scope), ["1", "2"]);
-    });
-    it("and a keyless tuple does not take a surviving row down with it", async () => {
-        // A tuple with no key contributes no key to the arrived set, so the
-        // reconciliation that follows must not read its absence as a removal.
-        const scope = list();
-        applyRows(scope, rows([{ id: "1", name: "Ada" }]));
-        await captured(() => applyRows(scope, rows([{ id: "1", name: "Ada" }, { name: "nameless" }])));
-        assert.deepEqual(keys(scope), ["1"]);
-    });
-});
-// --- The properties ------------------------------------------------------
-describe("reconciliation converges", () => {
-    const SET = [
-        { id: "1", name: "Ada" },
-        { id: "2", name: "Bab" },
-        { id: "3", name: "Cai" },
-    ];
-    it("so applying the same set twice is applying it once", () => {
-        const once = list();
-        applyRows(once, rows(SET));
-        const twice = list();
-        applyRows(twice, rows(SET));
-        applyRows(twice, rows(SET));
-        assert.equal(twice.innerHTML, once.innerHTML);
-        assert.equal(twice.getAttribute("data-rows"), once.getAttribute("data-rows"));
-    });
-    it("so a set reached through any patches is the set reached from empty", () => {
-        // Every history below ends at SET. A reconciler that leaks state — a row
-        // it forgot to remove, an order it kept from before, a count it stamped
-        // from the wrong branch — fails here and nowhere else.
-        const histories = [
-            [],
-            [rows([])],
-            [rows([{ id: "9", name: "Zed" }])],
-            [rows(SET.slice().reverse())],
-            [
-                rows([{ id: "1", name: "Wrong" }]),
-                patch({ rows: [{ id: "5", name: "Eve" }] }),
-            ],
-            [rows(SET), patch({ drop: ["2"] })],
-            [
-                rows(SET),
-                patch({ rows: [{ id: "3", name: "Changed" }] }),
-                patch({ drop: ["1"] }),
-            ],
-            [patch({ rows: [{ id: "4", name: "Dot" }] }), patch({ drop: ["4"] })],
-        ];
-        const fresh = list();
-        applyRows(fresh, rows(SET));
-        const expected = fresh.innerHTML;
-        for (const [index, history] of histories.entries()) {
-            const scope = list();
-            for (const step of history)
-                applyRows(scope, step);
-            applyRows(scope, rows(SET));
-            assert.equal(scope.innerHTML, expected, `history ${index} did not converge`);
-            assert.equal(scope.getAttribute("data-rows"), String(SET.length));
-        }
-    });
-});

package/dist/tests/lb-server.test.d.ts

@@ -1,9 +0,0 @@
-/**
- * The engine — see docs/testing.md, tier 2.
- *
- * `createHub` takes a plain object and returns an object. Nothing in
- * server/lb-server.ts opens a socket or knows what a request is, so every
- * fixture here is a counting stub and the whole tier runs in node.
- */
-export {};
-//# sourceMappingURL=lb-server.test.d.ts.map

package/dist/tests/lb-server.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lb-server.test.d.ts","sourceRoot":"","sources":["../../tests/lb-server.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}