@lokascript/compilation-service 2.0.0

package/dist/chunk-CY26COTT.js

@@ -0,0 +1,77 @@
+// ../aot-compiler/dist/chunk-QKE5BEQY.js
+var SemanticParserAdapter = class {
+  constructor(analyzer, ASTBuilderClass, parseWithConfidenceFn, converter) {
+    this.analyzer = analyzer;
+    this.ASTBuilderClass = ASTBuilderClass;
+    this.parseWithConfidenceFn = parseWithConfidenceFn;
+    this.converter = converter;
+  }
+  /**
+   * Analyze code in the given language.
+   * Uses the full semantic parser (parseWithConfidence) which correctly
+   * returns event-handler nodes with body commands.
+   */
+  analyze(code, language) {
+    try {
+      const result = this.parseWithConfidenceFn(code, language);
+      return {
+        node: result.node ?? void 0,
+        confidence: result.confidence,
+        errors: result.error ? [result.error] : void 0
+      };
+    } catch (error) {
+      return {
+        confidence: 0,
+        errors: [error instanceof Error ? error.message : String(error)]
+      };
+    }
+  }
+  /**
+   * Build an AOT-compatible AST from the SemanticNode.
+   * Converts the semantic package's AST format to AOT types via interchange.
+   */
+  buildAST(node) {
+    const semanticNode = node;
+    const builder = new this.ASTBuilderClass();
+    const semanticAST = builder.build(semanticNode);
+    const aotAST = this.converter(semanticAST);
+    return { ast: aotAST, warnings: builder.warnings };
+  }
+  /**
+   * Check if the given language is supported.
+   */
+  supportsLanguage(language) {
+    return this.analyzer.supportsLanguage(language);
+  }
+};
+var _converter = null;
+function convertSemanticASTToAOT(node) {
+  if (_converter) return _converter(node);
+  return node;
+}
+async function createSemanticAdapter() {
+  const semantic = await import("@lokascript/semantic");
+  const analyzer = semantic.createSemanticAnalyzer();
+  const ASTBuilderClass = semantic.ASTBuilder;
+  const parseWithConfidence = semantic.parseWithConfidence;
+  const converter = semantic.fromSemanticAST;
+  if (!converter) {
+    throw new Error(
+      "@lokascript/semantic does not export fromSemanticAST. Ensure @lokascript/semantic >= 1.3.0 is installed."
+    );
+  }
+  _converter = converter;
+  return new SemanticParserAdapter(
+    analyzer,
+    ASTBuilderClass,
+    parseWithConfidence,
+    converter
+  );
+}
+
+export {
+  SemanticParserAdapter,
+  convertSemanticASTToAOT,
+  createSemanticAdapter
+};
+//# sourceMappingURL=chunk-CY26COTT.js.map

