@symbo.ls/mermaid 3.14.4 → 3.14.5

package/src/server.js

@@ -1,190 +0,0 @@
-/**
- * Express factory for the mermaid runner.
- *
- * Self-sustaining: pass `jsonPath` to serve a project from a local JSON file
- * with no infrastructure dependencies. Or inject a `getProjectData` callback
- * to source data from KV / API / database / anywhere.
- *
- *   import { createMermaidApp } from '@symbo.ls/mermaid';
- *
- *   // From a JSON file:
- *   const app = createMermaidApp({ jsonPath: './app.json' });
- *
- *   // From a custom data source (e.g. KV worker):
- *   const app = createMermaidApp({
- *     async getProjectData(req, { appkey }) {
- *       return { data: await myKv.fetch(appkey), channel: 'production' };
- *     },
- *   });
- *
- *   app.listen(3333);
- */
-
-import path from 'path';
-import fs from 'fs';
-import express from 'express';
-import cors from 'cors';
-import log from './utils/logger.js';
-import { STATIC_EXT } from './route.js';
-import { renderProjectHtml, renderNotPublishedHtml, generateSitemap } from './render.js';
-
-/**
- * Load project data from a local JSON file (or app.json inside a directory).
- */
-export function loadJsonData(jsonPath) {
-  const resolved = path.resolve(jsonPath);
-  let filePath = resolved;
-
-  if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
-    filePath = path.join(resolved, 'app.json');
-  }
-
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`JSON data file not found: ${filePath}`);
-  }
-
-  const raw = fs.readFileSync(filePath, 'utf8');
-  const data = JSON.parse(raw);
-  log.info(`[MERMAID] Loaded project data from ${filePath}`);
-  return data;
-}
-
-function normalizeAppkey(rawAppkey, req) {
-  if (typeof rawAppkey !== 'string') return rawAppkey;
-
-  // When renderUrl includes its own query, split and merge nested params
-  if (rawAppkey.includes('?') && req) {
-    const [baseAppkey, nestedQuery] = rawAppkey.split('?');
-    rawAppkey = baseAppkey.replace(/\/$/, '');
-
-    try {
-      const nestedParams = new URLSearchParams(nestedQuery);
-      for (const [key, value] of nestedParams.entries()) {
-        if (req.query[key] === undefined) req.query[key] = value;
-      }
-    } catch (err) {
-      log.warn(`[MERMAID] Failed to parse nested query in renderUrl: ${err.message}`);
-    }
-  }
-
-  // Strip scheme, port, leading www., trailing slash
-  return rawAppkey
-    .replace(/^https?:\/\//, '')
-    .split(':')[0]
-    .replace(/^www\./, '')
-    .replace(/\/$/, '');
-}
-
-/**
- * Create an Express app that serves Symbols projects.
- *
- * @param {object} options
- * @param {string} [options.jsonPath] — local JSON file (or directory containing app.json)
- * @param {string} [options.appkeyOverride] — force a specific appkey for all requests
- * @param {string} [options.channel='production'] — channel for JSON-mode rendering
- * @param {Function} [options.getProjectData] — async (req, ctx) → { data, appkey?, channel?, isProd? }
- * @param {boolean} [options.cors=true] — enable CORS middleware
- * @param {object} [options.editor] — { bundle: string } to inject preview-editor for non-prod
- * @returns {express.Application}
- */
-export function createMermaidApp(options = {}) {
-  const {
-    jsonPath,
-    appkeyOverride,
-    channel: defaultChannel = 'production',
-    getProjectData,
-    cors: enableCors = true,
-    editor,
-  } = options;
-
-  // Pre-load JSON data if a path is provided
-  let jsonData = null;
-  if (jsonPath) jsonData = loadJsonData(jsonPath);
-
-  const app = express();
-
-  if (enableCors) app.use(cors({ origin: '*', methods: 'GET, POST' }));
-  app.use(express.json());
-
-  app.get('/health', (_req, res) =>
-    res.send({ alive: true, service: 'mermaid', version: '3.14.0' }),
-  );
-
-  app.get('*', async (req, res) => {
-    try {
-      const pathname = req.originalUrl.split('?')[0];
-
-      // Skip static asset requests
-      if (STATIC_EXT.test(pathname)) {
-        if (pathname === '/favicon.ico') return res.status(204).end();
-        return res.status(404).send('Not Found');
-      }
-
-      // Resolve appkey from override / renderUrl / Host header
-      let rawAppkey = appkeyOverride || req.query.renderUrl || req.headers.host;
-      rawAppkey = normalizeAppkey(rawAppkey, req);
-
-      let data = null;
-      let appkey = rawAppkey;
-      let channel = defaultChannel;
-      let isProd = false;
-
-      if (jsonData) {
-        data = jsonData;
-        log.debug('[MERMAID] Using local JSON data');
-      } else if (getProjectData) {
-        const result = await getProjectData(req, { appkey: rawAppkey });
-        if (result) {
-          data = result.data;
-          if (result.appkey) appkey = result.appkey;
-          if (result.channel) channel = result.channel;
-          if (typeof result.isProd === 'boolean') isProd = result.isProd;
-        }
-      }
-
-      if (!appkey) {
-        return res.send(
-          'Hello, this is Mermaid (Symbols runner). Read developer documentation at https://symbols.app/developers',
-        );
-      }
-
-      if (!data) {
-        log.warn(`[MERMAID] Project not found for appkey: ${appkey}`);
-        return res.status(404).type('html').send(renderNotPublishedHtml(appkey, channel));
-      }
-
-      // Sitemap
-      if (pathname === '/sitemap.xml') {
-        if (generateSitemap && data.pages && Object.keys(data.pages).length) {
-          const baseUrl = `https://${appkey}`;
-          const sitemap = generateSitemap(baseUrl, data.pages);
-          return res.type('application/xml').send(sitemap);
-        }
-        return res.status(404).send('No sitemap available');
-      }
-
-      const userId = req.headers['x-user-id'] || '';
-
-      const result = await renderProjectHtml(data, {
-        appkey,
-        pathname,
-        channel,
-        isProd,
-        req,
-        userId,
-        editorBundle: editor?.bundle,
-      });
-
-      return res
-        .status(result.status)
-        .set({ host: 'https://' + appkey + '/' })
-        .type(result.contentType === 'text/html' ? 'html' : result.contentType)
-        .send(result.html);
-    } catch (error) {
-      log.error(`[MERMAID] Error in request: ${error}`);
-      return res.status(500).send('Internal Server Error');
-    }
-  });
-
-  return app;
-}

package/src/template.html

@@ -1,23 +0,0 @@
-<!doctype html>
-<html'${{{ ROOT_ATTRS }}}'>
-  <head>
-    <meta charset="UTF-8" />
-    '${{{ HEAD_BOOT }}}'
-    '${{{ META }}}'
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    '${{{ IMPORTMAP }}}'
-  </head>
-  <body>
-    <div data-ssr>'${{{ BODY }}}'</div>
-    <script>
-      window.process = { env: { NODE_ENV: '${{{ NODE_ENV }}}' } };
-    </script>
-    <script>
-      '${{{ SMBLS_IIFE }}}';
-    </script>
-    <script>
-      '${{{ BUNDLE }}}';
-    </script>
-    '${{{ EDITOR }}}'
-  </body>
-</html>

package/src/utils/deepDestringify.js

@@ -1,149 +0,0 @@
-'use strict';
-
-// Inspired by @symbo.ls/utils deepDestringifyFunctions but implemented locally to remove the
-// dependency on the external package. The implementation is pure-JS and node
-// friendly (it works whether `window` is available or not).
-//
-// The function walks an object tree and converts any string that represents a
-// JavaScript function back into an executable function by using `eval`.
-//
-//   const obj = { fn: "(x) => x * 2" }
-//   deepDestringifyFunctions(obj) // => { fn: [Function] }
-//
-// It keeps the structure (arrays / nested objects) intact and leaves all other
-// primitives untouched.
-//
-// NOTE: Executing code coming from a string is potentially dangerous. Make sure
-// the input is trusted or sandboxed appropriately before calling this helper.
-
-/**
- * Tests if the provided string represents a JavaScript function.
- * We intentionally keep the (rather heavy) RegExp logic from the original
- * implementation because it has been field-tested and produces reliable
- * results for arrow functions, classic functions and async functions.
- *
- * @param {string} str
- * @returns {boolean}
- */
-function hasFunction(str) {
-  if (!str) return false;
-
-  const trimmed = str.trim().replace(/\n\s*/g, ' ').trim();
-  if (trimmed === '' || trimmed === '{}' || trimmed === '[]') return false;
-
-  const patterns = [
-    /^\(\s*\{[^}]*\}\s*\)\s*=>/, // ({ ... }) =>
-    /^(\([^)]*\)|[^=]*)\s*=>/, // () => or x =>
-    /^function[\s(]/, // function () {}
-    /^async\s+/, // async () => {}
-    /^\(\s*function/, // (function () { })
-    /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/, // named =>
-  ];
-
-  const isFunctionLike = patterns.some((p) => p.test(trimmed));
-  const isObjectLiteral = trimmed.startsWith('{') && !trimmed.includes('=>');
-  const isArrayLiteral = trimmed.startsWith('[');
-  const isJSONLike = /^["[{]/.test(trimmed) && !trimmed.includes('=>');
-
-  return isFunctionLike && !isObjectLiteral && !isArrayLiteral && !isJSONLike;
-}
-
-const isString = (val) => typeof val === 'string';
-const isArray = Array.isArray;
-const isObject = (val) => val !== null && typeof val === 'object' && !isArray(val);
-
-/**
- * Recursively converts stringified functions inside an object (or array) back
- * to real functions.
- *
- * @template T
- * @param {T} obj - The source object (or array).
- * @param {any} [target={}] - Used internally for recursion, pass nothing.
- * @returns {T} A new object with functions revived.
- */
-export function deepDestringifyFunctions(obj, target = Array.isArray(obj) ? [] : {}) {
-  for (const prop in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue;
-
-    const value = obj[prop];
-
-    // 1. String ==> maybe turn into function
-    if (isString(value)) {
-      if (hasFunction(value)) {
-        try {
-          const fn = (0, Function)('return (' + value + ')')();
-          target[prop] = fn;
-        } catch (_) {
-          // If evaluation fails, preserve the original string.
-          target[prop] = value;
-        }
-      } else {
-        target[prop] = value;
-      }
-      continue;
-    }
-
-    // 2. Array ==> recurse per entry
-    if (isArray(value)) {
-      target[prop] = [];
-      value.forEach((item) => {
-        if (isString(item)) {
-          if (hasFunction(item)) {
-            try {
-              const fn = (0, Function)('return (' + item + ')')();
-              target[prop].push(fn);
-            } catch (_) {
-              target[prop].push(item);
-            }
-          } else {
-            target[prop].push(item);
-          }
-        } else if (isObject(item) || isArray(item)) {
-          target[prop].push(deepDestringifyFunctions(item));
-        } else {
-          target[prop].push(item);
-        }
-      });
-      continue;
-    }
-
-    // 3. Nested object ==> recurse
-    if (isObject(value)) {
-      target[prop] = deepDestringifyFunctions(value);
-      continue;
-    }
-
-    // 4. Primitive (number, boolean, function, null, undefined)
-    target[prop] = value;
-  }
-
-  return target;
-}
-
-/**
- * Strips function-like strings from an object tree, replacing them with null.
- * Use in environments where eval/Function are blocked (e.g. Cloudflare Workers)
- * so that brender renders empty placeholders instead of raw function source code.
- */
-export function stripFunctionStrings(obj, target = Array.isArray(obj) ? [] : {}) {
-  for (const prop in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue;
-    const value = obj[prop];
-    if (isString(value)) {
-      target[prop] = hasFunction(value) ? null : value;
-    } else if (isArray(value)) {
-      target[prop] = value.map((item) => {
-        if (isString(item) && hasFunction(item)) return null;
-        if (isObject(item) || isArray(item)) return stripFunctionStrings(item);
-        return item;
-      });
-    } else if (isObject(value)) {
-      target[prop] = stripFunctionStrings(value);
-    } else {
-      target[prop] = value;
-    }
-  }
-  return target;
-}
-
-export default deepDestringifyFunctions;

package/src/utils/funcql-transpile.js

@@ -1,346 +0,0 @@
-'use strict';
-
-/**
- * Transpile a stringified JavaScript function into a funcql schema.
- *
- * Handles common DOMQL patterns:
- *  - Property access:  (el, s) => s.visible
- *  - Ternary:          (el, s) => s.active ? 'yes' : 'no'
- *  - Negation:         (el, s) => !s.hidden
- *  - Comparison:       (el, s) => s.count > 0
- *  - el.call():        (el, s) => el.call("polyglot", s.key)
- *  - Logical AND/OR:   (el, s) => s.a && s.b
- *  - Void comparison:  (el, s) => s.x !== void 0
- *  - Concatenation:    (el, s) => s.count + " items"
- *
- * For unsupported patterns, returns null (caller should keep the original string).
- *
- * @param {string} source - stringified JS function
- * @returns {{ schema: *, args: string[] } | null}
- */
-export const transpile = (source) => {
-  if (typeof source !== 'string') return null;
-
-  const trimmed = source.trim();
-
-  // Parse arrow function: (args) => body
-  const arrowMatch = trimmed.match(/^\(?([^)]*?)\)?\s*=>\s*([\s\S]+)$/);
-  if (!arrowMatch) return null;
-
-  const rawArgs = arrowMatch[1];
-  const body = arrowMatch[2].trim();
-
-  // Extract argument names
-  const args = rawArgs
-    .split(',')
-    .map((a) => a.trim())
-    .filter(Boolean);
-
-  // Skip multi-line / block bodies
-  if (body.startsWith('{')) return null;
-
-  // Map standard DOMQL arg names to funcql context paths
-  // (el, s) → el = element, s = state
-  // (el, s, ctx) → ctx = context
-  const argMap = buildArgMap(args);
-
-  // Try to transpile the expression body
-  const schema = transpileExpr(body, argMap);
-  if (schema === null) return null;
-
-  return { schema, args };
-};
-
-/**
- * Build a mapping from arg names to funcql context paths.
- * Standard DOMQL patterns: (el, s, ctx) or (element, state, context)
- */
-const buildArgMap = (args) => {
-  const map = {};
-  if (args[0]) map[args[0]] = 'el'; // element
-  if (args[1]) map[args[1]] = 'state'; // state
-  if (args[2]) map[args[2]] = 'context'; // context
-  return map;
-};
-
-/**
- * Transpile a single JS expression to a funcql schema node.
- */
-const transpileExpr = (expr, argMap) => {
-  const e = expr.trim();
-  if (!e) return null;
-
-  // Ternary: condition ? thenExpr : elseExpr
-  const ternary = splitTernary(e);
-  if (ternary) {
-    const cond = transpileExpr(ternary.condition, argMap);
-    const then_ = transpileExpr(ternary.consequent, argMap);
-    const else_ = transpileExpr(ternary.alternate, argMap);
-    if (cond !== null && then_ !== null && else_ !== null) {
-      return { if: [cond, then_, else_] };
-    }
-    return null;
-  }
-
-  // el.call("polyglot", ...) → ['call', 'polyglot', ...args]
-  const callMatch = e.match(/^(\w+)\.call\((.+)\)$/);
-  if (callMatch) {
-    const callArgs = splitCallArgs(callMatch[2]);
-    if (callArgs) {
-      const resolvedArgs = callArgs.map((a) => transpileExpr(a.trim(), argMap));
-      if (resolvedArgs.every((a) => a !== null)) {
-        return ['call', ...resolvedArgs];
-      }
-    }
-    return null;
-  }
-
-  // Logical OR: a || b (lowest precedence, split first)
-  {
-    const parts = splitOnOperator(e, '||');
-    if (parts) {
-      const left = transpileExpr(parts.left, argMap);
-      const right = transpileExpr(parts.right, argMap);
-      if (left !== null && right !== null) {
-        return ['||', left, right];
-      }
-      return null;
-    }
-  }
-
-  // Logical AND: a && b
-  {
-    const parts = splitOnOperator(e, '&&');
-    if (parts) {
-      const left = transpileExpr(parts.left, argMap);
-      const right = transpileExpr(parts.right, argMap);
-      if (left !== null && right !== null) {
-        return ['&&', left, right];
-      }
-      return null;
-    }
-  }
-
-  // Comparison operators: ===, !==, >, <, >=, <=
-  for (const op of ['!==', '===', '>=', '<=', '>', '<']) {
-    const parts = splitOnOperator(e, op);
-    if (parts) {
-      const left = transpileExpr(parts.left, argMap);
-      const right = transpileExpr(parts.right, argMap);
-      if (left !== null && right !== null) {
-        return [op, left, right];
-      }
-      return null;
-    }
-  }
-
-  // Negation: !expr
-  if (e.startsWith('!')) {
-    const inner = transpileExpr(e.slice(1).trim(), argMap);
-    if (inner !== null && typeof inner === 'string') {
-      return '!' + inner;
-    }
-    return null;
-  }
-
-  // String concatenation with + (left-associative, collect all parts)
-  if (e.includes('+') && !e.startsWith('"') && !e.startsWith("'")) {
-    const allParts = splitAllOnOperator(e, '+');
-    if (allParts && allParts.length >= 2) {
-      const transpiled = allParts.map((p) => transpileExpr(p.trim(), argMap));
-      if (transpiled.every((t) => t !== null)) {
-        // Build left-associative tree: ['+', ['+', a, b], c]
-        let result = transpiled[0];
-        for (let i = 1; i < transpiled.length; i++) {
-          result = ['+', result, transpiled[i]];
-        }
-        return result;
-      }
-    }
-  }
-
-  // String literal: "..." or '...' → prefix with = so funcql treats as literal
-  if ((e.startsWith('"') && e.endsWith('"')) || (e.startsWith("'") && e.endsWith("'"))) {
-    return '=' + e.slice(1, -1);
-  }
-
-  // void 0 / undefined — use special sentinel that funcql evaluate can handle
-  if (e === 'void 0' || e === 'undefined') return '__undefined__';
-
-  // Numeric literal
-  if (/^-?\d+(\.\d+)?$/.test(e)) return Number(e);
-
-  // Boolean
-  if (e === 'true') return true;
-  if (e === 'false') return false;
-  if (e === 'null') return null;
-
-  // Empty string
-  if (e === '""' || e === "''") return '';
-
-  // Property access path: s.x.y.z → remap arg names
-  if (/^[\w$.[\]]+$/.test(e) && !e.includes('(')) {
-    return remapPath(e, argMap);
-  }
-
-  // Bracket access: s["key"] or s[variable]
-  // Skip for now — too complex
-
-  return null;
-};
-
-/**
- * Remap argument names in a dot-path to funcql context paths.
- * e.g. s.root.lang → state.root.lang (when argMap says s→state)
- */
-const remapPath = (path, argMap) => {
-  const parts = path.split('.');
-  const first = parts[0];
-  if (argMap[first]) {
-    parts[0] = argMap[first];
-    return parts.join('.');
-  }
-  return path;
-};
-
-/**
- * Split a ternary expression respecting nesting.
- * Returns { condition, consequent, alternate } or null.
- */
-const splitTernary = (expr) => {
-  let depth = 0;
-  let qIdx = -1;
-  let cIdx = -1;
-
-  for (let i = 0; i < expr.length; i++) {
-    const ch = expr[i];
-    if (ch === '(' || ch === '[' || ch === '{') depth++;
-    else if (ch === ')' || ch === ']' || ch === '}') depth--;
-    else if (ch === '?' && depth === 0 && qIdx === -1) qIdx = i;
-    else if (ch === ':' && depth === 0 && qIdx !== -1) {
-      cIdx = i;
-      break;
-    }
-    // Skip strings
-    if (ch === '"' || ch === "'") {
-      const quote = ch;
-      i++;
-      while (i < expr.length && expr[i] !== quote) {
-        if (expr[i] === '\\') i++;
-        i++;
-      }
-    }
-  }
-
-  if (qIdx === -1 || cIdx === -1) return null;
-
-  return {
-    condition: expr.slice(0, qIdx).trim(),
-    consequent: expr.slice(qIdx + 1, cIdx).trim(),
-    alternate: expr.slice(cIdx + 1).trim(),
-  };
-};
-
-/**
- * Split expression on a binary operator (respecting nesting).
- * Returns { left, right } or null.
- */
-const splitOnOperator = (expr, op) => {
-  let depth = 0;
-  const opLen = op.length;
-
-  for (let i = 0; i < expr.length - opLen + 1; i++) {
-    const ch = expr[i];
-    if (ch === '(' || ch === '[' || ch === '{') depth++;
-    else if (ch === ')' || ch === ']' || ch === '}') depth--;
-    // Skip strings
-    if (ch === '"' || ch === "'") {
-      const quote = ch;
-      i++;
-      while (i < expr.length && expr[i] !== quote) {
-        if (expr[i] === '\\') i++;
-        i++;
-      }
-      continue;
-    }
-    if (depth === 0 && expr.slice(i, i + opLen) === op) {
-      // Make sure we're not inside a longer operator
-      const before = i > 0 ? expr[i - 1] : '';
-      const after = i + opLen < expr.length ? expr[i + opLen] : '';
-      // Skip if this is part of ===, !==, etc.
-      if (op === '=' && (before === '!' || before === '=' || after === '=')) continue;
-      if (op === '>' && before === '=') continue;
-      if (op === '<' && after === '=') continue;
-
-      return {
-        left: expr.slice(0, i).trim(),
-        right: expr.slice(i + opLen).trim(),
-      };
-    }
-  }
-  return null;
-};
-
-/**
- * Split expression on ALL occurrences of a binary operator (respecting nesting).
- * Returns array of parts or null.
- */
-const splitAllOnOperator = (expr, op) => {
-  const parts = [];
-  let depth = 0;
-  let start = 0;
-  const opLen = op.length;
-
-  for (let i = 0; i < expr.length; i++) {
-    const ch = expr[i];
-    if (ch === '(' || ch === '[' || ch === '{') depth++;
-    else if (ch === ')' || ch === ']' || ch === '}') depth--;
-    if (ch === '"' || ch === "'") {
-      const quote = ch;
-      i++;
-      while (i < expr.length && expr[i] !== quote) {
-        if (expr[i] === '\\') i++;
-        i++;
-      }
-      continue;
-    }
-    if (depth === 0 && expr.slice(i, i + opLen) === op) {
-      parts.push(expr.slice(start, i));
-      start = i + opLen;
-    }
-  }
-  parts.push(expr.slice(start));
-
-  if (parts.length < 2) return null;
-  return parts;
-};
-
-/**
- * Split function call arguments respecting nesting.
- */
-const splitCallArgs = (str) => {
-  const args = [];
-  let depth = 0;
-  let start = 0;
-
-  for (let i = 0; i < str.length; i++) {
-    const ch = str[i];
-    if (ch === '(' || ch === '[' || ch === '{') depth++;
-    else if (ch === ')' || ch === ']' || ch === '}') depth--;
-    else if (ch === ',' && depth === 0) {
-      args.push(str.slice(start, i));
-      start = i + 1;
-    }
-    // Skip strings
-    if (ch === '"' || ch === "'") {
-      const quote = ch;
-      i++;
-      while (i < str.length && str[i] !== quote) {
-        if (str[i] === '\\') i++;
-        i++;
-      }
-    }
-  }
-  args.push(str.slice(start));
-  return args.filter((a) => a.trim());
-};