jetfast 0.0.1

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "jetfast",
+  "dependencies": {
+    "chokidar": "^5.0.0"
+  },
+  "version": "0.0.1",
+  "description": "Ultra-fast CSS engine with purge and arbitrary values",
+  "bin": {
+    "jetfast": "tools/cli.js"
+  },
+  "files": ["tools", "dist"],
+  "license": "MIT"
+}

package/tools/cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const command = process.argv[2];
+
+if (command === "init") {
+  require(path.join(__dirname, "init.js"));
+} else if (command === "dev") {
+  require(path.join(__dirname, "watcher.js"));
+} else if (command === "build") {
+  require(path.join(__dirname, "generate-output.js"));
+} else {
+  console.log("Usage: jetfast <init|dev|build>");
+}

package/tools/config.js

@@ -0,0 +1,39 @@
+const fs = require("fs");
+const path = require("path");
+
+const defaultConfig = {
+  input: ["**/*.html"],
+  output: "JetFast/output/output.css",
+
+  classPrefix: "",
+  separator: "-",
+
+  theme: {
+    colors: {},
+    spacing: {},
+    fontSize: {},
+  },
+
+  debug: false,
+};
+
+function loadUserConfig() {
+  const configPath = path.resolve(process.cwd(), "jetfast.config.js");
+
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    return require(configPath);
+  } catch (err) {
+    console.error("\n❌ JetFast config error");
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  defaultConfig,
+  loadUserConfig,
+};

package/tools/generate-arbitrary.js

