@lokascript/compilation-service 2.0.0 → 2.1.0

package/dist/{dist-ICUX26U7.js → dist-SWJWTU4Z.js}

@@ -1,7 +1,7 @@
 import {
   CoreParserAdapter,
   createCoreParserAdapter
-} from "./chunk-JDOSUTCM.js";
+} from "./chunk-UQULNKOC.js";
 import {
   SemanticParserAdapter,
   createSemanticAdapter
@@ -9,6 +9,11 @@ import {
 import "./chunk-HMLY7DHA.js";
 
 // ../aot-compiler/dist/index.js
+import {
+  isExplicitSyntax,
+  parseExplicit,
+  fromProtocolJSON
+} from "@lokascript/framework";
 var DEFAULT_OPTIONS = {
   attributeNames: ["_", "data-hs", "data-hyperscript"],
   includeScriptTags: true,
@@ -683,6 +688,166 @@ function analyze(ast) {
   const analyzer = new Analyzer();
   return analyzer.analyze(ast);
 }
+var CLASS_COMMANDS = /* @__PURE__ */ new Set(["add", "remove", "toggle"]);
+function extractClassOp(node) {
+  if (node.type !== "command") return null;
+  const cmd = node;
+  if (!CLASS_COMMANDS.has(cmd.name)) return null;
+  const args = cmd.args ?? [];
+  if (args.length === 0) return null;
+  const arg = args[0];
+  if (arg.type !== "selector") return null;
+  const selector = arg.value;
+  if (!selector.startsWith(".")) return null;
+  const className = selector.slice(1);
+  if (!className) return null;
+  return {
+    command: cmd.name,
+    className,
+    hasExplicitTarget: !!cmd.target
+  };
+}
+function isSameTarget(a, b) {
+  if (a.type !== "command" || b.type !== "command") return false;
+  const cmdA = a;
+  const cmdB = b;
+  if (!cmdA.target && !cmdB.target) return true;
+  if (cmdA.target && cmdB.target) {
+    return getTargetKey(cmdA.target) === getTargetKey(cmdB.target);
+  }
+  return false;
+}
+function getTargetKey(target) {
+  if (target.type === "selector") {
+    return `selector:${target.value}`;
+  }
+  if (target.type === "identifier") {
+    return `identifier:${target.value}`;
+  }
+  return null;
+}
+function resolveTarget(cmd) {
+  if (!cmd.target) return "_ctx.me";
+  if (cmd.target.type === "selector") {
+    const sel = cmd.target.value;
+    if (sel.startsWith("#") && !sel.includes(" ") && !sel.includes(".")) {
+      return `document.getElementById('${sel.slice(1)}')`;
+    }
+    return `document.querySelector('${sel}')`;
+  }
+  if (cmd.target.type === "identifier") {
+    const val = cmd.target.value;
+    if (val === "me") return "_ctx.me";
+    return val;
+  }
+  return "_ctx.me";
+}
+function createBatchNode(run) {
+  const adds = [];
+  const removes = [];
+  const toggles = [];
+  for (const node of run) {
+    const op = extractClassOp(node);
+    switch (op.command) {
+      case "add":
+        adds.push(op.className);
+        break;
+      case "remove":
+        removes.push(op.className);
+        break;
+      case "toggle":
+        toggles.push(op.className);
+        break;
+    }
+  }
+  const target = resolveTarget(run[0]);
+  return {
+    type: "batchedClassOps",
+    target,
+    adds,
+    removes,
+    toggles
+  };
+}
+function batchBody(nodes) {
+  const result = [];
+  let currentRun = [];
+  function flushRun() {
+    if (currentRun.length >= 2) {
+      result.push(createBatchNode(currentRun));
+    } else if (currentRun.length === 1) {
+      result.push(currentRun[0]);
+    }
+    currentRun = [];
+  }
+  for (const node of nodes) {
+    const op = extractClassOp(node);
+    if (op) {
+      if (currentRun.length > 0 && isSameTarget(currentRun[0], node)) {
+        currentRun.push(node);
+      } else {
+        flushRun();
+        currentRun = [node];
+      }
+    } else {
+      flushRun();
+      result.push(node);
+    }
+  }
+  flushRun();
+  return result;
+}
+function walkAndBatch(node) {
+  switch (node.type) {
+    case "event": {
+      const event = node;
+      if (event.body && event.body.length > 0) {
+        return { ...event, body: batchBody(event.body).map(walkAndBatch) };
+      }
+      return node;
+    }
+    case "if": {
+      const ifNode = node;
+      const result = { ...ifNode };
+      result.thenBranch = batchBody(ifNode.thenBranch).map(walkAndBatch);
+      if (ifNode.elseBranch) {
+        result.elseBranch = batchBody(ifNode.elseBranch).map(walkAndBatch);
+      }
+      if (ifNode.elseIfBranches) {
+        result.elseIfBranches = ifNode.elseIfBranches.map((branch) => ({
+          condition: branch.condition,
+          body: batchBody(branch.body).map(walkAndBatch)
+        }));
+      }
+      return result;
+    }
+    case "repeat": {
+      const repeat = node;
+      return { ...repeat, body: batchBody(repeat.body).map(walkAndBatch) };
+    }
+    case "foreach": {
+      const forEach = node;
+      return { ...forEach, body: batchBody(forEach.body).map(walkAndBatch) };
+    }
+    case "while": {
+      const whileNode = node;
+      return { ...whileNode, body: batchBody(whileNode.body).map(walkAndBatch) };
+    }
+    default:
+      return node;
+  }
+}
+var ClassBatchingPass = class {
+  constructor() {
+    this.name = "class-batching";
+  }
+  shouldRun(analysis) {
+    return analysis.commandsUsed.has("add") || analysis.commandsUsed.has("remove") || analysis.commandsUsed.has("toggle");
+  }
+  transform(ast, _analysis) {
+    return walkAndBatch(ast);
+  }
+};
 var ConstantFoldingPass = class {
   constructor() {
     this.name = "constant-folding";
@@ -1007,6 +1172,7 @@ var OptimizationPipeline = class {
       new ConstantFoldingPass(),
       new SelectorCachingPass(),
       new DeadCodeEliminationPass(),
+      new ClassBatchingPass(),
       new LoopUnrollingPass()
     ];
   }
@@ -1039,12 +1205,184 @@ var OptimizationPipeline = class {
   }
 };
 function createOptimizer() {
-  return new OptimizationPipeline();
+  return /* @__PURE__ */ new OptimizationPipeline();
 }
 function optimize(ast, analysis, level = 2) {
   const pipeline = new OptimizationPipeline();
   return pipeline.optimize(ast, analysis, level);
 }
+function classifyCommand(node) {
+  if (node.type !== "command") return null;
+  const cmd = node;
+  switch (cmd.name) {
+    case "add":
+      return classifyAddCommand(cmd);
+    case "remove":
+      return classifyRemoveCommand(cmd);
+    case "put":
+      return classifyPutCommand(cmd);
+    case "set":
+      return classifySetCommand(cmd);
+    default:
+      return null;
+  }
+}
+function getIdTarget(cmd) {
+  if (!cmd.target) return null;
+  if (cmd.target.type !== "selector") return null;
+  const sel = cmd.target.value;
+  if (!sel.startsWith("#")) return null;
+  return sel.slice(1);
+}
+function classifyAddCommand(cmd) {
+  const targetId = getIdTarget(cmd);
+  if (!targetId) return null;
+  const args = cmd.args ?? [];
+  if (args.length === 0) return null;
+  const arg = args[0];
+  if (arg.type !== "selector") return null;
+  const val = arg.value;
+  if (!val.startsWith(".")) return null;
+  return { type: "addClass", targetId, value: val.slice(1) };
+}
+function classifyRemoveCommand(cmd) {
+  const targetId = getIdTarget(cmd);
+  if (!targetId) return null;
+  const args = cmd.args ?? [];
+  if (args.length === 0) return null;
+  const arg = args[0];
+  if (arg.type !== "selector") return null;
+  const val = arg.value;
+  if (!val.startsWith(".")) return null;
+  return { type: "removeClass", targetId, value: val.slice(1) };
+}
+function classifyPutCommand(cmd) {
+  const targetId = getIdTarget(cmd);
+  if (!targetId) return null;
+  const args = cmd.args ?? [];
+  if (args.length === 0) return null;
+  const arg = args[0];
+  if (arg.type !== "literal") return null;
+  const val = arg.value;
+  if (typeof val !== "string") return null;
+  return { type: "putContent", targetId, value: val };
+}
+function classifySetCommand(cmd) {
+  const targetId = getIdTarget(cmd);
+  if (!targetId) return null;
+  const args = cmd.args ?? [];
+  if (args.length < 2) return null;
+  const attrArg = args[0];
+  if (attrArg.type !== "identifier") return null;
+  const attrValue = attrArg.value;
+  if (!attrValue || !attrValue.startsWith("@")) return null;
+  const attrName = attrValue.slice(1);
+  const valArg = args[1];
+  if (valArg.type !== "literal") return null;
+  const val = valArg.value;
+  if (typeof val !== "string" && typeof val !== "number") return null;
+  return { type: "setAttribute", targetId, value: String(val), attrName };
+}
+function classifyInitCommands(commands) {
+  const pure = [];
+  const impure = [];
+  for (let i = 0; i < commands.length; i++) {
+    const classified = classifyCommand(commands[i]);
+    if (classified) {
+      pure.push({ index: i, command: classified });
+    } else {
+      impure.push({ index: i, node: commands[i] });
+    }
+  }
+  return { pure, impure };
+}
+function applyPureCommand(html, cmd) {
+  switch (cmd.type) {
+    case "addClass":
+      return addClassToElement(html, cmd.targetId, cmd.value);
+    case "removeClass":
+      return removeClassFromElement(html, cmd.targetId, cmd.value);
+    case "putContent":
+      return putContentIntoElement(html, cmd.targetId, cmd.value);
+    case "setAttribute":
+      return setAttributeOnElement(html, cmd.targetId, cmd.attrName, cmd.value);
+    default:
+      return html;
+  }
+}
+function transformElementById(html, id, transform) {
+  const idPattern = new RegExp(`(<[^>]*\\bid=["']${escapeRegExp(id)}["'][^>]*>)`, "i");
+  const match = html.match(idPattern);
+  if (!match) return html;
+  return html.replace(match[1], transform(match[1]));
+}
+function addClassToElement(html, id, className) {
+  return transformElementById(html, id, (tag) => {
+    const classMatch = tag.match(/\bclass=["']([^"']*)["']/i);
+    if (classMatch) {
+      const existing = classMatch[1];
+      const classes = existing.split(/\s+/).filter(Boolean);
+      if (!classes.includes(className)) {
+        classes.push(className);
+      }
+      return tag.replace(classMatch[0], `class="${classes.join(" ")}"`);
+    }
+    return tag.replace(/>$/, ` class="${className}">`);
+  });
+}
+function removeClassFromElement(html, id, className) {
+  return transformElementById(html, id, (tag) => {
+    const classMatch = tag.match(/\bclass=["']([^"']*)["']/i);
+    if (!classMatch) return tag;
+    const classes = classMatch[1].split(/\s+/).filter((c) => c !== className);
+    if (classes.length === 0) {
+      return tag.replace(classMatch[0], "").replace(/\s+>/, ">");
+    }
+    return tag.replace(classMatch[0], `class="${classes.join(" ")}"`);
+  });
+}
+function putContentIntoElement(html, id, content) {
+  const idPattern = new RegExp(
+    `(<[a-zA-Z][^>]*\\bid=["']${escapeRegExp(id)}["'][^>]*>)((?:(?!<\\/[a-zA-Z]).)*?)(<\\/[a-zA-Z][^>]*>)`,
+    "is"
+  );
+  const match = html.match(idPattern);
+  if (!match) return html;
+  return html.replace(match[0], `${match[1]}${escapeHtml(content)}${match[3]}`);
+}
+function setAttributeOnElement(html, id, attrName, value) {
+  return transformElementById(html, id, (tag) => {
+    const attrPattern = new RegExp(`\\b${escapeRegExp(attrName)}=["'][^"']*["']`, "i");
+    const attrMatch = tag.match(attrPattern);
+    if (attrMatch) {
+      return tag.replace(attrMatch[0], `${attrName}="${escapeHtml(value)}"`);
+    }
+    return tag.replace(/>$/, ` ${attrName}="${escapeHtml(value)}">`);
+  });
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function preRenderInitBlock(html, initCommands) {
+  const { pure, impure } = classifyInitCommands(initCommands);
+  let modifiedHtml = html;
+  let preRenderedCount = 0;
+  for (const { command } of pure) {
+    const before = modifiedHtml;
+    modifiedHtml = applyPureCommand(modifiedHtml, command);
+    if (modifiedHtml !== before) {
+      preRenderedCount++;
+    }
+  }
+  return {
+    html: modifiedHtml,
+    remainingInitCommands: impure.map((i) => i.node),
+    preRenderedCount
+  };
+}
 function sanitizeClassName(name) {
   if (!/^-?[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name)) {
     return null;
@@ -2918,6 +3256,22 @@ var EventHandlerCodegen = class {
         const nested = node;
         return this.generateBody(nested.body ?? []);
       }
+      case "batchedClassOps": {
+        const batch = node;
+        const lines = [];
+        if (batch.adds.length > 0) {
+          lines.push(`${batch.target}.classList.add(${batch.adds.map((c) => `'${c}'`).join(", ")})`);
+        }
+        if (batch.removes.length > 0) {
+          lines.push(
+            `${batch.target}.classList.remove(${batch.removes.map((c) => `'${c}'`).join(", ")})`
+          );
+        }
+        for (const t of batch.toggles) {
+          lines.push(`${batch.target}.classList.toggle('${t}')`);
+        }
+        return lines.join(";\n");
+      }
       default:
         return null;
     }
@@ -3165,10 +3519,40 @@ var AOTCompiler = class {
   // ===========================================================================
   /**
    * Parse a hyperscript string to AST.
+   * Supports natural language, explicit bracket syntax, and JSON input.
    */
   parse(code, options = {}) {
     const { language = "en", confidenceThreshold = 0.7, debug = false } = options;
     let ast = null;
+    if (isExplicitSyntax(code)) {
+      try {
+        const node = parseExplicit(code);
+        ast = this.semanticNodeToAOT(node);
+        if (debug) {
+          console.log(`[aot] Parsed explicit syntax: "${code}"`);
+        }
+      } catch (error) {
+        if (debug) {
+          console.log(`[aot] Explicit parse error for "${code}":`, error);
+        }
+      }
+      if (ast) return this.ensureEventHandler(ast);
+    }
+    if (this.looksLikeJSON(code)) {
+      try {
+        const json = JSON.parse(code.trim());
+        const node = fromProtocolJSON(json);
+        ast = this.semanticNodeToAOT(node);
+        if (debug) {
+          console.log(`[aot] Parsed JSON input: "${code.slice(0, 80)}..."`);
+        }
+      } catch (error) {
+        if (debug) {
+          console.log(`[aot] JSON parse error for "${code.slice(0, 80)}":`, error);
+        }
+      }
+      if (ast) return this.ensureEventHandler(ast);
+    }
     if (language !== "en" && this.semanticParser?.supportsLanguage(language)) {
       const result = this.semanticParser.analyze(code, language);
       if (result.node && result.confidence >= confidenceThreshold) {
@@ -3195,15 +3579,7 @@ var AOTCompiler = class {
     if (!ast) {
       ast = this.createSimpleAST(code);
     }
-    if (ast && ast.type !== "event") {
-      ast = {
-        type: "event",
-        event: "click",
-        modifiers: {},
-        body: [ast]
-      };
-    }
-    return ast;
+    return this.ensureEventHandler(ast);
   }
   /**
    * Create a simple AST from code (for testing without full parser).
@@ -3368,6 +3744,86 @@ var AOTCompiler = class {
     return { type: "identifier", value: trimmed };
   }
   // ===========================================================================
+  // EXPLICIT / JSON INPUT HELPERS
+  // ===========================================================================
+  /**
+   * Check if input looks like JSON (LLM JSON format).
+   */
+  looksLikeJSON(code) {
+    const trimmed = code.trim();
+    return trimmed.startsWith("{") && trimmed.includes('"action"');
+  }
+  /**
+   * Ensure top-level node is always an event handler.
+   * The codegen pipeline (EventHandlerCodegen) requires this.
+   */
+  ensureEventHandler(ast) {
+    if (ast && ast.type !== "event") {
+      return {
+        type: "event",
+        event: "click",
+        modifiers: {},
+        body: [ast]
+      };
+    }
+    return ast;
+  }
+  /**
+   * Convert a framework SemanticNode to an AOT ASTNode.
+   * Handles the simple cases produced by explicit/JSON parsing.
+   */
+  semanticNodeToAOT(node) {
+    if (node.kind === "event-handler") {
+      const eh = node;
+      const eventValue = eh.roles.get("event");
+      const eventName = eventValue && "value" in eventValue ? String(eventValue.value) : "click";
+      return {
+        type: "event",
+        event: eventName,
+        modifiers: {},
+        body: (eh.body ?? []).map((child) => this.semanticNodeToAOT(child))
+      };
+    }
+    const roles = {};
+    const args = [];
+    for (const [roleName, value] of node.roles) {
+      const astValue = this.semanticValueToAOT(value);
+      roles[roleName] = astValue;
+      args.push(astValue);
+    }
+    return {
+      type: "command",
+      name: node.action,
+      args,
+      roles
+    };
+  }
+  /**
+   * Convert a SemanticValue to an ASTNode.
+   */
+  semanticValueToAOT(value) {
+    switch (value.type) {
+      case "selector":
+        return { type: "selector", value: value.value };
+      case "reference":
+        return { type: "identifier", value: value.value };
+      case "literal": {
+        const lit = value;
+        if (lit.dataType === "duration") {
+          const str = String(lit.value);
+          const match = /^(\d+(?:\.\d+)?)(ms|s)$/.exec(str);
+          if (match) {
+            const ms = match[2] === "s" ? parseFloat(match[1]) * 1e3 : parseFloat(match[1]);
+            return { type: "literal", value: ms };
+          }
+        }
+        return { type: "literal", value: lit.value };
+      }
+      default:
+        return { type: "literal", value: String(value.value ?? "") };
+    }
+  }
+  // ===========================================================================
   // ANALYSIS
   // ===========================================================================
   /**
@@ -3377,6 +3833,63 @@ var AOTCompiler = class {
     return this.analyzer.analyze(ast);
   }
   // ===========================================================================
+  // INIT PRE-RENDERING
+  // ===========================================================================
+  /**
+   * Pre-render pure init block commands into an HTML template at build time.
+   *
+   * Analyzes init block commands for purity (static DOM writes with literal
+   * values targeting #id selectors) and applies them directly to the HTML.
+   * Impure commands are preserved for normal runtime execution.
+   *
+   * @param html - The HTML template string
+   * @param initCommands - Parsed commands from an init block
+   * @returns Modified HTML, remaining impure commands, and count of pre-rendered commands
+   */
+  preRenderInit(html, initCommands) {
+    return preRenderInitBlock(html, initCommands);
+  }
+  /**
+   * Extract init blocks from HTML, pre-render pure commands, and return modified HTML.
+   * This is a higher-level convenience that combines extraction, parsing, and pre-rendering.
+   *
+   * @param html - The HTML template string
+   * @param options - Compile options (language, etc.)
+   * @returns Modified HTML with pre-rendered init effects and compilation results
+   */
+  preRenderInitBlocks(html, options = {}) {
+    const scripts = this.extract(html, "template.html");
+    let modifiedHtml = html;
+    let totalPreRendered = 0;
+    const remainingScripts = [];
+    for (const script of scripts) {
+      const ast = this.parse(script.code, {
+        ...options,
+        language: script.language ?? options.language ?? "en"
+      });
+      if (!ast) {
+        remainingScripts.push(script);
+        continue;
+      }
+      const eventNode = ast;
+      if (eventNode.type === "event" && eventNode.event === "init" && eventNode.body) {
+        const result = preRenderInitBlock(modifiedHtml, eventNode.body);
+        modifiedHtml = result.html;
+        totalPreRendered += result.preRenderedCount;
+        if (result.remainingInitCommands.length > 0) {
+          remainingScripts.push(script);
+        }
+      } else {
+        remainingScripts.push(script);
+      }
+    }
+    return {
+      html: modifiedHtml,
+      preRenderedCount: totalPreRendered,
+      remainingScripts
+    };
+  }
+  // ===========================================================================
   // COMPILATION
   // ===========================================================================
   /**
@@ -3499,6 +4012,30 @@ var AOTCompiler = class {
       }
     };
   }
+  /**
+   * Compile explicit bracket syntax or LLM JSON to JavaScript.
+   * Uses the framework IR directly — no semantic or traditional parser needed.
+   */
+  compileExplicit(code, options = {}) {
+    try {
+      const ast = isExplicitSyntax(code) ? this.semanticNodeToAOT(parseExplicit(code)) : this.semanticNodeToAOT(fromProtocolJSON(JSON.parse(code.trim())));
+      return this.compileAST(ast, options);
+    } catch (error) {
+      return {
+        success: false,
+        errors: [error instanceof Error ? error.message : String(error)],
+        warnings: [],
+        metadata: {
+          handlerId: "",
+          parserUsed: "traditional",
+          commandsUsed: [],
+          optimizationsApplied: [],
+          needsRuntime: false,
+          runtimeHelpers: []
+        }
+      };
+    }
+  }
   /**
    * Compile multiple extracted scripts.
    */
@@ -3734,7 +4271,7 @@ async function compileHyperscript(code, options) {
 async function createMultilingualCompiler() {
   const compiler = new AOTCompiler();
   try {
-    const { createCoreParserAdapter: createCoreParserAdapter2 } = await import("./core-parser-adapter-VCJB52SO-MDHRIVZ7.js");
+    const { createCoreParserAdapter: createCoreParserAdapter2 } = await import("./core-parser-adapter-VCJB52SO-5HK2TL6Q.js");
     compiler.setParser(await createCoreParserAdapter2());
   } catch {
   }
@@ -3787,4 +4324,4 @@ export {
   sanitizeSelector,
   scanFiles
 };
-//# sourceMappingURL=dist-ICUX26U7.js.map
+//# sourceMappingURL=dist-SWJWTU4Z.js.map