package/dist/chunk-CY26COTT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../aot-compiler/src/compiler/semantic-adapter.ts"],"sourcesContent":["/**\n * Semantic Parser Adapter\n *\n * Bridges @lokascript/semantic's parse output into AOT ASTNode types.\n * Delegates AST conversion to the shared interchange format (fromSemanticAST)\n * exported by @lokascript/semantic.\n */\n\nimport type { ASTNode } from '../types/aot-types.js';\n\n// =============================================================================\n// SEMANTIC TYPES (imported dynamically)\n// =============================================================================\n\n// These mirror the types from @lokascript/semantic but are declared locally\n// so the adapter can be compiled without the optional peer dependency.\n\ninterface SemanticAnalysisResult {\n  confidence: number;\n  node?: SemanticNodeLike;\n  errors?: string[];\n}\n\ninterface SemanticAnalyzerLike {\n  analyze(input: string, language: string): SemanticAnalysisResult;\n  supportsLanguage(language: string): boolean;\n}\n\ninterface SemanticNodeLike {\n  kind: string;\n  action: string;\n  roles: ReadonlyMap<string, unknown>;\n  metadata?: { confidence?: number };\n  body?: SemanticNodeLike[];\n  eventModifiers?: Record<string, unknown>;\n  parameterNames?: readonly string[];\n  thenBranch?: SemanticNodeLike[];\n  elseBranch?: SemanticNodeLike[];\n  statements?: SemanticNodeLike[];\n  loopVariant?: string;\n  loopVariable?: string;\n  indexVariable?: string;\n}\n\ninterface ASTBuilderLike {\n  build(node: SemanticNodeLike): SemanticASTNodeLike;\n  warnings: string[];\n}\n\ninterface SemanticASTNodeLike {\n  type: string;\n  [key: string]: unknown;\n}\n\ntype ParseWithConfidenceFn = (\n  code: string,\n  language: string\n) => { node: SemanticNodeLike | null; confidence: number; error: string | undefined };\n\n/** Interchange converter function signature */\ntype InterchangeConverter = (node: SemanticASTNodeLike) => ASTNode;\n\n// =============================================================================\n// SEMANTIC PARSER ADAPTER\n// =============================================================================\n\n/**\n * Adapts @lokascript/semantic into the SemanticParser interface expected by\n * AOTCompiler.\n *\n * Uses `parseWithConfidence()` for analysis — this is the full semantic parser\n * (not just the pattern matcher), so it correctly handles event handlers with\n * body commands, compound statements, etc.\n */\nexport class SemanticParserAdapter {\n  private analyzer: SemanticAnalyzerLike;\n  private ASTBuilderClass: new () => ASTBuilderLike;\n  private parseWithConfidenceFn: ParseWithConfidenceFn;\n  private converter: InterchangeConverter;\n\n  constructor(\n    analyzer: SemanticAnalyzerLike,\n    ASTBuilderClass: new () => ASTBuilderLike,\n    parseWithConfidenceFn: ParseWithConfidenceFn,\n    converter: InterchangeConverter\n  ) {\n    this.analyzer = analyzer;\n    this.ASTBuilderClass = ASTBuilderClass;\n    this.parseWithConfidenceFn = parseWithConfidenceFn;\n    this.converter = converter;\n  }\n\n  /**\n   * Analyze code in the given language.\n   * Uses the full semantic parser (parseWithConfidence) which correctly\n   * returns event-handler nodes with body commands.\n   */\n  analyze(\n    code: string,\n    language: string\n  ): { node?: unknown; confidence: number; errors?: string[] } {\n    try {\n      const result = this.parseWithConfidenceFn(code, language);\n      return {\n        node: result.node ?? undefined,\n        confidence: result.confidence,\n        errors: result.error ? [result.error] : undefined,\n      };\n    } catch (error) {\n      return {\n        confidence: 0,\n        errors: [error instanceof Error ? error.message : String(error)],\n      };\n    }\n  }\n\n  /**\n   * Build an AOT-compatible AST from the SemanticNode.\n   * Converts the semantic package's AST format to AOT types via interchange.\n   */\n  buildAST(node: unknown): { ast: ASTNode; warnings: string[] } {\n    const semanticNode = node as SemanticNodeLike;\n\n    const builder = new this.ASTBuilderClass();\n    const semanticAST = builder.build(semanticNode);\n    const aotAST = this.converter(semanticAST);\n\n    return { ast: aotAST, warnings: builder.warnings };\n  }\n\n  /**\n   * Check if the given language is supported.\n   */\n  supportsLanguage(language: string): boolean {\n    return this.analyzer.supportsLanguage(language);\n  }\n}\n\n// =============================================================================\n// STANDALONE CONVERTER (backward compat)\n// =============================================================================\n\nlet _converter: InterchangeConverter | null = null;\n\n/**\n * Convert a semantic package AST node to an AOT AST node.\n *\n * Delegates to `fromSemanticAST` from `@lokascript/semantic`'s interchange format.\n * This function is available after `createSemanticAdapter()` has been called.\n *\n * @deprecated Import `fromSemanticAST` from `@lokascript/semantic` directly instead.\n */\nexport function convertSemanticASTToAOT(node: SemanticASTNodeLike): ASTNode {\n  if (_converter) return _converter(node);\n  return node as ASTNode;\n}\n\n// =============================================================================\n// FACTORY FUNCTION\n// =============================================================================\n\n/**\n * Create a SemanticParserAdapter by dynamically importing @lokascript/semantic.\n * Throws if the package is not available.\n */\nexport async function createSemanticAdapter(): Promise<SemanticParserAdapter> {\n  const semantic = await import('@lokascript/semantic');\n  const analyzer = semantic.createSemanticAnalyzer();\n  const ASTBuilderClass = semantic.ASTBuilder;\n  const parseWithConfidence = semantic.parseWithConfidence;\n\n  // Use the interchange converter from semantic\n  const converter = (semantic as Record<string, unknown>).fromSemanticAST as InterchangeConverter;\n  if (!converter) {\n    throw new Error(\n      '@lokascript/semantic does not export fromSemanticAST. ' +\n        'Ensure @lokascript/semantic >= 1.3.0 is installed.'\n    );\n  }\n\n  // Cache for standalone convertSemanticASTToAOT()\n  _converter = converter;\n\n  return new SemanticParserAdapter(\n    analyzer as unknown as SemanticAnalyzerLike,\n    ASTBuilderClass as unknown as new () => ASTBuilderLike,\n    parseWithConfidence as unknown as ParseWithConfidenceFn,\n    converter\n  );\n}\n"],"mappings":";AA0EO,IAAM,wBAAN,MAA4B;EAMjC,YACE,UACA,iBACA,uBACA,WACA;AACA,SAAK,WAAW;AAChB,SAAK,kBAAkB;AACvB,SAAK,wBAAwB;AAC7B,SAAK,YAAY;EACnB;;;;;;EAOA,QACE,MACA,UAC2D;AAC3D,QAAI;AACF,YAAM,SAAS,KAAK,sBAAsB,MAAM,QAAQ;AACxD,aAAO;QACL,MAAM,OAAO,QAAQ;QACrB,YAAY,OAAO;QACnB,QAAQ,OAAO,QAAQ,CAAC,OAAO,KAAK,IAAI;MAC1C;IACF,SAAS,OAAO;AACd,aAAO;QACL,YAAY;QACZ,QAAQ,CAAC,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;MACjE;IACF;EACF;;;;;EAMA,SAAS,MAAqD;AAC5D,UAAM,eAAe;AAErB,UAAM,UAAU,IAAI,KAAK,gBAAgB;AACzC,UAAM,cAAc,QAAQ,MAAM,YAAY;AAC9C,UAAM,SAAS,KAAK,UAAU,WAAW;AAEzC,WAAO,EAAE,KAAK,QAAQ,UAAU,QAAQ,SAAS;EACnD;;;;EAKA,iBAAiB,UAA2B;AAC1C,WAAO,KAAK,SAAS,iBAAiB,QAAQ;EAChD;AACF;AAMA,IAAI,aAA0C;AAUvC,SAAS,wBAAwB,MAAoC;AAC1E,MAAI,WAAY,QAAO,WAAW,IAAI;AACtC,SAAO;AACT;AAUA,eAAsB,wBAAwD;AAC5E,QAAM,WAAW,MAAM,OAAO,sBAAsB;AACpD,QAAM,WAAW,SAAS,uBAAuB;AACjD,QAAM,kBAAkB,SAAS;AACjC,QAAM,sBAAsB,SAAS;AAGrC,QAAM,YAAa,SAAqC;AACxD,MAAI,CAAC,WAAW;AACd,UAAM,IAAI;MACR;IAEF;EACF;AAGA,eAAa;AAEb,SAAO,IAAI;IACT;IACA;IACA;IACA;EACF;AACF;","names":[]}

