@constela/compiler 0.14.6 → 0.15.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Program, ConstelaError, Expression, LayoutProgram, ComponentDef, ViewNode } from '@constela/core';
+import { Program, ConstelaError, Expression, IslandStrategy, IslandStrategyOptions, LayoutProgram, ComponentDef, ViewNode } from '@constela/core';
 export { createUndefinedVarError } from '@constela/core';
 
 /**
@@ -21,6 +21,7 @@ interface AnalysisContext {
     dataNames: Set<string>;
     refNames: Set<string>;
     styleNames: Set<string>;
+    islandIds: Set<string>;
 }
 interface AnalyzePassSuccess {
     ok: true;
@@ -102,7 +103,7 @@ interface CompiledAction {
     name: string;
     steps: CompiledActionStep[];
 }
-type CompiledActionStep = CompiledSetStep | CompiledUpdateStep | CompiledSetPathStep | CompiledFetchStep | CompiledStorageStep | CompiledClipboardStep | CompiledNavigateStep | CompiledImportStep | CompiledCallStep | CompiledSubscribeStep | CompiledDisposeStep | CompiledDomStep | CompiledIfStep | CompiledSendStep | CompiledCloseStep | CompiledDelayStep | CompiledIntervalStep | CompiledClearTimerStep | CompiledFocusStep;
+type CompiledActionStep = CompiledSetStep | CompiledUpdateStep | CompiledSetPathStep | CompiledFetchStep | CompiledStorageStep | CompiledClipboardStep | CompiledNavigateStep | CompiledImportStep | CompiledCallStep | CompiledSubscribeStep | CompiledDisposeStep | CompiledDomStep | CompiledIfStep | CompiledSendStep | CompiledCloseStep | CompiledDelayStep | CompiledIntervalStep | CompiledClearTimerStep | CompiledFocusStep | CompiledGenerateStep | CompiledSSEConnectStep | CompiledSSECloseStep | CompiledOptimisticStep | CompiledConfirmStep | CompiledRejectStep | CompiledBindStep | CompiledUnbindStep;
 interface CompiledSetStep {
     do: 'set';
     target: string;
@@ -265,6 +266,90 @@ interface CompiledFocusStep {
     onSuccess?: CompiledActionStep[];
     onError?: CompiledActionStep[];
 }
+/**
+ * Compiled generate step for AI generation
+ */
+interface CompiledGenerateStep {
+    do: 'generate';
+    provider: 'anthropic' | 'openai';
+    prompt: CompiledExpression;
+    output: 'component' | 'view';
+    result: string;
+    model?: string;
+    onSuccess?: CompiledActionStep[];
+    onError?: CompiledActionStep[];
+}
+/**
+ * Compiled SSE connect step
+ */
+interface CompiledSSEConnectStep {
+    do: 'sseConnect';
+    connection: string;
+    url: CompiledExpression;
+    eventTypes?: string[];
+    reconnect?: {
+        enabled: boolean;
+        strategy: string;
+        maxRetries: number;
+        baseDelay: number;
+        maxDelay?: number;
+    };
+    onOpen?: CompiledActionStep[];
+    onMessage?: CompiledActionStep[];
+    onError?: CompiledActionStep[];
+}
+/**
+ * Compiled SSE close step
+ */
+interface CompiledSSECloseStep {
+    do: 'sseClose';
+    connection: string;
+}
+/**
+ * Compiled optimistic step
+ */
+interface CompiledOptimisticStep {
+    do: 'optimistic';
+    target: string;
+    path?: CompiledExpression;
+    value: CompiledExpression;
+    result?: string;
+    timeout?: number;
+}
+/**
+ * Compiled confirm step
+ */
+interface CompiledConfirmStep {
+    do: 'confirm';
+    id: CompiledExpression;
+}
+/**
+ * Compiled reject step
+ */
+interface CompiledRejectStep {
+    do: 'reject';
+    id: CompiledExpression;
+}
+/**
+ * Compiled bind step
+ */
+interface CompiledBindStep {
+    do: 'bind';
+    connection: string;
+    eventType?: string;
+    target: string;
+    path?: CompiledExpression;
+    transform?: CompiledExpression;
+    patch?: boolean;
+}
+/**
+ * Compiled unbind step
+ */
+interface CompiledUnbindStep {
+    do: 'unbind';
+    connection: string;
+    target: string;
+}
 /**
  * Compiled local action
  */
