forgecss 0.4.0 → 0.6.0

package/cli.js

@@ -4,9 +4,10 @@ import fs from 'fs';
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { program } from "commander";
-import ForgeCSS from './index.js';
 import chokidar from "chokidar";
 
+import ForgeCSS from './index.js';
+
 program.option("-c, --config <string>,", "Path to forgecss config file", process.cwd() + "/forgecss.config.js");
 program.option("-w, --watch", "Enable watch mode", false);
 program.option("-v, --verbose", "Enable watch mode", false);

package/client/fx.js

@@ -6,7 +6,7 @@ export default function fx(classes) {
       label = normalizeLabel(label);
       return rest
         .split(",")
-        .map((cls) => `${label}--${cls}`)
+        .map((cls) => `${label}_${cls}`)
         .join(" ");
     })
     .filter(Boolean)

package/dist/forgecss.min.js

@@ -1 +1 @@
-(()=>{function s(n){return a(n).map(t=>{let[e,i]=f(t);return!e||e==="[true]"?i:e==="[false]"?!1:(e=c(e),i.split(",").map(l=>`${e}--${l}`).join(" "))}).filter(Boolean).join(" ")}function f(n){let t=n.lastIndexOf(":");if(t===-1)return[null,n];let e=n.slice(0,t),i=n.slice(t+1);return[e,i]}function c(n){let t=n.trim();return t=t.replace(/[&]/g,"I"),t=t.replace(/[:| =]/g,"-"),t=t.replace(/[^a-zA-Z0-9_-]/g,""),t}function a(n){let t=[],e="",i=0,l=null;for(let r=0;r<n.length;r++){let o=n[r];if(i>0){if(l){e+=o,o===l&&n[r-1]!=="\\"&&(l=null);continue}else if(o==="'"||o==='"'){l=o,e+=o;continue}}if(o==="["){i++,e+=o;continue}if(o==="]"&&i>0){i--,e+=o;continue}if(i===0&&/\s/.test(o)){for(e&&t.push(e),e="";r+1<n.length&&/\s/.test(n[r+1]);)r++;continue}e+=o}return e&&t.push(e),t}function u(n){for(var t=n||document,e=t.querySelectorAll("[class]"),i=0;i<e.length;i++){var l=e[i],r=l.getAttribute("class");if(r){var o=s(r);typeof o=="string"&&o!==r&&l.setAttribute("class",o)}}}window.fx=s;window.forgecss=u;document.readyState!=="loading"?u():document.addEventListener("DOMContentLoaded",function(){u()});window.addEventListener("load",function(){u()});})();
+(()=>{function s(n){return a(n).map(t=>{let[e,i]=f(t);return!e||e==="[true]"?i:e==="[false]"?!1:(e=c(e),i.split(",").map(l=>`${e}_${l}`).join(" "))}).filter(Boolean).join(" ")}function f(n){let t=n.lastIndexOf(":");if(t===-1)return[null,n];let e=n.slice(0,t),i=n.slice(t+1);return[e,i]}function c(n){let t=n.trim();return t=t.replace(/[&]/g,"I"),t=t.replace(/[:| =]/g,"-"),t=t.replace(/[^a-zA-Z0-9_-]/g,""),t}function a(n){let t=[],e="",i=0,l=null;for(let r=0;r<n.length;r++){let o=n[r];if(i>0){if(l){e+=o,o===l&&n[r-1]!=="\\"&&(l=null);continue}else if(o==="'"||o==='"'){l=o,e+=o;continue}}if(o==="["){i++,e+=o;continue}if(o==="]"&&i>0){i--,e+=o;continue}if(i===0&&/\s/.test(o)){for(e&&t.push(e),e="";r+1<n.length&&/\s/.test(n[r+1]);)r++;continue}e+=o}return e&&t.push(e),t}function u(n){for(var t=n||document,e=t.querySelectorAll("[class]"),i=0;i<e.length;i++){var l=e[i],r=l.getAttribute("class");if(r){var o=s(r);typeof o=="string"&&o!==r&&l.setAttribute("class",o)}}}window.fx=s;window.forgecss=u;document.readyState!=="loading"?u():document.addEventListener("DOMContentLoaded",function(){u()});window.addEventListener("load",function(){u()});})();

