@constela/runtime 0.1.0 → 0.3.0

package/dist/index.js

@@ -150,8 +150,25 @@ function evaluate(expr, ctx) {
       return evaluateBinary(expr.op, expr.left, expr.right, ctx);
     case "not":
       return !evaluate(expr.operand, ctx);
-    default:
-      throw new Error("Unknown expression type");
+    case "cond":
+      return evaluate(expr.if, ctx) ? evaluate(expr.then, ctx) : evaluate(expr.else, ctx);
+    case "get": {
+      const baseValue = evaluate(expr.base, ctx);
+      if (baseValue == null) return void 0;
+      const pathParts = expr.path.split(".");
+      const forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+      let value = baseValue;
+      for (const part of pathParts) {
+        if (forbiddenKeys.has(part)) return void 0;
+        if (value == null) return void 0;
+        value = value[part];
+      }
+      return value;
+    }
+    default: {
+      const _exhaustiveCheck = expr;
+      throw new Error(`Unknown expression type: ${JSON.stringify(_exhaustiveCheck)}`);
+    }
   }
 }
 function evaluateBinary(op, left, right, ctx) {
@@ -228,7 +245,7 @@ async function executeStep(step, ctx) {
       await executeSetStep(step.target, step.value, ctx);
       break;
     case "update":
-      await executeUpdateStep(step.target, step.operation, step.value, ctx);
+      await executeUpdateStep(step, ctx);
       break;
     case "fetch":
       await executeFetchStep(step, ctx);
@@ -240,7 +257,8 @@ async function executeSetStep(target, value, ctx) {
   const newValue = evaluate(value, evalCtx);
   ctx.state.set(target, newValue);
 }
-async function executeUpdateStep(target, operation, value, ctx) {
+async function executeUpdateStep(step, ctx) {
+  const { target, operation, value } = step;
   const evalCtx = { state: ctx.state, locals: ctx.locals };
   const currentValue = ctx.state.get(target);
   switch (operation) {
@@ -279,6 +297,50 @@ async function executeUpdateStep(target, operation, value, ctx) {
       }
       break;
     }
+    case "toggle": {
+      const current = typeof currentValue === "boolean" ? currentValue : false;
+      ctx.state.set(target, !current);
+      break;
+    }
+    case "merge": {
+      const evalResult = value ? evaluate(value, evalCtx) : {};
+      const mergeValue = typeof evalResult === "object" && evalResult !== null ? evalResult : {};
+      const current = typeof currentValue === "object" && currentValue !== null ? currentValue : {};
+      ctx.state.set(target, { ...current, ...mergeValue });
+      break;
+    }
+    case "replaceAt": {
+      const idx = step.index ? evaluate(step.index, evalCtx) : 0;
+      const newValue = value ? evaluate(value, evalCtx) : void 0;
+      const arr = Array.isArray(currentValue) ? [...currentValue] : [];
+      if (typeof idx === "number" && idx >= 0 && idx < arr.length) {
+        arr[idx] = newValue;
+      }
+      ctx.state.set(target, arr);
+      break;
+    }
+    case "insertAt": {
+      const idx = step.index ? evaluate(step.index, evalCtx) : 0;
+      const newValue = value ? evaluate(value, evalCtx) : void 0;
+      const arr = Array.isArray(currentValue) ? [...currentValue] : [];
+      if (typeof idx === "number" && idx >= 0) {
+        arr.splice(idx, 0, newValue);
+      }
+      ctx.state.set(target, arr);
+      break;
+    }
+    case "splice": {
+      const idx = step.index ? evaluate(step.index, evalCtx) : 0;
+      const delCount = step.deleteCount ? evaluate(step.deleteCount, evalCtx) : 0;
+      const items = value ? evaluate(value, evalCtx) : [];
+      const arr = Array.isArray(currentValue) ? [...currentValue] : [];
+      if (typeof idx === "number" && typeof delCount === "number") {
+        const insertItems = Array.isArray(items) ? items : [];
+        arr.splice(idx, delCount, ...insertItems);
+      }
+      ctx.state.set(target, arr);
+      break;
+    }
   }
 }
 async function executeFetchStep(step, ctx) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/runtime",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Runtime DOM renderer for Constela UI framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,8 +15,8 @@
     "dist"
   ],
   "dependencies": {
-    "@constela/core": "0.1.0",
-    "@constela/compiler": "0.1.0"
+    "@constela/core": "0.3.0",
+    "@constela/compiler": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",

package/dist/index.d.ts

@@ -1,101 +0,0 @@
-import { CompiledExpression, CompiledAction, CompiledNode, CompiledProgram } from '@constela/compiler';
-
-interface Signal<T> {
-    get(): T;
-    set(value: T): void;
-    subscribe?(fn: (value: T) => void): () => void;
-}
-declare function createSignal<T>(initial: T): Signal<T>;
-
-/**
- * Effect - Reactive side effect
- *
- * An effect runs a function and automatically tracks signal dependencies.
- * When any tracked signal changes, the effect re-runs.
- */
-type CleanupFn = () => void;
-type EffectFn = () => void | CleanupFn;
-declare function createEffect(fn: EffectFn): () => void;
-
-/**
- * StateStore - Centralized state management
- *
- * Creates signals for each state field defined in the program.
- * Provides get/set methods for accessing state.
- */
-interface StateStore {
-    get(name: string): unknown;
-    set(name: string, value: unknown): void;
-}
-interface StateDefinition {
-    type: string;
-    initial: unknown;
-}
-declare function createStateStore(definitions: Record<string, StateDefinition>): StateStore;
-
-/**
- * Expression Evaluator - Evaluates compiled expressions
- *
- * Supports:
- * - Literal values (lit)
- * - State reads (state)
- * - Variable reads (var)
- * - Binary operations (bin)
- * - Not operation (not)
- */
-
-interface EvaluationContext {
-    state: StateStore;
-    locals: Record<string, unknown>;
-}
-declare function evaluate(expr: CompiledExpression, ctx: EvaluationContext): unknown;
-
-/**
- * Action Executor - Executes compiled action steps
- *
- * Supports:
- * - set: Update state with value
- * - update: Increment/decrement numbers, push/pop/remove for arrays
- * - fetch: Make HTTP requests with onSuccess/onError handlers
- */
-
-interface ActionContext {
-    state: StateStore;
-    actions: Record<string, CompiledAction>;
-    locals: Record<string, unknown>;
-    eventPayload?: unknown;
-}
-declare function executeAction(action: CompiledAction, ctx: ActionContext): Promise<void>;
-
-/**
- * Renderer - DOM rendering for compiled view nodes
- *
- * Renders:
- * - element: Creates DOM elements with props and event handlers
- * - text: Creates text nodes
- * - if: Conditional rendering with reactive updates
- * - each: List rendering with reactive updates
- */
-
-interface RenderContext {
-    state: StateStore;
-    actions: Record<string, CompiledAction>;
-    locals: Record<string, unknown>;
-    cleanups?: (() => void)[];
-}
-declare function render(node: CompiledNode, ctx: RenderContext): Node;
-
-/**
- * App - Main entry point for creating Constela applications
- *
- * Creates a reactive application from a CompiledProgram and mounts it to the DOM.
- */
-
-interface AppInstance {
-    destroy(): void;
-    setState(name: string, value: unknown): void;
-    getState(name: string): unknown;
-}
-declare function createApp(program: CompiledProgram, mount: HTMLElement): AppInstance;
-
-export { type ActionContext, type AppInstance, type EvaluationContext, type RenderContext, type Signal, type StateStore, createApp, createEffect, createSignal, createStateStore, evaluate, executeAction, render };