@excom/quark 0.1.0

package/support/tests/resolvers.test.ts

@@ -0,0 +1,346 @@
+/**
+ * Field resolvers: value semantics (wipe / preserve) per declaration kind,
+ * content rendering of raw nodes and promises, and the DevTools result
+ * presentation of each shape.
+ */
+import { Quark } from "../../index";
+import { SYMBOL_NOOP } from "../../src/constants";
+import { FIELD_RESOLVERS, resolveField } from "../../src/resolvers";
+import { NUCLEUS_DEVTOOLS_HOOK_KEY } from "@excom/kit-devtools";
+import {
+  afterEach,
+  describe,
+  expect,
+  it,
+  vi,
+  wait,
+} from "@excom/heft-rig/profiles/default/config/test-utils";
+import { flush, mount, unregisterAll } from "./helpers";
+
+describe("resolvers", () => {
+  afterEach(() => {
+    unregisterAll();
+    document.body.innerHTML = "";
+    delete (globalThis as any)[NUCLEUS_DEVTOOLS_HOOK_KEY];
+    vi.restoreAllMocks();
+  });
+
+  describe("content", () => {
+    it("wipes rendered rows but keeps the source <template>", async () => {
+      const { root } = mount(
+        `<ul><template><li></li></template><li>old</li></ul>`,
+        `ul { content: none; }`
+      );
+      await flush();
+      const ul = root.querySelector("ul")!;
+      expect(ul.querySelector("template")).toBeTruthy();
+      expect(ul.querySelectorAll("li")).toHaveLength(0);
+    });
+
+    it("wipes on null and on unbound variables", async () => {
+      const { root } = mount(
+        `<p bind-a>stale</p><p bind-b>stale</p>`,
+        `[bind-a] { content: null; }
+         [bind-b] { content: $missing; }`
+      );
+      await flush();
+      expect(root.querySelector("[bind-a]")?.textContent).toBe("");
+      expect(root.querySelector("[bind-b]")?.textContent).toBe("");
+    });
+
+    it("paints a Node and a NodeList into a regular element", async () => {
+      const node = document.createElement("em");
+      node.textContent = "one";
+      const wrap = document.createElement("div");
+      wrap.innerHTML = `<i>a</i><i>b</i>`;
+      const { root } = mount(
+        `<p bind-node></p><p bind-list></p>`,
+        `[bind-node] { content: getNode(); }
+         [bind-list] { content: getList(); }`,
+        { getNode: () => node, getList: () => wrap.childNodes }
+      );
+      await flush();
+      expect(root.querySelector("[bind-node]")?.innerHTML).toBe("<em>one</em>");
+      expect(root.querySelector("[bind-list]")?.innerHTML).toBe(
+        "<i>a</i><i>b</i>"
+      );
+    });
+
+    it("settles promises: strings paint, wipes clear, preserve keeps", async () => {
+      const { root } = mount(
+        `<p bind-s>stale</p><p bind-w>stale</p><p bind-p>stale</p>`,
+        `[bind-s] { content: later("done"); }
+         [bind-w] { content: later(null); }
+         [bind-p] { content: later(keep); }`,
+        {
+          later: (v: unknown) => Promise.resolve(v),
+          keep: SYMBOL_NOOP,
+        }
+      );
+      await flush();
+      expect(root.querySelector("[bind-s]")?.textContent).toBe("done");
+      expect(root.querySelector("[bind-w]")?.textContent).toBe("");
+      expect(root.querySelector("[bind-p]")?.textContent).toBe("stale");
+    });
+
+    it("logs a rejected content promise without touching the element", async () => {
+      const error = vi.spyOn(console, "error").mockImplementation(() => {});
+      const { root } = mount(
+        `<p bind-x>stale</p>`,
+        `[bind-x] { content: failing(); }`,
+        { failing: () => Promise.reject(new Error("nope")) }
+      );
+      await flush();
+      expect(root.querySelector("[bind-x]")?.textContent).toBe("stale");
+      expect(error).toHaveBeenCalled();
+    });
+
+    it("re-paints only when the text differs from the sole text node", async () => {
+      const { root, quark } = mount(
+        `<p bind-x>same</p>`,
+        `[bind-x] { content: "same"; }`
+      );
+      await flush();
+      const p = root.querySelector("[bind-x]")!;
+      const first = p.firstChild;
+      quark.queueRunRules({ element: p as HTMLElement, attribute: "NEW_SELF" });
+      await flush();
+      expect(p.firstChild).toBe(first);
+    });
+  });
+
+  describe("class", () => {
+    it("accepts strings, arrays and maps; preserve and none", async () => {
+      const { root } = mount(
+        `<p bind-a class="old"></p><p bind-b class="old"></p>
+         <p bind-c class="keep"></p><p bind-d class="gone"></p>`,
+        `[bind-a] { class: ["x", "y"]; }
+         [bind-b] { class: (old: false, z: true); }
+         [bind-c] { class: preserve; }
+         [bind-d] { class: none; }`
+      );
+      await flush();
+      expect(root.querySelector("[bind-a]")?.className).toBe("x y");
+      expect(root.querySelector("[bind-b]")?.className).toBe("z");
+      expect(root.querySelector("[bind-c]")?.className).toBe("keep");
+      expect(root.querySelector("[bind-d]")?.hasAttribute("class")).toBe(false);
+    });
+  });
+
+  describe("dataset / ariaset", () => {
+    it("replaces previously written prefixed attributes and honours wipe / preserve", async () => {
+      const { root } = mount(
+        `<p bind-x data-mode="a" title="t"></p><p bind-y></p><p bind-z aria-label="k"></p>`,
+        `[bind-x] { title: "t2"; dataset: prop("box"); ariaset: prop("aria"); }
+         [bind-y] { dataset: none; ariaset: none; }
+         [bind-z] { dataset: preserve; ariaset: preserve; }`
+      );
+      const p = root.querySelector("[bind-x]") as HTMLElement & {
+        box?: unknown;
+        aria?: unknown;
+      };
+      p.box = { first: 1 };
+      p.aria = { label: "one" };
+      await flush();
+      expect(p.getAttribute("data-first")).toBe("1");
+      expect(p.getAttribute("aria-label")).toBe("one");
+      p.box = { second: 2 };
+      p.aria = { hidden: "true" };
+      await flush();
+      // attributes written by the earlier object are removed; foreign ones stay
+      expect(p.hasAttribute("data-first")).toBe(false);
+      expect(p.getAttribute("data-second")).toBe("2");
+      expect(p.hasAttribute("aria-label")).toBe(false);
+      expect(p.getAttribute("aria-hidden")).toBe("true");
+      expect(p.getAttribute("data-mode")).toBe("a");
+      expect(p.getAttribute("title")).toBe("t2");
+      expect(root.querySelector("[bind-z]")?.getAttribute("aria-label")).toBe(
+        "k"
+      );
+    });
+  });
+
+  describe("direct resolver calls", () => {
+    it("publishes failures without a rule and with non-Error throws", async () => {
+      const error = vi.spyOn(console, "error").mockImplementation(() => {});
+      const publications: { path: string[]; meta: any }[] = [];
+      Quark.attachDevtools({
+        version: 1,
+        inject: () => {},
+        publicize: (path, meta) => {
+          publications.push({ path: path as string[], meta });
+        },
+      });
+      const element = document.createElement("p");
+      expect(
+        resolveField({
+          element,
+          key: "data-x",
+          value: "nope()",
+          options: {},
+          hash: "h",
+        })
+      ).toBe(SYMBOL_NOOP);
+      const [err] = publications.filter(
+        (p) => p.path.join("/") === "quark/error"
+      );
+      expect(err.meta).toMatchObject({
+        selector: null,
+        ruleId: null,
+        sheetId: null,
+        runId: null,
+        errorName: "QuarkEvalError",
+      });
+      const [apply] = publications.filter(
+        (p) => p.path.join("/") === "quark/apply"
+      );
+      expect(apply.meta).toMatchObject({
+        selector: null,
+        ruleId: null,
+        isNoop: true,
+      });
+      expect(error).toHaveBeenCalledTimes(1);
+    });
+
+    it("stringifies thrown non-Error values", async () => {
+      vi.spyOn(console, "error").mockImplementation(() => {});
+      const publications: { path: string[]; meta: any }[] = [];
+      Quark.attachDevtools({
+        version: 1,
+        inject: () => {},
+        publicize: (path, meta) => {
+          publications.push({ path: path as string[], meta });
+        },
+      });
+      const { root } = mount(
+        `<p bind-x>stale</p>`,
+        `[bind-x] { content: boom(); }`,
+        {
+          boom: () => {
+            throw "plain string";
+          },
+        }
+      );
+      await flush();
+      expect(root.querySelector("[bind-x]")?.textContent).toBe("stale");
+      const [err] = publications.filter(
+        (p) => p.path.join("/") === "quark/error"
+      );
+      expect(err.meta.errorMessage).toBe("plain string");
+      expect(err.meta.errorName).toBeUndefined();
+    });
+
+    it("ignores falsy non-wipe dataset values and unsupported class shapes", async () => {
+      const { root } = mount(
+        `<p bind-x class="keep"></p>`,
+        `[bind-x] { dataset: false; ariaset: 0; class: 5; }`
+      );
+      await flush();
+      const p = root.querySelector("[bind-x]")!;
+      expect(p.className).toBe("keep");
+      expect([...p.attributes].map((a) => a.name)).toEqual(["bind-x", "class"]);
+    });
+
+    it("treats an empty declaration value as a wipe", async () => {
+      const element = document.createElement("p");
+      element.setAttribute("data-x", "1");
+      const result = FIELD_RESOLVERS.attribute({
+        element,
+        key: "data-x",
+        value: "",
+        options: {},
+        hash: "h",
+      });
+      expect(result).toBeUndefined();
+      await wait(0);
+      expect(element.hasAttribute("data-x")).toBe(false);
+    });
+  });
+
+  describe("listener", () => {
+    it("leaves listeners untouched when the handler list is preserve", async () => {
+      const handler = vi.fn();
+      const { root } = mount(
+        `<button type="button" bind-x></button>`,
+        `[bind-x] { @on click (handle: handler); }
+         [bind-x] { @on click (handle: preserve); }`,
+        { handler }
+      );
+      await flush();
+      (root.querySelector("[bind-x]") as HTMLButtonElement).click();
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("DevTools result presentation", () => {
+    const publications: { path: string[]; meta: any }[] = [];
+    const installHook = () =>
+      Quark.attachDevtools({
+        version: 1,
+        inject: () => {},
+        publicize: (path, meta) => {
+          publications.push({ path: path as string[], meta });
+        },
+      });
+    afterEach(() => {
+      publications.length = 0;
+    });
+    const applyFor = (selector: string) =>
+      publications.find(
+        (p) =>
+          p.path.join("/") === "quark/apply" &&
+          p.meta.key === "content" &&
+          p.meta.selector === selector
+      )!;
+
+    it("expands NodeLists, fragments and arrays; unwraps rejected promises", async () => {
+      installHook();
+      const wrap = document.createElement("div");
+      wrap.innerHTML = `<i>a</i><i>b</i>`;
+      const fragment = document.createDocumentFragment();
+      fragment.appendChild(document.createTextNode("  "));
+      fragment.appendChild(document.createTextNode("txt"));
+      fragment.appendChild(document.createElement("b"));
+      const error = vi.spyOn(console, "error").mockImplementation(() => {});
+      mount(
+        `<p bind-list></p><p bind-frag></p><p bind-arr></p><p bind-fail></p>`,
+        `[bind-list] { content: getList(); }
+         [bind-frag] { content: getFragment(); }
+         [bind-arr] { data-x: getArray(); }
+         [bind-fail] { content: failing(); }`,
+        {
+          getList: () => wrap.childNodes,
+          getFragment: () => fragment,
+          getArray: () => ["a", 1],
+          failing: () => Promise.reject(new Error("nope")),
+        }
+      );
+      await flush();
+      expect(applyFor("[bind-list]").meta.result).toEqual([
+        { $element: "i", id: null },
+        { $element: "i", id: null },
+      ]);
+      // whitespace-only text nodes are dropped; others serialise as nodes
+      expect(applyFor("[bind-frag]").meta.result).toEqual([
+        { $node: "#text" },
+        { $element: "b", id: null },
+      ]);
+      const arr = publications.find((p) => p.meta.key === "data-x")!;
+      expect(arr.meta.result).toEqual(["a", 1]);
+      const failed = applyFor("[bind-fail]");
+      expect(failed.meta.result).toBeUndefined();
+      expect(failed.meta.isNoop).toBe(false);
+      expect(error).toHaveBeenCalled();
+    });
+
+    it("publishes a settled promise that resolves to preserve as a no-op", async () => {
+      installHook();
+      mount(`<p bind-x>stale</p>`, `[bind-x] { content: later(keep); }`, {
+        later: (v: unknown) => Promise.resolve(v),
+        keep: SYMBOL_NOOP,
+      });
+      await flush();
+      expect(applyFor("[bind-x]").meta.isNoop).toBe(true);
+    });
+  });
+});

package/support/tests/selector-analysis.test.ts

@@ -0,0 +1,281 @@
+/**
+ * `analyzeSelector` classifies what a selector depends on and where the
+ * subjects sit relative to each change (see `CompoundDependency`). These
+ * are the build-time facts `Rule._run` dispatches on; the DOM behaviour
+ * they drive is covered in `selectors.test.ts`.
+ */
+import { PSEUDO_CLASSES } from "../../src/language";
+import { analyzeSelector } from "../../src/selector-utils";
+import {
+  describe,
+  expect,
+  it,
+} from "@excom/heft-rig/profiles/default/config/test-utils";
+
+const sorted = (set: Set<string>) => [...set].sort();
+
+describe("analyzeSelector", () => {
+  it("buckets plain attribute gates on their own compound", () => {
+    const { path, attrs, compounds, reactsToRemovals, unobserved } =
+      analyzeSelector("section[data-on] > li[data-x]");
+    expect(path).toEqual(["section[data-on]", ">", "li[data-x]"]);
+    expect(sorted(attrs)).toEqual(["data-on", "data-x"]);
+    expect(compounds).toHaveLength(2);
+    expect(compounds[0]).toMatchObject({
+      pathIndex: 0,
+      prefix: "section[data-on]",
+      prefixNeedsScope: false,
+      isSubject: false,
+      root: "self",
+    });
+    expect(sorted(compounds[0].selfAttrs)).toEqual(["data-on"]);
+    expect(compounds[1]).toMatchObject({
+      pathIndex: 2,
+      prefix: "section[data-on] > li[data-x]",
+      isSubject: true,
+    });
+    expect(sorted(compounds[1].selfAttrs)).toEqual(["data-x"]);
+    expect(reactsToRemovals).toBe(false);
+    expect(unobserved).toEqual([]);
+  });
+
+  it("scopes only a prefix that starts with a combinator", () => {
+    expect(analyzeSelector("> span").compounds[0].prefixNeedsScope).toBe(true);
+    expect(analyzeSelector("+ span").compounds[0].prefixNeedsScope).toBe(true);
+    expect(analyzeSelector("span").compounds[0].prefixNeedsScope).toBe(false);
+  });
+
+  it("ignores blacklisted attribute names", () => {
+    const { attrs } = analyzeSelector(
+      "[q-scope] [n-x] [style] [content] [data-ok]"
+    );
+    expect(sorted(attrs)).toEqual(["data-ok"]);
+  });
+
+  describe("class and id selectors", () => {
+    it("gates on class / id like attributes and collects the class tokens", () => {
+      const { attrs, compounds, classNames } = analyzeSelector(
+        "section.card[data-on] > li.item#main"
+      );
+      expect(sorted(attrs)).toEqual(["class", "data-on", "id"]);
+      expect(sorted(compounds[0].selfAttrs)).toEqual(["class", "data-on"]);
+      expect(sorted(compounds[1].selfAttrs)).toEqual(["class", "id"]);
+      expect(sorted(classNames!)).toEqual(["card", "item"]);
+    });
+
+    it("follows classes into arguments", () => {
+      const { compounds, classNames } = analyzeSelector(
+        "ul:has(li.is-active) li:not(.is-done):is(section.is-open *)"
+      );
+      expect(sorted(compounds[0].hasAttrs)).toEqual(["class"]);
+      expect(sorted(compounds[1].selfAttrs)).toEqual(["class"]);
+      expect(sorted(compounds[1].looseAttrs)).toEqual(["class"]);
+      expect(sorted(classNames!)).toEqual(["is-active", "is-done", "is-open"]);
+    });
+
+    it("drops the class filter when the whole class value matters", () => {
+      expect(analyzeSelector('li[class~="is-done"]').classNames).toBeNull();
+      expect(analyzeSelector("li.done:not([class])").classNames).toBeNull();
+      expect(analyzeSelector("li.sm\\:hidden").classNames).toBeNull();
+      expect(analyzeSelector("li[data-x]").classNames).toEqual(new Set());
+    });
+  });
+
+  describe("logical pseudo-classes", () => {
+    it("treats simple :is() / :where() / :not() arguments as the compound's own", () => {
+      const { compounds, attrs } = analyzeSelector(
+        "li:is([data-a], [data-b]):where([data-c]):not([data-d])"
+      );
+      expect(sorted(attrs)).toEqual(["data-a", "data-b", "data-c", "data-d"]);
+      expect(sorted(compounds[0].selfAttrs)).toEqual([
+        "data-a",
+        "data-b",
+        "data-c",
+        "data-d",
+      ]);
+      expect(compounds[0].looseAttrs.size).toBe(0);
+    });
+
+    it("puts the earlier compounds of a complex argument in the loose bucket", () => {
+      const [c] = analyzeSelector(
+        ":is(section[data-on] li[data-x], [data-y])"
+      ).compounds;
+      expect(sorted(c.selfAttrs)).toEqual(["data-x", "data-y"]);
+      expect(sorted(c.looseAttrs)).toEqual(["data-on"]);
+      expect(c.looseRoot).toBe("self");
+    });
+
+    it("fans loose changes out from the parent when an argument uses a sibling combinator", () => {
+      const { compounds, positional, reactsToRemovals } = analyzeSelector(
+        "b:is(a[data-x] ~ b)"
+      );
+      expect(sorted(compounds[0].looseAttrs)).toEqual(["data-x"]);
+      expect(compounds[0].siblingInArgs).toBe(true);
+      expect(compounds[0].looseRoot).toBe("parent");
+      expect(positional).toBe(true);
+      expect(reactsToRemovals).toBe(true);
+    });
+  });
+
+  describe("sibling combinators", () => {
+    it("roots the compound before + / ~ at the parent", () => {
+      const { compounds, positional, reactsToRemovals } = analyzeSelector(
+        "a[data-x] ~ b[data-y] + c > d"
+      );
+      expect(compounds.map((c) => c.root)).toEqual([
+        "parent",
+        "parent",
+        "self",
+        "self",
+      ]);
+      expect(sorted(compounds[0].selfAttrs)).toEqual(["data-x"]);
+      expect(sorted(compounds[1].selfAttrs)).toEqual(["data-y"]);
+      expect(compounds[3].isSubject).toBe(true);
+      expect(positional).toBe(true);
+      expect(reactsToRemovals).toBe(true);
+    });
+  });
+
+  describe(":has()", () => {
+    it("puts descendant-relative argument attributes in the has bucket", () => {
+      const { compounds, usesHas, reactsToRemovals } = analyzeSelector(
+        "div:not([data-a]) > [data-b]:has([q-x], [data-c])"
+      );
+      const [ancestor, subject] = compounds;
+      expect(sorted(ancestor.selfAttrs)).toEqual(["data-a"]);
+      expect(ancestor.reactsToChildren).toBe(false);
+      expect(sorted(subject.selfAttrs)).toEqual(["data-b"]);
+      expect(sorted(subject.hasAttrs)).toEqual(["data-c"]);
+      expect(subject.reactsToChildren).toBe(true);
+      expect(subject.broad).toBe(false);
+      expect(usesHas).toBe(true);
+      expect(reactsToRemovals).toBe(true);
+    });
+
+    it("keeps :has() in an ancestor compound rooted there", () => {
+      const { compounds } = analyzeSelector("section:has([data-open]) button");
+      expect(sorted(compounds[0].hasAttrs)).toEqual(["data-open"]);
+      expect(compounds[0].isSubject).toBe(false);
+      expect(compounds[0].root).toBe("self");
+      expect(compounds[1].hasAttrs.size).toBe(0);
+    });
+
+    it("marks sibling-relative arguments broad", () => {
+      const [c] = analyzeSelector("label:has(+ input[data-invalid])").compounds;
+      expect(sorted(c.broadAttrs)).toEqual(["data-invalid"]);
+      expect(c.hasAttrs.size).toBe(0);
+      expect(c.broad).toBe(true);
+      expect(c.reactsToChildren).toBe(true);
+    });
+
+    it("marks the earlier compounds of a complex :has() argument broad", () => {
+      const [c] = analyzeSelector(
+        "div:has(section[data-s] [data-x])"
+      ).compounds;
+      expect(sorted(c.hasAttrs)).toEqual(["data-x"]);
+      expect(sorted(c.broadAttrs)).toEqual(["data-s"]);
+      expect(c.broad).toBe(false);
+    });
+
+    it("keeps :not(:has()) in the has bucket but a :has() inside a complex :is() arm broad", () => {
+      const [negated] = analyzeSelector("ul:not(:has([data-x]))").compounds;
+      expect(sorted(negated.hasAttrs)).toEqual(["data-x"]);
+      expect(negated.broad).toBe(false);
+      const [nested] = analyzeSelector(
+        "p:is(section:has([data-x]) p)"
+      ).compounds;
+      expect(sorted(nested.broadAttrs)).toEqual(["data-x"]);
+      expect(nested.broad).toBe(true);
+    });
+  });
+
+  describe("structural pseudo-classes", () => {
+    it("flags sibling position and removals", () => {
+      for (const pseudo of [
+        ":first-child",
+        ":last-child",
+        ":only-child",
+        ":nth-child(2n+1)",
+        ":nth-last-child(2)",
+        ":first-of-type",
+        ":last-of-type",
+        ":only-of-type",
+        ":nth-of-type(3)",
+        ":nth-last-of-type(odd)",
+      ]) {
+        const { compounds, positional, reactsToRemovals, usesHas } =
+          analyzeSelector(`li${pseudo}`);
+        expect(compounds[0].positional, pseudo).toBe(true);
+        expect(positional, pseudo).toBe(true);
+        expect(reactsToRemovals, pseudo).toBe(true);
+        expect(usesHas, pseudo).toBe(false);
+      }
+    });
+
+    it("observes the selector of `of S` on the siblings", () => {
+      const [c] = analyzeSelector(
+        "li:nth-child(1 of [data-visible]:not([data-x]))"
+      ).compounds;
+      expect(sorted(c.looseAttrs)).toEqual(["data-visible", "data-x"]);
+      expect(c.looseRoot).toBe("parent");
+      expect(c.positional).toBe(true);
+    });
+
+    it("re-checks :empty on child changes", () => {
+      const { compounds, usesHas, reactsToRemovals } =
+        analyzeSelector("ul:empty");
+      expect(compounds[0].reactsToChildren).toBe(true);
+      expect(usesHas).toBe(true);
+      expect(reactsToRemovals).toBe(true);
+    });
+  });
+
+  describe("attribute-backed pseudo-classes", () => {
+    it("observes the backing attribute on the element and above it", () => {
+      const cases: Record<string, string[]> = {
+        ":disabled": ["disabled"],
+        ":enabled": ["disabled"],
+        ":required": ["required"],
+        ":optional": ["required"],
+        ":read-only": ["contenteditable", "disabled", "readonly"],
+        ":read-write": ["contenteditable", "disabled", "readonly"],
+        ":any-link": ["href"],
+        ":lang(en)": ["lang"],
+        ":open": ["open"],
+      };
+      for (const [pseudo, names] of Object.entries(cases)) {
+        const { compounds, attrs, unobserved } = analyzeSelector(`*${pseudo}`);
+        expect(sorted(attrs), pseudo).toEqual(names);
+        expect(sorted(compounds[0].selfAttrs), pseudo).toEqual(names);
+        expect(sorted(compounds[0].looseAttrs), pseudo).toEqual(names);
+        expect(unobserved, pseudo).toEqual([]);
+      }
+    });
+
+    it("keeps an attribute pseudo-class inside :has() in the has bucket", () => {
+      const [c] = analyzeSelector("form:has(input:required)").compounds;
+      expect(sorted(c.hasAttrs)).toEqual(["required"]);
+      expect(c.looseAttrs.size).toBe(0);
+    });
+  });
+
+  describe("unobserved selectors", () => {
+    it("reports interaction pseudo-classes, pseudo-elements and unknown names", () => {
+      expect(analyzeSelector("a:hover::before").unobserved).toEqual([
+        ":hover",
+        "::before",
+      ]);
+      expect(analyzeSelector("input:checked").unobserved).toEqual([":checked"]);
+      expect(analyzeSelector("x:made-up").unobserved).toEqual([":made-up"]);
+      expect(analyzeSelector(":scope:root").unobserved).toEqual([]);
+    });
+
+    it("documents every unobserved pseudo-class it warns for", () => {
+      for (const doc of PSEUDO_CLASSES.filter((d) => d.kind === "unobserved")) {
+        expect(analyzeSelector(`a:${doc.name}`).unobserved).toEqual([
+          `:${doc.name}`,
+        ]);
+      }
+    });
+  });
+});