@constela/server 9.0.0 → 11.0.1

package/README.md

@@ -90,6 +90,23 @@ Features:
 - CSS custom properties for theme switching
 - Preloaded languages: javascript, typescript, json, html, css, python, rust, go, java, bash, markdown
 
+### Call/Lambda Expressions
+
+Full support for call and lambda expressions during SSR:
+
+```json
+{
+  "expr": "call",
+  "target": { "expr": "data", "name": "posts" },
+  "method": "filter",
+  "args": [{
+    "expr": "lambda",
+    "param": "post",
+    "body": { "expr": "get", "base": { "expr": "var", "name": "post" }, "path": "published" }
+  }]
+}
+```
+
 ### Route Context
 
 Pass route parameters for dynamic pages:

package/dist/index.js

@@ -125,9 +125,278 @@ var VOID_ELEMENTS = /* @__PURE__ */ new Set([
   "track",
   "wbr"
 ]);
+var SAFE_ARRAY_METHODS = /* @__PURE__ */ new Set([
+  "length",
+  "at",
+  "includes",
+  "slice",
+  "indexOf",
+  "join",
+  "filter",
+  "map",
+  "find",
+  "findIndex",
+  "some",
+  "every"
+]);
+var SAFE_STRING_METHODS = /* @__PURE__ */ new Set([
+  "length",
+  "charAt",
+  "substring",
+  "slice",
+  "split",
+  "trim",
+  "toUpperCase",
+  "toLowerCase",
+  "replace",
+  "includes",
+  "startsWith",
+  "endsWith",
+  "indexOf"
+]);
+var SAFE_MATH_METHODS = /* @__PURE__ */ new Set([
+  "min",
+  "max",
+  "round",
+  "floor",
+  "ceil",
+  "abs",
+  "sqrt",
+  "pow",
+  "random",
+  "sin",
+  "cos",
+  "tan"
+]);
+var SAFE_DATE_STATIC_METHODS = /* @__PURE__ */ new Set(["now", "parse"]);
+var SAFE_DATE_INSTANCE_METHODS = /* @__PURE__ */ new Set([
+  "toISOString",
+  "toDateString",
+  "toTimeString",
+  "getTime",
+  "getFullYear",
+  "getMonth",
+  "getDate",
+  "getHours",
+  "getMinutes",
+  "getSeconds",
+  "getMilliseconds"
+]);
 function isEventHandler(value) {
   return typeof value === "object" && value !== null && "event" in value && "action" in value;
 }
