@constela/compiler 0.5.0 → 0.6.0

package/dist/index.d.ts

@@ -19,6 +19,7 @@ interface AnalysisContext {
     routeParams: Set<string>;
     importNames: Set<string>;
     dataNames: Set<string>;
+    refNames: Set<string>;
 }
 interface AnalyzePassSuccess {
     ok: true;
@@ -86,7 +87,7 @@ interface CompiledAction {
     name: string;
     steps: CompiledActionStep[];
 }
-type CompiledActionStep = CompiledSetStep | CompiledUpdateStep | CompiledFetchStep | CompiledStorageStep | CompiledClipboardStep | CompiledNavigateStep;
+type CompiledActionStep = CompiledSetStep | CompiledUpdateStep | CompiledFetchStep | CompiledStorageStep | CompiledClipboardStep | CompiledNavigateStep | CompiledImportStep | CompiledCallStep | CompiledSubscribeStep | CompiledDisposeStep;
 interface CompiledSetStep {
     do: 'set';
     target: string;
@@ -133,10 +134,55 @@ interface CompiledNavigateStep {
     target?: '_self' | '_blank';
     replace?: boolean;
 }
+/**
+ * Compiled ref expression
+ */
+interface CompiledRefExpr {
+    expr: 'ref';
+    name: string;
+}
+/**
+ * Compiled import step
+ */
+interface CompiledImportStep {
+    do: 'import';
+    module: string;
+    result: string;
+    onSuccess?: CompiledActionStep[];
+    onError?: CompiledActionStep[];
+}
+/**
+ * Compiled call step
+ */
+interface CompiledCallStep {
+    do: 'call';
+    target: CompiledExpression;
+    args?: CompiledExpression[];
+    result?: string;
+    onSuccess?: CompiledActionStep[];
+    onError?: CompiledActionStep[];
+}
+/**
+ * Compiled subscribe step
+ */
+interface CompiledSubscribeStep {
+    do: 'subscribe';
+    target: CompiledExpression;
+    event: string;
+    action: string;
+}
+/**
+ * Compiled dispose step
+ */
+interface CompiledDisposeStep {
+    do: 'dispose';
+    target: CompiledExpression;
+}
 type CompiledNode = CompiledElementNode | CompiledTextNode | CompiledIfNode | CompiledEachNode | CompiledMarkdownNode | CompiledCodeNode;
 interface CompiledElementNode {
     kind: 'element';
     tag: string;
+    ref?: string;
     props?: Record<string, CompiledExpression | CompiledEventHandler>;
     children?: CompiledNode[];
 }
@@ -167,7 +213,7 @@ interface CompiledCodeNode {
     language: CompiledExpression;
     content: CompiledExpression;
 }
-type CompiledExpression = CompiledLitExpr | CompiledStateExpr | CompiledVarExpr | CompiledBinExpr | CompiledNotExpr | CompiledCondExpr | CompiledGetExpr | CompiledRouteExpr | CompiledImportExpr;
+type CompiledExpression = CompiledLitExpr | CompiledStateExpr | CompiledVarExpr | CompiledBinExpr | CompiledNotExpr | CompiledCondExpr | CompiledGetExpr | CompiledRouteExpr | CompiledImportExpr | CompiledRefExpr;
 interface CompiledLitExpr {
     expr: 'lit';
     value: string | number | boolean | null | unknown[];
@@ -344,4 +390,4 @@ declare function transformLayoutPass(layout: LayoutProgram, _context: LayoutAnal
  */
 declare function composeLayoutWithPage(layout: CompiledProgram, page: CompiledProgram, 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 CompiledClipboardStep, type CompiledCodeNode, type CompiledEachNode, type CompiledElementNode, type CompiledEventHandler, type CompiledExpression, type CompiledFetchStep, type CompiledIfNode, type CompiledImportExpr, type CompiledLayoutProgram, type CompiledLifecycleHooks, type CompiledMarkdownNode, type CompiledNavigateStep, type CompiledNode, type CompiledProgram, type CompiledRouteDefinition, type CompiledRouteExpr, type CompiledSetStep, type CompiledStorageStep, type CompiledTextNode, type CompiledUpdateStep, 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 CompiledCallStep, type CompiledClipboardStep, type CompiledCodeNode, type CompiledDisposeStep, type CompiledEachNode, type CompiledElementNode, type CompiledEventHandler, type CompiledExpression, type CompiledFetchStep, type CompiledIfNode, type CompiledImportExpr, type CompiledImportStep, type CompiledLayoutProgram, type CompiledLifecycleHooks, type CompiledMarkdownNode, type CompiledNavigateStep, type CompiledNode, type CompiledProgram, type CompiledRefExpr, type CompiledRouteDefinition, type CompiledRouteExpr, type CompiledSetStep, type CompiledStorageStep, type CompiledSubscribeStep, type CompiledTextNode, type CompiledUpdateStep, 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

@@ -41,6 +41,7 @@ import {
   createInvalidClipboardOperationError,
   createClipboardWriteMissingValueError,
   createInvalidNavigateTargetError,
+  createUndefinedRefError,
   isEventHandler,
   DATA_SOURCE_TYPES,
   DATA_TRANSFORMS,
@@ -62,22 +63,68 @@ function extractRouteParams(path) {
   }
   return params;
 }
-function collectContext(ast2) {
-  const stateNames = new Set(Object.keys(ast2.state));
-  const actionNames = new Set(ast2.actions.map((a) => a.name));
+function collectRefs(node) {
+  const refs = /* @__PURE__ */ new Set();
+  switch (node.kind) {
+    case "element":
+      if (node.ref) {
+        refs.add(node.ref);
+      }
+      if (node.children) {
+        for (const child of node.children) {
+          for (const ref of collectRefs(child)) {
+            refs.add(ref);
+          }
+        }
+      }
+      break;
+    case "if":
+      for (const ref of collectRefs(node.then)) {
+        refs.add(ref);
+      }
+      if (node.else) {
+        for (const ref of collectRefs(node.else)) {
+          refs.add(ref);
+        }
+      }
+      break;
+    case "each":
+      for (const ref of collectRefs(node.body)) {
+        refs.add(ref);
+      }
+      break;
+    case "component":
+      if (node.children) {
+        for (const child of node.children) {
+          for (const ref of collectRefs(child)) {
+            refs.add(ref);
+          }
+        }
+      }
+      break;
+    case "text":
+    case "slot":
+      break;
+  }
+  return refs;
+}
+function collectContext(programAst) {
+  const stateNames = new Set(Object.keys(programAst.state));
+  const actionNames = new Set(programAst.actions.map((a) => a.name));
   const componentNames = new Set(
-    ast2.components ? Object.keys(ast2.components) : []
+    programAst.components ? Object.keys(programAst.components) : []
   );
   const routeParams = new Set(
-    ast2.route ? extractRouteParams(ast2.route.path) : []
+    programAst.route ? extractRouteParams(programAst.route.path) : []
   );
   const importNames = new Set(
-    ast2.imports ? Object.keys(ast2.imports) : []
+    programAst.imports ? Object.keys(programAst.imports) : []
   );
   const dataNames = new Set(
-    ast2.data ? Object.keys(ast2.data) : []
+    programAst.data ? Object.keys(programAst.data) : []
   );
-  return { stateNames, actionNames, componentNames, routeParams, importNames, dataNames };
+  const refNames = collectRefs(programAst.view);
+  return { stateNames, actionNames, componentNames, routeParams, importNames, dataNames, refNames };
 }
 function checkDuplicateActions(ast2) {
   const errors = [];
@@ -137,6 +184,12 @@ function validateExpression(expr, path, context, scope, paramScope) {
       }
       break;
     }
+    case "ref": {
+      if (!context.refNames.has(expr.name)) {
+        errors.push(createUndefinedRefError(expr.name, path));
+      }
+      break;
+    }
     case "bin":
       errors.push(...validateExpression(expr.left, buildPath(path, "left"), context, scope, paramScope));
       errors.push(...validateExpression(expr.right, buildPath(path, "right"), context, scope, paramScope));
@@ -322,6 +375,79 @@ function validateActionStep(step, path, context) {
       }
       break;
     }
+    case "import": {
+      const importStep = step;
+      if (importStep.onSuccess) {
+        for (let i = 0; i < importStep.onSuccess.length; i++) {
+          const successStep = importStep.onSuccess[i];
+          if (successStep === void 0) continue;
+          errors.push(
+            ...validateActionStep(successStep, buildPath(path, "onSuccess", i), context)
+          );
+        }
+      }
+      if (importStep.onError) {
+        for (let i = 0; i < importStep.onError.length; i++) {
+          const errorStep = importStep.onError[i];
+          if (errorStep === void 0) continue;
+          errors.push(
+            ...validateActionStep(errorStep, buildPath(path, "onError", i), context)
+          );
+        }
+      }
+      break;
+    }
+    case "call": {
+      const callStep = step;
+      errors.push(
+        ...validateExpressionStateOnly(callStep.target, buildPath(path, "target"), context)
+      );
+      if (callStep.args) {
+        for (let i = 0; i < callStep.args.length; i++) {
+          const arg = callStep.args[i];
+          if (arg === void 0) continue;
+          errors.push(
+            ...validateExpressionStateOnly(arg, buildPath(path, "args", i), context)
+          );
+        }
+      }
+      if (callStep.onSuccess) {
+        for (let i = 0; i < callStep.onSuccess.length; i++) {
+          const successStep = callStep.onSuccess[i];
+          if (successStep === void 0) continue;
+          errors.push(
+            ...validateActionStep(successStep, buildPath(path, "onSuccess", i), context)
+          );
+        }
+      }
+      if (callStep.onError) {
+        for (let i = 0; i < callStep.onError.length; i++) {
+          const errorStep = callStep.onError[i];
+          if (errorStep === void 0) continue;
+          errors.push(
+            ...validateActionStep(errorStep, buildPath(path, "onError", i), context)
+          );
+        }
+      }
+      break;
+    }
+    case "subscribe": {
+      const subscribeStep = step;
+      errors.push(
+        ...validateExpressionStateOnly(subscribeStep.target, buildPath(path, "target"), context)
+      );
+      if (!context.actionNames.has(subscribeStep.action)) {
+        errors.push(createUndefinedActionError(subscribeStep.action, buildPath(path, "action")));
+      }
+      break;
+    }
+    case "dispose": {
+      const disposeStep = step;
+      errors.push(
+        ...validateExpressionStateOnly(disposeStep.target, buildPath(path, "target"), context)
+      );
+      break;
+    }
   }
   return errors;
 }
@@ -362,6 +488,12 @@ function validateExpressionStateOnly(expr, path, context) {
       }
       break;
     }
+    case "ref": {
+      if (!context.refNames.has(expr.name)) {
+        errors.push(createUndefinedRefError(expr.name, path));
+      }
+      break;
+    }
     case "bin":
       errors.push(...validateExpressionStateOnly(expr.left, buildPath(path, "left"), context));
       errors.push(...validateExpressionStateOnly(expr.right, buildPath(path, "right"), context));
@@ -421,6 +553,12 @@ function validateExpressionInEventPayload(expr, path, context, scope) {
       }
       break;
     }
+    case "ref": {
+      if (!context.refNames.has(expr.name)) {
+        errors.push(createUndefinedRefError(expr.name, path));
+      }
+      break;
+    }
     case "bin":
       errors.push(
         ...validateExpressionInEventPayload(expr.left, buildPath(path, "left"), context, scope)
@@ -912,6 +1050,8 @@ function transformExpression(expr, ctx) {
       }
       return dataExpr;
     }
+    case "ref":
+      return { expr: "ref", name: expr.name };
   }
 }
 function transformEventHandler(handler, ctx) {
@@ -1028,6 +1168,57 @@ function transformActionStep(step) {
       }
       return compiledNavigateStep;
     }
