@mmapp/react 0.1.0-alpha.18 → 0.1.0-alpha.19

package/dist/chunk-HHMWR6NA.mjs

@@ -0,0 +1,504 @@
+// src/player/expression-engine.ts
+var _wasmModule = null;
+var _wasmAvailable = false;
+function setWasmModule(module) {
+  _wasmModule = module;
+  _wasmAvailable = module != null;
+}
+var LRUCache = class {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    const val = this.map.get(key);
+    if (val !== void 0) {
+      this.map.delete(key);
+      this.map.set(key, val);
+    }
+    return val;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > this.maxSize) {
+      const first = this.map.keys().next().value;
+      if (first !== void 0) this.map.delete(first);
+    }
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+};
+var classificationCache = new LRUCache(500);
+function classifyExpression(expr) {
+  const cached = classificationCache.get(expr);
+  if (cached) return cached;
+  const cls = classifyUncached(expr);
+  classificationCache.set(expr, cls);
+  return cls;
+}
+function classifyUncached(expr) {
+  const t = expr.trim();
+  if (t === "[Expression]" || t.includes("[Expression]")) return "literal";
+  if (t.startsWith("$expr(") && t.endsWith(")")) return "condition";
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) return "literal";
+  if (/^-?\d+(\.\d+)?$/.test(t)) return "literal";
+  if (t === "true" || t === "false" || t === "null" || t === "undefined") return "literal";
+  if (t === "[]" || t === "{}") return "literal";
+  if (/^\$fn\.\w+\(/.test(t)) return "function";
+  if (/^\$action\.\w+\(/.test(t)) return "action";
+  if (t.startsWith("$action.") && !t.includes("(")) return "action";
+  if (t.startsWith("$") && !/[!=<>&|+\-*/%?:]/.test(t) && !t.includes("(")) return "path";
+  if (/^[a-zA-Z_]\w*(\.\w+)+$/.test(t) && !/[!=<>&|+\-*/%?:]/.test(t)) return "path";
+  if (/^[a-zA-Z_]\w*$/.test(t)) return "path";
+  return "condition";
+}
+function resolvePath(path, scope) {
+  const parts = path.split(".");
+  let current = scope;
+  for (const part of parts) {
+    if (current == null) return void 0;
+    if (typeof current !== "object") return void 0;
+    const asNum = Number(part);
+    if (Array.isArray(current) && !isNaN(asNum)) {
+      current = current[asNum];
+    } else {
+      current = current[part];
+    }
+  }
+  return current;
+}
+var builtinFunctions = {
+  // Array
+  filter: (arr, fn) => {
+    if (!Array.isArray(arr)) return [];
+    if (typeof fn === "function") return arr.filter(fn);
+    return arr;
+  },
+  map: (arr, fn) => {
+    if (!Array.isArray(arr)) return [];
+    if (typeof fn === "function") return arr.map(fn);
+    return arr;
+  },
+  reduce: (arr, fn, init) => {
+    if (!Array.isArray(arr)) return init;
+    if (typeof fn === "function") return arr.reduce(fn, init);
+    return init;
+  },
+  find: (arr, fn) => {
+    if (!Array.isArray(arr)) return void 0;
+    if (typeof fn === "function") return arr.find(fn);
+    return void 0;
+  },
+  includes: (arr, item) => {
+    if (Array.isArray(arr)) return arr.includes(item);
+    if (typeof arr === "string") return arr.includes(String(item));
+    return false;
+  },
+  indexOf: (arr, item) => {
+    if (Array.isArray(arr)) return arr.indexOf(item);
+    if (typeof arr === "string") return arr.indexOf(String(item));
+    return -1;
+  },
+  slice: (arr, start, end) => {
+    if (Array.isArray(arr) || typeof arr === "string") {
+      return arr.slice(Number(start) || 0, end != null ? Number(end) : void 0);
+    }
+    return arr;
+  },
+  sort: (arr, fn) => {
+    if (!Array.isArray(arr)) return [];
+    const copy = [...arr];
+    if (typeof fn === "function") return copy.sort(fn);
+    return copy.sort();
+  },
+  reverse: (arr) => {
+    if (!Array.isArray(arr)) return [];
+    return [...arr].reverse();
+  },
+  unique: (arr) => {
+    if (!Array.isArray(arr)) return [];
+    return [...new Set(arr)];
+  },
+  flat: (arr, depth) => {
+    if (!Array.isArray(arr)) return [];
+    return arr.flat(Number(depth) || 1);
+  },
+  concat: (a, b) => {
+    if (Array.isArray(a)) return a.concat(Array.isArray(b) ? b : [b]);
+    if (typeof a === "string") return a + String(b ?? "");
+    return [a, b];
+  },
+  any: (arr, fn) => {
+    if (!Array.isArray(arr)) return false;
+    if (typeof fn === "function") return arr.some(fn);
+    return arr.length > 0;
+  },
+  all: (arr, fn) => {
+    if (!Array.isArray(arr)) return false;
+    if (typeof fn === "function") return arr.every(fn);
+    return false;
+  },
+  group_by: (arr, key) => {
+    if (!Array.isArray(arr) || typeof key !== "string") return {};
+    const groups = {};
+    for (const item of arr) {
+      const k = String(item?.[key] ?? "undefined");
+      (groups[k] ??= []).push(item);
+    }
+    return groups;
+  },
+  count: (arr) => Array.isArray(arr) ? arr.length : 0,
+  sum: (arr, key) => {
+    if (!Array.isArray(arr)) return 0;
+    if (typeof key === "string") {
+      return arr.reduce((s, item) => s + (Number(item?.[key]) || 0), 0);
+    }
+    return arr.reduce((s, v) => s + (Number(v) || 0), 0);
+  },
+  avg: (arr, key) => {
+    if (!Array.isArray(arr) || arr.length === 0) return 0;
+    const s = builtinFunctions.sum(arr, key);
+    return s / arr.length;
+  },
+  min: (...args) => {
+    if (args.length === 1 && Array.isArray(args[0])) return Math.min(...args[0].map(Number));
+    return Math.min(...args.map(Number));
+  },
+  max: (...args) => {
+    if (args.length === 1 && Array.isArray(args[0])) return Math.max(...args[0].map(Number));
+    return Math.max(...args.map(Number));
+  },
+  // String
+  len: (v) => {
+    if (Array.isArray(v)) return v.length;
+    if (typeof v === "string") return v.length;
+    return 0;
+  },
+  upper: (v) => typeof v === "string" ? v.toUpperCase() : String(v ?? "").toUpperCase(),
+  lower: (v) => typeof v === "string" ? v.toLowerCase() : String(v ?? "").toLowerCase(),
+  trim: (v) => typeof v === "string" ? v.trim() : String(v ?? "").trim(),
+  contains: (haystack, needle) => {
+    if (typeof haystack === "string") return haystack.includes(String(needle));
+    if (Array.isArray(haystack)) return haystack.includes(needle);
+    return false;
+  },
+  starts_with: (v, prefix) => typeof v === "string" ? v.startsWith(String(prefix)) : false,
+  ends_with: (v, suffix) => typeof v === "string" ? v.endsWith(String(suffix)) : false,
+  replace: (v, search, rep) => typeof v === "string" ? v.replaceAll(String(search), String(rep)) : v,
+  split: (v, sep) => typeof v === "string" ? v.split(String(sep)) : [],
+  join: (arr, sep) => Array.isArray(arr) ? arr.join(String(sep ?? ",")) : String(arr),
+  substr: (v, start, len) => {
+    if (typeof v !== "string") return "";
+    return v.substring(Number(start) || 0, len != null ? (Number(start) || 0) + Number(len) : void 0);
+  },
+  format: (template, ...args) => {
+    if (typeof template !== "string") return String(template);
+    return template.replace(/\{(\d+)\}/g, (_, i) => String(args[Number(i)] ?? ""));
+  },
+  // Math
+  abs: (v) => Math.abs(Number(v) || 0),
+  ceil: (v) => Math.ceil(Number(v) || 0),
+  floor: (v) => Math.floor(Number(v) || 0),
+  round: (v, decimals) => {
+    const n = Number(v) || 0;
+    const d = Number(decimals) || 0;
+    const f = Math.pow(10, d);
+    return Math.round(n * f) / f;
+  },
+  pow: (base, exp) => Math.pow(Number(base) || 0, Number(exp) || 0),
+  sqrt: (v) => Math.sqrt(Number(v) || 0),
+  random: () => Math.random(),
+  clamp: (v, lo, hi) => Math.min(Math.max(Number(v), Number(lo)), Number(hi)),
+  // Date
+  now: () => (/* @__PURE__ */ new Date()).toISOString(),
+  formatDate: (v, fmt) => {
+    try {
+      const d = new Date(v);
+      if (isNaN(d.getTime())) return String(v);
+      if (fmt === "relative") {
+        const diff = Date.now() - d.getTime();
+        if (diff < 6e4) return "just now";
+        if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+        if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
+        return `${Math.floor(diff / 864e5)}d ago`;
+      }
+      return d.toLocaleDateString();
+    } catch {
+      return String(v);
+    }
+  },
+  // Utility
+  coalesce: (...args) => args.find((a) => a != null),
+  default: (v, fallback) => v ?? fallback,
+  json: (v) => JSON.stringify(v),
+  keys: (v) => v && typeof v === "object" && !Array.isArray(v) ? Object.keys(v) : [],
+  values: (v) => v && typeof v === "object" && !Array.isArray(v) ? Object.values(v) : [],
+  entries: (v) => v && typeof v === "object" && !Array.isArray(v) ? Object.entries(v) : [],
+  merge: (...args) => Object.assign({}, ...args.filter((a) => a && typeof a === "object")),
+  debug: (v, label) => {
+    console.log(label ? `[debug:${label}]` : "[debug]", v);
+    return v;
+  },
+  Boolean: (v) => Boolean(v),
+  Number: (v) => Number(v),
+  String: (v) => String(v ?? "")
+};
+var compiledCache = new LRUCache(2e3);
+var FORBIDDEN_PATTERNS = [
+  /\beval\b/,
+  /\bFunction\b/,
+  /\bfetch\b/,
+  /\bdocument\b/,
+  /\bwindow\b/,
+  /\bprocess\b/,
+  /\bglobalThis\b/,
+  /\bimport\b/,
+  /\brequire\b/,
+  /\b__proto__\b/,
+  /\bconstructor\b/
+];
+function validateExpression(expr) {
+  for (const pat of FORBIDDEN_PATTERNS) {
+    if (pat.test(expr)) {
+      return { valid: false, error: `Forbidden pattern: ${pat.source}` };
+    }
+  }
+  const depth = (expr.match(/\(/g) || []).length;
+  if (depth > 15) return { valid: false, error: "Expression too deeply nested" };
+  return { valid: true };
+}
+function compileToFunction(expr, paramNames) {
+  const cached = compiledCache.get(expr);
+  if (cached) return cached;
+  const validation = validateExpression(expr);
+  if (!validation.valid) {
+    console.warn(`[expression-engine] Unsafe expression blocked: ${validation.error} in "${expr}"`);
+    return null;
+  }
+  try {
+    const fn = new Function(...paramNames, `"use strict"; try { return (${expr}); } catch(e) { return undefined; }`);
+    compiledCache.set(expr, fn);
+    return fn;
+  } catch {
+    try {
+      const fn = new Function(...paramNames, `"use strict"; try { ${expr} } catch(e) { return undefined; }`);
+      compiledCache.set(expr, fn);
+      return fn;
+    } catch {
+      return null;
+    }
+  }
+}
+function evaluateExpression(expr, context) {
+  const trimmed = expr.trim();
+  if (!trimmed) return void 0;
+  const cls = classifyExpression(trimmed);
+  if (cls === "literal") return parseLiteral(trimmed);
+  if (cls === "path") return resolveScopePath(trimmed, context);
+  let evalExpr = trimmed;
+  if (evalExpr.startsWith("$expr(") && evalExpr.endsWith(")")) {
+    evalExpr = evalExpr.slice(6, -1);
+  }
+  if (_wasmAvailable && _wasmModule) {
+    try {
+      const translated = translateForWasm(evalExpr);
+      const contextJson = JSON.stringify(buildWasmContext(context));
+      const resultJson = _wasmModule.evaluateExpressionSync(translated, contextJson);
+      return JSON.parse(resultJson);
+    } catch {
+    }
+  }
+  return evaluateWithJS(evalExpr, context);
+}
+function parseLiteral(expr) {
+  if (expr.startsWith('"') && expr.endsWith('"') || expr.startsWith("'") && expr.endsWith("'")) {
+    return expr.slice(1, -1);
+  }
+  if (/^-?\d+(\.\d+)?$/.test(expr)) return Number(expr);
+  if (expr === "true") return true;
+  if (expr === "false") return false;
+  if (expr === "null") return null;
+  if (expr === "undefined") return void 0;
+  if (expr === "[]") return [];
+  if (expr === "{}") return {};
+  if (expr === "[Expression]") return void 0;
+  return void 0;
+}
+function resolveScopePath(expr, context) {
+  const trimmed = expr.trim();
+  if (trimmed.startsWith("$")) {
+    const dotIdx = trimmed.indexOf(".");
+    if (dotIdx === -1) {
+      return context[trimmed];
+    }
+    const root = trimmed.slice(0, dotIdx);
+    const rest = trimmed.slice(dotIdx + 1);
+    const rootVal = context[root];
+    if (rootVal == null) return void 0;
+    return resolvePath(rest, rootVal);
+  }
+  return resolvePath(trimmed, context);
+}
+function translateForWasm(expr) {
+  return expr.replace(/\$fn\./g, "").replace(/\$instance\./g, "state_data.").replace(/\$data\./g, "state_data.").replace(/\$row\./g, "state_data.");
+}
+function buildWasmContext(context) {
+  const wasmCtx = {};
+  if (context.$instance && typeof context.$instance === "object") {
+    const inst = context.$instance;
+    wasmCtx.state_data = inst.fields ?? inst;
+  }
+  if (context.$local) wasmCtx.$local = context.$local;
+  if (context.$user) wasmCtx.$user = context.$user;
+  if (context.$entity) wasmCtx.$entity = context.$entity;
+  if (context.state_data) wasmCtx.state_data = context.state_data;
+  if (context.memory) wasmCtx.memory = context.memory;
+  if (context.context) wasmCtx.context = context.context;
+  return wasmCtx;
+}
+function evaluateWithJS(expr, context) {
+  const paramNames = [];
+  const paramValues = [];
+  for (const [key, value] of Object.entries(context)) {
+    if (key.startsWith("$")) {
+      paramNames.push(key);
+      paramValues.push(value);
+    }
+  }
+  if (context.$fn && typeof context.$fn === "object") {
+    for (const [name, fn2] of Object.entries(context.$fn)) {
+      if (!paramNames.includes(name)) {
+        paramNames.push(name);
+        paramValues.push(fn2);
+      }
+    }
+  }
+  if ("item" in context) {
+    paramNames.push("item");
+    paramValues.push(context.item);
+  }
+  if ("index" in context) {
+    paramNames.push("index");
+    paramValues.push(context.index);
+  }
+  if (context.$instances) {
+    paramNames.push("items");
+    paramValues.push(context.$instances);
+  }
+  if (context.$instance) {
+    paramNames.push("instance");
+    paramValues.push(context.$instance);
+  }
+  if ("loading" in context) {
+    paramNames.push("loading");
+    paramValues.push(context.loading);
+  }
+  const fn = compileToFunction(expr, paramNames);
+  if (!fn) return void 0;
+  try {
+    return fn(...paramValues);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/player/scope-builder.ts
+import { createContext, useContext } from "react";
+var emptyScopeData = {
+  $local: {},
+  $user: { roles: [] },
+  $fn: builtinFunctions,
+  $action: {}
+};
+var ScopeContext = createContext(emptyScopeData);
+function useScope() {
+  return useContext(ScopeContext);
+}
+function buildScope(opts) {
+  const {
+    dataSources = {},
+    localState = {},
+    auth,
+    entity,
+    parentScope,
+    actionScope,
+    functions = {}
+  } = opts;
+  const scope = {
+    ...parentScope ?? emptyScopeData,
+    $local: { ...parentScope?.$local ?? {}, ...localState },
+    $fn: { ...builtinFunctions, ...parentScope?.$fn ?? {}, ...functions }
+  };
+  if (auth) {
+    scope.$user = { id: auth.userId, roles: auth.roles ?? [] };
+  }
+  if (entity) {
+    scope.$entity = entity;
+  }
+  if (actionScope) {
+    scope.$action = actionScope;
+  }
+  if (Object.keys(dataSources).length > 0) {
+    const allInstances = [];
+    let primaryInstance;
+    let primaryDefinition;
+    let primaryPagination;
+    for (const [name, result] of Object.entries(dataSources)) {
+      if (result.instance) {
+        primaryInstance = result.instance;
+        scope[name] = result.instance;
+      }
+      if (result.instances) {
+        allInstances.push(...result.instances);
+        scope[name] = result.instances;
+      }
+      if (result.definition) {
+        primaryDefinition = result.definition;
+      }
+      if (result.pagination) {
+        primaryPagination = result.pagination;
+      }
+    }
+    if (primaryInstance) scope.$instance = primaryInstance;
+    if (allInstances.length > 0) scope.$instances = allInstances;
+    if (primaryDefinition) scope.$definition = primaryDefinition;
+    if (primaryPagination) scope.$pagination = primaryPagination;
+    const anyLoading = Object.values(dataSources).some((r) => r.loading);
+    scope.loading = anyLoading;
+  }
+  return scope;
+}
+function mergeScope(parent, child) {
+  return {
+    ...parent,
+    ...child,
+    $local: { ...parent.$local, ...child.$local ?? {} },
+    $fn: { ...parent.$fn, ...child.$fn ?? {} },
+    $action: child.$action ?? parent.$action
+  };
+}
+function buildLoopScope(parent, item, index, as) {
+  return {
+    ...parent,
+    $item: item,
+    $index: index,
+    [as]: item,
+    // Convenience: flatten item fields for direct access
+    item,
+    index
+  };
+}
+
+export {
+  setWasmModule,
+  resolvePath,
+  builtinFunctions,
+  evaluateExpression,
+  ScopeContext,
+  useScope,
+  buildScope,
+  mergeScope,
+  buildLoopScope
+};

package/dist/chunk-HULEMSN2.mjs

@@ -0,0 +1,120 @@
+import {
+  useScope
+} from "./chunk-WV7DVCP6.mjs";
+
+// src/player/atoms/navigation.tsx
+import { useState, useCallback, createContext, useContext, useMemo } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var RouterCtx = createContext({
+  path: "/",
+  navigate: () => {
+  },
+  params: {}
+});
+function usePlayerRouter() {
+  return useContext(RouterCtx);
+}
+var Router = ({ children, basePath, className, style }) => {
+  const [path, setPath] = useState(basePath ?? "/");
+  const navigate = useCallback((to) => {
+    setPath(to);
+  }, []);
+  return /* @__PURE__ */ jsx(RouterCtx.Provider, { value: { path, navigate, params: {} }, children: /* @__PURE__ */ jsx("div", { className, style, children }) });
+};
+function matchPath(pattern, currentPath, exact) {
+  const params = {};
+  const patternParts = pattern.split("/").filter(Boolean);
+  const pathParts = currentPath.split("/").filter(Boolean);
+  if (exact && patternParts.length !== pathParts.length) {
+    return { match: false, params };
+  }
+  if (patternParts.length > pathParts.length) {
+    return { match: false, params };
+  }
+  for (let i = 0; i < patternParts.length; i++) {
+    const pp = patternParts[i];
+    if (pp.startsWith(":")) {
+      params[pp.slice(1)] = pathParts[i];
+    } else if (pp === "*") {
+      return { match: true, params };
+    } else if (pp !== pathParts[i]) {
+      return { match: false, params };
+    }
+  }
+  return { match: true, params };
+}
+var Route = ({ children, path: routePath, exact, className, style }) => {
+  const { path } = useContext(RouterCtx);
+  const pattern = routePath ?? "/";
+  const { match, params } = matchPath(pattern, path, exact !== false);
+  if (!match) return null;
+  return /* @__PURE__ */ jsx(RouterCtx.Provider, { value: { path, navigate: useContext(RouterCtx).navigate, params }, children: /* @__PURE__ */ jsx("div", { className, style, children }) });
+};
+var NavLink = ({
+  children,
+  to,
+  label,
+  icon,
+  activeClassName,
+  className,
+  style,
+  onClick
+}) => {
+  const { path, navigate } = useContext(RouterCtx);
+  const target = to ?? "/";
+  const isActive = path === target || path.startsWith(target + "/");
+  const text = children ?? label;
+  const handleClick = useCallback((e) => {
+    e.preventDefault();
+    navigate(target);
+    if (typeof onClick === "function") onClick(e);
+  }, [navigate, target, onClick]);
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      className: `${className ?? ""} ${isActive && activeClassName ? activeClassName : ""}`.trim() || void 0,
+      onClick: handleClick,
+      style: {
+        background: isActive ? "#ebf8ff" : "transparent",
+        color: isActive ? "#2b6cb0" : "#4a5568",
+        border: "none",
+        borderRadius: 6,
+        padding: "6px 12px",
+        fontSize: 14,
+        fontWeight: isActive ? 600 : 400,
+        cursor: "pointer",
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 6,
+        transition: "background 0.15s, color 0.15s",
+        ...style
+      },
+      children: [
+        icon ? /* @__PURE__ */ jsx("span", { children: String(icon) }) : null,
+        text != null ? String(text) : null
+      ]
+    }
+  );
+};
+var RoleGuard = ({ children, role, roles, fallback }) => {
+  const scope = useScope();
+  const allowed = useMemo(() => {
+    const required = Array.isArray(roles) ? roles : role != null ? [String(role)] : [];
+    if (required.length === 0) return true;
+    const userRoles = scope.$user?.roles ?? [];
+    if (userRoles.length === 0) return false;
+    return required.some((r) => userRoles.includes(r));
+  }, [role, roles, scope.$user]);
+  if (!allowed) {
+    return fallback ? /* @__PURE__ */ jsx(Fragment, { children: fallback }) : null;
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children });
+};
+
+export {
+  usePlayerRouter,
+  Router,
+  Route,
+  NavLink,
+  RoleGuard
+};