@loadbare/app 0.6.0 → 0.7.1

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

@@ -1,339 +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 { applyList } from "../hub/lb-apply";
-import { body } from "./helpers/dom";
-import { captured } from "./helpers/console";
-/**
- * A list scope: the template a developer wrote, and nothing else. No widget,
- * because the hub reconciles a list itself and the default placement 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(`<div lb-list="members">${template}</div>`).firstElementChild;
-}
-/** The same scope, with a widget's placement hook on it. */
-function placing(lbPlaceRow, template) {
-    const scope = list(template);
-    scope.lbPlaceRow = lbPlaceRow;
-    return scope;
-}
-/** The keys of the rows showing, in document order. */
-function keys(scope) {
-    return [...scope.querySelectorAll(`[lb-key-value]`)].map((el) => el.getAttribute("lb-key-value"));
-}
-/** What each row is showing, in document order. */
-function shown(scope) {
-    return [...scope.querySelectorAll(`[lb-key-value]`)].map((el) => el.textContent.trim());
-}
-/** A whole set is the array itself; `Array.isArray` is the discriminant. */
-const rows = (set) => set;
-const patch = (change) => change;
-// --- The whole set -------------------------------------------------------
-describe("a rows result", () => {
-    it("clones the template once per row and fills it", () => {
-        const scope = list();
-        applyList(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; lb-key-value is
-        // stamped on the row with that row's value of it.
-        const scope = list();
-        applyList(scope, rows([{ id: "7", name: "Ada" }]));
-        const row = scope.querySelector("p");
-        assert.equal(row.getAttribute("lb-key-value"), "7");
-    });
-    it("leaves the template where it was, after the rows", () => {
-        const scope = list();
-        applyList(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();
-        applyList(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        applyList(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();
-        applyList(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        applyList(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();
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        const before = scope.querySelector("p");
-        applyList(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();
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        applyList(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();
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        applyList(scope, patch({ rows: [{ id: "2", name: "Bab" }] }));
-        assert.deepEqual(keys(scope), ["1", "2"]);
-    });
-    it("updates a row it names", () => {
-        const scope = list();
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        applyList(scope, patch({ rows: [{ id: "1", name: "Grace" }] }));
-        assert.deepEqual(shown(scope), ["Grace"]);
-    });
-    it("drops a row it names", () => {
-        const scope = list();
-        applyList(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        applyList(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();
-        applyList(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-            { id: "3", name: "Cai" },
-        ]));
-        applyList(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 scope = placing((el, _row, template) => {
-            placed.push(el.getAttribute("lb-key-value"));
-            template.parentElement.insertBefore(el, template);
-        });
-        applyList(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        placed.length = 0;
-        applyList(scope, patch({ rows: [{ id: "1", name: "Grace" }] }));
-        assert.deepEqual(placed, [], "an existing row is filled, never placed");
-    });
-    it("places a row it has not seen before", () => {
-        const placed = [];
-        const scope = placing((el, _row, template) => {
-            placed.push(el.getAttribute("lb-key-value"));
-            template.parentElement.insertBefore(el, template);
-        });
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        placed.length = 0;
-        applyList(scope, patch({ rows: [{ id: "2", name: "Bab" }] }));
-        assert.deepEqual(placed, ["2"]);
-    });
-    it("ignores a drop for a row that is not showing", () => {
-        const scope = list();
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        assert.doesNotThrow(() => applyList(scope, patch({ drop: ["9"] })));
-        assert.deepEqual(keys(scope), ["1"]);
-    });
-    it("naming nothing changes nothing", () => {
-        const scope = list();
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        const before = scope.innerHTML;
-        applyList(scope, patch({}));
-        assert.equal(scope.innerHTML, before);
-    });
-});
-// --- Placement -----------------------------------------------------------
-describe("placement", () => {
-    it("hands the widget the element, the row and the template", () => {
-        const seen = [];
-        const scope = placing((el, row, template) => {
-            seen.push([el.localName, row, template.localName]);
-            template.parentElement.insertBefore(el, template);
-        });
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        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 scope = placing((el, _row, template) => {
-            atPlacement = el.textContent.trim();
-            template.parentElement.insertBefore(el, template);
-        });
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        assert.equal(atPlacement, "Ada");
-    });
-    it("hands the widget a row that is not yet in the document", () => {
-        let connected = true;
-        const scope = placing((el, _row, template) => {
-            connected = el.parentElement !== null;
-            template.parentElement.insertBefore(el, template);
-        });
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        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();
-        applyList(scope, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        assert.equal(scope.getAttribute("lb-row-count"), "2");
-    });
-    it("is zero for an empty set", () => {
-        const scope = list();
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        applyList(scope, rows([]));
-        assert.equal(scope.getAttribute("lb-row-count"), "0");
-    });
-    it("reports the same fact the same way after a set and after a patch", () => {
-        const viaRows = list();
-        applyList(viaRows, rows([
-            { id: "1", name: "Ada" },
-            { id: "2", name: "Bab" },
-        ]));
-        const viaPatch = list();
-        applyList(viaPatch, rows([
-            { id: "1", name: "Ada" },
-            { id: "3", name: "Cai" },
-        ]));
-        applyList(viaPatch, patch({ rows: [{ id: "2", name: "Bab" }], drop: ["3"] }));
-        assert.equal(viaPatch.getAttribute("lb-row-count"), viaRows.getAttribute("lb-row-count"));
-    });
-});
-// --- What it refuses to guess at ----------------------------------------
-describe("applyList reports and stops", () => {
-    it("says nothing about a scope with no row template", async () => {
-        // Bound to the list without displaying it: an insert form names the list
-        // it adds a row to, and has no rows of its own. Not a mistake, so not a
-        // message.
-        const scope = body(`<div></div>`).firstElementChild;
-        const { error } = await captured(() => applyList(scope, rows([{ id: "1" }])));
-        assert.deepEqual(error, []);
-        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(() => applyList(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(`<div></div>`).firstElementChild;
-        await captured(() => applyList(scope, rows([{ id: "1" }])));
-        assert.equal(scope.hasAttribute("lb-row-count"), false);
-    });
-    it("when a row has no key cell, and lands its siblings anyway", async () => {
-        const scope = list();
-        const { error } = await captured(() => applyList(scope, rows([
-            { id: "1", name: "Ada" },
-            { name: "nameless" },
-            { id: "2", name: "Bab" },
-        ])));
-        assert.match(error.join("\n"), /a row for <div> has no 'id' column/);
-        assert.deepEqual(keys(scope), ["1", "2"]);
-    });
-    it("and a keyless row does not take a surviving row down with it", async () => {
-        // A row 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();
-        applyList(scope, rows([{ id: "1", name: "Ada" }]));
-        await captured(() => applyList(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();
-        applyList(once, rows(SET));
-        const twice = list();
-        applyList(twice, rows(SET));
-        applyList(twice, rows(SET));
-        assert.equal(twice.innerHTML, once.innerHTML);
-        assert.equal(twice.getAttribute("lb-row-count"), once.getAttribute("lb-row-count"));
-    });
-    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();
-        applyList(fresh, rows(SET));
-        const expected = fresh.innerHTML;
-        for (const [index, history] of histories.entries()) {
-            const scope = list();
-            for (const step of history)
-                applyList(scope, step);
-            applyList(scope, rows(SET));
-            assert.equal(scope.innerHTML, expected, `history ${index} did not converge`);
-            assert.equal(scope.getAttribute("lb-row-count"), 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"}