package/index.d.ts

@@ -3,14 +3,16 @@ export type ForgeCSSOptions = {
   usageFiles?: string[];
   usageAttributes?: string[];
   breakpoints?: {
-    [key: string]: string
+    [key: string]: string;
   };
+  verbose?: boolean;
+  minify?: boolean;
 };
 
 export type ForgeInstance = {
-  parseDirectory: (options: { dir: string; output?: string }) => Promise<string>;
-  parseFile: (options: { file: string; output?: string }) => Promise<string>;
-  parse: (options: { css: string; html?: string; jsx?: string; output?: string }) => Promise<string>;
+  parseDirectory: (options: { dir: string; output?: string; watch?: boolean }) => Promise<string>;
+  parseFile: (options: { file: string; output?: string; watch?: boolean }) => Promise<string>;
+  parse: (options: { css: string; html?: string; jsx?: string; output?: string; }) => Promise<string>;
 };
 
 declare function ForgeCSS(options?: ForgeCSSOptions): ForgeInstance;

package/index.js

@@ -1,26 +1,53 @@
+import path from 'path';
 import { writeFile } from "fs/promises";
-import getAllFiles from "./lib/getAllFiles.js";
-import { extractStyles, invalidateInvetory } from "./lib/inventory.js";
-import { invalidateUsageCache, findUsages } from "./lib/usages.js";
-import { generateOutputCSS } from "./lib/generator.js";
+import chokidar from "chokidar";
+
+import { extractStyles, getStylesByClassName, invalidateInventory, resolveApplys } from "./lib/inventory.js";
+import { invalidateUsageCache, findUsages, getUsages } from "./lib/usages.js";
+import { astToRules, rulesToCSS } from './lib/forge-lang/Compiler.js';
+import { toAST } from './lib/forge-lang/Parser.js';
+import { getAllFiles } from './lib/helpers.js';
 
 const DEFAULT_OPTIONS = {
   inventoryFiles: ["css", "less", "scss"],
   usageFiles: ["html", "jsx", "tsx"],
   usageAttributes: ["class", "className"],
-  breakpoints: {}
+  breakpoints: {},
+  verbose: true,
+  minify: true
 };
 
 export default function ForgeCSS(options) {
   const config = { ...DEFAULT_OPTIONS };
 
   config.breakpoints = Object.assign({}, DEFAULT_OPTIONS.breakpoints, options?.breakpoints ?? {});
+  config.inventoryFiles = options?.inventoryFiles ?? DEFAULT_OPTIONS.inventoryFiles;
+  config.usageFiles = options?.usageFiles ?? DEFAULT_OPTIONS.usageFiles;
+  config.usageAttributes = options?.usageAttributes ?? DEFAULT_OPTIONS.usageAttributes;
+  config.verbose = options?.verbose ?? DEFAULT_OPTIONS.verbose;
+  config.minify = options?.minify ?? DEFAULT_OPTIONS.minify;
 
   async function result(output) {
     try {
-      const css = await generateOutputCSS(config);
+      const cache = {};
+      const usages = getUsages();
+      const ast = toAST(
+        Object.values(usages).reduce((acc, i) => {
+          return acc.concat(i);
+        }, [])
+      );
+      let rules = astToRules(ast, {
+        getStylesByClassName,
+        cache,
+        config
+      });
+      rules.push(resolveApplys());
+      const css = rulesToCSS(rules.filter(Boolean), config);
       if (output) {
-        await writeFile(output, `/* ForgeCSS autogenerated file */\n${css}`, "utf-8");
+        await writeFile(output, `/* ForgeCSS auto-generated file */\n${css}`, "utf-8");
+      }
+      if (config.verbose) {
+        console.log("forgecss: Output CSS generated successfully.");
       }
       return css;
     } catch (err) {
@@ -28,9 +55,27 @@ export default function ForgeCSS(options) {
     }
     return null;
   }
+  function runWatcher(what, output, callback) {
+    const watcher = chokidar.watch(what, {
+      persistent: true,
+      ignoreInitial: true,
+      ignored: (p, stats) => output && path.resolve(p) === path.resolve(output)
+    });
+    watcher.on("change", async (filePath) => {
+      if (config.verbose) {
+        invalidateUsageCache(filePath)
+        invalidateInventory(filePath);
+        console.log(`forgecss: Detected change in ${filePath}`);
+      }
+      callback();
+    });
+    if (config.verbose) {
+      console.log("forgecss: Watch mode enabled. Listening for file changes...");
+    }
+  }
 
   return {
-    async parseDirectory({ dir, output = null }) {
+    async parseDirectory({ dir, output = null, watch = false }) {
       if (!dir) {
         throw new Error('forgecss: parseDirectory requires "dir" as an argument.');
       }
@@ -52,10 +97,13 @@ export default function ForgeCSS(options) {
       } catch (err) {
         console.error(`forgecss: error extracting usages`, err);
       }
+      watch && runWatcher(dir, output, () => {
+        this.parseDirectory({ dir, output, watch: false });
+      });
       // generating the output CSS
       return result(output);
     },
-    async parseFile({ file, output = null }) {
+    async parseFile({ file, output = null, watch = false }) {
       if (!file) {
         throw new Error('forgecss: parseFile requires "file" as an argument.');
       }
@@ -77,6 +125,9 @@ export default function ForgeCSS(options) {
       } catch (err) {
         console.error(`forgecss: error extracting usages.`, err);
       }
+       watch && runWatcher(file, output, () => {
+        this.parseFile({ file, output, watch: false });
+       });
       // generating the output CSS
       return result(output);
     },
@@ -87,7 +138,7 @@ export default function ForgeCSS(options) {
       if (!html && !jsx) {
         throw new Error('forgecss: parse requires "html" or "jsx".');
       }
-      invalidateInvetory();
+      invalidateInventory();
       invalidateUsageCache();
       // filling the inventory
       try {

package/lib/forge-lang/Compiler.js

@@ -0,0 +1,122 @@
+import postcss from "postcss";
+import { NODE_TYPE, ALLOWED_PSEUDO_CLASSES } from "./constants.js";
+import { minifyCSS } from './utils.js'
+import { normalizeLabel } from "../../client/fx.js";
+
+export function astToRules(ast, options) {
+  let rules = [];
+  const { getStylesByClassName, cache = {}, config } = options
+  // console.log(
+  //   "\n====================================================================== ^\n",
+  //   JSON.stringify(ast, null, 2),
+  //   "\n====================================================================== $\n"
+  // );
+
+  for(let node of ast) {
+    switch (node.type) {
+      case NODE_TYPE.TOKEN:
+        // ignoring ... just tokens
+        break;
+      case NODE_TYPE.VARIANT:
+        let variantSelector = node.selector;
+        let classes = (node?.payload?.value ?? "").split(",").map((c) => c.trim()).filter(Boolean);
+        let childRules;
+        if (!node.payload.value && typeof node.payload === 'object') {
+          childRules = astToRules([node.payload], options);
+        }
+
+        // -------------------------------------------------------- pseudo
+        if (ALLOWED_PSEUDO_CLASSES.includes(variantSelector)) {
+          classes.forEach(cls => {
+            let selector = `.${variantSelector}_${cls}`;
+            const rule = createRule(`${selector}:${variantSelector}`, cls, cache);
+            if (rule) {
+              rules.push(rule);
+            }
+          });
+        // -------------------------------------------------------- media queries
+        } else if (config.breakpoints[variantSelector]) {
+          let mediaRule;
+          if (cache[config.breakpoints[variantSelector]]) {
+            mediaRule = cache[config.breakpoints[variantSelector]];
+          } else {
+            mediaRule = cache[config.breakpoints[variantSelector]] = postcss.atRule({
+              name: "media",
+              params: config.breakpoints[variantSelector]
+            });
+            rules.push(mediaRule);
+          }
+          if (childRules) {
+            childRules.forEach(r => {
+              mediaRule.append(r);
+            })
+          } else {
+            classes.forEach((cls) => {
+              let selector = `.${variantSelector}_${cls}`;
+              const rule = createRule(selector, cls, cache);
+              if (rule) {
+                mediaRule.append(rule);
+              }
+            });
+          }
+        } else if (node.payload?.type === NODE_TYPE.TOKEN && node.simple === true) {
+          console.warn(`forgecss: there is no breakpoint defined for label "${variantSelector}".`);
+        // -------------------------------------------------------- arbitrary
+        } else {
+          classes.forEach(cls => {
+            if (Array.isArray(variantSelector)) {
+              variantSelector = variantSelector
+                .map(({ type, value, selector, payload }) => {
+                  if (type === "token") {
+                    return value;
+                  }
+                })
+                .filter(Boolean)
+                .join(" ");
+            }
+            if (["", "true"].includes(variantSelector)) {
+              return;
+            }
+            const I = normalizeLabel(variantSelector) + "_" + cls;
+            const selector = evaluateArbitrary(variantSelector, I);
+            const rule = createRule(selector, cls, cache);
+            if (rule) {
+              rules.push(rule);
+            }
+          })
+        }
+        break;
+    }
+  }
+
+  function createRule(selector, pickStylesFrom, cache = {}) {
+    if (cache[selector]) {
+      return;
+    }
+    const newRule = cache[selector] = postcss.rule({ selector });
+    const decls = getStylesByClassName(pickStylesFrom);
+    if (decls.length === 0) {
+      return;
+    }
+    decls.forEach((d) => {
+      newRule.append(
+        postcss.decl({
+          prop: d.prop,
+          value: d.value,
+          important: d.important
+        })
+      );
+    });
+    return newRule;
+  }
+  function evaluateArbitrary(variant, I) {
+    variant = variant.replace(/[&]/g, `.${I}`);
+    return variant;
+  }
+  
+  return rules;
+}
+
+export function rulesToCSS(rules, { minify } = { minify: true }) {
+  return minify ? minifyCSS(rules.map((r) => r.toString()).join("")) : rules.map((r) => r.toString()).join("\n");
+}

package/lib/forge-lang/Parser.js

@@ -0,0 +1,208 @@
+export function toAST(input, cache = {}) {
+  if (cache[input]) return cache[input];
+
+  if (Array.isArray(input)) {
+    const optimized = [];
+    input.forEach((str) => {
+      str
+        .trim()
+        .split(" ")
+        .forEach((part) => {
+          if (!optimized.includes(part)) optimized.push(part);
+        });
+    });
+    input = optimized.join(" ");
+  }
+
+  const s = String(input ?? "").trim();
+  let i = 0;
+
+  const isWS = (ch) => ch === " " || ch === "\n" || ch === "\t" || ch === "\r";
+
+  function skipWS() {
+    while (i < s.length && isWS(s[i])) i++;
+  }
+
+  function parseSequence(stopChar) {
+    const nodes = [];
+    while (i < s.length) {
+      skipWS();
+      if (stopChar && s[i] === stopChar) break;
+      if (i >= s.length) break;
+      nodes.push(parseItem());
+    }
+    return nodes;
+  }
+
+  function readIdentUntilDelimiter() {
+    let out = "";
+    while (i < s.length) {
+      const ch = s[i];
+      // stop at whitespace, "(", ")", ":" (variant separator)
+      if (isWS(ch) || ch === "(" || ch === ")" || ch === ":") break;
+      // IMPORTANT: DO NOT consume "[" here; it may be:
+      //  - leading bracket variant (handled in parseItem when ch === "[")
+      //  - attribute selector suffix (handled in parseItem after reading head)
+      if (ch === "[") break;
+
+      out += ch;
+      i++;
+    }
+    return out.trim();
+  }
+
+  function isVariantLabel(str) {
+    return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(str);
+  }
+
+  function isCallName(str) {
+    return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(str);
+  }
+
+  function parseItem() {
+    skipWS();
+    const ch = s[i];
+
+    // Bracket variant: [selector]:payload
+    if (ch === "[") {
+      const selectorRaw = parseBracketContent(); // returns content WITHOUT outer []
+      const selectorAst = toAST(selectorRaw, cache);
+
+      if (s[i] === ":") {
+        i++;
+        const payload = parseItem();
+        return { type: "variant", selector: selectorAst, payload };
+      }
+
+      // If it's just a standalone bracket chunk (not a variant),
+      // keep it as a token string. (You can change this if you prefer AST here.)
+      return { type: "token", value: `[${selectorRaw}]` };
+    }
+
+    // Read label/name/token
+    let head = readIdentUntilDelimiter();
+
+    // NEW: absorb attribute selector suffixes: foo[...][...]
+    // This handles &\[type=...\] and similar.
+    while (s[i] === "[") {
+      const inner = parseBracketContent(); // consumes the bracket block
+      head += `[${inner}]`;
+    }
+
+    // Label variant: hover:..., desktop:..., focus:...
+    if (s[i] === ":" && isVariantLabel(head)) {
+      i++; // consume ":"
+      const payload = parseItem();
+      return { type: "variant", selector: head, payload, simple: true };
+    }
+
+    // Call: name(...)
+    if (s[i] === "(" && isCallName(head)) {
+      i++; // consume "("
+      const args = [];
+      while (i < s.length) {
+        skipWS();
+        if (s[i] === ")") {
+          i++;
+          break;
+        }
+        args.push(parseItem());
+        skipWS();
+        if (s[i] === ",") i++;
+      }
+      return { type: "call", name: head, args };
+    }
+
+    if (s[i] === ":") {
+      head += ":";
+      i++; // consume ":"
+
+      // absorb following identifier / call / selector chunk
+      while (i < s.length) {
+        const ch = s[i];
+        if (isWS(ch) || ch === ")" || ch === ",") break;
+
+        if (ch === "[") {
+          const inner = parseBracketContent();
+          head += `[${inner}]`;
+          continue;
+        }
+
+        if (ch === "(") {
+          head += "(";
+          i++;
+          let depth = 1;
+          while (i < s.length && depth > 0) {
+            if (s[i] === "(") depth++;
+            if (s[i] === ")") depth--;
+            head += s[i++];
+          }
+          continue;
+        }
+
+        head += ch;
+        i++;
+      }
+    }
+
+    return { type: "token", value: head };
+  }
+
+  function parseBracketContent() {
+    // assumes s[i] === "["
+    i++; // consume "["
+    let out = "";
+    let bracket = 1;
+    let quote = null;
+
+    while (i < s.length) {
+      const ch = s[i];
+
+      if (quote) {
+        out += ch;
+        if (ch === "\\" && i + 1 < s.length) {
+          i++;
+          out += s[i];
+        } else if (ch === quote) {
+          quote = null;
+        }
+        i++;
+        continue;
+      }
+
+      if (ch === "'" || ch === '"') {
+        quote = ch;
+        out += ch;
+        i++;
+        continue;
+      }
+
+      if (ch === "[") {
+        bracket++;
+        out += ch;
+        i++;
+        continue;
+      }
+
+      if (ch === "]") {
+        bracket--;
+        if (bracket === 0) {
+          i++; // consume final "]"
+          break;
+        }
+        out += ch;
+        i++;
+        continue;
+      }
+
+      out += ch;
+      i++;
+    }
+
+    return out;
+  }
+
+  const ast = parseSequence(null);
+  cache[input] = ast;
+  return ast;
+}

package/lib/forge-lang/constants.js

@@ -0,0 +1,27 @@
+export const NODE_TYPE = {
+  VARIANT: "variant",
+  CALL: "call",
+  TOKEN: "token"
+};
+export const ALLOWED_PSEUDO_CLASSES = [
+  "hover",
+  "active",
+  "focus",
+  "focus-visible",
+  "focus-within",
+  "disabled",
+  "enabled",
+  "read-only",
+  "read-write",
+  "checked",
+  "indeterminate",
+  "valid",
+  "invalid",
+  "required",
+  "optional",
+  "in-range",
+  "out-of-range",
+  "placeholder-shown",
+  "autofill",
+  "user-invalid"
+];

package/lib/forge-lang/utils.js

@@ -0,0 +1,18 @@
+export function minifyCSS(css) {
+  return (
+    css
+      // remove comments
+      .replace(/\/\*[\s\S]*?\*\//g, "")
+      // remove whitespace around symbols
+      .replace(/\s*([{}:;,])\s*/g, "$1")
+      // remove trailing semicolons
+      .replace(/;}/g, "}")
+      // collapse multiple spaces
+      .replace(/\s+/g, " ")
+      // remove spaces before/after braces
+      .replace(/\s*{\s*/g, "{")
+      .replace(/\s*}\s*/g, "}")
+      // trim
+      .trim()
+  );
+}

package/lib/helpers.js

@@ -1,19 +1,30 @@
-import postcss from "postcss";
-import { getStylesByClassName } from "./inventory.js";
+import fs from "fs/promises";
+import path from "path";
 
-export function setDeclarations(selector, rule) {
-  const decls = getStylesByClassName(selector);
-  if (decls.length === 0) {
-    console.warn(`forgecss: no class ".${selector}" found`);
-    return;
+export async function getAllFiles(dir, matchFiles) {
+  const result = [];
+  const stack = [dir];
+
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+
+    let dirHandle;
+    try {
+      dirHandle = await fs.opendir(currentDir);
+    } catch (err) {
+      throw err;
+    }
+
+    for await (const entry of dirHandle) {
+      const fullPath = path.join(currentDir, entry.name);
+
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (matchFiles.includes(fullPath.split(".").pop()?.toLowerCase())) {
+        result.push(fullPath);
+      }
+    }
   }
-  decls.forEach((d) => {
-    rule.append(
-      postcss.decl({
-        prop: d.prop,
-        value: d.value,
-        important: d.important
-      })
-    );
-  });
+
+  return result;
 }

package/lib/inventory.js

@@ -20,14 +20,21 @@ export function getStylesByClassName(selector) {
     });
   });
   if (decls.length === 0) {
-    console.warn(`forgecss: Warning - no styles found for class "${selector}".`);
+    console.warn(`forgecss: no styles found for class "${selector}".`);
   }
   return decls;
 }
-export function invalidateInvetory() {
-  INVENTORY = {};
+export function invalidateInventory(filePath) {
+  if (!filePath) {
+    INVENTORY = {};
+    return;
+  }
+  if (INVENTORY[filePath]) {
+    delete INVENTORY[filePath];
+  }
 }
-export function resolveApplys(bucket) {
+export function resolveApplys() {
+  let resolvedApplies;
   Object.keys(INVENTORY).forEach((filePath) => {
     INVENTORY[filePath].walkRules((rule) => {
       rule.walkDecls((d) => {
@@ -44,12 +51,13 @@ export function resolveApplys(bucket) {
               });
             });
           });
-          if (!bucket['_APPLY_']) {
-            bucket["_APPLY_"] = postcss.root();
+          if (!resolvedApplies) {
+            resolvedApplies = postcss.root();
           }
-          bucket["_APPLY_"].append(newRule);
+          resolvedApplies.append(newRule);
         }
       });
     });
   });
+  return resolvedApplies;
 }

package/lib/usages.js

@@ -15,7 +15,7 @@ export async function findUsages(filePath, fileContent = null) {
       // already processed
       return;
     }
-    USAGES[filePath] = {};
+    USAGES[filePath] = [];
     const content = fileContent ? fileContent : await readFile(filePath, "utf-8");
     const extension = filePath.split('.').pop().toLowerCase();
 
@@ -24,7 +24,7 @@ export async function findUsages(filePath, fileContent = null) {
       const ast = fromHtml(content);
       visit(ast, "element", (node) => {
         if (node.properties.className) {
-          storeUsage(filePath, node.properties.className.join(' '));
+          USAGES[filePath].push(node.properties.className.join(" "));
         }
       });
       return;
@@ -47,7 +47,7 @@ export async function findUsages(filePath, fileContent = null) {
               let quasis = arg.expression.quasis.map((elem) => elem?.cooked || "");
               value = quasis.join("");
             }
-            storeUsage(filePath, value);
+            USAGES[filePath].push(value);
           }
         }
       }
