@pathscale/rebuild-plugin-ui-css-purge 0.1.0

package/README.md

@@ -0,0 +1 @@
+# bun-plugin-ui-css-purge

package/dist/generate-manifest.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Lib-side database generator.
+ *
+ * Reads all `*.classnames.ts` files from @pathscale/ui's component tree
+ * and produces a `purge-manifest.json` that the consumer-side plugin uses
+ * to build safelists.
+ *
+ * Usage:  bun run src/generate-manifest.ts <path-to-ui-src/components>
+ * Output: purge-manifest.json in cwd (or pass --out <path>)
+ */
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { pluginCssPurge } from "./rsbuild-plugin";
+export type { CssPurgeOptions } from "./rsbuild-plugin";

package/dist/index.js

@@ -0,0 +1,337 @@
+// src/rsbuild-plugin.ts
+import { PurgeCSS } from "purgecss";
+import postcss from "postcss";
+import swc from "@swc/core";
+import path from "path";
+import { readFile as nodeReadFile } from "node:fs/promises";
+import { glob as fastGlob } from "fast-glob";
+function walkAST(node, visitor) {
+  if (!node || typeof node !== "object")
+    return;
+  visitor(node);
+  for (const key of Object.keys(node)) {
+    if (key === "span")
+      continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      for (const item of val)
+        walkAST(item, visitor);
+    } else if (val && typeof val === "object") {
+      walkAST(val, visitor);
+    }
+  }
+}
+function extractUIImports(ast) {
+  const imports = new Map;
+  for (const node of ast.body) {
+    if (node.type !== "ImportDeclaration")
+      continue;
+    const src = node.source?.value;
+    if (!src || !src.startsWith("@pathscale/ui"))
+      continue;
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier") {
+        const imported = spec.imported?.value ?? spec.local?.value;
+        const local = spec.local?.value;
+        if (local && imported)
+          imports.set(local, imported);
+      } else if (spec.type === "ImportDefaultSpecifier") {
+        const local = spec.local?.value;
+        if (local)
+          imports.set(local, local);
+      }
+    }
+  }
+  return imports;
+}
+function extractJSXUsages(ast, uiComponents) {
+  const usages = [];
+  walkAST(ast, (node) => {
+    if (node.type !== "JSXOpeningElement")
+      return;
+    let elementName = null;
+    let rootName = null;
+    if (node.name?.type === "Identifier") {
+      elementName = node.name.value;
+      rootName = elementName;
+    } else if (node.name?.type === "JSXMemberExpression") {
+      const parts = [];
+      let cursor = node.name;
+      while (cursor?.type === "JSXMemberExpression") {
+        parts.unshift(cursor.property?.value);
+        cursor = cursor.object;
+      }
+      if (cursor?.type === "Identifier") {
+        parts.unshift(cursor.value);
+        rootName = cursor.value;
+      }
+      elementName = parts.join(".");
+    }
+    if (!rootName || !uiComponents.has(rootName))
+      return;
+    const usage = {
+      component: elementName,
+      props: new Map,
+      booleanProps: new Set,
+      hasSpread: false
+    };
+    for (const attr of node.attributes || []) {
+      if (attr.type === "SpreadElement" || attr.type === "JSXSpreadAttribute") {
+        usage.hasSpread = true;
+        continue;
+      }
+      if (attr.type !== "JSXAttribute")
+        continue;
+      const propName = attr.name?.value;
+      if (!propName)
+        continue;
+      if (!attr.value) {
+        usage.booleanProps.add(propName);
+      } else if (attr.value.type === "StringLiteral") {
+        usage.props.set(propName, attr.value.value);
+      } else {
+        usage.props.set(propName, "DYNAMIC");
+      }
+    }
+    usages.push(usage);
+  });
+  return usages;
+}
+function buildSafelists(allUsages, manifest) {
+  const classSafelist = new Set;
+  const attrSafelist = new Set;
+  const componentUsages = new Map;
+  for (const usage of allUsages) {
+    const existing = componentUsages.get(usage.component) ?? [];
+    existing.push(usage);
+    componentUsages.set(usage.component, existing);
+  }
+  for (const [entryName, entry] of Object.entries(manifest)) {
+    const matchingUsages = findMatchingUsages(entryName, componentUsages);
+    if (matchingUsages.length === 0)
+      continue;
+    for (const cls of entry.classes.always)
+      classSafelist.add(cls);
+    for (const [propOrSlot, value] of Object.entries(entry.classes.byProp)) {
+      if (Array.isArray(value)) {
+        if (isPropUsed(propOrSlot, matchingUsages)) {
+          for (const cls of value)
+            classSafelist.add(cls);
+        }
+      } else {
+        const usedValues = getUsedEnumValues(propOrSlot, matchingUsages);
+        if (usedValues === "ALL") {
+          for (const classes of Object.values(value)) {
+            for (const cls of classes)
+              classSafelist.add(cls);
+          }
+        } else {
+          for (const val of usedValues) {
+            if (value[val]) {
+              for (const cls of value[val])
+                classSafelist.add(cls);
+            }
+          }
+        }
+      }
+    }
+    if (entry.attrs) {
+      for (const [propName, attrMap] of Object.entries(entry.attrs)) {
+        if (isPropUsed(propName, matchingUsages)) {
+          for (const [attr, val] of Object.entries(attrMap)) {
+            attrSafelist.add(`[${attr}="${val}"]`);
+          }
+        }
+      }
+    }
+  }
+  return { classSafelist, attrSafelist };
+}
+function findMatchingUsages(entryName, usageMap) {
+  if (usageMap.has(entryName))
+    return usageMap.get(entryName);
+  const results = [];
+  for (const [usageName, usages] of usageMap) {
+    if (usageName === entryName) {
+      results.push(...usages);
+    }
+    if (entryName.includes(".")) {
+      const [family, part] = entryName.split(".");
+      if (part === family && usageName === family) {
+        results.push(...usages);
+      }
+    }
+  }
+  return results;
+}
+function isPropUsed(propName, usages) {
+  for (const usage of usages) {
+    if (usage.hasSpread)
+      return true;
+    if (usage.booleanProps.has(propName))
+      return true;
+    if (usage.props.has(propName))
+      return true;
+  }
+  return false;
+}
+function getUsedEnumValues(slotName, usages) {
+  const values = new Set;
+  for (const usage of usages) {
+    if (usage.hasSpread)
+      return "ALL";
+    const val = usage.props.get(slotName);
+    if (val === "DYNAMIC")
+      return "ALL";
+    if (val !== undefined)
+      values.add(val);
+    if (usage.booleanProps.has(slotName))
+      return "ALL";
+  }
+  return values;
+}
+async function scanConsumerSource(srcDir) {
+  const allUsages = [];
+  const files = await fastGlob("**/*.{tsx,ts,jsx,js}", { cwd: srcDir, ignore: ["**/node_modules/**"] });
+  for (const relPath of files) {
+    const fullPath = path.join(srcDir, relPath);
+    const code = await nodeReadFile(fullPath, "utf-8");
+    if (!code.includes("@pathscale/ui"))
+      continue;
+    const isTsx = /\.[tj]sx$/.test(relPath);
+    const ast = await swc.parse(code, { syntax: "typescript", tsx: isTsx });
+    const uiImports = extractUIImports(ast);
+    if (uiImports.size === 0)
+      continue;
+    allUsages.push(...extractJSXUsages(ast, uiImports));
+  }
+  return allUsages;
+}
+function purgeAttributes(css, attrSafelist) {
+  const root = postcss.parse(css);
+  root.walkRules((rule) => {
+    const selectors = rule.selectors;
+    const kept = [];
+    for (const sel of selectors) {
+      const attrMatches = sel.matchAll(/\[(data-[a-z-]+|aria-[a-z-]+)="([^"]+)"\]/g);
+      let shouldKeep = true;
+      for (const match of attrMatches) {
+        const attrSelector = `[${match[1]}="${match[2]}"]`;
+        if (match[1] === "data-slot")
+          continue;
+        if (!attrSafelist.has(attrSelector)) {
+          shouldKeep = false;
+          break;
+        }
+      }
+      if (shouldKeep)
+        kept.push(sel);
+    }
+    if (kept.length === 0) {
+      rule.remove();
+    } else if (kept.length < selectors.length) {
+      rule.selectors = kept;
+    }
+  });
+  return root.toString();
+}
+function cleanUnusedVars(css) {
+  let changed = true;
+  let result = css;
+  while (changed) {
+    changed = false;
+    const root = postcss.parse(result);
+    const declared = new Map;
+    root.walkDecls(/^--/, (decl) => {
+      const entries = declared.get(decl.prop) ?? [];
+      entries.push({ rule: decl.parent, prop: decl.prop, index: entries.length });
+      declared.set(decl.prop, entries);
+    });
+    const referenced = new Set;
+    root.walkDecls((decl) => {
+      const refs = decl.value.matchAll(/var\(\s*(--[a-zA-Z0-9_-]+)/g);
+      for (const ref of refs) {
+        referenced.add(ref[1]);
+      }
+    });
+    for (const [varName, entries] of declared) {
+      if (!referenced.has(varName)) {
+        for (const entry of entries) {
+          entry.rule.walkDecls(entry.prop, (decl) => {
+            decl.remove();
+            changed = true;
+          });
+        }
+      }
+    }
+    root.walkRules((rule) => {
+      if (rule.nodes && rule.nodes.length === 0)
+        rule.remove();
+    });
+    root.walkAtRules((atRule) => {
+      if (atRule.nodes && atRule.nodes.length === 0)
+        atRule.remove();
+    });
+    result = root.toString();
+  }
+  return result;
+}
+var pluginCssPurge = (options) => ({
+  name: "plugin-css-purge",
+  setup(api) {
+    const {
+      manifest: manifestPath,
+      srcDir = "src",
+      attrPurge = true,
+      cleanVars = true,
+      verbose = true
+    } = options;
+    api.processAssets({ stage: "optimize-size" }, async ({ assets, sources, compilation }) => {
+      const log = verbose ? console.log.bind(console) : () => {};
+      const manifest = JSON.parse(await nodeReadFile(path.resolve(manifestPath), "utf-8"));
+      log(`[css-purge] Manifest loaded: ${Object.keys(manifest).length} entries`);
+      const resolvedSrc = path.resolve(srcDir);
+      const usages = await scanConsumerSource(resolvedSrc);
+      log(`[css-purge] Scanned ${resolvedSrc}: ${usages.length} component usages`);
+      const { classSafelist, attrSafelist } = buildSafelists(usages, manifest);
+      log(`[css-purge] Safelist: ${classSafelist.size} classes, ${attrSafelist.size} attrs`);
+      for (const [name, asset] of Object.entries(assets)) {
+        if (!name.endsWith(".css"))
+          continue;
+        const originalCss = asset.source().toString();
+        const originalSize = Buffer.byteLength(originalCss, "utf-8");
+        log(`[css-purge] Processing ${name} (${(originalSize / 1024).toFixed(1)} KB)`);
+        const purgeResult = await new PurgeCSS().purge({
+          content: [],
+          css: [{ raw: originalCss }],
+          safelist: [...classSafelist],
+          keyframes: false,
+          fontFace: false
+        });
+        let purgedCss = purgeResult[0]?.css ?? originalCss;
+        const afterL1 = Buffer.byteLength(purgedCss, "utf-8");
+        log(`[css-purge]   L1 class purge: ${(originalSize / 1024).toFixed(1)} → ${(afterL1 / 1024).toFixed(1)} KB`);
+        if (attrPurge && attrSafelist.size > 0) {
+          purgedCss = purgeAttributes(purgedCss, attrSafelist);
+          const afterL2 = Buffer.byteLength(purgedCss, "utf-8");
+          log(`[css-purge]   L2 attr purge: ${(afterL1 / 1024).toFixed(1)} → ${(afterL2 / 1024).toFixed(1)} KB`);
+        }
+        if (cleanVars) {
+          purgedCss = cleanUnusedVars(purgedCss);
+          const afterL3 = Buffer.byteLength(purgedCss, "utf-8");
+          log(`[css-purge]   L3 var cleanup: → ${(afterL3 / 1024).toFixed(1)} KB`);
+        }
+        const finalSize = Buffer.byteLength(purgedCss, "utf-8");
+        log(`[css-purge]   Final: ${(originalSize / 1024).toFixed(1)} → ${(finalSize / 1024).toFixed(1)} KB (${((1 - finalSize / originalSize) * 100).toFixed(1)}% reduction)`);
+        const source = new sources.RawSource(purgedCss);
+        compilation.updateAsset(name, source);
+      }
+    });
+  }
+});
+export {
+  pluginCssPurge
+};
+
+//# debugId=CB5B2093063663E864756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/rsbuild-plugin.ts"],
  "sourcesContent": [
    "/**\n * rsbuild-plugin-css-purge\n *\n * Two-level CSS purge for @pathscale/ui consumers.\n *\n * Level 1: class-level purge via purgecss — removes entire rules whose selectors\n *          don't match the safelist built from consumer JSX analysis.\n * Level 2: attribute-level purge — within kept rules, strips compound selectors\n *          containing data-attr / aria-attr attribute selectors not in the attr safelist.\n *\n * Usage in rsbuild.config.ts:\n *   import { pluginCssPurge } from \"@pathscale/rebuild-plugin-ui-css-purge\";\n *   export default defineConfig({ plugins: [pluginCssPurge({ manifest: \"...\" })] });\n */\n\nimport type { RsbuildPlugin } from \"@rsbuild/core\";\nimport { PurgeCSS } from \"purgecss\";\nimport postcss from \"postcss\";\nimport type { Rule, AtRule } from \"postcss\";\nimport swc from \"@swc/core\";\nimport path from \"path\";\nimport { readFile as nodeReadFile } from \"node:fs/promises\";\nimport { glob as fastGlob } from \"fast-glob\";\n\n// ── Types ─────────────────────────────────────────────────────────────────────\n\ninterface ComponentManifest {\n  classes: {\n    always: string[];\n    byProp: Record<string, string[] | Record<string, string[]>>;\n  };\n  attrs?: Record<string, Record<string, string>>;\n}\n\ntype PurgeManifest = Record<string, ComponentManifest>;\n\ninterface PropUsage {\n  component: string;\n  props: Map<string, string | \"DYNAMIC\">;\n  booleanProps: Set<string>;\n  hasSpread: boolean;\n}\n\n// ── Plugin options ─────────────────────────────────────────────────────────────\n\nexport interface CssPurgeOptions {\n  /** Path to purge-manifest.json (generated by generate-manifest.ts) */\n  manifest: string;\n  /** Consumer source directory to scan for JSX usage (default: \"src\") */\n  srcDir?: string;\n  /** Enable Level 2 attribute purge (default: true) */\n  attrPurge?: boolean;\n  /** Enable CSS variable cleanup (default: true) */\n  cleanVars?: boolean;\n  /** Log purge stats (default: true) */\n  verbose?: boolean;\n}\n\n// ── AST utilities ─────────────────────────────────────────────────────────────\n\nfunction walkAST(node: any, visitor: (node: any) => void) {\n  if (!node || typeof node !== \"object\") return;\n  visitor(node);\n  for (const key of Object.keys(node)) {\n    if (key === \"span\") continue;\n    const val = node[key];\n    if (Array.isArray(val)) {\n      for (const item of val) walkAST(item, visitor);\n    } else if (val && typeof val === \"object\") {\n      walkAST(val, visitor);\n    }\n  }\n}\n\nfunction extractUIImports(ast: any): Map<string, string> {\n  const imports = new Map<string, string>();\n  for (const node of ast.body) {\n    if (node.type !== \"ImportDeclaration\") continue;\n    const src = node.source?.value as string;\n    if (!src || !src.startsWith(\"@pathscale/ui\")) continue;\n    for (const spec of node.specifiers) {\n      if (spec.type === \"ImportSpecifier\") {\n        const imported = spec.imported?.value ?? spec.local?.value;\n        const local = spec.local?.value;\n        if (local && imported) imports.set(local, imported);\n      } else if (spec.type === \"ImportDefaultSpecifier\") {\n        const local = spec.local?.value;\n        if (local) imports.set(local, local);\n      }\n    }\n  }\n  return imports;\n}\n\nfunction extractJSXUsages(ast: any, uiComponents: Map<string, string>): PropUsage[] {\n  const usages: PropUsage[] = [];\n  walkAST(ast, (node) => {\n    if (node.type !== \"JSXOpeningElement\") return;\n    let elementName: string | null = null;\n    let rootName: string | null = null;\n    if (node.name?.type === \"Identifier\") {\n      elementName = node.name.value;\n      rootName = elementName;\n    } else if (node.name?.type === \"JSXMemberExpression\") {\n      const parts: string[] = [];\n      let cursor = node.name;\n      while (cursor?.type === \"JSXMemberExpression\") {\n        parts.unshift(cursor.property?.value);\n        cursor = cursor.object;\n      }\n      if (cursor?.type === \"Identifier\") {\n        parts.unshift(cursor.value);\n        rootName = cursor.value;\n      }\n      elementName = parts.join(\".\");\n    }\n    if (!rootName || !uiComponents.has(rootName)) return;\n    const usage: PropUsage = {\n      component: elementName!,\n      props: new Map(),\n      booleanProps: new Set(),\n      hasSpread: false,\n    };\n    for (const attr of node.attributes || []) {\n      if (attr.type === \"SpreadElement\" || attr.type === \"JSXSpreadAttribute\") {\n        usage.hasSpread = true;\n        continue;\n      }\n      if (attr.type !== \"JSXAttribute\") continue;\n      const propName = attr.name?.value;\n      if (!propName) continue;\n      if (!attr.value) {\n        usage.booleanProps.add(propName);\n      } else if (attr.value.type === \"StringLiteral\") {\n        usage.props.set(propName, attr.value.value);\n      } else {\n        usage.props.set(propName, \"DYNAMIC\");\n      }\n    }\n    usages.push(usage);\n  });\n  return usages;\n}\n\n// ── Safelist builder ───────────────────────────────────────────────────────────\n\nfunction buildSafelists(\n  allUsages: PropUsage[],\n  manifest: PurgeManifest,\n): { classSafelist: Set<string>; attrSafelist: Set<string> } {\n  const classSafelist = new Set<string>();\n  const attrSafelist = new Set<string>();\n\n  const componentUsages = new Map<string, PropUsage[]>();\n  for (const usage of allUsages) {\n    const existing = componentUsages.get(usage.component) ?? [];\n    existing.push(usage);\n    componentUsages.set(usage.component, existing);\n  }\n\n  for (const [entryName, entry] of Object.entries(manifest)) {\n    const matchingUsages = findMatchingUsages(entryName, componentUsages);\n    if (matchingUsages.length === 0) continue;\n\n    for (const cls of entry.classes.always) classSafelist.add(cls);\n\n    for (const [propOrSlot, value] of Object.entries(entry.classes.byProp)) {\n      if (Array.isArray(value)) {\n        if (isPropUsed(propOrSlot, matchingUsages)) {\n          for (const cls of value) classSafelist.add(cls);\n        }\n      } else {\n        const usedValues = getUsedEnumValues(propOrSlot, matchingUsages);\n        if (usedValues === \"ALL\") {\n          for (const classes of Object.values(value)) {\n            for (const cls of classes) classSafelist.add(cls);\n          }\n        } else {\n          for (const val of usedValues) {\n            if (value[val]) {\n              for (const cls of value[val]) classSafelist.add(cls);\n            }\n          }\n        }\n      }\n    }\n\n    if (entry.attrs) {\n      for (const [propName, attrMap] of Object.entries(entry.attrs)) {\n        if (isPropUsed(propName, matchingUsages)) {\n          for (const [attr, val] of Object.entries(attrMap)) {\n            attrSafelist.add(`[${attr}=\"${val}\"]`);\n          }\n        }\n      }\n    }\n  }\n\n  return { classSafelist, attrSafelist };\n}\n\nfunction findMatchingUsages(entryName: string, usageMap: Map<string, PropUsage[]>): PropUsage[] {\n  if (usageMap.has(entryName)) return usageMap.get(entryName)!;\n  const results: PropUsage[] = [];\n  for (const [usageName, usages] of usageMap) {\n    if (usageName === entryName) {\n      results.push(...usages);\n    }\n    if (entryName.includes(\".\")) {\n      const [family, part] = entryName.split(\".\");\n      if (part === family && usageName === family) {\n        results.push(...usages);\n      }\n    }\n  }\n  return results;\n}\n\nfunction isPropUsed(propName: string, usages: PropUsage[]): boolean {\n  for (const usage of usages) {\n    if (usage.hasSpread) return true;\n    if (usage.booleanProps.has(propName)) return true;\n    if (usage.props.has(propName)) return true;\n  }\n  return false;\n}\n\nfunction getUsedEnumValues(slotName: string, usages: PropUsage[]): Set<string> | \"ALL\" {\n  const values = new Set<string>();\n  for (const usage of usages) {\n    if (usage.hasSpread) return \"ALL\";\n    const val = usage.props.get(slotName);\n    if (val === \"DYNAMIC\") return \"ALL\";\n    if (val !== undefined) values.add(val);\n    if (usage.booleanProps.has(slotName)) return \"ALL\";\n  }\n  return values;\n}\n\n// ── Consumer source scanning ───────────────────────────────────────────────────\n\nasync function scanConsumerSource(srcDir: string): Promise<PropUsage[]> {\n  const allUsages: PropUsage[] = [];\n  const files = await fastGlob(\"**/*.{tsx,ts,jsx,js}\", { cwd: srcDir, ignore: [\"**/node_modules/**\"] });\n\n  for (const relPath of files) {\n    const fullPath = path.join(srcDir, relPath);\n    const code = await nodeReadFile(fullPath, \"utf-8\");\n    if (!code.includes(\"@pathscale/ui\")) continue;\n\n    const isTsx = /\\.[tj]sx$/.test(relPath);\n    const ast = await swc.parse(code, { syntax: \"typescript\", tsx: isTsx });\n    const uiImports = extractUIImports(ast);\n    if (uiImports.size === 0) continue;\n\n    allUsages.push(...extractJSXUsages(ast, uiImports));\n  }\n\n  return allUsages;\n}\n\n// ── Level 2: attribute purge ───────────────────────────────────────────────────\n\nfunction purgeAttributes(css: string, attrSafelist: Set<string>): string {\n  const root = postcss.parse(css);\n\n  root.walkRules((rule) => {\n    const selectors = rule.selectors;\n    const kept: string[] = [];\n\n    for (const sel of selectors) {\n      const attrMatches = sel.matchAll(/\\[(data-[a-z-]+|aria-[a-z-]+)=\"([^\"]+)\"\\]/g);\n      let shouldKeep = true;\n\n      for (const match of attrMatches) {\n        const attrSelector = `[${match[1]}=\"${match[2]}\"]`;\n        if (match[1] === \"data-slot\") continue;\n        if (!attrSafelist.has(attrSelector)) {\n          shouldKeep = false;\n          break;\n        }\n      }\n\n      if (shouldKeep) kept.push(sel);\n    }\n\n    if (kept.length === 0) {\n      rule.remove();\n    } else if (kept.length < selectors.length) {\n      rule.selectors = kept;\n    }\n  });\n\n  return root.toString();\n}\n\n// ── Level 3: unused CSS variable cleanup ───────────────────────────────────────\n\nfunction cleanUnusedVars(css: string): string {\n  let changed = true;\n  let result = css;\n\n  while (changed) {\n    changed = false;\n    const root = postcss.parse(result);\n\n    const declared = new Map<string, { rule: Rule | AtRule; prop: string; index: number }[]>();\n    root.walkDecls(/^--/, (decl) => {\n      const entries = declared.get(decl.prop) ?? [];\n      entries.push({ rule: decl.parent as Rule, prop: decl.prop, index: entries.length });\n      declared.set(decl.prop, entries);\n    });\n\n    const referenced = new Set<string>();\n    root.walkDecls((decl) => {\n      const refs = decl.value.matchAll(/var\\(\\s*(--[a-zA-Z0-9_-]+)/g);\n      for (const ref of refs) {\n        referenced.add(ref[1]);\n      }\n    });\n\n    for (const [varName, entries] of declared) {\n      if (!referenced.has(varName)) {\n        for (const entry of entries) {\n          entry.rule.walkDecls(entry.prop, (decl) => {\n            decl.remove();\n            changed = true;\n          });\n        }\n      }\n    }\n\n    root.walkRules((rule) => {\n      if (rule.nodes && rule.nodes.length === 0) rule.remove();\n    });\n    root.walkAtRules((atRule) => {\n      if (atRule.nodes && atRule.nodes.length === 0) atRule.remove();\n    });\n\n    result = root.toString();\n  }\n\n  return result;\n}\n\n// ── The rsbuild plugin ─────────────────────────────────────────────────────────\n\nexport const pluginCssPurge = (options: CssPurgeOptions): RsbuildPlugin => ({\n  name: \"plugin-css-purge\",\n\n  setup(api) {\n    const {\n      manifest: manifestPath,\n      srcDir = \"src\",\n      attrPurge = true,\n      cleanVars = true,\n      verbose = true,\n    } = options;\n\n    api.processAssets(\n      { stage: \"optimize-size\" },\n      async ({ assets, sources, compilation }) => {\n        const log = verbose ? console.log.bind(console) : () => {};\n\n        // 1. Load manifest\n        const manifest: PurgeManifest = JSON.parse(\n          await nodeReadFile(path.resolve(manifestPath), \"utf-8\"),\n        );\n        log(`[css-purge] Manifest loaded: ${Object.keys(manifest).length} entries`);\n\n        // 2. Scan consumer source\n        const resolvedSrc = path.resolve(srcDir);\n        const usages = await scanConsumerSource(resolvedSrc);\n        log(`[css-purge] Scanned ${resolvedSrc}: ${usages.length} component usages`);\n\n        // 3. Build safelists\n        const { classSafelist, attrSafelist } = buildSafelists(usages, manifest);\n        log(`[css-purge] Safelist: ${classSafelist.size} classes, ${attrSafelist.size} attrs`);\n\n        // 4. Process each CSS asset\n        for (const [name, asset] of Object.entries(assets)) {\n          if (!name.endsWith(\".css\")) continue;\n\n          const originalCss = asset.source().toString();\n          const originalSize = Buffer.byteLength(originalCss, \"utf-8\");\n          log(`[css-purge] Processing ${name} (${(originalSize / 1024).toFixed(1)} KB)`);\n\n          // Level 1: class-level purge\n          const purgeResult = await new PurgeCSS().purge({\n            content: [],\n            css: [{ raw: originalCss }],\n            safelist: [...classSafelist],\n            keyframes: false,\n            fontFace: false,\n          });\n\n          let purgedCss = purgeResult[0]?.css ?? originalCss;\n          const afterL1 = Buffer.byteLength(purgedCss, \"utf-8\");\n          log(`[css-purge]   L1 class purge: ${(originalSize / 1024).toFixed(1)} → ${(afterL1 / 1024).toFixed(1)} KB`);\n\n          // Level 2: attribute-level purge\n          if (attrPurge && attrSafelist.size > 0) {\n            purgedCss = purgeAttributes(purgedCss, attrSafelist);\n            const afterL2 = Buffer.byteLength(purgedCss, \"utf-8\");\n            log(`[css-purge]   L2 attr purge: ${(afterL1 / 1024).toFixed(1)} → ${(afterL2 / 1024).toFixed(1)} KB`);\n          }\n\n          // Level 3: unused CSS variable cleanup\n          if (cleanVars) {\n            purgedCss = cleanUnusedVars(purgedCss);\n            const afterL3 = Buffer.byteLength(purgedCss, \"utf-8\");\n            log(`[css-purge]   L3 var cleanup: → ${(afterL3 / 1024).toFixed(1)} KB`);\n          }\n\n          const finalSize = Buffer.byteLength(purgedCss, \"utf-8\");\n          log(`[css-purge]   Final: ${(originalSize / 1024).toFixed(1)} → ${(finalSize / 1024).toFixed(1)} KB (${((1 - finalSize / originalSize) * 100).toFixed(1)}% reduction)`);\n\n          // Write back\n          const source = new sources.RawSource(purgedCss);\n          compilation.updateAsset(name, source);\n        }\n      },\n    );\n  },\n});\n"
  ],
  "mappings": "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",
  "debugId": "CB5B2093063663E864756E2164756E21",
  "names": []
}

