Merge branch 'wp-d-chips'

This commit is contained in:
Wolf committed 2026-09-29 22:01:07 +02:00
commit 7a282a181d
3 files changed
+811

No files matched your search

+409
View File
@@ -0,0 +1,409 @@
// The chip input, static/chips.js, without a browser: `keyAction` and
// `unpicked` as functions, then the widget on a DOM stub just large enough
// for it, with the clock mocked for the 150 ms wait.
//
// node --test tests/js/*.test.mjs
//
// Node 22 takes files or globs, not a directory: `node --test tests/js/`
// fails with MODULE_NOT_FOUND.
import { test, beforeEach, afterEach, mock } from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import vm from "node:vm";
// ------------------------------------------------------------ the DOM stub
class Node {
constructor(tag) {
this.tagName = tag.toUpperCase();
this.children = [];
this.parentNode = null;
this.attributes = new Map();
this.listeners = new Map();
this.hidden = false;
this.id = "";
this.value = "";
this._text = "";
this.classList = {
add: (c) => { const s = new Set(this.className.split(" ").filter(Boolean)); s.add(c); this.className = [...s].join(" "); },
contains: (c) => this.className.split(" ").includes(c),
};
this.className = "";
}
get textContent() { return this._text + this.children.map((c) => c.textContent).join(""); }
set textContent(t) { this.children = []; this._text = String(t); }
get lastChild() { return this.children[this.children.length - 1] || null; }
setAttribute(k, v) { this.attributes.set(k, String(v)); }
getAttribute(k) { return this.attributes.has(k) ? this.attributes.get(k) : null; }
removeAttribute(k) { this.attributes.delete(k); }
appendChild(c) { c.remove(); c.parentNode = this; this.children.push(c); return c; }
append(...cs) { for (const c of cs) this.appendChild(c); }
insertBefore(c, ref) {
c.remove();
c.parentNode = this;
const at = this.children.indexOf(ref);
this.children.splice(at < 0 ? this.children.length : at, 0, c);
}
replaceChildren(...cs) { for (const c of [...this.children]) c.remove(); this.append(...cs); }
remove() {
if (!this.parentNode) return;
const siblings = this.parentNode.children;
siblings.splice(siblings.indexOf(this), 1);
this.parentNode = null;
}
addEventListener(type, fn) {
if (!this.listeners.has(type)) this.listeners.set(type, []);
this.listeners.get(type).push(fn);
}
dispatchEvent(event) {
event.target ??= this;
for (let node = this; node && !event.stopped; node = node.parentNode) {
for (const fn of node.listeners.get(event.type) || []) fn(event);
}
return !event.defaultPrevented;
}
focus() {
const was = document.activeElement;
if (was === this) return;
document.activeElement = this;
if (was) was.dispatchEvent(new Event("blur"));
}
blur() { if (document.activeElement === this) { document.activeElement = null; this.dispatchEvent(new Event("blur")); } }
click() { this.dispatchEvent(new Event("click")); }
find(pred) {
for (const c of this.children) {
if (pred(c)) return c;
const deeper = c.find(pred);
if (deeper) return deeper;
}
return null;
}
findAll(pred, out = []) {
for (const c of this.children) { if (pred(c)) out.push(c); c.findAll(pred, out); }
return out;
}
}
class Event {
constructor(type, init = {}) { Object.assign(this, init); this.type = type; this.defaultPrevented = false; this.stopped = false; }
preventDefault() { this.defaultPrevented = true; }
stopPropagation() { this.stopped = true; }
}
const document = { activeElement: null, createElement: (tag) => new Node(tag) };
const window = {};
Object.assign(globalThis, { document, window });
vm.runInThisContext(readFileSync(new URL("../../app/static/chips.js", import.meta.url), "utf8"));
const { chipInput } = window;
const { keyAction, unpicked } = chipInput;
// ------------------------------------------------------------- keyAction
const state = (s) => ({ open: false, active: -1, count: 0, fresh: false, text: "", chips: 0, ...s });
test("arrows move through an open list and wrap at both ends", () => {
const open = state({ open: true, active: 0, count: 3, fresh: true, text: "ma" });
assert.deepEqual(keyAction(open, "ArrowDown"), { act: "move", to: 1, prevent: true });
assert.equal(keyAction({ ...open, active: 2 }, "ArrowDown").to, 0);
assert.equal(keyAction(open, "ArrowUp").to, 2);
assert.equal(keyAction({ ...open, active: 2 }, "ArrowUp").to, 1);
});
test("ArrowDown on a shut list opens it, if there is text to ask about", () => {
assert.equal(keyAction(state({ text: "ma" }), "ArrowDown").act, "open");
assert.equal(keyAction(state({ text: " " }), "ArrowDown"), null);
assert.equal(keyAction(state({ text: "ma" }), "ArrowUp"), null);
});
test("Enter picks the highlighted option, the first when none is", () => {
const open = state({ open: true, active: 2, count: 3, fresh: true, text: "ma" });
assert.deepEqual(keyAction(open, "Enter"), { act: "pick", to: 2, prevent: true });
assert.equal(keyAction({ ...open, active: -1 }, "Enter").to, 0);
});
test("Enter before the answer to the text asks now, and Enter on nothing is the browser's", () => {
assert.equal(keyAction(state({ open: true, count: 3, active: 0, text: "mal" }), "Enter").act, "ask");
assert.equal(keyAction(state({ fresh: true, text: "mal" }), "Enter").act, "ask");
assert.equal(keyAction(state({ text: "" }), "Enter"), null);
});
test("Escape shuts an open list and stops there; on a shut list it is the page's", () => {
assert.deepEqual(keyAction(state({ open: true, count: 1 }), "Escape"), { act: "shut", prevent: true, stop: true });
assert.equal(keyAction(state({}), "Escape"), null);
});
test("Backspace removes the last chip only from an empty field", () => {
assert.equal(keyAction(state({ chips: 2 }), "Backspace").act, "unchip");
assert.equal(keyAction(state({ chips: 2, text: "m" }), "Backspace"), null);
assert.equal(keyAction(state({ chips: 0 }), "Backspace"), null);
});
test("Tab shuts the list without picking, and letters are left alone", () => {
assert.deepEqual(keyAction(state({ open: true, count: 1 }), "Tab"), { act: "shut" });
assert.equal(keyAction(state({ open: true, count: 1 }), "j"), null);
});
test("unpicked drops what is a chip already and repeats of one value", () => {
const got = unpicked(
[{ value: "country:DK" }, { value: "region:skane" }, { value: "region:skane" }, { value: 7 }],
[{ value: "country:DK", label: "Denmark" }, { value: "7", label: "Seven" }],
);
assert.deepEqual(got.map((s) => s.value), ["region:skane"]);
assert.deepEqual(unpicked(null, []), []);
});
// ------------------------------------------------------------ the widget
let root, field, changes, asked, answers;
// `suggest` answers from `answers`, and a query in `slow` only when released.
function make(extra = {}) {
root = new Node("div");
changes = [];
asked = [];
const widget = chipInput(root, {
suggest: (q) => { asked.push(q); return answers(q); },
onChange: (items) => changes.push(items.map((i) => i.value)),
placeholder: "Place",
label: "Place",
...extra,
});
field = root.find((n) => n.tagName === "INPUT");
return widget;
}
const PLACES = [
{ value: "region:skane", label: "Skåne", hint: "region" },
{ value: "place:malmo", label: "Malmö", hint: 203 },
{ value: "place:lund", label: "Lund", hint: 88 },
];
const settle = () => new Promise((resolve) => setImmediate(resolve));
const list = () => root.find((n) => n.getAttribute("role") === "listbox");
const options = () => list().children;
const chips = () => root.findAll((n) => n.classList.contains("chip"));
function type(text) {
field.value = text;
field.dispatchEvent(new Event("input"));
}
function key(k) {
const e = new Event("keydown", { key: k });
field.dispatchEvent(e);
return e;
}
async function typeAndWait(text) {
type(text);
mock.timers.tick(150);
await settle();
}
beforeEach(() => {
mock.timers.enable({ apis: ["setTimeout"] });
document.activeElement = null;
answers = () => Promise.resolve(PLACES);
});
afterEach(() => mock.timers.reset());
test("the field is a combobox that controls a listbox", () => {
make();
assert.equal(field.getAttribute("role"), "combobox");
assert.equal(field.getAttribute("aria-expanded"), "false");
assert.equal(field.getAttribute("aria-controls"), list().id);
assert.equal(field.getAttribute("aria-label"), "Place");
assert.equal(field.placeholder, "Place");
assert.ok(root.classList.contains("chip-input"));
assert.equal(list().hidden, true);
});
test("suggest waits 150 ms after the last keystroke and is not asked for blank text", async () => {
make();
type("m");
mock.timers.tick(100);
type("ma");
mock.timers.tick(149);
assert.deepEqual(asked, []);
mock.timers.tick(1);
assert.deepEqual(asked, ["ma"]);
type(" ");
mock.timers.tick(500);
assert.deepEqual(asked, ["ma"]);
});
test("an answer shows the options with label and hint, the first highlighted", async () => {
make();
await typeAndWait("s");
assert.equal(field.getAttribute("aria-expanded"), "true");
assert.equal(list().hidden, false);
assert.equal(options().length, 3);
const [first, second] = options();
assert.equal(first.getAttribute("role"), "option");
assert.equal(first.textContent, "Skåneregion");
assert.equal(second.children[1].className, "chip-option-hint");
assert.equal(second.children[1].textContent, "203");
assert.equal(first.getAttribute("aria-selected"), "true");
assert.equal(field.getAttribute("aria-activedescendant"), first.id);
});
test("a late answer to an older query is dropped", async () => {
const release = {};
answers = (q) => new Promise((resolve) => { release[q] = () => resolve(q === "s" ? PLACES : [PLACES[0]]); });
make();
type("s");
mock.timers.tick(150);
type("sk");
mock.timers.tick(150);
release.sk();
await settle();
release.s();
await settle();
assert.deepEqual([...options()].map((o) => o.children[0].textContent), ["Skåne"]);
});
test("arrows move the highlight and Enter picks it", async () => {
make();
await typeAndWait("s");
key("ArrowDown");
key("ArrowDown");
assert.equal(field.getAttribute("aria-activedescendant"), options()[2].id);
assert.equal(key("Enter").defaultPrevented, true);
assert.deepEqual(changes, [["place:lund"]]);
});
test("Enter picks the first suggestion, empties the field and keeps focus", async () => {
const widget = make();
field.focus();
await typeAndWait("s");
key("Enter");
assert.deepEqual(widget.values(), [{ value: "region:skane", label: "Skåne" }]);
assert.equal(field.value, "");
assert.equal(document.activeElement, field);
assert.equal(list().hidden, true);
assert.equal(field.getAttribute("aria-expanded"), "false");
assert.equal(chips().length, 1);
assert.equal(chips()[0].getAttribute("aria-label"), "Remove Skåne");
assert.deepEqual(changes, [["region:skane"]]);
});
test("a suggestion already a chip is not offered again", async () => {
make();
await typeAndWait("s");
key("Enter");
await typeAndWait("s");
assert.deepEqual([...options()].map((o) => o.children[0].textContent), ["Malmö", "Lund"]);
});
test("Enter before the answer waits for it and picks its first", async () => {
const widget = make();
type("lund");
answers = () => Promise.resolve([PLACES[2]]);
key("Enter");
assert.deepEqual(asked, ["lund"]);
await settle();
assert.deepEqual(widget.values().map((i) => i.value), ["place:lund"]);
mock.timers.tick(500);
assert.deepEqual(asked, ["lund"], "the waiting query was not asked a second time");
});
test("text that matches no suggestion becomes no chip", async () => {
const widget = make();
answers = () => Promise.resolve([]);
await typeAndWait("zzz");
key("Enter");
await settle();
assert.deepEqual(widget.values(), []);
assert.equal(field.value, "zzz");
assert.deepEqual(changes, []);
assert.equal(list().hidden, true);
});
test("Escape shuts the list and keeps the key from the page; shut, it passes", async () => {
make();
await typeAndWait("s");
const e = key("Escape");
assert.equal(e.stopped, true);
assert.equal(list().hidden, true);
assert.equal(field.getAttribute("aria-activedescendant"), null);
assert.equal(key("Escape").stopped, false);
key("ArrowDown");
assert.equal(list().hidden, false, "ArrowDown brings the same list back");
});
test("Backspace in an empty field removes the last chip", async () => {
const widget = make();
widget.set([{ value: "country:DK", label: "Denmark" }, { value: "region:skane", label: "Skåne" }]);
key("Backspace");
assert.deepEqual(widget.values().map((i) => i.value), ["country:DK"]);
assert.deepEqual(changes, [["country:DK"]]);
field.value = "d";
key("Backspace");
assert.equal(widget.values().length, 1);
});
test("a chip's button removes it and gives the field focus", () => {
const widget = make();
widget.set([{ value: "country:DK", label: "Denmark" }, { value: "region:skane", label: "Skåne" }]);
chips()[0].click();
assert.deepEqual(widget.values().map((i) => i.value), ["region:skane"]);
assert.deepEqual(changes, [["region:skane"]]);
assert.equal(document.activeElement, field);
});
test("a click on an option picks it, and its mousedown keeps the field's focus", async () => {
const widget = make();
await typeAndWait("s");
const down = new Event("mousedown");
options()[1].dispatchEvent(down);
assert.equal(down.defaultPrevented, true);
options()[1].click();
assert.deepEqual(widget.values().map((i) => i.value), ["place:malmo"]);
});
test("leaving the field shuts the list, and a late answer does not open it", async () => {
let release;
answers = () => new Promise((resolve) => { release = () => resolve(PLACES); });
make();
field.focus();
type("s");
mock.timers.tick(150);
field.blur();
release();
await settle();
assert.equal(list().hidden, true);
assert.equal(field.getAttribute("aria-expanded"), "false");
});
test("a failed suggest shuts the list and makes no chip", async () => {
const widget = make();
answers = () => Promise.reject(new Error("down"));
await typeAndWait("s");
key("Enter");
await settle();
assert.equal(list().hidden, true);
assert.deepEqual(widget.values(), []);
});
test("set and clear do not call onChange, and values is a copy", () => {
const widget = make();
widget.set([{ value: "country:DK", label: "Denmark" }, { value: "country:DK", label: "Denmark" }, { value: "x" }]);
assert.deepEqual(widget.values(), [{ value: "country:DK", label: "Denmark" }, { value: "x", label: "x" }]);
assert.equal(chips().length, 2);
widget.values()[0].label = "changed";
assert.equal(widget.values()[0].label, "Denmark");
field.value = "left over";
widget.clear();
assert.deepEqual(widget.values(), []);
assert.equal(field.value, "");
assert.equal(chips().length, 0);
assert.deepEqual(changes, []);
});
test("two fields on one page have their own ids", () => {
make();
const first = list().id;
make();
assert.notEqual(list().id, first);
});