@@ -284,7 +369,39 @@ interface CompiledLocalStateNode {
     actions: Record<string, CompiledLocalAction>;
     child: CompiledNode;
 }
-type CompiledNode = CompiledElementNode | CompiledTextNode | CompiledIfNode | CompiledEachNode | CompiledMarkdownNode | CompiledCodeNode | CompiledSlotNode | CompiledPortalNode | CompiledLocalStateNode;
+/**
+ * Compiled island node - represents an interactive island in the Islands Architecture
+ */
+interface CompiledIslandNode {
+    kind: 'island';
+    id: string;
+    strategy: IslandStrategy;
+    strategyOptions?: IslandStrategyOptions;
+    content: CompiledNode;
+    state?: Record<string, {
+        type: string;
+        initial: unknown;
+    }>;
+    actions?: Record<string, CompiledAction>;
+}
+/**
+ * Compiled suspense node - represents an async boundary with fallback
+ */
+interface CompiledSuspenseNode {
+    kind: 'suspense';
+    id: string;
+    fallback: CompiledNode;
+    content: CompiledNode;
+}
+/**
+ * Compiled error boundary node - represents an error handling boundary
+ */
+interface CompiledErrorBoundaryNode {
+    kind: 'errorBoundary';
+    fallback: CompiledNode;
+    content: CompiledNode;
+}
+type CompiledNode = CompiledElementNode | CompiledTextNode | CompiledIfNode | CompiledEachNode | CompiledMarkdownNode | CompiledCodeNode | CompiledSlotNode | CompiledPortalNode | CompiledLocalStateNode | CompiledIslandNode | CompiledSuspenseNode | CompiledErrorBoundaryNode;
 interface CompiledElementNode {
     kind: 'element';
     tag: string;
@@ -563,4 +680,4 @@ declare function transformLayoutPass(layout: LayoutProgram, _context: LayoutAnal
  */
 declare function composeLayoutWithPage(layout: CompiledProgram, page: CompiledProgram, layoutParams?: Record<string, Expression>, slots?: Record<string, ViewNode>): CompiledProgram;
 
-export { type AnalysisContext, type AnalyzePassFailure, type AnalyzePassResult, type AnalyzePassSuccess, type CompileFailure, type CompileResult, type CompileSuccess, type CompiledAction, type CompiledActionStep, type CompiledArrayExpr, type CompiledBinExpr, type CompiledCallExpr, type CompiledCallStep, type CompiledClearTimerStep, type CompiledClipboardStep, type CompiledCloseStep, type CompiledCodeNode, type CompiledConcatExpr, type CompiledCondExpr, type CompiledDataExpr, type CompiledDelayStep, type CompiledDisposeStep, type CompiledDomStep, type CompiledEachNode, type CompiledElementNode, type CompiledEventHandler, type CompiledEventHandlerOptions, type CompiledExpression, type CompiledFetchStep, type CompiledFocusStep, type CompiledGetExpr, type CompiledIfNode, type CompiledIfStep, type CompiledImportExpr, type CompiledImportStep, type CompiledIndexExpr, type CompiledIntervalStep, type CompiledLambdaExpr, type CompiledLayoutProgram, type CompiledLifecycleHooks, type CompiledLitExpr, type CompiledLocalAction, type CompiledLocalStateNode, type CompiledMarkdownNode, type CompiledNavigateStep, type CompiledNode, type CompiledNotExpr, type CompiledParamExpr, type CompiledPortalNode, type CompiledProgram, type CompiledRefExpr, type CompiledRouteDefinition, type CompiledRouteExpr, type CompiledSendStep, type CompiledSetPathStep, type CompiledSetStep, type CompiledSlotNode, type CompiledStateExpr, type CompiledStorageStep, type CompiledStyleExpr, type CompiledSubscribeStep, type CompiledTextNode, type CompiledUpdateStep, type CompiledValidityExpr, type CompiledVarExpr, type LayoutAnalysisContext, type LayoutAnalysisFailure, type LayoutAnalysisResult, type LayoutAnalysisSuccess, type ValidatePassFailure, type ValidatePassResult, type ValidatePassSuccess, analyzeLayoutPass, analyzePass, compile, composeLayoutWithPage, transformLayoutPass, transformPass, validatePass };
+export { type AnalysisContext, type AnalyzePassFailure, type AnalyzePassResult, type AnalyzePassSuccess, type CompileFailure, type CompileResult, type CompileSuccess, type CompiledAction, type CompiledActionStep, type CompiledArrayExpr, type CompiledBinExpr, type CompiledBindStep, type CompiledCallExpr, type CompiledCallStep, type CompiledClearTimerStep, type CompiledClipboardStep, type CompiledCloseStep, type CompiledCodeNode, type CompiledConcatExpr, type CompiledCondExpr, type CompiledConfirmStep, type CompiledDataExpr, type CompiledDelayStep, type CompiledDisposeStep, type CompiledDomStep, type CompiledEachNode, type CompiledElementNode, type CompiledErrorBoundaryNode, type CompiledEventHandler, type CompiledEventHandlerOptions, type CompiledExpression, type CompiledFetchStep, type CompiledFocusStep, type CompiledGenerateStep, type CompiledGetExpr, type CompiledIfNode, type CompiledIfStep, type CompiledImportExpr, type CompiledImportStep, type CompiledIndexExpr, type CompiledIntervalStep, type CompiledIslandNode, type CompiledLambdaExpr, type CompiledLayoutProgram, type CompiledLifecycleHooks, type CompiledLitExpr, type CompiledLocalAction, type CompiledLocalStateNode, type CompiledMarkdownNode, type CompiledNavigateStep, type CompiledNode, type CompiledNotExpr, type CompiledOptimisticStep, type CompiledParamExpr, type CompiledPortalNode, type CompiledProgram, type CompiledRefExpr, type CompiledRejectStep, type CompiledRouteDefinition, type CompiledRouteExpr, type CompiledSSECloseStep, type CompiledSSEConnectStep, type CompiledSendStep, type CompiledSetPathStep, type CompiledSetStep, type CompiledSlotNode, type CompiledStateExpr, type CompiledStorageStep, type CompiledStyleExpr, type CompiledSubscribeStep, type CompiledSuspenseNode, type CompiledTextNode, type CompiledUnbindStep, type CompiledUpdateStep, type CompiledValidityExpr, type CompiledVarExpr, type LayoutAnalysisContext, type LayoutAnalysisFailure, type LayoutAnalysisResult, type LayoutAnalysisSuccess, type ValidatePassFailure, type ValidatePassResult, type ValidatePassSuccess, analyzeLayoutPass, analyzePass, compile, composeLayoutWithPage, transformLayoutPass, transformPass, validatePass };

package/dist/index.js

@@ -46,6 +46,7 @@ import {
   createUndefinedVariantError,
   createUndefinedLocalStateError,
   createLocalActionInvalidStepError,
+  createDuplicateIslandIdError,
   findSimilarNames,
   isEventHandler,
   DATA_SOURCE_TYPES,
@@ -141,7 +142,8 @@ function collectContext(programAst) {
   const styleNames = new Set(
     programAst.styles ? Object.keys(programAst.styles) : []
   );
-  return { stateNames, actionNames, componentNames, routeParams, importNames, dataNames, refNames, styleNames };
+  const islandIds = /* @__PURE__ */ new Set();
+  return { stateNames, actionNames, componentNames, routeParams, importNames, dataNames, refNames, styleNames, islandIds };
 }
 function checkDuplicateActions(ast2) {
   const errors = [];
@@ -911,6 +913,57 @@ function validateViewNode(node, path, context, scope, options = { insideComponen
         );
       }
       break;
+    case "island": {
+      if (context.islandIds.has(node.id)) {
+        errors.push(createDuplicateIslandIdError(node.id, path));
+      } else {
+        context.islandIds.add(node.id);
+      }
+      const islandStateNames = new Set(
+        node.state ? Object.keys(node.state) : []
+      );
+      const islandActionNames = new Set(
+        node.actions ? node.actions.map((a) => a.name) : []
+      );
+      const islandParamScope = {
+        params: /* @__PURE__ */ new Set(),
+        componentName: `island:${node.id}`,
+        localStateNames: islandStateNames,
+        localActionNames: islandActionNames
+      };
+      errors.push(
+        ...validateViewNode(
+          node.content,
+          buildPath(path, "content"),
+          context,
+          scope,
+          { ...options, paramScope: islandParamScope }
+        )
+      );
+      if (node.actions) {
+        for (let i = 0; i < node.actions.length; i++) {
+          const action = node.actions[i];
+          if (!action) continue;
+          for (let j = 0; j < action.steps.length; j++) {
+            const step = action.steps[j];
+            if (!step) continue;
+            if (step.do === "set" || step.do === "update" || step.do === "setPath") {
+              const target = step.target;
+              if (!islandStateNames.has(target) && !context.stateNames.has(target)) {
+                errors.push(
+                  createUndefinedStateError(
+                    target,
+                    buildPath(path, "actions", i, "steps", j, "target"),
+                    createErrorOptionsWithSuggestion(target, /* @__PURE__ */ new Set([...islandStateNames, ...context.stateNames]))
+                  )
+                );
+              }
+            }
+          }
+        }
+      }
+      break;
+    }
   }
   return errors;
 }
@@ -1667,6 +1720,82 @@ function transformActionStep(step) {
       }
       return compiledIfStep;
     }
+    case "generate": {
+      const generateStep = step;
+      const compiledGenerateStep = {
+        do: "generate",
+        provider: generateStep.provider,
+        prompt: transformExpression(generateStep.prompt, emptyContext),
+        output: generateStep.output,
+        result: generateStep.result
+      };
+      if (generateStep.model) {
+        compiledGenerateStep.model = generateStep.model;
+      }
+      if (generateStep.onSuccess) {
+        compiledGenerateStep.onSuccess = generateStep.onSuccess.map(transformActionStep);
+      }
+      if (generateStep.onError) {
+        compiledGenerateStep.onError = generateStep.onError.map(transformActionStep);
+      }
+      return compiledGenerateStep;
+    }
+    // ==================== Realtime Steps ====================
+    case "sseConnect": {
+      const sseStep = step;
+      const compiled = {
+        do: "sseConnect",
+        connection: sseStep.connection,
+        url: transformExpression(sseStep.url, emptyContext)
+      };
+      if (sseStep.eventTypes) compiled.eventTypes = sseStep.eventTypes;
+      if (sseStep.reconnect) compiled.reconnect = sseStep.reconnect;
+      if (sseStep.onOpen) compiled.onOpen = sseStep.onOpen.map(transformActionStep);
+      if (sseStep.onMessage) compiled.onMessage = sseStep.onMessage.map(transformActionStep);
+      if (sseStep.onError) compiled.onError = sseStep.onError.map(transformActionStep);
+      return compiled;
+    }
+    case "sseClose": {
+      const sseCloseStep = step;
+      return { do: "sseClose", connection: sseCloseStep.connection };
+    }
+    case "optimistic": {
+      const optStep = step;
+      const compiled = {
+        do: "optimistic",
+        target: optStep.target,
+        value: transformExpression(optStep.value, emptyContext)
+      };
+      if (optStep.path) compiled.path = transformExpression(optStep.path, emptyContext);
+      if (optStep.result) compiled.result = optStep.result;
+      if (optStep.timeout) compiled.timeout = optStep.timeout;
+      return compiled;
+    }
+    case "confirm": {
+      const confirmStep = step;
+      return { do: "confirm", id: transformExpression(confirmStep.id, emptyContext) };
+    }
+    case "reject": {
+      const rejectStep = step;
+      return { do: "reject", id: transformExpression(rejectStep.id, emptyContext) };
+    }
+    case "bind": {
+      const bindStep = step;
+      const compiled = {
+        do: "bind",
+        connection: bindStep.connection,
+        target: bindStep.target
+      };
+      if (bindStep.eventType) compiled.eventType = bindStep.eventType;
+      if (bindStep.path) compiled.path = transformExpression(bindStep.path, emptyContext);
+      if (bindStep.transform) compiled.transform = transformExpression(bindStep.transform, emptyContext);
+      if (bindStep.patch) compiled.patch = bindStep.patch;
+      return compiled;
+    }
+    case "unbind": {
+      const unbindStep = step;
+      return { do: "unbind", connection: unbindStep.connection, target: unbindStep.target };
+    }
   }
 }
 function flattenSlotChildren(children, ctx) {
@@ -1811,6 +1940,46 @@ function transformViewNode(node, ctx) {
         children: compiledChildren
       };
     }
