@constela/runtime 0.8.0 → 0.9.1

package/dist/index.d.ts

@@ -56,6 +56,7 @@ interface EvaluationContext {
         path: string;
     };
     imports?: Record<string, unknown>;
+    refs?: Record<string, Element>;
 }
 declare function evaluate(expr: CompiledExpression, ctx: EvaluationContext): unknown;
 
@@ -76,6 +77,8 @@ interface ActionContext {
     actions: Record<string, CompiledAction>;
     locals: Record<string, unknown>;
     eventPayload?: unknown;
+    refs?: Record<string, Element>;
+    subscriptions?: (() => void)[];
 }
 declare function executeAction(action: CompiledAction, ctx: ActionContext): Promise<void>;
 

package/dist/index.js

@@ -193,6 +193,8 @@ function evaluate(expr, ctx) {
       }
       return importData;
     }
+    case "ref":
+      return ctx.refs?.[expr.name] ?? null;
     default: {
       const _exhaustiveCheck = expr;
       throw new Error(`Unknown expression type: ${JSON.stringify(_exhaustiveCheck)}`);
@@ -418,6 +420,18 @@ async function executeStep(step, ctx) {
     case "navigate":
       await executeNavigateStep(step, ctx);
       break;
+    case "import":
+      await executeImportStep(step, ctx);
+      break;
+    case "call":
+      await executeCallStep(step, ctx);
+      break;
+    case "subscribe":
+      await executeSubscribeStep(step, ctx);
+      break;
+    case "dispose":
+      await executeDisposeStep(step, ctx);
+      break;
   }
 }
 async function executeSetStep(target, value, ctx) {
@@ -534,13 +548,21 @@ async function executeFetchStep(step, ctx) {
         }
       }
     } else {
+      ctx.locals["error"] = {
+        message: `HTTP error: ${response.status} ${response.statusText}`,
+        name: "HTTPError"
+      };
       if (step.onError) {
         for (const errorStep of step.onError) {
           await executeStep(errorStep, ctx);
         }
       }
     }
-  } catch (_error) {
+  } catch (err) {
+    ctx.locals["error"] = {
+      message: err instanceof Error ? err.message : String(err),
+      name: err instanceof Error ? err.name : "Error"
+    };
     if (step.onError) {
       for (const errorStep of step.onError) {
         await executeStep(errorStep, ctx);
@@ -581,7 +603,11 @@ async function executeStorageStep(step, ctx) {
         await executeStep(successStep, ctx);
       }
     }
-  } catch (_error) {
+  } catch (err) {
+    ctx.locals["error"] = {
+      message: err instanceof Error ? err.message : String(err),
+      name: err instanceof Error ? err.name : "Error"
+    };
     if (step.onError) {
       for (const errorStep of step.onError) {
         await executeStep(errorStep, ctx);
@@ -612,7 +638,11 @@ async function executeClipboardStep(step, ctx) {
         await executeStep(successStep, ctx);
       }
     }
-  } catch (_error) {
+  } catch (err) {
+    ctx.locals["error"] = {
+      message: err instanceof Error ? err.message : String(err),
+      name: err instanceof Error ? err.name : "Error"
+    };
     if (step.onError) {
       for (const errorStep of step.onError) {
         await executeStep(errorStep, ctx);
@@ -632,6 +662,98 @@ async function executeNavigateStep(step, ctx) {
     window.location.assign(url);
   }
 }
+async function executeImportStep(step, ctx) {
+  try {
+    const module = await import(
+      /* @vite-ignore */
+      step.module
+    );
+    ctx.locals[step.result] = module;
+    if (step.onSuccess) {
+      for (const successStep of step.onSuccess) {
+        await executeStep(successStep, ctx);
+      }
+    }
+  } catch (err) {
+    ctx.locals["error"] = {
+      message: err instanceof Error ? err.message : String(err),
+      name: err instanceof Error ? err.name : "Error"
+    };
+    if (step.onError) {
+      for (const errorStep of step.onError) {
+        await executeStep(errorStep, ctx);
+      }
+    }
+  }
+}
+async function executeCallStep(step, ctx) {
+  const evalCtx = { state: ctx.state, locals: ctx.locals, ...ctx.refs && { refs: ctx.refs } };
+  try {
+    const target = evaluate(step.target, evalCtx);
+    const args = step.args?.map((arg) => evaluate(arg, evalCtx)) ?? [];
+    if (typeof target === "function") {
+      const result = await target(...args);
+      if (step.result) {
+        ctx.locals[step.result] = result;
+      }
+    } else {
+      throw new Error(`Target is not callable: received ${typeof target}`);
+    }
+    if (step.onSuccess) {
+      for (const successStep of step.onSuccess) {
+        await executeStep(successStep, ctx);
+      }
+    }
+  } catch (err) {
+    ctx.locals["error"] = {
+      message: err instanceof Error ? err.message : String(err),
+      name: err instanceof Error ? err.name : "Error"
+    };
+    if (step.onError) {
+      for (const errorStep of step.onError) {
+        await executeStep(errorStep, ctx);
+      }
+    }
+  }
+}
+async function executeSubscribeStep(step, ctx) {
+  const evalCtx = { state: ctx.state, locals: ctx.locals, ...ctx.refs && { refs: ctx.refs } };
+  const target = evaluate(step.target, evalCtx);
+  if (target && typeof target === "object" && step.event in target) {
+    const eventMethod = target[step.event];
+    if (typeof eventMethod === "function") {
+      const disposable = eventMethod.call(target, async (eventData) => {
+        const action = ctx.actions[step.action];
+        if (action) {
+          const subscriptionCtx = {
+            ...ctx,
+            locals: { ...ctx.locals, event: eventData }
+          };
+          await executeAction(action, subscriptionCtx);
+        }
+      });
+      if (ctx.subscriptions) {
+        if (disposable && typeof disposable === "object" && "dispose" in disposable && typeof disposable.dispose === "function") {
+          ctx.subscriptions.push(() => disposable.dispose());
+        } else if (typeof disposable === "function") {
+          ctx.subscriptions.push(disposable);
+        }
+      }
+    }
+  }
+}
+async function executeDisposeStep(step, ctx) {
+  const evalCtx = { state: ctx.state, locals: ctx.locals, ...ctx.refs && { refs: ctx.refs } };
+  const target = evaluate(step.target, evalCtx);
+  if (target && typeof target === "object") {
+    const obj = target;
+    if (typeof obj["dispose"] === "function") {
+      obj["dispose"]();
+    } else if (typeof obj["destroy"] === "function") {
+      obj["destroy"]();
+    }
+  }
+}
 
 // src/renderer/markdown.ts
 import { marked } from "marked";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/runtime",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Runtime DOM renderer for Constela UI framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,8 +18,8 @@
     "dompurify": "^3.3.1",
     "marked": "^17.0.1",
     "shiki": "^3.20.0",
-    "@constela/compiler": "0.5.0",
-    "@constela/core": "0.5.0"
+    "@constela/compiler": "0.6.1",
+    "@constela/core": "0.7.0"
   },
   "devDependencies": {
     "@types/dompurify": "^3.2.0",
@@ -29,7 +29,7 @@
     "tsup": "^8.0.0",
     "typescript": "^5.3.0",
     "vitest": "^2.0.0",
-    "@constela/server": "1.0.0"
+    "@constela/server": "2.0.0"
   },
   "engines": {
     "node": ">=20.0.0"