package/dist/rsbuild-plugin.d.ts

@@ -0,0 +1,28 @@
+/**
+ * rsbuild-plugin-css-purge
+ *
+ * Two-level CSS purge for @pathscale/ui consumers.
+ *
+ * Level 1: class-level purge via purgecss — removes entire rules whose selectors
+ *          don't match the safelist built from consumer JSX analysis.
+ * Level 2: attribute-level purge — within kept rules, strips compound selectors
+ *          containing data-attr / aria-attr attribute selectors not in the attr safelist.
+ *
+ * Usage in rsbuild.config.ts:
+ *   import { pluginCssPurge } from "@pathscale/rebuild-plugin-ui-css-purge";
+ *   export default defineConfig({ plugins: [pluginCssPurge({ manifest: "..." })] });
+ */
+import type { RsbuildPlugin } from "@rsbuild/core";
+export interface CssPurgeOptions {
+    /** Path to purge-manifest.json (generated by generate-manifest.ts) */
+    manifest: string;
+    /** Consumer source directory to scan for JSX usage (default: "src") */
+    srcDir?: string;
+    /** Enable Level 2 attribute purge (default: true) */
+    attrPurge?: boolean;
+    /** Enable CSS variable cleanup (default: true) */
+    cleanVars?: boolean;
+    /** Log purge stats (default: true) */
+    verbose?: boolean;
+}
+export declare const pluginCssPurge: (options: CssPurgeOptions) => RsbuildPlugin;

