@jxsuite/runtime 6.2.1 → 6.3.0

package/dist/runtime.js

@@ -1489,7 +1489,100 @@ function isTemplateString(value) {
   return typeof value === "string" && value.includes("${");
 }
 function bodyReturnsValue(body) {
-  return /\breturn\b[^\S\n]*(?![;}\s]|$)/.test(body);
+  return /\breturn\b[^\S\n]*(?![;}\s]|$)/.test(maskCode(body));
+}
+function isFunctionEntry(value) {
+  return value.$prototype === "Function" || isString2(value.role) && value.role !== "field";
+}
+function maskCode(body) {
+  if (!/[/'"`]/u.test(body)) {
+    return body;
+  }
+  const known = masked.get(body);
+  if (known !== undefined) {
+    return known;
+  }
+  const result = scanCode(body);
+  if (masked.size >= MASKED_LIMIT) {
+    masked.clear();
+  }
+  masked.set(body, result);
+  return result;
+}
+var masked = new Map;
+var MASKED_LIMIT = 2048;
+function scanCode(body) {
+  const out = body.split("");
+  const blank = (at) => {
+    if (out[at] !== undefined && out[at] !== `
+`) {
+      out[at] = " ";
+    }
+  };
+  const substitutions = [];
+  let inTemplate = false;
+  let at = 0;
+  while (at < body.length) {
+    const char = body.charAt(at);
+    if (inTemplate) {
+      if (char === "\\") {
+        blank(at);
+        blank(at + 1);
+        at += 2;
+      } else if (char === "`") {
+        inTemplate = false;
+        at += 1;
+      } else if (char === "$" && body.charAt(at + 1) === "{") {
+        substitutions.push(0);
+        inTemplate = false;
+        at += 2;
+      } else {
+        blank(at);
+        at += 1;
+      }
+    } else if (char === "/" && body.charAt(at + 1) === "/") {
+      while (at < body.length && body.charAt(at) !== `
+`) {
+        blank(at);
+        at += 1;
+      }
+    } else if (char === "/" && body.charAt(at + 1) === "*") {
+      const end = body.indexOf("*/", at + 2);
+      const stop = end === -1 ? body.length : end + 2;
+      for (;at < stop; at += 1) {
+        blank(at);
+      }
+    } else if (char === "'" || char === '"') {
+      at += 1;
+      while (at < body.length && body.charAt(at) !== char && body.charAt(at) !== `
+`) {
+        if (body.charAt(at) === "\\") {
+          blank(at);
+          at += 1;
+        }
+        blank(at);
+        at += 1;
+      }
+      at += 1;
+    } else if (char === "`") {
+      inTemplate = true;
+      at += 1;
+    } else {
+      const open = substitutions.length - 1;
+      if (open >= 0 && char === "{") {
+        substitutions[open] = (substitutions[open] ?? 0) + 1;
+      } else if (open >= 0 && char === "}") {
+        if (substitutions[open] === 0) {
+          substitutions.pop();
+          inTemplate = true;
+        } else {
+          substitutions[open] = (substitutions[open] ?? 1) - 1;
+        }
+      }
+      at += 1;
+    }
+  }
+  return out.join("");
 }
 function isNestedStyle(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2483,6 +2576,96 @@ function evaluateOperand(operand, state, event, iterCtx) {
   return resolveOperand(operand, state, event, iterCtx);
 }
 
+// ../schema/src/function-role.ts
+var LIFECYCLE_KEYS = new Set(["onMount", "onUnmount", "onAdopted"]);
+function collectCallableKeys(doc) {
+  const keys = new Set;
+  const seen = new Set;
+  const addStateRef = (ref) => {
+    if (ref.startsWith("#/state/")) {
+      keys.add(ref.slice("#/state/".length).split("/")[0]);
+    }
+  };
+  const visit = (node) => {
+    if (isString2(node)) {
+      for (const call of node.matchAll(/\bstate\.([A-Za-z_$][\w$]*)\s*\(/gu)) {
+        keys.add(call[1]);
+      }
+      return;
+    }
+    if (Array.isArray(node)) {
+      if (!seen.has(node)) {
+        seen.add(node);
+        for (const item of node) {
+          visit(item);
+        }
+      }
+      return;
+    }
+    if (!isJsonObject(node) || seen.has(node)) {
+      return;
+    }
+    seen.add(node);
+    if (node.operator === "call" && isRef2(node.target)) {
+      addStateRef(node.target.$ref);
+    }
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "$defs") {
+        continue;
+      }
+      if (key.startsWith("on") && isRef2(value)) {
+        addStateRef(value.$ref);
+      }
+      visit(value);
+    }
+  };
+  visit(doc);
+  for (const hook of LIFECYCLE_KEYS) {
+    if (isJsonObject(doc.state) && hook in doc.state) {
+      keys.add(hook);
+    }
+  }
+  return keys;
+}
+function declaresBodyAndSrc(def) {
+  return "body" in def && "$src" in def;
+}
+function handlerParamNames(def) {
+  const list = ["state"];
+  for (const name of paramNames(def.parameters ?? def.arguments)) {
+    if (name !== "state") {
+      list.push(name);
+    }
+  }
+  return list;
+}
+function functionEntryRole(key, def, callableKeys) {
+  if (hasStructuredBody(def)) {
+    return "callable";
+  }
+  if (paramNames(def.parameters ?? def.arguments).length > 0) {
+    return "callable";
+  }
+  if (isString2(def.body)) {
+    return bodyReturnsValue(def.body) ? "computed" : "callable";
+  }
+  if (def.$src) {
+    return callableKeys().has(key) ? "callable" : "computed";
+  }
+  return "callable";
+}
+function classifyFunctionEntries(doc) {
+  const roles = new Map;
+  let callable = null;
+  const callableKeys = () => callable ??= collectCallableKeys(doc);
+  for (const [key, def] of Object.entries(doc.state ?? {})) {
+    if (isFunctionDef(def)) {
+      roles.set(key, functionEntryRole(key, def, callableKeys));
+    }
+  }
+  return roles;
+}
+
 // ../schema/src/asset-paths.ts
 var URL_TERMINATOR = String.raw`"'\s<>()\\`;
 function parseSrcset(value) {
@@ -2611,6 +2794,111 @@ async function runStatements(statements, state, event, opts = {}) {
   }
 }
 
+// src/body-eraser.ts
+var eraser = null;
+var loader = null;
+var loading = null;
+var erased = new Map;
+function setBodyEraser(fn) {
+  eraser = fn;
+  erased.clear();
+  if (!fn) {
+    loading = null;
+  }
+}
+function setBodyEraserLoader(load) {
+  loader = load;
+  loading = null;
+}
+function compiles(text) {
+  for (const source of [text, `return async function () {
+${text}
+}`]) {
+    try {
+      Reflect.construct(Function, [source]);
+      return true;
+    } catch {}
+  }
+  return false;
+}
+var GENERIC_CALL = /<[^<>]*>\s*[(`]/u;
+function bodyNeedsEraser(text) {
+  return GENERIC_CALL.test(text) || !compiles(text);
+}
+function* bodiesOf(value) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      yield* bodiesOf(item);
+    }
+    return;
+  }
+  if (!isJsonObject(value)) {
+    return;
+  }
+  const isFunction = isFunctionEntry(value);
+  for (const [key, child] of Object.entries(value)) {
+    if (isFunction && key === "body") {
+      if (isString2(child)) {
+        yield child;
+      } else if (Array.isArray(child) && child.every((line) => isString2(line))) {
+        yield child.join(`
+`);
+      } else {
+        yield* bodiesOf(child);
+      }
+    } else if (isFunction && (key === "getter" || key === "setter") && isJsonObject(child)) {
+      if (isString2(child.body)) {
+        yield child.body;
+      }
+    } else {
+      yield* bodiesOf(child);
+    }
+  }
+}
+async function prepareBodies(doc) {
+  const load = loader;
+  if (eraser || !load) {
+    return;
+  }
+  const tree = doc;
+  if (!bodiesOf(tree).some((body) => bodyNeedsEraser(body))) {
+    return;
+  }
+  loading ??= load().then((module) => {
+    if (loader === load) {
+      setBodyEraser(module.eraseBody);
+    }
+  });
+  await loading;
+}
+function javaScriptOf(body, where) {
+  if (!eraser) {
+    return body;
+  }
+  let code = erased.get(body);
+  if (code === undefined) {
+    const result = eraser(body);
+    const refused = result.problems.find((problem) => problem.kind === "unsupported");
+    if (refused) {
+      throw new SyntaxError(`Jx: ${where} cannot run: ${refused.message}`);
+    }
+    ({ code } = result);
+    erased.set(body, code);
+  }
+  return code;
+}
+function compileBody(params, body, where) {
+  const code = javaScriptOf(body, where);
+  try {
+    return new Function(...params, code);
+  } catch (error) {
+    if (!(error instanceof SyntaxError) || eraser) {
+      throw error;
+    }
+    throw new SyntaxError(`Jx: ${where} does not compile as JavaScript (${error.message}). A function body may be ` + `TypeScript: give this page an eraser with setBodyEraser(eraseBody), eraseBody from ` + `@jxsuite/erase/browser.`, { cause: error });
+  }
+}
+
 // src/cookie.ts
 var HOST_PREFIX = "__Host-";
 var SECURE_PREFIX = "__Secure-";
@@ -2649,7 +2937,6 @@ function serializeCookie(name, value, options) {
   }
   return parts.join("; ");
 }
-
 // src/runtime.ts
 var SUPPORTED_SCHEMA_VERSION = 1;
 var _schemaVersionWarned = false;
@@ -2773,6 +3060,7 @@ function responseContentType(res) {
 }
 async function resolve(source, ctx) {
   if (!isString2(source)) {
+    await prepareBodies(source);
     return source;
   }
   const served = ctx?.resolver?.(source);
@@ -2782,7 +3070,7 @@ async function resolve(source, ctx) {
   if (_resolveCache.has(source)) {
     return _resolveCache.get(source);
   }
-  const p = fetch(source).then(async (res) => {
+  const fetched = fetch(source).then(async (res) => {
     if (!res.ok) {
       throw new Error(`Jx: failed to fetch ${source} (${res.status})`);
     }
@@ -2798,6 +3086,10 @@ async function resolve(source, ctx) {
     }
     return await res.json();
   });
+  const p = fetched.then(async (doc) => {
+    await prepareBodies(doc);
+    return doc;
+  });
   _resolveCache.set(source, p);
   return p;
 }
@@ -3069,7 +3361,11 @@ async function buildScope(doc, parentScope = {}, base = location.href, ctx) {
       }
     }
   }
+  const roles = classifyFunctionEntries(doc);
   for (const [key, def] of Object.entries(defs)) {
+    if (isFunctionDef(def) && declaresBodyAndSrc(def)) {
+      throw new Error(`Jx: '${key}' declares both body and $src — these are mutually exclusive`);
+    }
     if (hasStructuredBody(def)) {
       const { body } = def;
       if (Array.isArray(def.parameters) && def.parameters.length > 0) {
@@ -3085,7 +3381,7 @@ async function buildScope(doc, parentScope = {}, base = location.href, ctx) {
         state[key] = handler;
       }
     } else if (isFunctionDef(def)) {
-      state[key] = await resolveFunction(def, state, key, base);
+      state[key] = await resolveFunction(def, state, key, roles.get(key) ?? "callable", base);
     }
   }
   for (const [key, def] of Object.entries(defs)) {
@@ -3298,12 +3594,9 @@ function seededModule(src) {
   _moduleLoaders.set(src, load);
   return load;
 }
-async function resolveFunction(def, state, key, base) {
-  if (def.body && def.$src) {
-    throw new Error(`Jx: '${key}' declares both body and $src — these are mutually exclusive`);
-  }
+async function resolveFunction(def, state, key, role, base) {
   if (!def.body && !def.$src) {
-    const params = resolveParamNames(def);
+    const params = handlerParamNames(def);
     const noop = new Function(...params, "");
     Object.defineProperty(noop, "name", {
       configurable: true,
@@ -3313,8 +3606,8 @@ async function resolveFunction(def, state, key, base) {
   }
   let fn;
   if (isString2(def.body)) {
-    const params = resolveParamNames(def);
-    fn = new Function(...params, def.body);
+    const params = handlerParamNames(def);
+    fn = compileBody(params, def.body, `'${key}'`);
     Object.defineProperty(fn, "name", {
       configurable: true,
       value: def.name ?? key
@@ -3341,20 +3634,11 @@ async function resolveFunction(def, state, key, base) {
     }
     fn = candidate;
   }
-  const hasParams = (def.parameters ?? def.arguments ?? []).length > 0;
-  let isComputed = false;
-  if (!hasParams) {
-    isComputed = isString2(def.body) ? bodyReturnsValue(def.body) : fn.length <= 1 && bodyReturnsValue(fn.toString());
-  }
-  if (isComputed) {
+  if (role === "computed") {
     return computed(() => fn(state));
   }
   return fn;
 }
-function resolveParamNames(def) {
-  const names = def.parameters ? paramNames(def.parameters) : def.arguments ?? [];
-  return names.length > 0 && names[0] === "state" ? names : ["state", ...names];
-}
 var RESERVED_KEYS = new Set([
   "$schema",
   "$id",
@@ -3569,6 +3853,9 @@ function bindHandler(el, key, val, state) {
     }
     return true;
   }
+  if (isFunctionDef(val) && declaresBodyAndSrc(val)) {
+    throw new Error(`Jx: inline '${key}' handler declares both body and $src — these are mutually exclusive`);
+  }
   if (hasStructuredBody(val)) {
     const { body } = val;
     el.addEventListener(type, (e) => {
@@ -3577,8 +3864,8 @@ function bindHandler(el, key, val, state) {
     return true;
   }
   if (isFunctionDef(val) && isString2(val.body)) {
-    const params = resolveParamNames(val);
-    const fn = new Function(...params, val.body);
+    const params = handlerParamNames(val);
+    const fn = compileBody(params, val.body, `the ${type} handler`);
     el.addEventListener(type, (e) => fn(scope, e));
     return true;
   }
@@ -4444,6 +4731,7 @@ async function resolveClassJson(def, state, key, base) {
   } catch {
     return resolveViaDevProxy(def, state, key, base);
   }
+  await prepareBodies(classDef);
   if (classDef.$implementation) {
     const schemaStr = JSON.stringify(classDef);
     if (schemaStr.includes('"#/$context/')) {
@@ -4477,6 +4765,7 @@ function classFromSchema(classDef) {
   const rawCtor = classDef.$defs?.constructor;
   const ctor = isCtorDef(rawCtor) ? rawCtor : undefined;
   const methods = classDef.$defs?.methods ?? {};
+  const className = classDef.title ?? "a class";
 
   class DynClass {
     constructor(config = {}) {
@@ -4496,7 +4785,7 @@ function classFromSchema(classDef) {
       if (ctor?.body) {
         const bodyStr = Array.isArray(ctor.body) ? ctor.body.join(`
 `) : ctor.body;
-        const init = new Function("config", bodyStr);
+        const init = compileBody(["config"], bodyStr, `the constructor of ${className}`);
         init.call(this, config);
       }
     }
@@ -4515,20 +4804,20 @@ function classFromSchema(classDef) {
     if (typedMethod.role === "accessor") {
       const descriptor = {};
       if (typedMethod.getter) {
-        descriptor.get = new Function(typedMethod.getter.body ?? "");
+        descriptor.get = compileBody([], typedMethod.getter.body ?? "", `the getter ${name} of ${className}`);
       }
       if (typedMethod.setter) {
         const sp = (typedMethod.setter.parameters ?? []).map((p) => p.$ref?.split("/").pop() ?? "v");
-        descriptor.set = new Function(...sp, typedMethod.setter.body ?? "");
+        descriptor.set = compileBody(sp, typedMethod.setter.body ?? "", `the setter ${name} of ${className}`);
       }
       Object.defineProperty(DynClass.prototype, name, {
         ...descriptor,
         configurable: true
       });
     } else if (typedMethod.scope === "static") {
-      DynClass[name] = new Function(...params, bodyStr);
+      DynClass[name] = compileBody(params, bodyStr, `${name} of ${className}`);
     } else {
-      DynClass.prototype[name] = new Function(...params, bodyStr);
+      DynClass.prototype[name] = compileBody(params, bodyStr, `${name} of ${className}`);
     }
   }
   Object.defineProperty(DynClass, "name", {
@@ -5307,6 +5596,7 @@ export {
   SUPPORTED_SCHEMA_VERSION,
   _resetPrivatePropWarnings,
   applyStyle,
+  bodyNeedsEraser,
   booleanAttrValue,
   buildScope,
   buildStyleRules,
@@ -5332,6 +5622,7 @@ export {
   observeScope,
   preloadDocument,
   preloadModule,
+  prepareBodies,
   pureSchemeOf,
   reapplyStyle,
   redefineElement,
@@ -5346,6 +5637,8 @@ export {
   resolveTagName,
   runScoped,
   schemeSelectors,
+  setBodyEraser,
+  setBodyEraserLoader,
   setCanvasAssetResolver,
   setCanvasDelinkAnchors,
   setCanvasDelinkCommands,
@@ -5367,5 +5660,5 @@ export {
   transposeCanvasUnits
 };
 
-//# debugId=16998FE20281F1D164756E2164756E21
+//# debugId=E573B4C42927B2CC64756E2164756E21
 //# sourceMappingURL=runtime.js.map