@constela/compiler 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -77,6 +77,8 @@ interface CompiledUpdateStep {
     target: string;
     operation: string;
     value?: CompiledExpression;
+    index?: CompiledExpression;
+    deleteCount?: CompiledExpression;
 }
 interface CompiledFetchStep {
     do: 'fetch';
@@ -112,7 +114,7 @@ interface CompiledEachNode {
     key?: CompiledExpression;
     body: CompiledNode;
 }
-type CompiledExpression = CompiledLitExpr | CompiledStateExpr | CompiledVarExpr | CompiledBinExpr | CompiledNotExpr;
+type CompiledExpression = CompiledLitExpr | CompiledStateExpr | CompiledVarExpr | CompiledBinExpr | CompiledNotExpr | CompiledCondExpr | CompiledGetExpr;
 interface CompiledLitExpr {
     expr: 'lit';
     value: string | number | boolean | null | unknown[];
@@ -136,6 +138,17 @@ interface CompiledNotExpr {
     expr: 'not';
     operand: CompiledExpression;
 }
+interface CompiledCondExpr {
+    expr: 'cond';
+    if: CompiledExpression;
+    then: CompiledExpression;
+    else: CompiledExpression;
+}
+interface CompiledGetExpr {
+    expr: 'get';
+    base: CompiledExpression;
+    path: string;
+}
 interface CompiledEventHandler {
     event: string;
     action: string;
@@ -200,4 +213,4 @@ type ValidatePassResult = ValidatePassSuccess | ValidatePassFailure;
  */
 declare function validatePass(input: unknown): ValidatePassResult;
 
-export { type AnalysisContext, type AnalyzePassFailure, type AnalyzePassResult, type AnalyzePassSuccess, type CompileFailure, type CompileResult, type CompileSuccess, type CompiledAction, type CompiledActionStep, type CompiledEachNode, type CompiledElementNode, type CompiledEventHandler, type CompiledExpression, type CompiledIfNode, type CompiledNode, type CompiledProgram, type CompiledTextNode, type ValidatePassFailure, type ValidatePassResult, type ValidatePassSuccess, analyzePass, compile, transformPass, validatePass };
+export { type AnalysisContext, type AnalyzePassFailure, type AnalyzePassResult, type AnalyzePassSuccess, type CompileFailure, type CompileResult, type CompileSuccess, type CompiledAction, type CompiledActionStep, type CompiledEachNode, type CompiledElementNode, type CompiledEventHandler, type CompiledExpression, type CompiledFetchStep, type CompiledIfNode, type CompiledNode, type CompiledProgram, type CompiledSetStep, type CompiledTextNode, type CompiledUpdateStep, type ValidatePassFailure, type ValidatePassResult, type ValidatePassSuccess, analyzePass, compile, transformPass, validatePass };

package/dist/index.js

@@ -25,6 +25,8 @@ import {
   createComponentCycleError,
   createUndefinedParamError,
   createSchemaError,
+  createOperationInvalidForTypeError,
+  createOperationMissingFieldError,
   isEventHandler
 } from "@constela/core";
 function buildPath(base, ...segments) {
@@ -78,6 +80,14 @@ function validateExpression(expr, path, context, scope, paramScope) {
       break;
     case "lit":
       break;
+    case "cond":
+      errors.push(...validateExpression(expr.if, buildPath(path, "if"), context, scope, paramScope));
+      errors.push(...validateExpression(expr.then, buildPath(path, "then"), context, scope, paramScope));
+      errors.push(...validateExpression(expr.else, buildPath(path, "else"), context, scope, paramScope));
+      break;
+    case "get":
+      errors.push(...validateExpression(expr.base, buildPath(path, "base"), context, scope, paramScope));
+      break;
   }
   return errors;
 }
@@ -92,16 +102,50 @@ function validateActionStep(step, path, context) {
         ...validateExpressionStateOnly(step.value, buildPath(path, "value"), context)
       );
       break;
-    case "update":
+    case "update": {
       if (!context.stateNames.has(step.target)) {
         errors.push(createUndefinedStateError(step.target, buildPath(path, "target")));
+      } else {
+        const stateField = ast.state[step.target];
+        if (stateField) {
+          const stateType = stateField.type;
+          const op = step.operation;
+          if (op === "toggle" && stateType !== "boolean") {
+            errors.push(createOperationInvalidForTypeError(op, stateType, buildPath(path, "operation")));
+          }
+          if (op === "merge" && stateType !== "object") {
+            errors.push(createOperationInvalidForTypeError(op, stateType, buildPath(path, "operation")));
+          }
+          if ((op === "increment" || op === "decrement") && stateType !== "number") {
+            errors.push(createOperationInvalidForTypeError(op, stateType, buildPath(path, "operation")));
+          }
+          if ((op === "push" || op === "pop" || op === "remove" || op === "replaceAt" || op === "insertAt" || op === "splice") && stateType !== "list") {
+            errors.push(createOperationInvalidForTypeError(op, stateType, buildPath(path, "operation")));
+          }
+          if (op === "merge" && !step.value) {
+            errors.push(createOperationMissingFieldError(op, "value", path));
+          }
+          if ((op === "replaceAt" || op === "insertAt") && (!step.index || !step.value)) {
+            if (!step.index) errors.push(createOperationMissingFieldError(op, "index", path));
+            if (!step.value) errors.push(createOperationMissingFieldError(op, "value", path));
+          }
+          if (op === "splice" && (!step.index || !step.deleteCount)) {
+            if (!step.index) errors.push(createOperationMissingFieldError(op, "index", path));
+            if (!step.deleteCount) errors.push(createOperationMissingFieldError(op, "deleteCount", path));
+          }
+        }
       }
       if (step.value) {
-        errors.push(
-          ...validateExpressionStateOnly(step.value, buildPath(path, "value"), context)
-        );
+        errors.push(...validateExpressionStateOnly(step.value, buildPath(path, "value"), context));
+      }
+      if (step.index) {
+        errors.push(...validateExpressionStateOnly(step.index, buildPath(path, "index"), context));
+      }
+      if (step.deleteCount) {
+        errors.push(...validateExpressionStateOnly(step.deleteCount, buildPath(path, "deleteCount"), context));
       }
       break;
+    }
     case "fetch":
       errors.push(
         ...validateExpressionStateOnly(step.url, buildPath(path, "url"), context)
@@ -154,6 +198,14 @@ function validateExpressionStateOnly(expr, path, context) {
       break;
     case "lit":
       break;
+    case "cond":
+      errors.push(...validateExpressionStateOnly(expr.if, buildPath(path, "if"), context));
+      errors.push(...validateExpressionStateOnly(expr.then, buildPath(path, "then"), context));
+      errors.push(...validateExpressionStateOnly(expr.else, buildPath(path, "else"), context));
+      break;
+    case "get":
+      errors.push(...validateExpressionStateOnly(expr.base, buildPath(path, "base"), context));
+      break;
   }
   return errors;
 }
@@ -187,6 +239,22 @@ function validateExpressionInEventPayload(expr, path, context, scope) {
       break;
     case "lit":
       break;
+    case "cond":
+      errors.push(
+        ...validateExpressionInEventPayload(expr.if, buildPath(path, "if"), context, scope)
+      );
+      errors.push(
+        ...validateExpressionInEventPayload(expr.then, buildPath(path, "then"), context, scope)
+      );
+      errors.push(
+        ...validateExpressionInEventPayload(expr.else, buildPath(path, "else"), context, scope)
+      );
+      break;
+    case "get":
+      errors.push(
+        ...validateExpressionInEventPayload(expr.base, buildPath(path, "base"), context, scope)
+      );
+      break;
   }
   return errors;
 }
@@ -507,6 +575,19 @@ function transformExpression(expr, ctx) {
       }
       return { expr: "lit", value: null };
     }
+    case "cond":
+      return {
+        expr: "cond",
+        if: transformExpression(expr.if, ctx),
+        then: transformExpression(expr.then, ctx),
+        else: transformExpression(expr.else, ctx)
+      };
+    case "get":
+      return {
+        expr: "get",
+        base: transformExpression(expr.base, ctx),
+        path: expr.path
+      };
   }
 }
 function transformEventHandler(handler, ctx) {
@@ -537,6 +618,12 @@ function transformActionStep(step) {
       if (step.value) {
         updateStep.value = transformExpression(step.value, emptyContext);
       }
+      if (step.index) {
+        updateStep.index = transformExpression(step.index, emptyContext);
+      }
+      if (step.deleteCount) {
+        updateStep.deleteCount = transformExpression(step.deleteCount, emptyContext);
+      }
       return updateStep;
     }
     case "fetch": {

package/package.json

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