@@ -68,27 +68,6 @@ export function invalidateUsageCache(filePath) {
 export function getUsages() {
   return USAGES;
 }
-function storeUsage(filePath, classesString = "") {
-  if (!classesString) return;
-
-  parseClass(classesString).forEach((part) => {
-    if (part.includes(":")) {
-      const lastColonIndex = part.lastIndexOf(":");
-      const label = part.slice(0, lastColonIndex); // "desktop" or "[&:hover]"
-      const clsPart = part.slice(lastColonIndex + 1); // e.g. "mt1"
-      const classes = clsPart.split(",");
-
-      if (label === "[]") return;
-
-      if (!USAGES[filePath][label]) {
-        USAGES[filePath][label] = [];
-      }
-      classes.forEach((cls) => {
-        USAGES[filePath][label].push(cls);
-      });
-    }
-  });
-}
 function traverseASTNode(node, visitors, stack = []) {
   if (!node || typeof node.type !== "string") {
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgecss",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "ForgeCSS turns strings into fully generated responsive CSS using a custom DSL.",
   "author": "Krasimir Tsonev",

package/lib/generator.js

@@ -1,42 +0,0 @@
-import { getUsages } from "./usages.js";
-import arbitraryTransformer from "./transformers/arbitrary.js";
-import mediaQueryTransformer from "./transformers/mediaQuery.js";
-import pseudoClassTransformer from "./transformers/pseudo.js";
-import { resolveApplys } from "./inventory.js";
-
-export async function generateOutputCSS(config) {
-  const bucket = {};
-  const usages = getUsages();
-  Object.keys(usages).map((file) => {
-    Object.keys(usages[file]).forEach(async (label) => {
-      try {
-        if (mediaQueryTransformer(config, label, usages[file][label], bucket)) {
-          return;
-        } else if (pseudoClassTransformer(label, usages[file][label], bucket)) {
-          return;
-        } else if (arbitraryTransformer(label, usages[file][label], bucket)) {
-          return;
-        }
-      } catch (err) {
-        console.error(
-          `forgecss: Error generating media query for label "${label}" (found in file ${file.replace(
-            process.cwd(),
-            ""
-          )})`,
-          err
-        );
-      }
-    });
-  });
-  resolveApplys(bucket);
-  return Object.keys(bucket)
-    .map((key) => {
-      if (bucket[key].rules) {
-        return bucket[key].rules.toString();
-      }
-      return bucket[key].toString();
-    })
-    .filter(Boolean)
-    .join("\n");
-}
-

package/lib/getAllFiles.js

@@ -1,30 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-
-export default async function getAllFiles(dir, matchFiles) {
-  const result = [];
-  const stack = [dir];
-
-  while (stack.length > 0) {
-    const currentDir = stack.pop();
-
-    let dirHandle;
-    try {
-      dirHandle = await fs.opendir(currentDir);
-    } catch (err) {
-      throw err;
-    }
-
-    for await (const entry of dirHandle) {
-      const fullPath = path.join(currentDir, entry.name);
-
-      if (entry.isDirectory()) {
-        stack.push(fullPath);
-      } else if (matchFiles.includes(fullPath.split(".").pop()?.toLowerCase())) {
-        result.push(fullPath);
-      }
-    }
-  }
-
-  return result;
-}

package/lib/inventory.d.ts

@@ -1,4 +0,0 @@
-export function extractStyles(filePath: string, css?: string | null): Promise<void>;
-export function getStylesByClassName(selector: string): object[];
-export function invalidateInvetory(): void;
-export function resolveApplys(bucket: object): void

package/lib/transformers/arbitrary.js

@@ -1,32 +0,0 @@
-import postcss from "postcss";
-
-import { normalizeLabel } from "../../client/fx.js";
-import { setDeclarations } from "../helpers.js";
-
-export default function arbitraryTransformer(label, classes, bucket) {
-  if (label.startsWith("[") && label.endsWith("]")) {
-    let arbitrarySelector = label.slice(1, -1).trim();
-    if (['', 'true'].includes(arbitrarySelector)) {
-      return true;
-    }
-    classes.forEach((cls) => {
-      const I = normalizeLabel(label) + "--" + cls;
-      const selector = evaluateArbitrary(arbitrarySelector, I);
-      const root = postcss.root();
-      if (bucket[I]) {
-        return;
-      }
-      const rule = postcss.rule({ selector });
-      setDeclarations(cls, rule);
-      root.append(rule);
-      bucket[I] = root;
-    });
-    return true;
-  }
-  return false;
-}
-
-function evaluateArbitrary(label, I) {
-  label = label.replace(/[&]/g, `.${I}`);
-  return label;
-}

package/lib/transformers/mediaQuery.js

@@ -1,31 +0,0 @@
-import postcss from "postcss";
-
-import { setDeclarations } from "../helpers.js";
-import {normalizeLabel} from "../../client/fx.js";
-
-export default function mediaQueryTransformer(config, label, classes, bucket) {
-  if (!config?.breakpoints[label]) {
-    return false;
-  }
-  if (!bucket[label]) {
-    bucket[label] = {
-      rules: postcss.atRule({
-        name: "media",
-        params: `all and (${config.breakpoints[label]})`
-      }),
-      classes: {}
-    };
-  }
-  const rules = bucket[label].rules;
-  classes.forEach((cls) => {
-    const selector = `.${normalizeLabel(label)}--${cls}`;
-    if (bucket[label].classes[selector]) {
-      return;
-    }
-    bucket[label].classes[selector] = true; // caching
-    const rule = postcss.rule({ selector });
-    setDeclarations(cls, rule);
-    rules.append(rule);
-  });
-  return true;
-}

package/lib/transformers/pseudo.js

@@ -1,46 +0,0 @@
-import postcss from "postcss";
-
-import {setDeclarations} from "../helpers.js";
-import {normalizeLabel} from "../../client/fx.js";
-
-const ALLOWED_PSEUDO_CLASSES = [
-  "hover",
-  "active",
-  "focus",
-  "focus-visible",
-  "focus-within",
-  "disabled",
-  "enabled",
-  "read-only",
-  "read-write",
-  "checked",
-  "indeterminate",
-  "valid",
-  "invalid",
-  "required",
-  "optional",
-  "in-range",
-  "out-of-range",
-  "placeholder-shown",
-  "autofill",
-  "user-invalid"
-];
-
-export default function pseudoClassTransformer(label, classes, bucket) {
-  if (ALLOWED_PSEUDO_CLASSES.includes(label)) {
-    classes.forEach((cls) => {
-      const selector = `.${normalizeLabel(label)}--${cls}:${label}`;
-      const root = postcss.root();
-      if (bucket[selector]) {
-        // already have that
-        return;
-      }
-      const rule = postcss.rule({ selector });
-      setDeclarations(cls, rule);
-      root.append(rule);
-      bucket[selector] = root;
-    });
-    return true;
-  }
-  return false;
-}

package/lib/usages.d.ts

@@ -1,3 +0,0 @@
-export declare function findUsages(filePath: string, content?: string | null): Promise<void>;
-export declare function invalidateUsageCache(filePath?: string): void;
-export declare function getUsages(): object;