@loadbare/app 0.4.0 → 0.5.0

package/dist/tests/elements.test.js

@@ -9,20 +9,26 @@ import { describe, it } from "node:test";
 import { fileURLToPath } from "node:url";
 import { customElementTags } from "../build/expand";
 import { loadElementManifest, resolveElements } from "../build/elements";
-import { discoverSrc, packageInfo } from "../build/locations";
+import { packageInfo } from "../build/locations";
+import { scanOrigin } from "../build/origins";
 const FIXTURES = fileURLToPath(new URL("./fixtures/elements", import.meta.url));
 /**
- * The locations resolveElements needs, discovered the same way the CLI
- * discovers them — but via discoverSrc/packageInfo directly rather than the
- * full resolveLocations, since none of these fixtures has a chrome file and
- * resolveElements does not need one.
+ * The cascade resolveElements reads, built here rather than by
+ * build/origins.ts's buildOrigins: these fixtures name packages that are not
+ * installed, and resolution is what is under test, not package lookup.
  */
-async function locationsFor(src) {
-    const [{ widgets, elementsCandidates }, info] = await Promise.all([
-        discoverSrc(src),
-        packageInfo(),
-    ]);
-    return { widgets, elementsFile: elementsCandidates[0], ...info };
+async function scansFor(src, packageDir) {
+    const info = await packageInfo();
+    const origins = [
+        {
+            name: info.packageName,
+            dirs: [info.builtinHubDir],
+            specifier: () => info.packageName,
+        },
+        ...(packageDir ? [{ name: "@acme/widget", dirs: [packageDir] }] : []),
+        { name: src, dirs: [src] },
+    ];
+    return Promise.all(origins.map(scanOrigin));
 }
 describe("customElementTags", () => {
     it("collects every hyphenated tag, native elements excluded", () => {
@@ -35,77 +41,67 @@ describe("customElementTags", () => {
     });
 });
 describe("loadElementManifest", () => {
-    it("returns the default export, keyed by tag", async () => {
-        const manifest = await loadElementManifest(`${FIXTURES}/manifest/elements.ts`);
-        assert.deepEqual(manifest, { "acme-widget": "@acme/widget" });
+    it("returns the declared package list", async () => {
+        const declared = await loadElementManifest(`${FIXTURES}/manifest/imports.ts`);
+        assert.deepEqual(declared, ["@acme/widget"]);
     });
-    it("returns empty when there is no elements.ts", async () => {
-        const manifest = await loadElementManifest(`${FIXTURES}/local/elements.ts`);
-        assert.deepEqual(manifest, {});
+    it("returns empty when there is no imports.ts", async () => {
+        const declared = await loadElementManifest(`${FIXTURES}/local/imports.ts`);
+        assert.deepEqual(declared, []);
     });
-    it("rejects a key that is not a valid custom element name", async () => {
-        await assert.rejects(() => loadElementManifest(`${FIXTURES}/manifest-bad-tag/elements.ts`), /'acmewidget' is not a valid custom element name/);
+    it("rejects a default export that is not an array", async () => {
+        await assert.rejects(() => loadElementManifest(`${FIXTURES}/manifest-not-array/imports.ts`), /must default-export an array of package names/);
     });
-    it("rejects a value that is not an import specifier string", async () => {
-        await assert.rejects(() => loadElementManifest(`${FIXTURES}/manifest-bad-value/elements.ts`), /must map to an import specifier string/);
+    it("rejects an entry that is not a package name", async () => {
+        await assert.rejects(() => loadElementManifest(`${FIXTURES}/manifest-bad-entry/imports.ts`), /every entry must be a package name/);
     });
 });
 describe("resolveElements", () => {
-    it("resolves a built-in tag to the package's own widgets export", async () => {
-        const { resolved } = await resolveElements({
-            used: new Set(["lb-input"]),
-            ...(await locationsFor(`${FIXTURES}/local`)),
-        });
-        assert.deepEqual(resolved.get("lb-input"), {
-            kind: "specifier",
-            value: "@loadbare/app/widgets/lb-input",
-        });
-    });
-    it("resolves lb-hub the same way, by its script in hub/ rather than widgets/", async () => {
-        const { resolved } = await resolveElements({
+    it("resolves lb-hub to the package itself, the one built-in", async () => {
+        const { resolved } = resolveElements({
             used: new Set(["lb-hub"]),
-            ...(await locationsFor(`${FIXTURES}/local`)),
+            scans: await scansFor(`${FIXTURES}/local`),
         });
         assert.deepEqual(resolved.get("lb-hub"), {
             kind: "specifier",
             value: "@loadbare/app",
         });
     });
-    it("resolves a local tag to its file in <src>/widgets", async () => {
-        const { resolved } = await resolveElements({
+    it("resolves a local tag to its file in <src>", async () => {
+        const { resolved } = resolveElements({
             used: new Set(["app-box"]),
-            ...(await locationsFor(`${FIXTURES}/local`)),
+            scans: await scansFor(`${FIXTURES}/local`),
         });
         assert.equal(resolved.get("app-box")?.kind, "file");
         assert.match(resolved.get("app-box").value, /local\/widgets\/app-box$/);
     });
-    it("resolves a tag declared only in elements.ts", async () => {
-        const { resolved } = await resolveElements({
+    it("resolves a tag found by scanning a declared package", async () => {
+        const { resolved } = resolveElements({
             used: new Set(["acme-widget"]),
-            ...(await locationsFor(`${FIXTURES}/manifest`)),
-        });
-        assert.deepEqual(resolved.get("acme-widget"), {
-            kind: "specifier",
-            value: "@acme/widget",
+            scans: await scansFor(`${FIXTURES}/manifest`, `${FIXTURES}/pkg`),
         });
+        assert.equal(resolved.get("acme-widget")?.kind, "file");
+        assert.match(resolved.get("acme-widget").value, /pkg\/acme-widget$/);
     });
     it("needs no script for a tag with only an .html definition", async () => {
-        const { resolved } = await resolveElements({
+        const { resolved } = resolveElements({
             used: new Set(["lb-nav"]),
-            ...(await locationsFor(`${FIXTURES}/markup-only`)),
+            scans: await scansFor(`${FIXTURES}/markup-only`),
         });
         assert.equal(resolved.size, 0);
     });
     it("throws when a used tag registers nothing", async () => {
         await assert.rejects(async () => resolveElements({
             used: new Set(["nowhere-widget"]),
-            ...(await locationsFor(`${FIXTURES}/local`)),
+            scans: await scansFor(`${FIXTURES}/local`),
         }), /<nowhere-widget> has neither a script nor a definition/);
     });
-    it("throws when a used tag is declared in more than one place", async () => {
-        await assert.rejects(async () => resolveElements({
+    it("lets src win over a package that has the same tag", async () => {
+        const { resolved } = resolveElements({
             used: new Set(["acme-widget"]),
-            ...(await locationsFor(`${FIXTURES}/collision`)),
-        }), /<acme-widget> is declared in more than one place: src, .*elements\.ts/);
+            scans: await scansFor(`${FIXTURES}/collision`, `${FIXTURES}/pkg`),
+        });
+        assert.equal(resolved.get("acme-widget")?.kind, "file");
+        assert.match(resolved.get("acme-widget").value, /collision\/widgets\/acme-widget$/);
     });
 });

package/dist/tests/expand.test.d.ts

@@ -1,5 +1,5 @@
 /**
- * Expansion — see docs/expansion.md and docs/testing.md, tier 1.
+ * Expansion — see docs/reference/custom-elements.md and docs/testing.md, tier 1.
  *
  * Definitions are written inline here because `expand` takes them as a map
  * and a two-line definition beside its assertion reads better than a file

package/dist/tests/expand.test.js

@@ -1,5 +1,5 @@
 /**
- * Expansion — see docs/expansion.md and docs/testing.md, tier 1.
+ * Expansion — see docs/reference/custom-elements.md and docs/testing.md, tier 1.
  *
  * Definitions are written inline here because `expand` takes them as a map
  * and a two-line definition beside its assertion reads better than a file
@@ -192,7 +192,7 @@ describe("placement", () => {
         assert.match(html, /<span>row<\/span>/);
     });
     it("expands a tag outside the lb- namespace when it has a definition", () => {
-        // An application's widget can use its own prefix — see docs/getting-started.md.
+        // An application's widget can use its own prefix — see docs/tutorials/000-getting-started.md.
         // The definition must still apply; discovering it is not enough.
         const html = expand(`<app-nav exp-label="Site"></app-nav>`, defs({ "app-nav": `<nav aria-label="{{label}}" lb-slot></nav>` }));
         assert.match(html, /<nav aria-label="Site"><\/nav>/);

package/dist/tests/fixtures/elements/collision/imports.d.ts

@@ -0,0 +1,3 @@
+declare const _default: string[];
+export default _default;
+//# sourceMappingURL=imports.d.ts.map

package/dist/tests/fixtures/elements/collision/imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../../../../tests/fixtures/elements/collision/imports.ts"],"names":[],"mappings":";AAAA,wBAAgC"}

package/dist/tests/fixtures/elements/collision/imports.js

@@ -0,0 +1 @@
+export default ["@acme/widget"];

package/dist/tests/fixtures/elements/manifest/imports.d.ts

@@ -0,0 +1,3 @@
+declare const _default: string[];
+export default _default;
+//# sourceMappingURL=imports.d.ts.map

package/dist/tests/fixtures/elements/manifest/imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../../../../tests/fixtures/elements/manifest/imports.ts"],"names":[],"mappings":";AAAA,wBAAgC"}

package/dist/tests/fixtures/elements/manifest/imports.js

@@ -0,0 +1 @@
+export default ["@acme/widget"];

package/dist/tests/fixtures/elements/manifest-bad-entry/imports.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (string | number)[];
+export default _default;
+//# sourceMappingURL=imports.d.ts.map

package/dist/tests/fixtures/elements/manifest-bad-entry/imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../../../../tests/fixtures/elements/manifest-bad-entry/imports.ts"],"names":[],"mappings":";AAAA,wBAAoC"}

package/dist/tests/fixtures/elements/manifest-bad-entry/imports.js

@@ -0,0 +1 @@
+export default ["@acme/widget", 42];

package/dist/tests/fixtures/elements/{collision/elements.d.ts → manifest-not-array/imports.d.ts}

@@ -2,4 +2,4 @@ declare const _default: {
     "acme-widget": string;
 };
 export default _default;
-//# sourceMappingURL=elements.d.ts.map
+//# sourceMappingURL=imports.d.ts.map

package/dist/tests/fixtures/elements/manifest-not-array/imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../../../../tests/fixtures/elements/manifest-not-array/imports.ts"],"names":[],"mappings":";;;AAAA,wBAAiD"}

package/dist/tests/fixtures/elements/manifest-not-array/imports.js

@@ -0,0 +1 @@
+export default { "acme-widget": "@acme/widget" };

package/dist/tests/fixtures/elements/pkg/acme-widget.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=acme-widget.d.ts.map

package/dist/tests/fixtures/elements/pkg/acme-widget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acme-widget.d.ts","sourceRoot":"","sources":["../../../../../tests/fixtures/elements/pkg/acme-widget.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC"}

package/dist/tests/fixtures/elements/pkg/acme-widget.js

@@ -0,0 +1 @@
+export {};

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

@@ -107,7 +107,7 @@ describe("the request endpoint", () => {
         assert.equal(calls[0].name, "pick");
         assert.equal(calls[0].page, "roster");
     });
-    it("passes on an action carrying no coordinates at all", async () => {
+    it("passes on an action carrying no binding at all", async () => {
         // A button carries no value and may sit outside any scope. Undefined
         // stays undefined rather than becoming the empty string.
         calls.length = 0;

package/dist/tests/origins.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The origin cascade — see build/origins.ts.
+ *
+ * Definitions, scripts and stylesheets all come from the same ordered list of
+ * origins, so they are all tested here: that one origin is scanned the same
+ * way whatever it is, that a duplicate tag inside one origin is an error, and
+ * that a later origin wins over an earlier one.
+ */
+export {};
+//# sourceMappingURL=origins.test.d.ts.map

package/dist/tests/origins.test.d.ts.map

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

package/dist/tests/origins.test.js

@@ -0,0 +1,326 @@
+/**
+ * The origin cascade — see build/origins.ts.
+ *
+ * Definitions, scripts and stylesheets all come from the same ordered list of
+ * origins, so they are all tested here: that one origin is scanned the same
+ * way whatever it is, that a duplicate tag inside one origin is an error, and
+ * that a later origin wins over an earlier one.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { buildOrigins, cssFrom, scanAll, scanOrigin } from "../build/origins";
+async function tree(files) {
+    const dir = await mkdtemp(path.join(tmpdir(), "loadbare-origins-"));
+    for (const [name, content] of Object.entries(files)) {
+        const file = path.join(dir, name);
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, content, "utf-8");
+    }
+    return dir;
+}
+/** A builtin with no files of its own, so a test sees only what it wrote. */
+const NO_BUILTIN = {
+    builtinHubDir: path.join(tmpdir(), "loadbare-absent-hub"),
+    packageName: "@loadbare/app",
+};
+const base = (name) => path.basename(name);
+describe("scanOrigin", () => {
+    it("classifies by filename: a tag-shaped .html, .ts, and any .css", async () => {
+        const dir = await tree({
+            "app-box.html": "<div lb-slot></div>",
+            "app-box.ts": "export {};",
+            "theme.css": "* {}",
+        });
+        try {
+            const scan = await scanOrigin({ name: "src", dirs: [dir] });
+            assert.deepEqual([...scan.definitions.keys()], ["app-box"]);
+            assert.deepEqual([...scan.scripts.keys()], ["app-box"]);
+            assert.deepEqual(scan.css.map(base), ["theme.css"]);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("ignores files whose basename is not a tag", async () => {
+        const dir = await tree({
+            "chrome.html": "<lb-hub><main></main></lb-hub>",
+            "about.page.html": "<h1>About</h1>",
+            "about.hooks.ts": "export const hooks = {};",
+            "imports.ts": "export default {};",
+        });
+        try {
+            const scan = await scanOrigin({ name: "src", dirs: [dir] });
+            assert.equal(scan.definitions.size, 0);
+            assert.equal(scan.scripts.size, 0);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("finds files at any depth, and sorts css by filename not directory", async () => {
+        const dir = await tree({
+            "deep/nested/app-box.ts": "export {};",
+            "widgets/app-box.css": ".b {}",
+            "00-reset.css": "* {}",
+        });
+        try {
+            const scan = await scanOrigin({ name: "src", dirs: [dir] });
+            assert.deepEqual([...scan.scripts.keys()], ["app-box"]);
+            assert.deepEqual(scan.css.map(base), ["00-reset.css", "app-box.css"]);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("throws when one origin has two definitions for the same tag", async () => {
+        const dir = await tree({
+            "a/app-box.html": "<div></div>",
+            "b/app-box.html": "<span></span>",
+        });
+        try {
+            await assert.rejects(() => scanOrigin({ name: "src", dirs: [dir] }), /'src' has two definition files for <app-box>/);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("throws when one origin has two scripts for the same tag", async () => {
+        const dir = await tree({
+            "a/app-box.ts": "export {};",
+            "b/app-box.ts": "export {};",
+        });
+        try {
+            await assert.rejects(() => scanOrigin({ name: "src", dirs: [dir] }), /'src' has two script files for <app-box>/);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("takes a compiled .js as a script, the way a published package ships one", async () => {
+        const dir = await tree({
+            "acme-widget.html": "<div lb-slot></div>",
+            "acme-widget.js": "export {};",
+            "acme-widget.d.ts": "export {};",
+        });
+        try {
+            const scan = await scanOrigin({ name: "@acme/widgets", dirs: [dir] });
+            assert.deepEqual([...scan.definitions.keys()], ["acme-widget"]);
+            // The .d.ts is not a second script: stripping ".ts" leaves a dot.
+            assert.deepEqual([...scan.scripts.keys()], ["acme-widget"]);
+            assert.match(scan.scripts.get("acme-widget"), /acme-widget$/);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("buildOrigins", () => {
+    it("orders the built-in first, then packages as declared, then src", async () => {
+        const src = await tree({
+            "node_modules/pkg-a/package.json": "{}",
+            "node_modules/pkg-b/package.json": "{}",
+        });
+        try {
+            const origins = await buildOrigins(NO_BUILTIN, ["pkg-b", "pkg-a"], src);
+            assert.deepEqual(origins.map((o) => o.name), ["@loadbare/app", "pkg-b", "pkg-a", src]);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("throws when a declared package is not installed", async () => {
+        const src = await tree({});
+        try {
+            await assert.rejects(() => buildOrigins(NO_BUILTIN, ["nowhere-pkg"], src), /could not find installed package 'nowhere-pkg'/);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("walks up from src to find node_modules at the application root", async () => {
+        const src = await tree({
+            "node_modules/pkg-a/package.json": "{}",
+            "node_modules/pkg-a/style.css": "a {}",
+            "app/src/chrome.html": "<lb-hub><main></main></lb-hub>",
+        });
+        try {
+            const inner = path.join(src, "app", "src");
+            const origins = await buildOrigins(NO_BUILTIN, ["pkg-a"], inner);
+            const scans = await Promise.all(origins.map(scanOrigin));
+            assert.deepEqual(cssFrom(scans).map(base), ["style.css"]);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+});
+describe("a package's declared widget directory", () => {
+    /**
+     * The published shape this exists for: compiled output beside the source it
+     * was built from.  Scanning the whole package finds both and calls the tag
+     * a duplicate; scanning what the package declared finds the one that ships.
+     */
+    it("scans only loadbare.widgets, so source beside dist is not a duplicate", async () => {
+        const src = await tree({
+            "node_modules/acme/package.json": JSON.stringify({
+                loadbare: { widgets: "./dist" },
+            }),
+            "node_modules/acme/dist/acme-widget.js": "export {};",
+            "node_modules/acme/dist/acme-widget.html": "<b lb-slot></b>",
+            "node_modules/acme/src/acme-widget.ts": "export {};",
+            "node_modules/acme/src/acme-widget.html": "<b lb-slot></b>",
+            "node_modules/acme/README.md": "# acme",
+            "imports.ts": `export default ["acme"];`,
+        });
+        try {
+            const scans = await scanAll(NO_BUILTIN, src, path.join(src, "imports.ts"));
+            const acme = scans.find((scan) => scan.name === "acme");
+            assert.deepEqual([...acme.scripts.keys()], ["acme-widget"]);
+            assert.match(acme.scripts.get("acme-widget"), /dist[/\\]acme-widget$/);
+            assert.match(acme.definitions.get("acme-widget"), /dist[/\\]acme-widget\.html$/);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("scans the whole package when it declares nothing", async () => {
+        const src = await tree({
+            "node_modules/acme/package.json": "{}",
+            "node_modules/acme/widgets/acme-widget.ts": "export {};",
+        });
+        try {
+            const origins = await buildOrigins(NO_BUILTIN, ["acme"], src);
+            const scans = await Promise.all(origins.map(scanOrigin));
+            assert.deepEqual([...scans[1].scripts.keys()], ["acme-widget"]);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("refuses a declared directory the installed package does not have", async () => {
+        const src = await tree({
+            "node_modules/acme/package.json": JSON.stringify({
+                loadbare: { widgets: "./dist" },
+            }),
+            "node_modules/acme/widgets/acme-widget.ts": "export {};",
+        });
+        try {
+            await assert.rejects(() => buildOrigins(NO_BUILTIN, ["acme"], src), /'acme' declares widgets at '\.\/dist', which is not in the installed package/);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("refuses a declared directory outside the package", async () => {
+        const src = await tree({
+            "node_modules/acme/package.json": JSON.stringify({
+                loadbare: { widgets: "../../src" },
+            }),
+        });
+        try {
+            await assert.rejects(() => buildOrigins(NO_BUILTIN, ["acme"], src), /which is outside the package/);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("refuses a loadbare.widgets that is not a path", async () => {
+        const src = await tree({
+            "node_modules/acme/package.json": JSON.stringify({
+                loadbare: { widgets: ["./dist"] },
+            }),
+        });
+        try {
+            await assert.rejects(() => buildOrigins(NO_BUILTIN, ["acme"], src), /is not a path/);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+});
+describe("the css cascade", () => {
+    it("collects one package's CSS, sorted by filename", async () => {
+        const src = await tree({
+            "node_modules/acme-widgets/package.json": "{}",
+            "node_modules/acme-widgets/z.css": "z {}",
+            "node_modules/acme-widgets/a.css": "a {}",
+            "node_modules/acme-widgets/dist/00-reset.css": "* { margin: 0; }",
+            "imports.ts": `export default ["acme-widgets"];`,
+        });
+        try {
+            const scans = await scanAll(NO_BUILTIN, src, path.join(src, "imports.ts"));
+            assert.deepEqual(cssFrom(scans).map(base), [
+                "00-reset.css",
+                "a.css",
+                "z.css",
+            ]);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("keeps packages in declaration order, without interleaving their files", async () => {
+        const src = await tree({
+            "node_modules/pkg-a/package.json": "{}",
+            "node_modules/pkg-a/a-only.css": "a {}",
+            "node_modules/pkg-b/package.json": "{}",
+            "node_modules/pkg-b/aaa-early.css": "b {}",
+            "imports.ts": `export default ["pkg-b", "pkg-a"];`,
+        });
+        try {
+            const scans = await scanAll(NO_BUILTIN, src, path.join(src, "imports.ts"));
+            assert.deepEqual(cssFrom(scans).map(base), [
+                "aaa-early.css",
+                "a-only.css",
+            ]);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("puts the application's own css last, after every package's", async () => {
+        const src = await tree({
+            "node_modules/pkg-a/package.json": "{}",
+            "node_modules/pkg-a/zzz-late.css": "a {}",
+            "00-reset.css": "* {}",
+            "imports.ts": `export default ["pkg-a"];`,
+        });
+        try {
+            const scans = await scanAll(NO_BUILTIN, src, path.join(src, "imports.ts"));
+            assert.deepEqual(cssFrom(scans).map(base), [
+                "zzz-late.css",
+                "00-reset.css",
+            ]);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("ignores a package's own nested node_modules", async () => {
+        const src = await tree({
+            "node_modules/pkg-a/package.json": "{}",
+            "node_modules/pkg-a/style.css": "a {}",
+            "node_modules/pkg-a/node_modules/transitive/style.css": "t {}",
+            "imports.ts": `export default ["pkg-a"];`,
+        });
+        try {
+            const scans = await scanAll(NO_BUILTIN, src, path.join(src, "imports.ts"));
+            assert.deepEqual(cssFrom(scans).map(base), ["style.css"]);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("returns nothing when there is no css anywhere", async () => {
+        const src = await tree({ "chrome.html": "<lb-hub><main></main></lb-hub>" });
+        try {
+            assert.deepEqual(cssFrom(await scanAll(NO_BUILTIN, src)), []);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/pages.test.js

@@ -22,7 +22,7 @@ async function tree(files) {
 describe("discovering hooks and queries", () => {
     it("pairs a *.hooks.ts and *.queries.ts with the page sharing their basename", async () => {
         const src = await tree({
-            "chrome.chrome.html": CHROME,
+            "chrome.html": CHROME,
             "pages/hello.page.html": `<p>hi</p>`,
             "pages/hello.hooks.ts": `export const hooks = {};`,
             "pages/hello.queries.ts": `export const queries = {};`,
@@ -42,7 +42,7 @@ describe("discovering hooks and queries", () => {
     });
     it("allows a page to have only one of the two", async () => {
         const src = await tree({
-            "chrome.chrome.html": CHROME,
+            "chrome.html": CHROME,
             "pages/counter.page.html": `<p>0</p>`,
             "pages/counter.queries.ts": `export const queries = {};`,
         });
@@ -61,7 +61,7 @@ describe("discovering hooks and queries", () => {
     });
     it("throws when a hooks or queries file has no matching page", async () => {
         const src = await tree({
-            "chrome.chrome.html": CHROME,
+            "chrome.html": CHROME,
             "pages/orphan.hooks.ts": `export const hooks = {};`,
         });
         try {