@loadbare/app 0.6.0 → 0.7.0

package/dist/tests/origins.test.js

@@ -1,387 +0,0 @@
-/**
- * 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, .browser.ts, and any .css", async () => {
-        const dir = await tree({
-            "app-box.html": "<div lb-slot></div>",
-            "app-box.browser.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("leaves a module alone when its name does not say .browser", async () => {
-        const dir = await tree({
-            "app-box.html": "<div lb-slot></div>",
-            "secrets.ts": "export const KEY = 'shh';",
-            "app-box.ts": "export const KEY = 'shh';",
-        });
-        try {
-            const scan = await scanOrigin({ name: "src", dirs: [dir] });
-            assert.equal(scan.scripts.size, 0);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it("remembers an unmarked module named after a tag, so the error can name it", async () => {
-        const dir = await tree({
-            "app-box.ts": "export {};",
-            "helpers.ts": "export {};",
-            "app-box.d.ts": "export {};",
-        });
-        try {
-            const scan = await scanOrigin({ name: "src", dirs: [dir] });
-            assert.deepEqual([...scan.unmarked.keys()], ["app-box"]);
-            assert.match(scan.unmarked.get("app-box"), /app-box\.ts$/);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it("takes the marked file when both names are present", async () => {
-        const dir = await tree({
-            "app-box.ts": "export {};",
-            "app-box.browser.ts": "export {};",
-        });
-        try {
-            const scan = await scanOrigin({ name: "src", dirs: [dir] });
-            assert.match(scan.scripts.get("app-box"), /app-box\.browser$/);
-            assert.match(scan.unmarked.get("app-box"), /app-box\.ts$/);
-        }
-        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.requests.ts": "export const requests = {};",
-            "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.browser.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 a definition filename carries capitals", async () => {
-        const dir = await tree({ "App-Box.html": "<div></div>" });
-        try {
-            await assert.rejects(() => scanOrigin({ name: "src", dirs: [dir] }), /carries capitals.*must be named 'app-box\.html'/);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it("throws when a widget script filename carries capitals", async () => {
-        const dir = await tree({ "App-Box.browser.ts": "export {};" });
-        try {
-            await assert.rejects(() => scanOrigin({ name: "src", dirs: [dir] }), /must be named 'app-box\.browser\.ts'/);
-        }
-        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.browser.ts": "export {};",
-            "b/app-box.browser.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.browser.js": "export {};",
-            "acme-widget.browser.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\.browser$/);
-        }
-        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.browser.js": "export {};",
-            "node_modules/acme/dist/acme-widget.html": "<b lb-slot></b>",
-            "node_modules/acme/src/acme-widget.browser.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\.browser$/);
-            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.browser.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.browser.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.d.ts

@@ -1,6 +0,0 @@
-/**
- * Discovering `*.requests.ts`/`*.queries.ts` pairs (build/locations.ts) and
- * generating the hub registry from them (build/pages.ts).
- */
-export {};
-//# sourceMappingURL=pages.test.d.ts.map

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

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

package/dist/tests/pages.test.js