+    case "import": {
+      const importStep = step;
+      const compiledImportStep = {
+        do: "import",
+        module: importStep.module,
+        result: importStep.result
+      };
+      if (importStep.onSuccess) {
+        compiledImportStep.onSuccess = importStep.onSuccess.map(transformActionStep);
+      }
+      if (importStep.onError) {
+        compiledImportStep.onError = importStep.onError.map(transformActionStep);
+      }
+      return compiledImportStep;
+    }
+    case "call": {
+      const callStep = step;
+      const compiledCallStep = {
+        do: "call",
+        target: transformExpression(callStep.target, emptyContext)
+      };
+      if (callStep.args) {
+        compiledCallStep.args = callStep.args.map((arg) => transformExpression(arg, emptyContext));
+      }
+      if (callStep.result) {
+        compiledCallStep.result = callStep.result;
+      }
+      if (callStep.onSuccess) {
+        compiledCallStep.onSuccess = callStep.onSuccess.map(transformActionStep);
+      }
+      if (callStep.onError) {
+        compiledCallStep.onError = callStep.onError.map(transformActionStep);
+      }
+      return compiledCallStep;
+    }
+    case "subscribe": {
+      const subscribeStep = step;
+      return {
+        do: "subscribe",
+        target: transformExpression(subscribeStep.target, emptyContext),
+        event: subscribeStep.event,
+        action: subscribeStep.action
+      };
+    }
+    case "dispose": {
+      const disposeStep = step;
+      return {
+        do: "dispose",
+        target: transformExpression(disposeStep.target, emptyContext)
+      };
+    }
   }
 }
 function flattenSlotChildren(children, ctx) {
@@ -1050,6 +1241,9 @@ function transformViewNode(node, ctx) {
         kind: "element",
         tag: node.tag
       };
+      if (node.ref) {
+        compiledElement.ref = node.ref;
+      }
       if (node.props) {
         compiledElement.props = {};
         for (const [propName, propValue] of Object.entries(node.props)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/compiler",
-  "version": "0.5.0",
+  "version": "0.6.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.5.0"
+    "@constela/core": "0.6.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",