@teacss/bun 0.10.9 → 0.10.10

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { type ShellOptions } from "@teacss/engine";
+import type { BuildConfig, BuildOutput, BunPlugin } from "bun";
+export type { ShellOptions } from "@teacss/engine";
+/**
+ * `import "virtual:teacss.css"` (or `"teacss.css"`) becomes the generated stylesheet; every other
+ * module goes through `project.transform`, and in a CSS file whose top level has `@teacss;` the generated
+ * stylesheet then takes that rule's place. `minify` defaults to false, as teacss-ts's Bun plugin emits the
+ * stylesheet unminified.
+ */
+export declare function teacss(options?: ShellOptions): BunPlugin;
+export interface WatchOptions {
+    /** The `Bun.build` configuration; a plugin of this package already in `plugins` is replaced. */
+    build: BuildConfig;
+    shell?: ShellOptions;
+    /** Milliseconds between the last file event and the rebuild. Default 200. */
+    debounce?: number;
+    /** Called with a failed build's error or a watcher error. Default `console.error`. */
+    onError?: (error: unknown) => void;
+}
+export interface WatchSession {
+    /** Successful builds so far, the first one included. */
+    readonly builds: number;
+    close(): void;
+}
+/**
+ * Builds once, then rebuilds whenever a file in a directory of `project.watchFiles()` (or the root) changes,
+ * or a file anywhere under a `@source` glob's directory (`project.sourceDirectories()`), outside `outdir`.
+ * Bun's plugin API has no dependency registration, so the watch owns the file list; it resolves after the
+ * first build has been reported.
+ */
+export declare function watch(options: WatchOptions, onBuild: (result: BuildOutput) => void | Promise<void>): Promise<WatchSession>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,188 @@
+import { existsSync, watch as watchDirectory } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import { createProject, extractBundledFonts, replaceEntry } from "@teacss/engine";
+const PLUGIN = "teacss";
+const VIRTUAL_ENTRY = /^(?:virtual:)?teacss\.css$/;
+const MODULE = /\.(?:[cm]?[jt]sx?|html)$/;
+const CSS = /\.css$/;
+const NODE_MODULES = `${sep}node_modules${sep}`;
+// teacss-ts `rewriteBundledAssets` writes each bundled font as `teacss-fonts/teacss-<sha256>.woff2` beside the CSS.
+const FONT_URL_PREFIX = "./teacss-fonts/teacss-";
+const FONT_URL = /^\.\/teacss-fonts\/teacss-[a-f0-9]{64}\.woff2$/;
+/**
+ * The tokens of every `@source` file read once and of `inline.content.inline`. `warned` holds the
+ * unmatched-token warnings already printed by earlier builds of the same plugin.
+ */
+function generateCss(project, minify, warned) {
+    const union = project.engine.extractFilesUnion(project.info.sourceFiles);
+    for (const path of project.info.unreadableDirectories)
+        console.warn(`[@teacss/bun] cannot read ${path} (E_IO)`);
+    for (const { path, error } of union.failed)
+        console.warn(`[@teacss/bun] cannot read ${path} (${error})`);
+    const tokens = [...new Set([...union.tokens, ...project.inlineTokens()])];
+    const result = project.engine.generate({ kind: "tokens", tokens }, { minify, css: true });
+    project.reportUnmatched(result, {
+        tokens,
+        warn: (message) => {
+            if (warned.has(message))
+                return;
+            warned.add(message);
+            console.warn(`[@teacss/bun] ${message}`);
+        },
+    });
+    return result.css;
+}
+function externalizeFonts(css, fonts) {
+    const extracted = extractBundledFonts(css, (digest) => `${FONT_URL_PREFIX}${digest}.woff2`);
+    for (const font of extracted.fonts)
+        fonts.set(font.digest, font.bytes);
+    return extracted.css;
+}
+async function writeFonts(result, fonts) {
+    if (!result.success || fonts.size === 0)
+        return;
+    for (const output of result.outputs) {
+        if (!output.path.endsWith(".css"))
+            continue;
+        const css = await output.text();
+        const directory = join(dirname(output.path), "teacss-fonts");
+        for (const [digest, bytes] of fonts) {
+            const name = `teacss-${digest}.woff2`;
+            if (!css.includes(`teacss-fonts/${name}`))
+                continue;
+            await mkdir(directory, { recursive: true });
+            await writeFile(join(directory, name), bytes);
+        }
+    }
+}
+function projectRoot(options, config) {
+    return resolve(options.root ?? config.root ?? process.cwd());
+}
+/**
+ * `import "virtual:teacss.css"` (or `"teacss.css"`) becomes the generated stylesheet; every other
+ * module goes through `project.transform`, and in a CSS file whose top level has `@teacss;` the generated
+ * stylesheet then takes that rule's place. `minify` defaults to false, as teacss-ts's Bun plugin emits the
+ * stylesheet unminified.
+ */
+export function teacss(options = {}) {
+    // `watch()` runs every build through this one plugin; each build gets a fresh project, so that no module or
+    // compile-class definition of a file deleted or renamed since lingers, and the warnings outlive it here.
+    const warned = new Set();
+    return {
+        name: PLUGIN,
+        setup(build) {
+            const project = createProject({ ...options, root: projectRoot(options, build.config) });
+            const fonts = new Map();
+            const externalize = build.config.outdir ? (css) => externalizeFonts(css, fonts) : (css) => css;
+            const generated = () => externalize(generateCss(project, options.minify ?? false, warned));
+            build.onResolve({ filter: VIRTUAL_ENTRY }, () => ({ path: "teacss.css", namespace: PLUGIN }));
+            // Bun bundles every `url()` of a stylesheet; the fonts exist only after `onEnd` writes them.
+            build.onResolve({ filter: FONT_URL }, (args) => (fonts.has(args.path.slice(FONT_URL_PREFIX.length, -".woff2".length)) ? { path: args.path, external: true } : undefined));
+            build.onLoad({ filter: /.*/, namespace: PLUGIN }, () => ({ contents: generated(), loader: "css" }));
+            build.onLoad({ filter: CSS }, async (args) => {
+                const { code } = project.transform(args.path, await readFile(args.path, "utf8"));
+                return { contents: replaceEntry(code, generated, args.path) ?? externalize(code), loader: "css" };
+            });
+            build.onLoad({ filter: MODULE }, async (args) => {
+                const code = await readFile(args.path, "utf8");
+                if (args.path.includes(NODE_MODULES) && !code.includes("@teacss-include"))
+                    return;
+                const result = project.transform(args.path, code);
+                return result.changed ? { contents: result.code, loader: args.loader } : undefined;
+            });
+            build.onEnd(async (result) => {
+                project.dispose();
+                await writeFonts(result, fonts);
+            });
+        },
+    };
+}
+/**
+ * Builds once, then rebuilds whenever a file in a directory of `project.watchFiles()` (or the root) changes,
+ * or a file anywhere under a `@source` glob's directory (`project.sourceDirectories()`), outside `outdir`.
+ * Bun's plugin API has no dependency registration, so the watch owns the file list; it resolves after the
+ * first build has been reported.
+ */
+export async function watch(options, onBuild) {
+    const { build, shell = {}, debounce = 200, onError = console.error } = options;
+    const root = projectRoot(shell, build);
+    const plugins = [...(build.plugins ?? []).filter((plugin) => plugin.name !== PLUGIN), teacss({ ...shell, root })];
+    const project = createProject({ ...shell, root });
+    const outdir = build.outdir === undefined ? undefined : resolve(build.outdir);
+    const watchers = new Map();
+    let timer;
+    let running = false;
+    let queued = false;
+    let closed = false;
+    let builds = 0;
+    function syncWatchers() {
+        project.reload();
+        const wanted = new Map([root, ...project.watchFiles().map((file) => dirname(file))].map((directory) => [directory, false]));
+        for (const { dir } of project.sourceDirectories())
+            if (existsSync(dir))
+                wanted.set(dir, true);
+        for (const [directory, { watcher, recursive }] of watchers) {
+            if (wanted.get(directory) === recursive)
+                continue;
+            watcher.close();
+            watchers.delete(directory);
+        }
+        for (const [directory, recursive] of wanted) {
+            if (watchers.has(directory))
+                continue;
+            const watcher = watchDirectory(directory, { recursive }, (_event, file) => {
+                if (file === null || !isOutput(resolve(directory, file)))
+                    schedule();
+            });
+            watchers.set(directory, { watcher: watcher.on("error", onError), recursive });
+        }
+    }
+    function isOutput(file) {
+        return outdir !== undefined && (file === outdir || file.startsWith(`${outdir}${sep}`));
+    }
+    async function run() {
+        running = true;
+        do {
+            queued = false;
+            try {
+                syncWatchers();
+                const result = await Bun.build({ ...build, plugins });
+                if (!result.success)
+                    throw new AggregateError(result.logs, "[@teacss/bun] build failed");
+                builds++;
+                await onBuild(result);
+            }
+            catch (error) {
+                onError(error);
+            }
+        } while (queued && !closed);
+        running = false;
+    }
+    function schedule() {
+        if (closed)
+            return;
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            if (running)
+                queued = true;
+            else
+                void run();
+        }, debounce);
+    }
+    await run();
+    return {
+        get builds() {
+            return builds;
+        },
+        close() {
+            closed = true;
+            clearTimeout(timer);
+            for (const { watcher } of watchers.values())
+                watcher.close();
+            watchers.clear();
+            project.dispose();
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teacss/bun",
-  "version": "0.10.9",
+  "version": "0.10.10",
   "description": "Bun.build plugin for TeaCSS: virtual:teacss.css and the entry's @teacss become the CSS the Rust engine generates",
   "license": "MIT",
   "type": "module",
@@ -31,7 +31,7 @@
     "node": ">=26"
   },
   "dependencies": {
-    "@teacss/engine": "0.10.9"
+    "@teacss/engine": "0.10.10"
   },
   "devDependencies": {
     "@types/bun": "1.4.3",