@hyperfixi/vite-plugin 2.0.0 → 2.1.0

package/dist/index.cjs

@@ -30,11 +30,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DomainAggregator: () => DomainAggregator,
+  DomainScanner: () => DomainScanner,
   REGIONS: () => REGIONS,
   SUPPORTED_LANGUAGES: () => SUPPORTED_LANGUAGES,
   clearCustomKeywords: () => clearCustomKeywords,
   clearSemanticParser: () => clearSemanticParser,
   default: () => index_default,
+  descriptorToScanRule: () => descriptorToScanRule,
   detectLanguages: () => detectLanguages,
   getAllLanguageCodes: () => getAllLanguageCodes,
   getKeywordsForLanguage: () => getKeywordsForLanguage,
@@ -522,6 +525,8 @@ var POLISH_KEYWORDS = /* @__PURE__ */ new Set([
   "zwi\u0119ksz",
   "zwieksz",
   "zmniejsz",
+  "uzyskaj",
+  "pobierz",
   "wywo\u0142aj",
   "wywolaj",
   "wyzw\xF3l",
@@ -1861,6 +1866,15 @@ async function evaluate(node, ctx) {
       const obj = await evaluate(node.object, ctx);
       if (obj == null) return undefined;
       const prop = node.computed ? await evaluate(node.property, ctx) : node.property;
+      if (prop === 'values' && obj instanceof Element) {
+        if (obj instanceof HTMLFormElement) return new FormData(obj);
+        const fd = new FormData();
+        obj.querySelectorAll('input, select, textarea').forEach(input => {
+          const name = input.getAttribute('name');
+          if (name && 'value' in input) fd.append(name, input.value);
+        });
+        return fd;
+      }
       return obj[prop];
 
     case 'call': {
@@ -2945,6 +2959,9 @@ function compileExpression(node) {
       if (prop.startsWith("*")) {
         return `${obj}.style.${prop.slice(1)}`;
       }
+      if (prop === "values") {
+        return `(function(el){if(el instanceof HTMLFormElement)return new FormData(el);var fd=new FormData();el.querySelectorAll('input,select,textarea').forEach(function(i){var n=i.getAttribute('name');if(n&&'value'in i)fd.append(n,i.value)});return fd})(${obj})`;
+      }
       return `${obj}.${prop}`;
     }
     case "member": {
@@ -3268,6 +3285,290 @@ function extractScripts(html) {
   return scripts;
 }
 
+// src/server-bridge-integration.ts
+var import_node_path = require("path");
+var import_promises = require("fs/promises");
+var serverBridge = null;
+var loadAttempted = false;
+var lastRouteHash = "";
+async function loadServerBridge(debug) {
+  if (loadAttempted) return serverBridge;
+  loadAttempted = true;
+  try {
+    const mod = await import("@hyperfixi/server-bridge");
+    serverBridge = mod;
+    if (debug) {
+      console.log("[hyperfixi] Server-bridge loaded successfully");
+    }
+    return serverBridge;
+  } catch {
+    console.warn(
+      "[hyperfixi] @hyperfixi/server-bridge is not installed. Install it to enable server route generation: npm install @hyperfixi/server-bridge"
+    );
+    return null;
+  }
+}
+function computeRouteHash(routes) {
+  return routes.map((r) => `${r.method}:${r.path}`).sort().join("|");
+}
+async function runServerBridge(cwd, options, debug, force) {
+  const mod = serverBridge ?? await loadServerBridge(debug);
+  if (!mod) return;
+  try {
+    const outputDir = (0, import_node_path.resolve)(cwd, options.output ?? "./server/routes");
+    const result = await mod.generate({
+      dir: cwd,
+      framework: options.framework ?? "express",
+      output: options.output,
+      typescript: options.typescript,
+      ignore: options.ignore
+    });
+    const routeHash = computeRouteHash(result.routes);
+    if (!force && routeHash === lastRouteHash) {
+      if (debug) {
+        console.log("[hyperfixi] Server-bridge: routes unchanged, skipping generation");
+      }
+      return;
+    }
+    lastRouteHash = routeHash;
+    if (result.routes.length === 0) {
+      if (debug) {
+        console.log("[hyperfixi] Server-bridge: no routes found");
+      }
+      return;
+    }
+    await (0, import_promises.mkdir)(outputDir, { recursive: true });
+    for (const file of result.generated.files) {
+      const filePath = (0, import_node_path.join)(outputDir, file.path);
+      const fileDir = (0, import_node_path.join)(filePath, "..");
+      await (0, import_promises.mkdir)(fileDir, { recursive: true });
+      await (0, import_promises.writeFile)(filePath, file.content, "utf-8");
+    }
+    const manifest = mod.createManifest(result.routes);
+    await mod.saveManifest(outputDir, manifest);
+    if (debug) {
+      console.log(
+        `[hyperfixi] Server-bridge: generated ${result.generated.files.length} file(s) for ${result.routes.length} route(s) in ${outputDir}/`
+      );
+    }
+    if (result.scan.conflicts.length > 0) {
+      console.warn(
+        `[hyperfixi] Server-bridge: ${result.scan.conflicts.length} route conflict(s) detected`
+      );
+    }
+  } catch (err) {
+    console.error(
+      "[hyperfixi] Server-bridge generation failed:",
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+
+// src/domain-scanner.ts
+function buildAttributePatterns(attributes) {
+  const patterns = [];
+  for (const attr of attributes) {
+    const escaped = attr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    patterns.push(new RegExp(`${escaped}\\s*=\\s*"([^"]+)"`, "g"));
+    patterns.push(new RegExp(`${escaped}\\s*=\\s*'([^']+)'`, "g"));
+    patterns.push(new RegExp(`${escaped}\\s*=\\s*\`([^\`]+)\``, "g"));
+  }
+  return patterns;
+}
+function buildScriptPatterns(scriptTypes) {
+  return scriptTypes.map((type) => {
+    const escaped = type.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`<script[^>]*type=["']?${escaped}["']?[^>]*>([\\s\\S]*?)<\\/script>`, "gi");
+  });
+}
+function detectKeywords(snippet, keywords) {
+  const detectedKeywords = /* @__PURE__ */ new Set();
+  const detectedLanguages = /* @__PURE__ */ new Set();
+  for (const [lang, kwList] of Object.entries(keywords)) {
+    for (const kw of kwList) {
+      const isLatin = /^[a-zA-Z]/.test(kw);
+      const found = isLatin ? new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i").test(snippet) : snippet.includes(kw);
+      if (found) {
+        detectedKeywords.add(kw);
+        detectedLanguages.add(lang);
+      }
+    }
+  }
+  return { detectedKeywords, detectedLanguages };
+}
+var DomainScanner = class {
+  constructor(rules) {
+    this.rules = rules;
+    const allAttrs = rules.flatMap((r) => [...r.attributes]);
+    const allScriptTypes = rules.flatMap((r) => r.scriptTypes ? [...r.scriptTypes] : []);
+    const parts = [];
+    for (const attr of allAttrs) {
+      parts.push(attr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    }
+    for (const type of allScriptTypes) {
+      parts.push(type.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    }
+    this.quickCheckPattern = parts.length > 0 ? new RegExp(parts.join("|"), "i") : null;
+  }
+  /**
+   * Fast pre-check: does this code contain any domain-related attributes?
+   */
+  hasAnyDomainUsage(code) {
+    if (!this.quickCheckPattern) return false;
+    return this.quickCheckPattern.test(code);
+  }
+  /**
+   * Scan a file for all registered domain syntaxes.
+   * Returns one DomainFileUsage per domain that had matches.
+   */
+  scan(code, _id) {
+    const results = [];
+    for (const rule of this.rules) {
+      const snippets = [];
+      const attrPatterns = buildAttributePatterns(rule.attributes);
+      for (const pattern of attrPatterns) {
+        pattern.lastIndex = 0;
+        let match;
+        while (match = pattern.exec(code)) {
+          const value = match[1].trim();
+          if (value) snippets.push(value);
+        }
+      }
+      if (rule.scriptTypes) {
+        const scriptPatterns = buildScriptPatterns(rule.scriptTypes);
+        for (const pattern of scriptPatterns) {
+          pattern.lastIndex = 0;
+          let match;
+          while (match = pattern.exec(code)) {
+            const value = match[1].trim();
+            if (value) snippets.push(value);
+          }
+        }
+      }
+      if (snippets.length === 0) continue;
+      const allDetectedKeywords = /* @__PURE__ */ new Set();
+      const allDetectedLanguages = /* @__PURE__ */ new Set();
+      if (rule.keywords) {
+        for (const snippet of snippets) {
+          const { detectedKeywords, detectedLanguages } = detectKeywords(snippet, rule.keywords);
+          for (const kw of detectedKeywords) allDetectedKeywords.add(kw);
+          for (const lang of detectedLanguages) allDetectedLanguages.add(lang);
+        }
+      }
+      results.push({
+        domain: rule.domain,
+        detectedKeywords: allDetectedKeywords,
+        detectedLanguages: allDetectedLanguages,
+        snippetCount: snippets.length
+      });
+    }
+    return results;
+  }
+};
+function descriptorToScanRule(descriptor) {
+  if (!descriptor.scanConfig) return null;
+  return {
+    domain: descriptor.name,
+    attributes: [...descriptor.scanConfig.attributes],
+    scriptTypes: descriptor.scanConfig.scriptTypes ? [...descriptor.scanConfig.scriptTypes] : void 0,
+    keywords: descriptor.scanConfig.keywords ? Object.fromEntries(
+      Object.entries(descriptor.scanConfig.keywords).map(([k, v]) => [k, [...v]])
+    ) : void 0
+  };
+}
+
+// src/domain-aggregator.ts
+var DomainAggregator = class {
+  constructor() {
+    this.fileUsage = /* @__PURE__ */ new Map();
+    this.cache = null;
+  }
+  /**
+   * Add or update domain usage for a file.
+   * Returns true if usage changed (invalidates cache).
+   */
+  add(filePath, usage) {
+    const existing = this.fileUsage.get(filePath);
+    const changed = !existing || !this.isEqual(existing, usage);
+    if (changed) {
+      this.fileUsage.set(filePath, usage);
+      this.cache = null;
+    }
+    return changed;
+  }
+  /**
+   * Remove a file's domain usage.
+   * Returns true if the file was tracked.
+   */
+  remove(filePath) {
+    const had = this.fileUsage.has(filePath);
+    if (had) {
+      this.fileUsage.delete(filePath);
+      this.cache = null;
+    }
+    return had;
+  }
+  /**
+   * Get aggregated usage across all files.
+   * Result is cached until add/remove changes it.
+   */
+  getUsage() {
+    if (this.cache) return this.cache;
+    const domainMap = /* @__PURE__ */ new Map();
+    for (const usages of this.fileUsage.values()) {
+      for (const usage of usages) {
+        let entry = domainMap.get(usage.domain);
+        if (!entry) {
+          entry = {
+            detectedKeywords: /* @__PURE__ */ new Set(),
+            detectedLanguages: /* @__PURE__ */ new Set(),
+            fileCount: 0,
+            totalSnippets: 0
+          };
+          domainMap.set(usage.domain, entry);
+        }
+        entry.fileCount++;
+        entry.totalSnippets += usage.snippetCount;
+        for (const kw of usage.detectedKeywords) entry.detectedKeywords.add(kw);
+        for (const lang of usage.detectedLanguages) entry.detectedLanguages.add(lang);
+      }
+    }
+    this.cache = Array.from(domainMap.entries()).map(([domain, data]) => ({
+      domain,
+      detectedKeywords: data.detectedKeywords,
+      detectedLanguages: data.detectedLanguages,
+      fileCount: data.fileCount,
+      totalSnippets: data.totalSnippets
+    }));
+    return this.cache;
+  }
+  /**
+   * Get aggregated usage for a specific domain.
+   */
+  getUsageForDomain(domain) {
+    return this.getUsage().find((u) => u.domain === domain) ?? null;
+  }
+  /**
+   * Clear all tracked data.
+   */
+  clear() {
+    this.fileUsage.clear();
+    this.cache = null;
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  isEqual(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i].domain !== b[i].domain) return false;
+      if (a[i].snippetCount !== b[i].snippetCount) return false;
+      if (a[i].detectedKeywords.size !== b[i].detectedKeywords.size) return false;
+    }
+    return true;
+  }
+};
+
 // src/index.ts
 var VIRTUAL_MODULE_ID = "virtual:hyperfixi";
 var RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
@@ -3277,6 +3578,8 @@ function hyperfixi(options = {}) {
   const scanner = new Scanner(options);
   const aggregator = new Aggregator();
   const generator = new Generator(options);
+  const domainScanner = options.domains && options.domains.length > 0 ? new DomainScanner(options.domains) : null;
+  const domainAggregator = domainScanner ? new DomainAggregator() : null;
   let server = null;
   let cachedBundle = null;
   let lastUsageHash = "";
@@ -3379,11 +3682,14 @@ function hyperfixi(options = {}) {
     /**
      * Configure plugin based on Vite mode
      */
-    configResolved(config) {
+    async configResolved(config) {
       isDev = config.command === "serve";
       if (options.debug) {
         console.log("[hyperfixi] Plugin initialized, mode:", isDev ? "development" : "production");
       }
+      if (options.serverBridge) {
+        await loadServerBridge(options.debug);
+      }
     },
     /**
      * Store server reference and pre-scan HTML files for HMR
@@ -3396,6 +3702,25 @@ function hyperfixi(options = {}) {
       }
       const scannedFiles = await scanner.scanProject(cwd);
       aggregator.loadFromScan(scannedFiles);
+      if (domainScanner && domainAggregator) {
+        for (const [filePath] of scannedFiles) {
+          try {
+            const fs = await import("fs");
+            const content = fs.readFileSync(filePath, "utf-8");
+            if (domainScanner.hasAnyDomainUsage(content)) {
+              const domainUsages = domainScanner.scan(content, filePath);
+              if (domainUsages.length > 0) {
+                domainAggregator.add(filePath, domainUsages);
+              }
+            }
+          } catch {
+          }
+        }
+        if (options.debug) {
+          const domainSummary = domainAggregator.getUsage();
+          console.log("[hyperfixi] Domain pre-scan:", domainSummary);
+        }
+      }
       if (options.debug) {
         const summary = aggregator.getSummary();
         console.log("[hyperfixi] Pre-scan complete:", summary);
@@ -3442,6 +3767,12 @@ function hyperfixi(options = {}) {
       }
       const usage = scanner.scan(code, id);
       const changed = aggregator.add(id, usage);
+      if (domainScanner && domainAggregator && domainScanner.hasAnyDomainUsage(code)) {
+        const domainUsages = domainScanner.scan(code, id);
+        if (domainUsages.length > 0) {
+          domainAggregator.add(id, domainUsages);
+        }
+      }
       if (changed && server) {
         setImmediate(() => {
           const currentHash = computeUsageHash(aggregator.getUsage());
@@ -3471,6 +3802,9 @@ function hyperfixi(options = {}) {
               invalidateVirtualModule();
             }
           }
+          if (options.serverBridge && server) {
+            await runServerBridge(server.config.root, options.serverBridge, options.debug);
+          }
         } catch {
           if (aggregator.remove(file)) {
             invalidateVirtualModule();
@@ -3501,6 +3835,25 @@ function hyperfixi(options = {}) {
         }
         const scannedFiles = await scanner.scanProject(cwd);
         aggregator.loadFromScan(scannedFiles);
+        if (domainScanner && domainAggregator) {
+          for (const [filePath] of scannedFiles) {
+            try {
+              const fs = await import("fs");
+              const content = fs.readFileSync(filePath, "utf-8");
+              if (domainScanner.hasAnyDomainUsage(content)) {
+                const domainUsages = domainScanner.scan(content, filePath);
+                if (domainUsages.length > 0) {
+                  domainAggregator.add(filePath, domainUsages);
+                }
+              }
+            } catch {
+            }
+          }
+          if (options.debug) {
+            const domainSummary = domainAggregator.getUsage();
+            console.log("[hyperfixi] Domain build scan:", domainSummary);
+          }
+        }
         if (mode === "compile") {
           const usage = aggregator.getUsage();
           if (usage.detectedLanguages.size > 0) {
@@ -3526,6 +3879,9 @@ function hyperfixi(options = {}) {
             languages: summary.languages
           });
         }
+        if (options.serverBridge) {
+          await runServerBridge(cwd, options.serverBridge, options.debug, true);
+        }
       }
     }
   };
@@ -3533,10 +3889,13 @@ function hyperfixi(options = {}) {
 var index_default = hyperfixi;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DomainAggregator,
+  DomainScanner,
   REGIONS,
   SUPPORTED_LANGUAGES,
   clearCustomKeywords,
   clearSemanticParser,
+  descriptorToScanRule,
   detectLanguages,
   getAllLanguageCodes,
   getKeywordsForLanguage,