@homebound/truss 2.4.0 → 2.5.0

package/build/plugin/index.d.ts

@@ -34,6 +34,52 @@ type TrussMappingEntry =
     chain: string[];
 };
 
+interface TrussEsbuildPluginOptions {
+    /** Path to the Css.json mapping file (relative to cwd or absolute). */
+    mapping: string;
+    /** Output path for the generated truss.css (relative to outDir or absolute). Defaults to `truss.css`. */
+    outputCss?: string;
+}
+/**
+ * esbuild plugin that transforms `Css.*.$` expressions and emits a `truss.css` file.
+ *
+ * Designed for library builds using tsup/esbuild. Transforms source files
+ * during the build and writes an annotated `truss.css` alongside the output
+ * that consuming applications can merge via the Vite plugin's `libraries` option.
+ *
+ * Usage with tsup:
+ * ```ts
+ * import { trussEsbuildPlugin } from "@homebound/truss/plugin";
+ *
+ * export default defineConfig({
+ *   esbuildPlugins: [trussEsbuildPlugin({ mapping: "./src/Css.json" })],
+ * });
+ * ```
+ */
+declare function trussEsbuildPlugin(opts: TrussEsbuildPluginOptions): {
+    name: string;
+    setup(build: EsbuildPluginBuild): void;
+};
+/**
+ * Minimal esbuild plugin types so we don't need esbuild as a dependency.
+ *
+ * These match the subset of the esbuild Plugin API that we use.
+ */
+interface EsbuildPluginBuild {
+    initialOptions: {
+        outdir?: string;
+    };
+    onLoad(options: {
+        filter: RegExp;
+    }, callback: (args: {
+        path: string;
+    }) => {
+        contents: string;
+        loader: string;
+    } | undefined): void;
+    onEnd(callback: () => void): void;
+}
+
 interface TrussPluginOptions {
     /** Path to the Css.json mapping file used for transforming files (relative to project root or absolute). */
     mapping: string;
@@ -72,4 +118,4 @@ declare function trussPlugin(opts: TrussPluginOptions): TrussVitePlugin;
 /** Load a truss mapping file synchronously (for tests). */
 declare function loadMapping(path: string): TrussMapping;
 
-export { type TrussMapping, type TrussMappingEntry, type TrussPluginOptions, type TrussVitePlugin, loadMapping, trussPlugin };
+export { type TrussEsbuildPluginOptions, type TrussMapping, type TrussMappingEntry, type TrussPluginOptions, type TrussVitePlugin, loadMapping, trussEsbuildPlugin, trussPlugin };

package/build/plugin/index.js

@@ -1,6 +1,6 @@
 // src/plugin/index.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync } from "fs";
-import { resolve, dirname, isAbsolute, join } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync } from "fs";
+import { resolve as resolve2, dirname, isAbsolute, join as join2 } from "path";
 
 // src/plugin/emit-truss.ts
 import * as t from "@babel/types";
@@ -2877,6 +2877,52 @@ function mergeTrussCss(sources) {
   return lines.join("\n");
 }
 
+// src/plugin/esbuild-plugin.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { resolve, join } from "path";
+function trussEsbuildPlugin(opts) {
+  const cssRegistry = /* @__PURE__ */ new Map();
+  let mapping = null;
+  let outDir;
+  return {
+    name: "truss",
+    setup(build) {
+      outDir = build.initialOptions.outdir ?? build.initialOptions.outdir;
+      build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, function(args) {
+        const code = readFileSync2(args.path, "utf8");
+        if (!code.includes("Css")) return void 0;
+        if (!mapping) {
+          mapping = loadMapping(resolve(process.cwd(), opts.mapping));
+        }
+        const result = transformTruss(code, args.path, mapping);
+        if (!result) return void 0;
+        if (result.rules) {
+          for (const [className, rule] of result.rules) {
+            if (!cssRegistry.has(className)) {
+              cssRegistry.set(className, rule);
+            }
+          }
+        }
+        return { contents: result.code, loader: loaderForPath(args.path) };
+      });
+      build.onEnd(function() {
+        if (cssRegistry.size === 0) return;
+        const css = generateCssText(cssRegistry);
+        const cssFileName = opts.outputCss ?? "truss.css";
+        const cssPath = resolve(outDir ?? join(process.cwd(), "dist"), cssFileName);
+        mkdirSync(resolve(cssPath, ".."), { recursive: true });
+        writeFileSync(cssPath, css, "utf8");
+      });
+    }
+  };
+}
+function loaderForPath(filePath) {
+  if (filePath.endsWith(".tsx")) return "tsx";
+  if (filePath.endsWith(".ts")) return "ts";
+  if (filePath.endsWith(".jsx")) return "jsx";
+  return "js";
+}
+
 // src/plugin/index.ts
 var VIRTUAL_CSS_PREFIX = "\0truss-css:";
 var CSS_TS_QUERY = "?truss-css";