package/dist/chunk-HMLY7DHA.js

@@ -0,0 +1,16 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export {
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod
+};
+//# sourceMappingURL=chunk-HMLY7DHA.js.map

package/dist/chunk-HMLY7DHA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-JDOSUTCM.js

@@ -0,0 +1,49 @@
+// ../aot-compiler/dist/chunk-PPZXJJ57.js
+var CoreParserAdapter = class {
+  constructor(api, converter) {
+    this.api = api;
+    this.converter = converter;
+  }
+  /**
+   * Parse hyperscript code to an AOT-compatible AST.
+   */
+  parse(code, language) {
+    const result = this.api.compileSync(code, {
+      language: language ?? "en",
+      traditional: true
+    });
+    if (!result.ok || !result.ast) {
+      throw new Error(result.errors?.[0]?.message ?? `Core parser failed for: ${code}`);
+    }
+    return this.converter(result.ast);
+  }
+};
+var _converter = null;
+function convertCoreASTToAOT(node) {
+  if (_converter) return _converter(node);
+  return node;
+}
+async function createCoreParserAdapter() {
+  const core = await import("./dist-JOIDNRL3.js");
+  const api = core.hyperscript ?? core.default ?? core;
+  if (!api?.compileSync) {
+    throw new Error(
+      "@hyperfixi/core does not export compileSync. Ensure @hyperfixi/core >= 1.0.0 is installed."
+    );
+  }
+  const converter = core.fromCoreAST;
+  if (!converter) {
+    throw new Error(
+      "@hyperfixi/core does not export fromCoreAST. Ensure @hyperfixi/core >= 1.3.0 is installed."
+    );
+  }
+  _converter = converter;
+  return new CoreParserAdapter(api, converter);
+}
+
+export {
+  CoreParserAdapter,
+  convertCoreASTToAOT,
+  createCoreParserAdapter
+};
+//# sourceMappingURL=chunk-JDOSUTCM.js.map