+    case "island": {
+      const islandNode = node;
+      const compiledIsland = {
+        kind: "island",
+        id: islandNode.id,
+        strategy: islandNode.strategy,
+        content: transformViewNode(islandNode.content, ctx)
+      };
+      if (islandNode.strategyOptions) {
+        compiledIsland.strategyOptions = islandNode.strategyOptions;
+      }
+      if (islandNode.state) {
+        compiledIsland.state = transformState(islandNode.state);
+      }
+      if (islandNode.actions && islandNode.actions.length > 0) {
+        compiledIsland.actions = transformActions(islandNode.actions);
+      }
+      return compiledIsland;
+    }
+    case "suspense": {
+      const suspenseNode = node;
+      return {
+        kind: "suspense",
+        id: suspenseNode.id,
+        fallback: transformViewNode(suspenseNode.fallback, ctx),
+        content: transformViewNode(suspenseNode.content, ctx)
+      };
+    }
+    case "errorBoundary": {
+      const errorBoundaryNode = node;
+      return {
+        kind: "errorBoundary",
+        fallback: transformViewNode(errorBoundaryNode.fallback, ctx),
+        content: transformViewNode(errorBoundaryNode.content, ctx)
+      };
+    }
+    default: {
+      const _exhaustiveCheck = node;
+      throw new Error(`Unknown node kind: ${JSON.stringify(_exhaustiveCheck)}`);
+    }
   }
 }
 function transformState(state) {
@@ -2652,6 +2821,52 @@ function transformViewNode2(node, ctx) {
           (child) => transformViewNode2(child, ctx)
         )
       };