package/dist/scan-consumer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Consumer-side JSX scanner.
+ *
+ * Walks a consumer's source tree, finds component imports from @pathscale/ui,
+ * collects prop values, and cross-references with the purge manifest to build
+ * Level 1 (class) and Level 2 (attribute) safelists.
+ *
+ * Usage:  bun run src/scan-consumer.ts <consumer-src-dir> <purge-manifest.json>
+ */
+interface ComponentManifest {
+    classes: {
+        always: string[];
+        byProp: Record<string, string[] | Record<string, string[]>>;
+    };
+    attrs?: Record<string, Record<string, string>>;
+}
+type PurgeManifest = Record<string, ComponentManifest>;
+/** What we collect per component usage from JSX */
+interface PropUsage {
+    component: string;
+    props: Map<string, string | "DYNAMIC">;
+    booleanProps: Set<string>;
+    hasSpread: boolean;
+}
+/** Extract @pathscale/ui imports from a parsed module */
+declare function extractUIImports(ast: any): Map<string, string>;
+/** Extract JSX usages of UI components */
+declare function extractJSXUsages(ast: any, uiComponents: Map<string, string>): PropUsage[];
+interface Safelists {
+    classSafelist: Set<string>;
+    attrSafelist: Set<string>;
+}
+declare function buildSafelists(allUsages: PropUsage[], manifest: PurgeManifest): Safelists;
+export { extractUIImports, extractJSXUsages, buildSafelists };
+export type { PropUsage, PurgeManifest, ComponentManifest, Safelists };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@pathscale/rebuild-plugin-ui-css-purge",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "generate-manifest": "src/generate-manifest.ts"
+  },
+  "files": ["dist", "src/generate-manifest.ts"],
+  "dependencies": {
+    "@swc/core": "^1.15.24",
+    "fast-glob": "^3.3.3",
+    "postcss": "^8.5.9",
+    "purgecss": "^8.0.0"
+  },
+  "peerDependencies": {
+    "@rsbuild/core": "^1.7.5"
+  },
+  "scripts": {
+    "build": "bun run build.ts",
+    "lint": "biome check .",
+    "format": "biome format . --write"
+  },
+  "devDependencies": {
+    "@rsbuild/core": "^1.7.5",
+    "bun-types": "^1.3.12"
+  }
+}