package/dist/chunk-JDOSUTCM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../aot-compiler/src/compiler/core-parser-adapter.ts"],"sourcesContent":["/**\n * Core Parser Adapter\n *\n * Bridges @hyperfixi/core's parser output into AOT ASTNode types.\n * Delegates AST conversion to the shared interchange format (fromCoreAST)\n * exported by @hyperfixi/core.\n */\n\nimport type { ASTNode } from '../types/aot-types.js';\n\n// =============================================================================\n// CORE TYPES (imported dynamically)\n// =============================================================================\n\n// Locally-declared types to avoid requiring the peer dependency at compile time.\n\ninterface CoreCompileResult {\n  ok: boolean;\n  ast?: CoreASTNode;\n  errors?: Array<{ message: string }>;\n}\n\ninterface CoreASTNode {\n  type: string;\n  [key: string]: unknown;\n}\n\ninterface CoreHyperscriptAPI {\n  compileSync(\n    code: string,\n    options?: { language?: string; traditional?: boolean }\n  ): CoreCompileResult;\n}\n\n/** Interchange converter function signature */\ntype InterchangeConverter = (node: CoreASTNode) => ASTNode;\n\n// =============================================================================\n// CORE PARSER ADAPTER\n// =============================================================================\n\n/**\n * Adapts @hyperfixi/core's compileSync() output into the Parser interface\n * expected by AOTCompiler.\n */\nexport class CoreParserAdapter {\n  private api: CoreHyperscriptAPI;\n  private converter: InterchangeConverter;\n\n  constructor(api: CoreHyperscriptAPI, converter: InterchangeConverter) {\n    this.api = api;\n    this.converter = converter;\n  }\n\n  /**\n   * Parse hyperscript code to an AOT-compatible AST.\n   */\n  parse(code: string, language?: string): ASTNode {\n    const result = this.api.compileSync(code, {\n      language: language ?? 'en',\n      traditional: true,\n    });\n\n    if (!result.ok || !result.ast) {\n      throw new Error(result.errors?.[0]?.message ?? `Core parser failed for: ${code}`);\n    }\n\n    return this.converter(result.ast);\n  }\n}\n\n// =============================================================================\n// STANDALONE CONVERTER (backward compat)\n// =============================================================================\n\n/**\n * Module-level converter, set by createCoreParserAdapter().\n * Falls back to a passthrough if not yet initialized (shouldn't happen in practice).\n */\nlet _converter: InterchangeConverter | null = null;\n\n/**\n * Convert a core parser AST node to an AOT AST node.\n *\n * Delegates to `fromCoreAST` from `@hyperfixi/core`'s interchange format.\n * This function is available after `createCoreParserAdapter()` has been called.\n *\n * @deprecated Import `fromCoreAST` from `@hyperfixi/core` directly instead.\n */\nexport function convertCoreASTToAOT(node: CoreASTNode): ASTNode {\n  if (_converter) return _converter(node);\n  // Should not reach here — factory sets _converter before anything uses it\n  return node as ASTNode;\n}\n\n// =============================================================================\n// FACTORY FUNCTION\n// =============================================================================\n\n/**\n * Create a CoreParserAdapter by dynamically importing @hyperfixi/core.\n * Throws if the package is not available.\n */\nexport async function createCoreParserAdapter(): Promise<CoreParserAdapter> {\n  const core = await import('@hyperfixi/core');\n  // The core package exports `hyperscript` with compileSync\n  const api = core.hyperscript ?? core.default ?? core;\n\n  if (!api?.compileSync) {\n    throw new Error(\n      '@hyperfixi/core does not export compileSync. ' +\n        'Ensure @hyperfixi/core >= 1.0.0 is installed.'\n    );\n  }\n\n  // Use the interchange converter from core\n  const converter = (core as Record<string, unknown>).fromCoreAST as InterchangeConverter;\n  if (!converter) {\n    throw new Error(\n      '@hyperfixi/core does not export fromCoreAST. ' +\n        'Ensure @hyperfixi/core >= 1.3.0 is installed.'\n    );\n  }\n\n  // Cache for standalone convertCoreASTToAOT()\n  _converter = converter;\n\n  return new CoreParserAdapter(api as unknown as CoreHyperscriptAPI, converter);\n}\n"],"mappings":";AA6CO,IAAM,oBAAN,MAAwB;EAI7B,YAAY,KAAyB,WAAiC;AACpE,SAAK,MAAM;AACX,SAAK,YAAY;EACnB;;;;EAKA,MAAM,MAAc,UAA4B;AAC9C,UAAM,SAAS,KAAK,IAAI,YAAY,MAAM;MACxC,UAAU,YAAY;MACtB,aAAa;IACf,CAAC;AAED,QAAI,CAAC,OAAO,MAAM,CAAC,OAAO,KAAK;AAC7B,YAAM,IAAI,MAAM,OAAO,SAAS,CAAC,GAAG,WAAW,2BAA2B,IAAI,EAAE;IAClF;AAEA,WAAO,KAAK,UAAU,OAAO,GAAG;EAClC;AACF;AAUA,IAAI,aAA0C;AAUvC,SAAS,oBAAoB,MAA4B;AAC9D,MAAI,WAAY,QAAO,WAAW,IAAI;AAEtC,SAAO;AACT;AAUA,eAAsB,0BAAsD;AAC1E,QAAM,OAAO,MAAM,OAAO,oBAAiB;AAE3C,QAAM,MAAM,KAAK,eAAe,KAAK,WAAW;AAEhD,MAAI,CAAC,KAAK,aAAa;AACrB,UAAM,IAAI;MACR;IAEF;EACF;AAGA,QAAM,YAAa,KAAiC;AACpD,MAAI,CAAC,WAAW;AACd,UAAM,IAAI;MACR;IAEF;EACF;AAGA,eAAa;AAEb,SAAO,IAAI,kBAAkB,KAAsC,SAAS;AAC9E;","names":[]}