+function createLambdaFunction(lambda, ctx) {
+  return (item, index) => {
+    const lambdaLocals = {
+      ...ctx.locals,
+      [lambda.param]: item
+    };
+    if (lambda.index !== void 0) {
+      lambdaLocals[lambda.index] = index;
+    }
+    return evaluate(lambda.body, { ...ctx, locals: lambdaLocals });
+  };
+}
+function callArrayMethod(target, method, args, ctx, rawArgs) {
+  if (!SAFE_ARRAY_METHODS.has(method)) return void 0;
+  switch (method) {
+    case "length":
+      return target.length;
+    case "at": {
+      const index = typeof args[0] === "number" ? args[0] : 0;
+      return target.at(index);
+    }
+    case "includes": {
+      const searchElement = args[0];
+      const fromIndex = typeof args[1] === "number" ? args[1] : void 0;
+      return target.includes(searchElement, fromIndex);
+    }
+    case "slice": {
+      const start = typeof args[0] === "number" ? args[0] : void 0;
+      const end = typeof args[1] === "number" ? args[1] : void 0;
+      return target.slice(start, end);
+    }
+    case "indexOf": {
+      const searchElement = args[0];
+      const fromIndex = typeof args[1] === "number" ? args[1] : void 0;
+      return target.indexOf(searchElement, fromIndex);
+    }
+    case "join": {
+      const separator = typeof args[0] === "string" ? args[0] : ",";
+      return target.join(separator);
+    }
+    case "filter": {
+      const lambdaExpr = rawArgs?.[0];
+      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
+      const fn = createLambdaFunction(lambdaExpr, ctx);
+      return target.filter((item, index) => !!fn(item, index));
+    }
+    case "map": {
+      const lambdaExpr = rawArgs?.[0];
+      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
+      const fn = createLambdaFunction(lambdaExpr, ctx);
+      return target.map((item, index) => fn(item, index));
+    }
+    case "find": {
+      const lambdaExpr = rawArgs?.[0];
+      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
+      const fn = createLambdaFunction(lambdaExpr, ctx);
+      return target.find((item, index) => !!fn(item, index));
+    }
+    case "findIndex": {
+      const lambdaExpr = rawArgs?.[0];
+      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
+      const fn = createLambdaFunction(lambdaExpr, ctx);
+      return target.findIndex((item, index) => !!fn(item, index));
+    }
+    case "some": {
+      const lambdaExpr = rawArgs?.[0];
+      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
+      const fn = createLambdaFunction(lambdaExpr, ctx);
+      return target.some((item, index) => !!fn(item, index));
+    }
+    case "every": {
+      const lambdaExpr = rawArgs?.[0];
+      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
+      const fn = createLambdaFunction(lambdaExpr, ctx);
+      return target.every((item, index) => !!fn(item, index));
+    }
+    default:
+      return void 0;
+  }
+}
+function callStringMethod(target, method, args) {
+  if (!SAFE_STRING_METHODS.has(method)) return void 0;
+  switch (method) {
+    case "length":
+      return target.length;
+    case "charAt": {
+      const index = typeof args[0] === "number" ? args[0] : 0;
+      return target.charAt(index);
+    }
+    case "substring": {
+      const start = typeof args[0] === "number" ? args[0] : 0;
+      const end = typeof args[1] === "number" ? args[1] : void 0;
+      return target.substring(start, end);
+    }
+    case "slice": {
+      const start = typeof args[0] === "number" ? args[0] : void 0;
+      const end = typeof args[1] === "number" ? args[1] : void 0;
+      return target.slice(start, end);
+    }
+    case "split": {
+      const separator = typeof args[0] === "string" ? args[0] : "";
+      return target.split(separator);
+    }
+    case "trim":
+      return target.trim();
+    case "toUpperCase":
+      return target.toUpperCase();
+    case "toLowerCase":
+      return target.toLowerCase();
+    case "replace": {
+      const search = typeof args[0] === "string" ? args[0] : "";
+      const replace = typeof args[1] === "string" ? args[1] : "";
+      return target.replace(search, replace);
+    }
+    case "includes": {
+      const search = typeof args[0] === "string" ? args[0] : "";
+      const position = typeof args[1] === "number" ? args[1] : void 0;
+      return target.includes(search, position);
+    }
+    case "startsWith": {
+      const search = typeof args[0] === "string" ? args[0] : "";
+      const position = typeof args[1] === "number" ? args[1] : void 0;
+      return target.startsWith(search, position);
+    }
+    case "endsWith": {
+      const search = typeof args[0] === "string" ? args[0] : "";
+      const length = typeof args[1] === "number" ? args[1] : void 0;
+      return target.endsWith(search, length);
+    }
+    case "indexOf": {
+      const search = typeof args[0] === "string" ? args[0] : "";
+      const position = typeof args[1] === "number" ? args[1] : void 0;
+      return target.indexOf(search, position);
+    }
+    default:
+      return void 0;
+  }
+}
+function callMathMethod(method, args) {
+  if (!SAFE_MATH_METHODS.has(method)) return void 0;
+  const numbers = args.filter((a) => typeof a === "number");
+  switch (method) {
+    case "min":
+      return numbers.length > 0 ? Math.min(...numbers) : void 0;
+    case "max":
+      return numbers.length > 0 ? Math.max(...numbers) : void 0;
+    case "round":
+      return numbers[0] !== void 0 ? Math.round(numbers[0]) : void 0;
+    case "floor":
+      return numbers[0] !== void 0 ? Math.floor(numbers[0]) : void 0;
+    case "ceil":
+      return numbers[0] !== void 0 ? Math.ceil(numbers[0]) : void 0;
+    case "abs":
+      return numbers[0] !== void 0 ? Math.abs(numbers[0]) : void 0;
+    case "sqrt":
+      return numbers[0] !== void 0 ? Math.sqrt(numbers[0]) : void 0;
+    case "pow":
+      return numbers[0] !== void 0 && numbers[1] !== void 0 ? Math.pow(numbers[0], numbers[1]) : void 0;
+    case "random":
+      return Math.random();
+    case "sin":
+      return numbers[0] !== void 0 ? Math.sin(numbers[0]) : void 0;
+    case "cos":
+      return numbers[0] !== void 0 ? Math.cos(numbers[0]) : void 0;
+    case "tan":
+      return numbers[0] !== void 0 ? Math.tan(numbers[0]) : void 0;
+    default:
+      return void 0;
+  }
+}
+function callDateStaticMethod(method, args) {
+  if (!SAFE_DATE_STATIC_METHODS.has(method)) return void 0;
+  switch (method) {
+    case "now":
+      return Date.now();
+    case "parse": {
+      const dateString = args[0];
+      return typeof dateString === "string" ? Date.parse(dateString) : void 0;
+    }
+    default:
+      return void 0;
+  }
+}
+function callDateInstanceMethod(target, method) {
+  if (!SAFE_DATE_INSTANCE_METHODS.has(method)) return void 0;
+  switch (method) {
+    case "toISOString":
+      return target.toISOString();
+    case "toDateString":
+      return target.toDateString();
+    case "toTimeString":
+      return target.toTimeString();
+    case "getTime":
+      return target.getTime();
+    case "getFullYear":
+      return target.getFullYear();
+    case "getMonth":
+      return target.getMonth();
+    case "getDate":
+      return target.getDate();
+    case "getHours":
+      return target.getHours();
+    case "getMinutes":
+      return target.getMinutes();
+    case "getSeconds":
+      return target.getSeconds();
+    case "getMilliseconds":
+      return target.getMilliseconds();
+    default:
+      return void 0;
+  }
+}
 function evaluate(expr, ctx) {
   switch (expr.expr) {
     case "lit":
@@ -231,6 +500,38 @@ function evaluate(expr, ctx) {
     case "validity": {
       return false;
     }
+    case "call": {
+      const callExpr = expr;
+      const target = evaluate(callExpr.target, ctx);
+      if (target == null) return void 0;
+      const args = callExpr.args?.map((arg) => {
+        if (arg.expr === "lambda") return arg;
+        return evaluate(arg, ctx);
+      }) ?? [];
+      if (Array.isArray(target)) {
+        return callArrayMethod(target, callExpr.method, args, ctx, callExpr.args);
+      }
+      if (typeof target === "string") {
+        return callStringMethod(target, callExpr.method, args);
+      }
+      if (target === Math) {
+        return callMathMethod(callExpr.method, args);
+      }
+      if (target === Date) {
+        return callDateStaticMethod(callExpr.method, args);
+      }
+      if (target instanceof Date) {
+        return callDateInstanceMethod(target, callExpr.method);
+      }
+      return void 0;
+    }
+    case "lambda": {
+      return void 0;
+    }
+    case "array": {
+      const arrayExpr = expr;
+      return arrayExpr.elements.map((elem) => evaluate(elem, ctx));
+    }
     default: {
       const _exhaustiveCheck = expr;
       throw new Error(`Unknown expression type: ${JSON.stringify(_exhaustiveCheck)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/server",
-  "version": "9.0.0",
+  "version": "11.0.1",
   "description": "Server-side rendering for Constela UI framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,8 +15,8 @@
     "dist"
   ],
   "peerDependencies": {
-    "@constela/compiler": "^0.12.0",
-    "@constela/core": "^0.13.0"
+    "@constela/compiler": "^0.14.0",
+    "@constela/core": "^0.15.0"
   },
   "dependencies": {
     "isomorphic-dompurify": "^2.35.0",
@@ -29,8 +29,8 @@
     "tsup": "^8.0.0",
     "typescript": "^5.3.0",
     "vitest": "^2.0.0",
-    "@constela/compiler": "0.12.0",
-    "@constela/core": "0.13.0"
+    "@constela/compiler": "0.14.0",
+    "@constela/core": "0.15.0"
   },
   "engines": {
     "node": ">=20.0.0"