@@ -2894,7 +2940,7 @@ function trussPlugin(opts) {
   let cssVersion = 0;
   let lastSentVersion = 0;
   function mappingPath() {
-    return resolve(projectRoot || process.cwd(), opts.mapping);
+    return resolve2(projectRoot || process.cwd(), opts.mapping);
   }
   function ensureMapping() {
     if (!mapping) {
@@ -2906,7 +2952,7 @@ function trussPlugin(opts) {
   function loadLibraries() {
     if (!libraryCache) {
       libraryCache = libraryPaths.map(function(libPath) {
-        const resolved = resolve(projectRoot || process.cwd(), libPath);
+        const resolved = resolve2(projectRoot || process.cwd(), libPath);
         return readTrussCss(resolved);
       });
     }
@@ -3008,7 +3054,7 @@ function trussPlugin(opts) {
       }
       if (!id.startsWith(VIRTUAL_CSS_PREFIX)) return null;
       const sourcePath = id.slice(VIRTUAL_CSS_PREFIX.length) + ".ts";
-      const sourceCode = readFileSync2(sourcePath, "utf8");
+      const sourceCode = readFileSync3(sourcePath, "utf8");
       return transformCssTs(sourceCode, sourcePath, ensureMapping());
     },
     transform(code, id) {
@@ -3072,15 +3118,15 @@ function trussPlugin(opts) {
       if (!isBuild) return;
       const css = collectCss();
       if (!css) return;
-      const outDir = options.dir || join(projectRoot, "dist");
-      const trussPath = join(outDir, "truss.css");
+      const outDir = options.dir || join2(projectRoot, "dist");
+      const trussPath = join2(outDir, "truss.css");
       if (!existsSync(trussPath)) {
         const alreadyEmitted = Object.keys(bundle).some(function(key) {
           const asset = bundle[key];
           return asset.type === "asset" && key.endsWith(".css") && typeof asset.source === "string" && asset.source.includes(css);
         });
         if (!alreadyEmitted) {
-          writeFileSync(trussPath, css, "utf8");
+          writeFileSync2(trussPath, css, "utf8");
         }
       }
     }
@@ -3091,9 +3137,9 @@ function resolveImportPath(source, importer, projectRoot) {
     return source;
   }
   if (importer) {
-    return resolve(dirname(importer), source);
+    return resolve2(dirname(importer), source);
   }
-  return resolve(projectRoot || process.cwd(), source);
+  return resolve2(projectRoot || process.cwd(), source);
 }
 function stripQueryAndHash(id) {
   const queryIndex = id.indexOf("?");
@@ -3111,11 +3157,12 @@ function isNodeModulesFile(filePath) {
   return filePath.replace(/\\/g, "/").includes("/node_modules/");
 }
 function loadMapping(path) {
-  const raw = readFileSync2(path, "utf8");
+  const raw = readFileSync3(path, "utf8");
   return JSON.parse(raw);
 }
 export {
   loadMapping,
+  trussEsbuildPlugin,
   trussPlugin
 };
 //# sourceMappingURL=index.js.map