+    case "island": {
+      const islandNode = node;
+      const compiledIsland = {
+        kind: "island",
+        id: islandNode.id,
+        strategy: islandNode.strategy,
+        content: transformViewNode2(islandNode.content, ctx)
+      };
+      if (islandNode.strategyOptions) {
+        compiledIsland.strategyOptions = islandNode.strategyOptions;
+      }
+      if (islandNode.state) {
+        compiledIsland.state = transformLocalState2(islandNode.state);
+      }
+      if (islandNode.actions && islandNode.actions.length > 0) {
+        compiledIsland.actions = {};
+        for (const action of islandNode.actions) {
+          compiledIsland.actions[action.name] = {
+            name: action.name,
+            steps: action.steps.map((s) => transformActionStep2(s))
+          };
+        }
+      }
+      return compiledIsland;
+    }
+    case "suspense": {
+      const suspenseNode = node;
+      return {
+        kind: "suspense",
+        id: suspenseNode.id,
+        fallback: transformViewNode2(suspenseNode.fallback, ctx),
+        content: transformViewNode2(suspenseNode.content, ctx)
+      };
+    }
+    case "errorBoundary": {
+      const errorBoundaryNode = node;
+      return {
+        kind: "errorBoundary",
+        fallback: transformViewNode2(errorBoundaryNode.fallback, ctx),
+        content: transformViewNode2(errorBoundaryNode.content, ctx)
+      };
+    }
+    default: {
+      const _exhaustiveCheck = node;
+      throw new Error(`Unknown node kind: ${JSON.stringify(_exhaustiveCheck)}`);
+    }
   }
 }
 function transformLayoutPass(layout, _context) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/compiler",
-  "version": "0.14.6",
+  "version": "0.15.0",
   "description": "Compiler for Constela UI framework - AST to Program transformation",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,7 +15,7 @@
     "dist"
   ],
   "dependencies": {
-    "@constela/core": "0.16.1"
+    "@constela/core": "0.17.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",