@symbo.ls/mermaid 3.14.1 → 3.14.5

package/src/template.html

@@ -1,22 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    '${{{ META }}}'
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta charset="UTF-8" />
-    '${{{ 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());
-};

package/src/utils/logger.js

@@ -1,131 +0,0 @@
-// Lightweight logger replacement (no external deps)
-// Provides log.trace/debug/info/warn/error/fatal
-
-const LEVELS = {
-  trace: 10,
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  fatal: 60,
-};
-
-let currentLevelName = process.env.LOG_LEVEL || 'info';
-if (!Object.prototype.hasOwnProperty.call(LEVELS, currentLevelName)) currentLevelName = 'info';
-let currentLevel = LEVELS[currentLevelName];
-
-let isLocal = process.env.NODE_ENV === 'local' || process.env.NODE_ENV === 'development';
-
-const COLORS = {
-  trace: '\x1b[34m',
-  debug: '\x1b[36m',
-  info: '\x1b[32m',
-  warn: '\x1b[33m',
-  error: '\x1b[31m',
-  fatal: '\x1b[35m',
-  reset: '\x1b[0m',
-};
-
-function pad(num, size = 2) {
-  let s = String(num);
-  while (s.length < size) s = '0' + s;
-  return s;
-}
-
-function utcTimestamp() {
-  const d = new Date();
-  const yyyy = d.getUTCFullYear();
-  const mm = pad(d.getUTCMonth() + 1);
-  const dd = pad(d.getUTCDate());
-  const hh = pad(d.getUTCHours());
-  const min = pad(d.getUTCMinutes());
-  const ss = pad(d.getUTCSeconds());
-  const ms = pad(d.getUTCMilliseconds(), 3);
-  return `${yyyy}-${mm}-${dd} ${hh}:${min}:${ss}.${ms} +0000`;
-}
-
-function shouldLog(levelName) {
-  return LEVELS[levelName] >= currentLevel;
-}
-
-function stringifyMeta(metaObjects) {
-  if (!metaObjects.length) return '';
-  try {
-    return JSON.stringify(Object.assign({}, ...metaObjects));
-  } catch {
-    return '';
-  }
-}
-
-function makeLoggerFn(levelName) {
-  const color = COLORS[levelName];
-  const useStderr = levelName === 'error' || levelName === 'fatal';
-  const stream = useStderr ? console.error : console.log;
-
-  return (...args) => {
-    if (!shouldLog(levelName)) return;
-
-    if (!args.length) {
-      stream('');
-      return;
-    }
-
-    let msg = '';
-    let metaObjects = [];
-
-    if (typeof args[0] === 'string') {
-      msg = args[0];
-      metaObjects = args.slice(1).filter((a) => typeof a === 'object' && a !== null);
-
-      if (levelName === 'error' && args[1] instanceof Error) {
-        metaObjects.push({
-          err: {
-            message: args[1].message,
-            stack: args[1].stack,
-          },
-        });
-      }
-    } else {
-      metaObjects = args.filter((a) => typeof a === 'object' && a !== null);
-    }
-
-    const metaStr = stringifyMeta(metaObjects);
-    const timeStr = utcTimestamp();
-    const lvl = levelName.toUpperCase();
-
-    let output = `[${timeStr}] ${lvl}: ${msg}`;
-    if (metaStr) output += ` ${metaStr}`;
-
-    if (isLocal && color) {
-      output = `${color}${output}${COLORS.reset}`;
-    }
-
-    stream(output);
-  };
-}
-
-const log = {};
-for (const lvl of Object.keys(LEVELS)) {
-  log[lvl] = makeLoggerFn(lvl);
-}
-
-Object.defineProperty(log, 'level', {
-  get: () => currentLevelName,
-  set: (lvl) => {
-    if (Object.prototype.hasOwnProperty.call(LEVELS, lvl)) {
-      currentLevelName = lvl;
-      currentLevel = LEVELS[lvl];
-    }
-  },
-});
-
-export const updateLoggerConfig = (config) => {
-  if (config?.logging?.level) {
-    log.level = config.logging.level;
-  }
-  if (config?.env) {
-    isLocal = config.env === 'local' || config.env === 'development';
-  }
-};
-
-export default log;

package/src/utils/vartranformer.js

@@ -1,30 +0,0 @@
-'use strict';
-import log from './logger.js';
-
-export default function replaceVariablesInFileSync(filedata, replacementObject, opts = {}) {
-  try {
-    const regex = /(['"])\${{{\s*([^}\s]+)\s*}}}\1/g;
-    if (!filedata) {
-      const error = new Error('File data is empty');
-      log.error('[REQ_FLOW] File data is empty in replaceVariablesInFileSync');
-      throw error;
-    }
-
-    const replacedData = filedata.replace(regex, (match, quoteChar, variableName) => {
-      if (Object.hasOwn(replacementObject, variableName)) {
-        const value = replacementObject[variableName];
-        return opts.allowScript ? value : value.replace(/<\/?script>/g, '&lt;/?script&gt;');
-      } else {
-        log.warn(
-          `[REQ_FLOW] Missing replacement value for ${JSON.stringify({ name: variableName })}`,
-        );
-        return match;
-      }
-    });
-
-    return replacedData;
-  } catch (err) {
-    log.error(`[REQ_FLOW] Error in replaceVariablesInFileSync: ${err}`);
-    return null;
-  }
-}