@lokascript/framework 2.3.1 → 2.4.0

package/dist/api/index.js

@@ -1,75 +1,23 @@
 // src/core/types.ts
-function createLiteral(value, dataType) {
-  return dataType ? { type: "literal", value, dataType } : { type: "literal", value };
-}
-function createSelector(value, selectorKind) {
-  return selectorKind ? { type: "selector", value, selectorKind } : { type: "selector", value };
-}
-function createReference(value) {
-  return { type: "reference", value };
-}
-function createPropertyPath(object, property) {
-  return { type: "property-path", object, property };
-}
-function createFlag(name, enabled = true) {
-  return { type: "flag", name, enabled };
-}
-function createCommandNode(action, roles, metadata) {
-  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
-  const node = {
-    kind: "command",
-    action,
-    roles: rolesMap
-  };
-  if (metadata) {
-    return { ...node, metadata };
-  }
-  return node;
-}
-function createEventHandlerNode(action, roles, body, metadata, eventModifiers) {
-  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
-  const base = {
-    kind: "event-handler",
-    action,
-    roles: rolesMap,
-    body
-  };
-  return {
-    ...base,
-    ...eventModifiers && { eventModifiers },
-    ...metadata && { metadata }
-  };
-}
-function createConditionalNode(action, roles, thenBranch, elseBranch, metadata) {
-  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
-  const base = {
-    kind: "conditional",
-    action,
-    roles: rolesMap,
-    thenBranch
-  };
-  return {
-    ...base,
-    ...elseBranch && { elseBranch },
-    ...metadata && { metadata }
-  };
-}
-function createLoopNode(action, roles, loopVariant, body, loopVariable, indexVariable, metadata) {
-  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
-  const base = {
-    kind: "loop",
-    action,
-    roles: rolesMap,
-    loopVariant,
-    body
-  };
-  return {
-    ...base,
-    ...loopVariable && { loopVariable },
-    ...indexVariable && { indexVariable },
-    ...metadata && { metadata }
-  };
-}
+import {
+  createLiteral,
+  createSelector,
+  createReference,
+  createPropertyPath,
+  createExpression,
+  createFlag,
+  createCommandNode,
+  createEventHandlerNode,
+  createConditionalNode,
+  createCompoundNode,
+  createLoopNode,
+  createTryNode,
+  createAsyncNode,
+  createMatchNode,
+  extractValue,
+  extractRoleValue,
+  getRoleValue
+} from "@lokascript/intent";
 
 // src/core/logger.ts
 var DebugLogger = class {
@@ -1657,454 +1605,19 @@ var InMemoryProfileProvider = class {
   }
 };
 
-// src/ir/references.ts
-var DEFAULT_REFERENCES = /* @__PURE__ */ new Set([
-  "me",
-  "you",
-  "it",
-  "result",
-  "event",
-  "target",
-  "body"
-]);
-function isValidReference2(value, referenceSet = DEFAULT_REFERENCES) {
-  return referenceSet.has(value);
-}
-
 // src/ir/explicit-parser.ts