package/src/generate-manifest.ts

@@ -0,0 +1,155 @@
+/**
+ * Lib-side database generator.
+ *
+ * Reads all `*.classnames.ts` files from @pathscale/ui's component tree
+ * and produces a `purge-manifest.json` that the consumer-side plugin uses
+ * to build safelists.
+ *
+ * Usage:  bun run src/generate-manifest.ts <path-to-ui-src/components>
+ * Output: purge-manifest.json in cwd (or pass --out <path>)
+ */
+
+import { Glob } from "bun";
+import path from "path";
+
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+type ClassValue = string | readonly string[];
+
+interface ComponentManifest {
+  classes: {
+    always: string[];
+    byProp: Record<string, string[] | Record<string, string[]>>;
+  };
+  attrs?: Record<string, Record<string, string>>;
+}
+
+type PurgeManifest = Record<string, ComponentManifest>;
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+/** Flatten a class value (string or string[]) into an array of individual class names. */
+function flattenClasses(val: ClassValue): string[] {
+  if (typeof val === "string") {
+    return val.split(/\s+/).filter(Boolean);
+  }
+  return (val as readonly string[]).flatMap((s) => s.split(/\s+/).filter(Boolean));
+}
+
+/** Check if a value is a plain object (not array, not null). */
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+
+/**
+ * Walk a single CLASSES object (one component or one part of a compound component)
+ * and produce the manifest entry.
+ */
+function walkClassesObject(obj: Record<string, unknown>): ComponentManifest {
+  const always: string[] = [];
+  const byProp: Record<string, string[] | Record<string, string[]>> = {};
+  let attrs: Record<string, Record<string, string>> | undefined;
+
+  for (const [slot, value] of Object.entries(obj)) {
+    if (slot === "base") {
+      always.push(...flattenClasses(value as ClassValue));
+    } else if (slot === "attrs") {
+      if (isRecord(value)) {
+        attrs = {};
+        for (const [propName, attrMap] of Object.entries(value)) {
+          if (isRecord(attrMap)) {
+            attrs[propName] = attrMap as Record<string, string>;
+          }
+        }
+      }
+    } else if (slot === "flag") {
+      if (isRecord(value)) {
+        for (const [propName, classVal] of Object.entries(value)) {
+          byProp[propName] = flattenClasses(classVal as ClassValue);
+        }
+      }
+    } else if (isRecord(value)) {
+      const enumMap: Record<string, string[]> = {};
+      for (const [enumKey, classVal] of Object.entries(value)) {
+        enumMap[enumKey] = flattenClasses(classVal as ClassValue);
+      }
+      byProp[slot] = enumMap;
+    }
+  }
+
+  const manifest: ComponentManifest = { classes: { always, byProp } };
+  if (attrs && Object.keys(attrs).length > 0) {
+    manifest.attrs = attrs;
+  }
+  return manifest;
+}
+
+/**
+ * Detect whether CLASSES is compound (top-level keys are part names like Root, Item)
+ * or flat (top-level keys are slots like base, variant, flag).
+ */
+const KNOWN_SLOTS = new Set(["base", "variant", "size", "flag", "color", "attrs"]);
+
+function isCompound(obj: Record<string, unknown>): boolean {
+  for (const key of Object.keys(obj)) {
+    if (KNOWN_SLOTS.has(key)) return false;
+  }
+  return true;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const args = process.argv.slice(2);
+  let componentsDir = args[0];
+  let outPath = "purge-manifest.json";
+
+  const outIdx = args.indexOf("--out");
+  if (outIdx !== -1 && args[outIdx + 1]) {
+    outPath = args[outIdx + 1];
+  }
+
+  if (!componentsDir) {
+    console.error("Usage: bun run src/generate-manifest.ts <path-to-components-dir> [--out <path>]");
+    process.exit(1);
+  }
+
+  componentsDir = path.resolve(componentsDir);
+  console.log(`Scanning ${componentsDir} for *.classnames.ts files…`);
+
+  const manifest: PurgeManifest = {};
+  const glob = new Glob("**/*.classnames.ts");
+
+  for await (const relPath of glob.scan({ cwd: componentsDir })) {
+    const fullPath = path.join(componentsDir, relPath);
+
+    const mod = await import(fullPath);
+    const CLASSES = mod.CLASSES;
+
+    if (!CLASSES || typeof CLASSES !== "object") {
+      console.warn(`  SKIP ${relPath} — no CLASSES export found`);
+      continue;
+    }
+
+    const fileName = path.basename(relPath, ".classnames.ts");
+
+    if (isCompound(CLASSES as Record<string, unknown>)) {
+      for (const [partName, partObj] of Object.entries(CLASSES as Record<string, unknown>)) {
+        if (isRecord(partObj)) {
+          const entryName = `${fileName}.${partName}`;
+          manifest[entryName] = walkClassesObject(partObj as Record<string, unknown>);
+          console.log(`  ✓ ${entryName}`);
+        }
+      }
+    } else {
+      manifest[fileName] = walkClassesObject(CLASSES as Record<string, unknown>);
+      console.log(`  ✓ ${fileName}`);
+    }
+  }
+
+  const json = JSON.stringify(manifest, null, 2);
+  await Bun.write(outPath, json);
+  console.log(`\nWrote ${outPath} (${Object.keys(manifest).length} entries, ${json.length} bytes)`);
+}
+
+main();