@@ -1,148 +0,0 @@
-/**
- * Discovering `*.requests.ts`/`*.queries.ts` pairs (build/locations.ts) and
- * generating the hub registry from them (build/pages.ts).
- */
-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 { resolveLocations } from "../build/locations";
-import { pagesSource } from "../build/pages";
-const CHROME = `<!doctype html><body><lb-hub><main></main></lb-hub></body>`;
-async function tree(files) {
-    const dir = await mkdtemp(path.join(tmpdir(), "loadbare-pages-"));
-    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;
-}
-describe("discovering requests and queries", () => {
-    it("pairs a *.requests.ts and *.queries.ts with the page sharing their basename", async () => {
-        const src = await tree({
-            "chrome.html": CHROME,
-            "pages/hello.page.html": `<p>hi</p>`,
-            "pages/hello.requests.ts": `export const requests = {};`,
-            "pages/hello.queries.ts": `export const queries = {};`,
-        });
-        try {
-            const { pageSources } = await resolveLocations({
-                src,
-                out: `${src}/dist`,
-            });
-            const hello = pageSources.get("hello");
-            assert.ok(hello?.requests?.endsWith("hello.requests"));
-            assert.ok(hello?.queries?.endsWith("hello.queries"));
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("allows a page to have only one of the two", async () => {
-        const src = await tree({
-            "chrome.html": CHROME,
-            "pages/counter.page.html": `<p>0</p>`,
-            "pages/counter.queries.ts": `export const queries = {};`,
-        });
-        try {
-            const { pageSources } = await resolveLocations({
-                src,
-                out: `${src}/dist`,
-            });
-            const counter = pageSources.get("counter");
-            assert.equal(counter?.requests, undefined);
-            assert.ok(counter?.queries?.endsWith("counter.queries"));
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("throws when no chrome file is found", async () => {
-        const src = await tree({ "pages/hello.page.html": `<p>hi</p>` });
-        try {
-            await assert.rejects(() => resolveLocations({ src, out: `${src}/dist` }), /no chrome\.html file found/);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("throws when two chrome files are found", async () => {
-        const src = await tree({
-            "chrome.html": CHROME,
-            "other/chrome.html": CHROME,
-        });
-        try {
-            await assert.rejects(() => resolveLocations({ src, out: `${src}/dist` }), /more than one chrome\.html file found/);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("throws when two imports.ts files are found", async () => {
-        const src = await tree({
-            "chrome.html": CHROME,
-            "imports.ts": `export default [];`,
-            "widgets/imports.ts": `export default [];`,
-        });
-        try {
-            await assert.rejects(() => resolveLocations({ src, out: `${src}/dist` }), /more than one imports\.ts found/);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("throws when two page files in different directories share a stub", async () => {
-        const src = await tree({
-            "chrome.html": CHROME,
-            "pages/members.page.html": `<p>one</p>`,
-            "admin/members.page.html": `<p>two</p>`,
-        });
-        try {
-            await assert.rejects(() => resolveLocations({ src, out: `${src}/dist` }), /more than one 'members\.page\.html'/);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("throws when a requests or queries file has no matching page", async () => {
-        const src = await tree({
-            "chrome.html": CHROME,
-            "pages/orphan.requests.ts": `export const requests = {};`,
-        });
-        try {
-            await assert.rejects(() => resolveLocations({ src, out: `${src}/dist` }), /no 'orphan\.page\.html'/);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-});
-describe("pagesSource", () => {
-    it("returns undefined when no page has requests or queries", () => {
-        assert.equal(pagesSource([{ name: "hello", file: "/src/hello.page.html" }], new Map(), "/out", "@loadbare/app"), undefined);
-    });
-    it("generates one import per file found and one entry per page", () => {
-        const pages = [
-            { name: "hello", file: "/src/hello.page.html" },
-            { name: "counter", file: "/src/counter.page.html" },
-        ];
-        const pageSources = new Map([
-            [
-                "hello",
-                { requests: "/src/hello.requests", queries: "/src/hello.queries" },
-            ],
-            ["counter", { queries: "/src/counter.queries" }],
-        ]);
-        const out = pagesSource(pages, pageSources, "/out", "@loadbare/app");
-        assert.match(out, /import \{ createHub \} from "@loadbare\/app\/server";/);
-        assert.match(out, /import \{ requests as page_hello_Requests \} from "\.\.\/src\/hello\.requests";/);
-        assert.match(out, /import \{ queries as page_hello_Queries \} from "\.\.\/src\/hello\.queries";/);
-        assert.match(out, /import \{ queries as page_counter_Queries \} from "\.\.\/src\/counter\.queries";/);
-        assert.doesNotMatch(out, /page_counter_Requests/);
-        assert.match(out, /"hello": \{ requests: page_hello_Requests, queries: page_hello_Queries \}/);
-        assert.match(out, /"counter": \{ requests: \{\}, queries: page_counter_Queries \}/);
-        assert.match(out, /export const hub = createHub\(\{/);
-    });
-});

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

@@ -1,7 +0,0 @@
-/**
- * Discovering `.css` files (build/locations.ts) and concatenating them
- * (build/styles.ts) — see that file's header for what ordering guarantee is
- * and is not made.
- */
-export {};
-//# sourceMappingURL=styles.test.d.ts.map

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

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

package/dist/tests/styles.test.js

@@ -1,76 +0,0 @@
-/**
- * Discovering `.css` files (build/locations.ts) and concatenating them
- * (build/styles.ts) — see that file's header for what ordering guarantee is
- * and is not made.
- */
-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 { resolveLocations } from "../build/locations";
-import { cssFrom, scanAll } from "../build/origins";
-import { stylesSource } from "../build/styles";
-const CHROME = `<!doctype html><body><lb-hub><main></main></lb-hub></body>`;
-async function tree(files) {
-    const dir = await mkdtemp(path.join(tmpdir(), "loadbare-styles-"));
-    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;
-}
-describe("discovering CSS", () => {
-    it("finds a .css file anywhere under src", async () => {
-        const src = await tree({
-            "chrome.html": CHROME,
-            "widgets/app-box.css": ".app-box {}",
-            "styles/00-reset.css": "* { margin: 0; }",
-        });
-        try {
-            const locations = await resolveLocations({ src, out: `${src}/dist` });
-            const cssFiles = cssFrom(await scanAll(locations, src, locations.importsFile));
-            assert.equal(cssFiles.length, 2);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-    it("orders by filename, not by directory, so a global sorts first by naming itself 00-", async () => {
-        const src = await tree({
-            "chrome.html": CHROME,
-            "widgets/app-box.css": ".app-box {}",
-            "00-reset.css": "* { margin: 0; }",
-        });
-        try {
-            const locations = await resolveLocations({ src, out: `${src}/dist` });
-            const cssFiles = cssFrom(await scanAll(locations, src, locations.importsFile));
-            assert.deepEqual(cssFiles.map((f) => path.basename(f)), ["00-reset.css", "app-box.css"]);
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-});
-describe("stylesSource", () => {
-    it("returns undefined for no files", async () => {
-        assert.equal(await stylesSource([]), undefined);
-    });
-    it("concatenates file contents in the order given", async () => {
-        const src = await tree({
-            "a.css": "a {}",
-            "b.css": "b {}",
-        });
-        try {
-            const out = await stylesSource([
-                path.join(src, "a.css"),
-                path.join(src, "b.css"),
-            ]);
-            assert.equal(out, "a {}\nb {}");
-        }
-        finally {
-            await rm(src, { recursive: true, force: true });
-        }
-    });
-});