-var STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
-  "body",
-  "then",
-  "else",
-  "condition",
-  "loop-body",
-  "variable",
-  "catch",
-  // v1.2: try/catch/finally
-  "finally"
-  // v1.2: try/catch/finally
-]);
-function isNestedCommand(value) {
-  const inner = value.slice(1, -1);
-  let depth = 0;
-  for (const ch of inner) {
-    if (ch === "[") depth++;
-    else if (ch === "]") depth--;
-    else if (depth === 0 && (ch === " " || ch === ":")) return true;
-  }
-  return false;
-}
-function parseExplicit(input, options = {}) {
-  const trimmed = input.trim();
-  const collect = options.collectDiagnostics === true;
-  const diagnostics = [];
-  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
-    throw new Error("Explicit syntax must be wrapped in brackets: [command role:value ...]");
-  }
-  const content = trimmed.slice(1, -1).trim();
-  if (!content) {
-    throw new Error("Empty explicit statement");
-  }
-  const tokens = tokenizeExplicit(content);
-  if (tokens.length === 0) {
-    throw new Error("No command specified in explicit statement");
-  }
-  const command = tokens[0].toLowerCase();
-  const roles = /* @__PURE__ */ new Map();
-  const refSet = options.referenceSet ?? DEFAULT_REFERENCES;
-  const schema = options.schemaLookup?.getSchema(command);
-  const validRoleNames = schema ? new Set(schema.roles.map((r) => r.role)) : null;
-  for (let i = 1; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (token.startsWith("+") || token.startsWith("~")) {
-      const enabled = token.startsWith("+");
-      const flagName = token.slice(1);
-      if (!flagName) {
-        if (collect) {
-          diagnostics.push({
-            severity: "error",
-            code: "EMPTY_FLAG",
-            message: `Empty flag name: "${token}"`,
-            source: "schema"
-          });
-          continue;
-        }
-        throw new Error(`Empty flag name: "${token}"`);
-      }
-      if (validRoleNames && !validRoleNames.has(flagName)) {
-        const roleList = [...validRoleNames].join(", ");
-        if (collect) {
-          diagnostics.push({
-            severity: "error",
-            code: "UNKNOWN_FLAG",
-            message: `Unknown flag "${flagName}" for command "${command}"`,
-            source: "schema",
-            suggestions: [...validRoleNames].map((r) => `+${r}`)
-          });
-          roles.set(flagName, createFlag(flagName, enabled));
-          continue;
-        }
-        throw new Error(
-          `Unknown flag "${flagName}" for command "${command}". Valid roles: ${roleList}`
-        );
-      }
-      roles.set(flagName, createFlag(flagName, enabled));
-      continue;
-    }
-    const colonIndex = token.indexOf(":");
-    if (colonIndex === -1) {
-      if (collect) {
-        diagnostics.push({
-          severity: "error",
-          code: "INVALID_ROLE_FORMAT",
-          message: `Invalid role format: "${token}". Expected role:value or +flag`,
-          source: "schema"
-        });
-        continue;
-      }
-      throw new Error(`Invalid role format: "${token}". Expected role:value or +flag`);
-    }
-    const roleName = token.slice(0, colonIndex);
-    if (validRoleNames && !STRUCTURAL_ROLES.has(roleName) && !validRoleNames.has(roleName)) {
-      const roleList = [...validRoleNames].join(", ");
-      if (collect) {
-        diagnostics.push({
-          severity: "error",
-          code: "UNKNOWN_ROLE",
-          message: `Unknown role "${roleName}" for command "${command}"`,
-          source: "schema",
-          suggestions: [...validRoleNames]
-        });
-      } else {
-        throw new Error(
-          `Unknown role "${roleName}" for command "${command}". Valid roles: ${roleList}`
-        );
-      }
-    }
-    const role = roleName;
-    const valueStr = token.slice(colonIndex + 1);
-    if (STRUCTURAL_ROLES.has(roleName) && valueStr.startsWith("[") && isNestedCommand(valueStr)) {
-      const nestedEnd = findMatchingBracket(token, colonIndex + 1);
-      const nestedSyntax = token.slice(colonIndex + 1, nestedEnd + 1);
-      roles.set(role, { type: "expression", raw: nestedSyntax });
-      continue;
-    }
-    const value = parseExplicitValue(valueStr, refSet);
-    roles.set(role, value);
-  }
-  if (schema && command !== "on") {
-    for (const roleSpec of schema.roles) {
-      if (roleSpec.required && !roles.has(roleSpec.role) && !roleSpec.default) {
-        if (collect) {
-          diagnostics.push({
-            severity: "error",
-            code: "MISSING_REQUIRED_ROLE",
-            message: `Missing required role "${roleSpec.role}" for command "${command}": ${roleSpec.description}`,
-            source: "schema"
-          });
-        } else {
-          throw new Error(
-            `Missing required role "${roleSpec.role}" for command "${command}": ${roleSpec.description}`
-          );
-        }
-      }
-    }
-  }
-  const attachDiagnostics = (node) => {
-    if (diagnostics.length === 0) return node;
-    return { ...node, diagnostics };
-  };
-  switch (command) {
-    case "on": {
-      const eventValue = roles.get("event");
-      if (!eventValue) {
-        if (collect) {
-          diagnostics.push({
-            severity: "error",
-            code: "MISSING_EVENT_ROLE",
-            message: "Event handler requires event role: [on event:click ...]",
-            source: "schema"
-          });
-          return attachDiagnostics(
-            createEventHandlerNode("on", roles, [], {
-              sourceLanguage: "explicit"
-            })
-          );
-        }
-        throw new Error("Event handler requires event role: [on event:click ...]");
-      }
-      const body = extractStructuralBody(roles, "body", options);
-      roles.delete("body");
-      return attachDiagnostics(
-        createEventHandlerNode("on", roles, body, {
-          sourceLanguage: "explicit"
-        })
-      );
-    }
-    case "if": {
-      const thenBranch = extractStructuralBody(roles, "then", options);
-      const elseBranch = extractStructuralBody(roles, "else", options);
-      roles.delete("then");
-      roles.delete("else");
-      return attachDiagnostics(
-        createConditionalNode(
-          command,
-          roles,
-          thenBranch,
-          elseBranch.length > 0 ? elseBranch : void 0,
-          {
-            sourceLanguage: "explicit"
-          }
-        )
-      );
-    }
-    case "repeat": {
-      const loopBody = extractStructuralBody(roles, "loop-body", options);
-      const loopVariantValue = roles.get("loop-variant");
-      const variableValue = roles.get("variable");
-      const indexVariableValue = roles.get("index-variable");
-      roles.delete("loop-body");
-      roles.delete("loop-variant");
-      roles.delete("variable");
-      roles.delete("index-variable");
-      let variant;
-      if (loopVariantValue && loopVariantValue.type === "literal" && typeof loopVariantValue.value === "string") {
-        variant = loopVariantValue.value;
-      } else if (roles.has("quantity")) {
-        variant = "times";
-      } else if (roles.has("source")) {
-        variant = "for";
-      } else if (roles.has("condition")) {
-        variant = "while";
-      } else {
-        variant = "forever";
-      }
-      const loopVariable = variableValue?.type === "literal" && typeof variableValue.value === "string" ? variableValue.value : variableValue?.type === "expression" ? variableValue.raw : void 0;
-      const indexVariable = indexVariableValue?.type === "literal" && typeof indexVariableValue.value === "string" ? indexVariableValue.value : void 0;
-      return attachDiagnostics(
-        createLoopNode(command, roles, variant, loopBody, loopVariable, indexVariable, {
-          sourceLanguage: "explicit"
-        })
-      );
-    }
-    default:
-      return attachDiagnostics(
-        createCommandNode(command, roles, {
-          sourceLanguage: "explicit"
-        })
-      );
-  }
-}
-function isExplicitSyntax(input) {
-  const trimmed = input.trim();
-  return trimmed.startsWith("[") && trimmed.endsWith("]");
-}
-function extractStructuralBody(roles, roleName, options) {
-  const value = roles.get(roleName);
-  if (!value) return [];
-  if (value.type === "expression") {
-    return [parseExplicit(value.raw, options)];
-  }
-  return [];
-}
-function inferSelectorKind(value) {
-  if (!value) return void 0;
-  if (value.startsWith("#")) return "id";
-  if (value.startsWith(".")) return "class";
-  if (value.startsWith("[")) return "attribute";
-  if (value.startsWith("<") || value.startsWith("*")) return "element";
-  if (/[>+~ ]/.test(value) && value.length > 1) return "complex";
-  return void 0;
-}
-function tokenizeExplicit(content) {
-  const tokens = [];
-  let current = "";
-  let inString = false;
-  let stringChar = "";
-  let bracketDepth = 0;
-  for (let i = 0; i < content.length; i++) {
-    const char = content[i];
-    if (inString) {
-      current += char;
-      if (char === stringChar && content[i - 1] !== "\\") {
-        inString = false;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      inString = true;
-      stringChar = char;
-      current += char;
-      continue;
-    }
-    if (char === "[") {
-      bracketDepth++;
-      current += char;
-      continue;
-    }
-    if (char === "]") {
-      bracketDepth--;
-      current += char;
-      continue;
-    }
-    if (char === " " && bracketDepth === 0) {
-      if (current) {
-        tokens.push(current);
-        current = "";
-      }
-      continue;
-    }
-    current += char;
-  }
-  if (current) {
-    tokens.push(current);
-  }
-  return tokens;
-}
-function parseExplicitValue(valueStr, referenceSet) {
-  if (valueStr.startsWith("#") || valueStr.startsWith(".") || valueStr.startsWith("[") || valueStr.startsWith("@") || valueStr.startsWith("*")) {
-    return createSelector(valueStr, inferSelectorKind(valueStr));
-  }
-  if (valueStr.startsWith('"') || valueStr.startsWith("'")) {
-    const inner = valueStr.slice(1, -1);
-    return createLiteral(inner, "string");
-  }
-  if (valueStr === "true") return createLiteral(true, "boolean");
-  if (valueStr === "false") return createLiteral(false, "boolean");
-  const lowerRef = valueStr.toLowerCase();
-  if (isValidReference2(lowerRef, referenceSet)) {
-    return createReference(lowerRef);
-  }
-  const numMatch = valueStr.match(/^(-?\d+(?:\.\d+)?)(ms|s|m|h)?$/);
-  if (numMatch) {
-    const num = parseFloat(numMatch[1]);
-    const suffix = numMatch[2];
-    if (suffix) {
-      return createLiteral(valueStr, "duration");
-    }
-    return createLiteral(num, "number");
-  }
-  return createLiteral(valueStr);
-}
-function findMatchingBracket(str, start) {
-  let depth = 0;
-  for (let i = start; i < str.length; i++) {
-    if (str[i] === "[") depth++;
-    else if (str[i] === "]") {
-      depth--;
-      if (depth === 0) return i;
-    }
-  }
-  return str.length - 1;
-}
+import {
+  STRUCTURAL_ROLES,
+  parseExplicit,
+  isExplicitSyntax,
+  parseCompound,
+  parseDocument,
+  isCompoundSyntax,
+  isDocumentSyntax
+} from "@lokascript/intent";
 
 // src/ir/explicit-renderer.ts
-function renderExplicit(node) {
-  let result;
-  if (node.kind === "compound") {
-    const compoundNode = node;
-    const renderedStatements = compoundNode.statements.map((stmt) => renderExplicit(stmt));
-    result = renderedStatements.join(` ${compoundNode.chainType} `);
-  } else {
-    result = renderBracketCommand(node);
-  }
-  if (node.annotations && node.annotations.length > 0) {
-    const annParts = node.annotations.map(
-      (ann) => ann.value !== void 0 ? `@${ann.name}(${ann.value})` : `@${ann.name}`
-    );
-    return annParts.join(" ") + " " + result;
-  }
-  return result;
-}
-function renderBracketCommand(node) {
-  const parts = [node.action];
-  for (const [role, value] of node.roles) {
-    if (value.type === "flag") {
-      parts.push(value.enabled ? `+${value.name}` : `~${value.name}`);
-    } else {
-      parts.push(`${role}:${valueToString(value)}`);
-    }
-  }
-  if (node.kind === "event-handler") {
-    const eventNode = node;
-    if (eventNode.body && eventNode.body.length > 0) {
-      const bodyParts = eventNode.body.map((n) => renderExplicit(n));
-      parts.push(`body:${bodyParts.join(" ")}`);
-    }
-  }
-  if (node.kind === "conditional") {
-    const condNode = node;
-    if (condNode.thenBranch && condNode.thenBranch.length > 0) {
-      const thenParts = condNode.thenBranch.map((n) => renderExplicit(n));
-      parts.push(`then:${thenParts.join(" ")}`);
-    }
-    if (condNode.elseBranch && condNode.elseBranch.length > 0) {
-      const elseParts = condNode.elseBranch.map((n) => renderExplicit(n));
-      parts.push(`else:${elseParts.join(" ")}`);
-    }
-  }
-  if (node.kind === "loop") {
-    const loopNode = node;
-    if (loopNode.loopVariant) {
-      parts.push(`loop-variant:${loopNode.loopVariant}`);
-    }
-    if (loopNode.loopVariable) {
-      parts.push(`variable:${loopNode.loopVariable}`);
-    }
-    if (loopNode.indexVariable) {
-      parts.push(`index-variable:${loopNode.indexVariable}`);
-    }
-    if (loopNode.body && loopNode.body.length > 0) {
-      const bodyParts = loopNode.body.map((n) => renderExplicit(n));
-      parts.push(`loop-body:${bodyParts.join(" ")}`);
-    }
-  }
-  if (node.kind === "command") {
-    const cmd = node;
-    if (cmd.body && cmd.body.length > 0) {
-      const bodyParts = cmd.body.map((n) => renderExplicit(n));
-      parts.push(`body:${bodyParts.join(" ")}`);
-    }
-    if (cmd.catchBranch && cmd.catchBranch.length > 0) {
-      const catchParts = cmd.catchBranch.map((n) => renderExplicit(n));
-      parts.push(`catch:${catchParts.join(" ")}`);
-    }
-    if (cmd.finallyBranch && cmd.finallyBranch.length > 0) {
-      const finallyParts = cmd.finallyBranch.map((n) => renderExplicit(n));
-      parts.push(`finally:${finallyParts.join(" ")}`);
-    }
-    if (cmd.asyncVariant) {
-      parts.push(`async-variant:${cmd.asyncVariant}`);
-    }
-    if (cmd.asyncBody && cmd.asyncBody.length > 0) {
-      const asyncParts = cmd.asyncBody.map((n) => renderExplicit(n));
-      parts.push(`async-body:${asyncParts.join(" ")}`);
-    }
-  }
-  return `[${parts.join(" ")}]`;
-}
-function valueToString(value) {
-  switch (value.type) {
-    case "literal":
-      if (typeof value.value === "string") {
-        if (value.dataType === "string" || /\s/.test(value.value)) {
-          return `"${value.value}"`;
-        }
-        return value.value;
-      }
-      return String(value.value);
-    case "selector":
-      return value.value;
-    case "reference":
-      return value.value;
-    case "property-path":
-      return `${valueToString(value.object)}'s ${value.property}`;
-    case "expression":
-      return value.raw;
-    case "flag":
-      return value.name;
-  }
-}
+import { renderExplicit, renderDocument } from "@lokascript/intent";
 
 // src/api/create-dsl.ts
 var DSLRegistry = class {