@@ -0,0 +1,120 @@
+const fs = require("fs");
+const path = require("path");
+
+// const { defaultConfig, loadUserConfig } = require("./config");
+// const deepMerge = require("../core/merge.js");
+
+// const userConfig = loadUserConfig();
+// const config = deepMerge(structuredClone(defaultConfig), userConfig);
+
+// if (config.debug) {
+//   console.log("🧠 JetFast Config Loaded:");
+//   console.log(JSON.stringify(config, null, 2));
+// }
+
+const HTML_ROOT = path.join(__dirname, "../../");
+const OUTPUT_FILE = path.join(__dirname, "../outputDev/arbitrary-jet.css");
+
+const IGNORED_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+]);
+
+function readIfExists(file) {
+  try {
+    return fs.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+let output = [];
+const globalSeen = new Set();
+
+const regexs = {
+  classRegex: /(class|className)="([^"]+)"/gi,
+};
+
+function getAllSourceFiles(dir, results = []) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (IGNORED_DIRS.has(entry.name)) continue;
+
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      getAllSourceFiles(fullPath, results);
+    } else if (/\.(html|jsx|tsx)$/.test(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+
+  return results; 
+}
+
+function escapeClassNames(cls) {
+  return cls.replace(/([!#$%&'()*+,./:;<=>?@[\\\]^`{|}~])/g, "\\$1");
+}
+
+output.length = 0;
+globalSeen.clear();
+
+const sourceFiles = getAllSourceFiles(HTML_ROOT);
+
+for (const file of sourceFiles) {
+  const content = fs.readFileSync(file, "utf-8");
+
+  if (!content.includes("AJ-")) continue;
+
+  for (const match of content.matchAll(regexs.classRegex)) {
+    const classList = match[2];
+
+    for (const className of classList.split(/\s+/)) {
+      if (!className) continue;
+      if (globalSeen.has(className)) continue;
+      if (!className.startsWith("AJ-")) continue;
+      if (!className.includes(":")) continue;
+
+      globalSeen.add(className);
+
+      const step1 = className.indexOf(":");
+      if (step1 === -1) continue;
+
+      const step2 = className.slice(0, step1);
+      const step3 = className.slice(step1 + 1);
+
+      const property = step2.split("-").slice(1).join("-");
+      let value = step3;
+
+      if (
+        property === "background-image" &&
+        !value.startsWith("url(") &&
+        !value.endsWith(")")
+      ) {
+        value = `url("${value}")`;
+      }
+
+      output.push(
+        `.${escapeClassNames(className)}{\n\t${property}:${value};\n}`,
+      );
+    }
+  }
+}
+
+const css = output.join("\n\n") + "\n";
+const prev = readIfExists(OUTPUT_FILE);
+
+if (prev === css) {
+  console.log("⏭️  No CSS changes, skipped write");
+  process.exit(0);
+}
+
+const TEMP_FILE = OUTPUT_FILE + ".tmp";
+
+fs.writeFileSync(TEMP_FILE, css);
+fs.renameSync(TEMP_FILE, OUTPUT_FILE);
+
+console.log(`✅ Generated ${output.length} Classes`);

package/tools/generate-intellisense.js

@@ -0,0 +1,46 @@
+const fs = require("fs");
+const path = require("path");
+
+const JETS_DIR = path.join(__dirname, "../Jets");
+
+// output file
+const OUTPUT = path.join(__dirname, "../jetfast.css-data.json");
+
+const CLASS_REGEX = /\.([a-zA-Z0-9_-]+)\s*\{/g;
+
+const classes = [];
+const globalSeen = new Set();
+
+const files = fs.readdirSync(JETS_DIR).filter(f => f.endsWith(".css"));
+
+for (const file of files) {
+  const filePath = path.join(JETS_DIR, file);
+  const content = fs.readFileSync(filePath, "utf8");
+
+  let match;
+
+  while ((match = CLASS_REGEX.exec(content)) !== null) {
+    const className = match[1];
+
+    if (globalSeen.has(className)) continue;
+    globalSeen.add(className);
+
+    classes.push({
+      name: className,
+      description: `JetFast class from ${file}`
+    });
+  }
+}
+
+const json = {
+  version: 1.1,
+  atDirectives: [],
+  pseudoClasses: [],
+  pseudoElements: [],
+  properties: [],
+  classes
+};
+
+fs.writeFileSync(OUTPUT, JSON.stringify(json, null, 2));
+
+console.log(`✅ Generated ${classes.length} IntelliSense classes`);

package/tools/generate-output.js

@@ -0,0 +1,6 @@
+const fs = require("fs")
+
+const arbitrary=fs.readFileSync("./outputDev/arbitrary-jet.css","utf-8")
+const purge=fs.readFileSync("./outputDev/output.css","utf-8")
+
+const output=fs.writeFileSync("./output/output.css",([arbitrary,purge].join("\n")))

package/tools/generate-purge.js

@@ -0,0 +1,97 @@
+let fs = require("fs");
+let path = require("path");
+
+let allCssClassName = new Set();
+let jetsPath = path.join(__dirname, "../Jets");
+let allClasses = {};
+
+let HTML_ROOT = path.join(__dirname, "../../");
+let globalSeen = new Set();
+
+let regexs = {
+  htmlClassRegex: /class(Name)?="([^"]+)"/g,
+  cssClassNameRegex: /\.([a-zA-Z_][a-zA-Z0-9_:\-]*)\s*\{/g,
+  cssBlockRegex: /\.([a-zA-Z_][a-zA-Z0-9_:\-]*)\s*\{([\s\S]*?)\}/g,
+};
+
+function getAllCssFiles(dir) {
+  let results = [];
+  let entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (let entry of entries) {
+    let fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      results = results.concat(getAllCssFiles(fullPath));
+    } else if (entry.name.endsWith(".css")) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}
+
+let allCssFiles = getAllCssFiles(jetsPath);
+
+let outputFilePath = path.join(__dirname, "../outputDev/output.css");
+
+fs.writeFileSync(outputFilePath, "");
+
+function getAllSourceFiles(dir) {
+  let results = [];
+  let entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (let entry of entries) {
+    let fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      results = results.concat(getAllSourceFiles(fullPath));
+    } else if (
+      entry.name.endsWith(".html") ||
+      entry.name.endsWith(".jsx") ||
+      entry.name.endsWith(".tsx")
+    ) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}
+
+let sourceFiles = getAllSourceFiles(HTML_ROOT);
+
+for (let file of sourceFiles) {
+  let content = fs.readFileSync(file, "utf-8");
+
+  for (let match of content.matchAll(regexs.htmlClassRegex)) {
+    let classList = match[2];
+
+    for (let className of classList.split(/\s+/)) {
+      if (!className) continue;
+      globalSeen.add(className);
+    }
+  }
+}
+
+for (let file of allCssFiles) {
+  let content = fs.readFileSync(file, "utf-8");
+
+  for (let match of content.matchAll(regexs.cssBlockRegex)) {
+    let className = match[1];
+    let body = match[2];
+
+    if (!globalSeen.has(className)) continue;
+    if (allClasses[className]) continue;
+
+    allClasses[className] = {};
+
+    for (let decl of body.split(";")) {
+      let [prop, value] = decl.split(":");
+      if (!prop || !value) continue;
+      allClasses[className][prop.trim()] = value.trim();
+    }
+
+    allCssClassName.add(className);
+    fs.appendFileSync(outputFilePath, `.${className}{${body}}\n`);
+  }
+}

package/tools/init.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+const pkgPath = path.join(projectRoot, "package.json");
+
+if (!fs.existsSync(pkgPath)) {
+  console.log("❌ No package.json found in this directory.");
+  process.exit(1);
+}
+
+const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+
+pkg.scripts = pkg.scripts || {};
+
+let addedSomething = false;
+
+if (!pkg.scripts.dev) {
+  pkg.scripts.dev = "JetFast dev";
+  console.log("✅ Added 'dev' script");
+  addedSomething = true;
+} else {
+  console.log("⚠️ 'dev' script already exists — not modifying");
+}
+
+if (!pkg.scripts.build) {
+  pkg.scripts.build = "JetFast build";
+  console.log("✅ Added 'build' script");
+  addedSomething = true;
+} else {
+  console.log("⚠️ 'build' script already exists — not modifying");
+}
+
+if (addedSomething) {
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+  console.log("🎉 package.json updated successfully");
+} else {
+  console.log("👍 Nothing to change — JetFast already configured");
+}

package/tools/watcher.js

@@ -0,0 +1,54 @@
+const chokidar = require("chokidar");
+const { exec } = require("child_process");
+const path = require("path");
+
+const ROOT = path.resolve(__dirname, "../../");
+
+console.log("🧐 Watching HTML files in:", ROOT);
+
+let timer = null;
+
+function isIgnored(file) {
+  const normalized = file.replace(/\\/g, "/");
+
+  return (
+    normalized.includes("/node_modules/") ||
+    normalized.includes("/.git/") ||
+    normalized.includes("/JetFast/outputDev/") ||
+    normalized.includes("/JetFast/output/") ||
+    normalized.includes("/JetFast/Jets/") ||
+    normalized.endsWith(".tmp")
+  );
+}
+
+const watcher = chokidar.watch(ROOT, {
+  ignored: isIgnored,
+  ignoreInitial: true,
+  awaitWriteFinish: {
+    stabilityThreshold: 300,
+    pollInterval: 100,
+  },
+});
+
+function runGenerator(reason, file) {
+  console.log(`🔁 ${reason}: ${file}`);
+
+  clearTimeout(timer);
+  timer = setTimeout(() => {
+    exec(
+      `node "${path.join(__dirname, "generate-arbitrary.js")}"`,
+      (err, stdout, stderr) => {
+        if (err) {
+          console.error("❌ arbitrary error", err);
+          return;
+        }
+      },
+    );
+  }, 300);
+}
+
+watcher.on("add", (file) => runGenerator("add", file));
+watcher.on("change", (file) => runGenerator("change", file));
+watcher.on("unlink", (file) => runGenerator("unlink", file));
+
+console.log("✅ Watcher ready");