stickyflow 0.8.0 → 0.9.0

package/dist/{chunk-LNW5VIEA.cjs → chunk-QL7MNEMT.cjs}

@@ -1069,7 +1069,8 @@ var NAMED_BLOCK_KINDS = [
   "Net",
   "Symbol",
   "Port",
-  "DataSource"
+  "DataSource",
+  "Repeat"
 ];
 var SIDES = ["top", "bottom", "left", "right"];
 var isSide = (s) => SIDES.includes(s);
@@ -1128,7 +1129,43 @@ function parseList(cursor) {
   cursor.expect("rbracket", "']'");
   return { type: "list", values };
 }
+var ARITHMETIC = /* @__PURE__ */ new Set(["+", "-", "*", "/", ">", "<", ">=", "<=", "==", "!=", "&&", "||"]);
+function startsComputed(cursor) {
+  const first = cursor.peek();
+  if (first.type === "op" && first.value === "-") {
+    return true;
+  }
+  if (first.type !== "number" && first.type !== "ident" && first.type !== "lparen") {
+    return false;
+  }
+  for (let offset = 0; ; offset++) {
+    const token = cursor.peek(offset);
+    if (token.type === "newline" || token.type === "semi" || token.type === "rbrace" || token.type === "eof") {
+      return false;
+    }
+    if (token.type === "lparen" || token.type === "op" && ARITHMETIC.has(token.value)) {
+      return true;
+    }
+    if (token.type === "ident" && cursor.peek(offset - 1).type === "comma") {
+      return true;
+    }
+    if (offset === 0 && token.type === "ident" && cursor.peek(1).type === "comma") {
+      return true;
+    }
+  }
+}
+function parseComputed(cursor) {
+  const items = [parseExpression(cursor)];
+  while (cursor.at("comma")) {
+    cursor.next();
+    items.push(parseExpression(cursor));
+  }
+  return { type: "expr", items };
+}
 function parseValue(cursor, allowTuple = true) {
+  if (allowTuple && startsComputed(cursor)) {
+    return parseComputed(cursor);
+  }
   const token = cursor.peek();
   switch (token.type) {
     case "string":
@@ -1594,6 +1631,8 @@ function emitValue(value) {
       return `[${value.values.map(emitValue).join(", ")}]`;
     case "ident":
       return value.segments.join(".");
+    case "expr":
+      return value.items.map((item) => emitExpression(item)).join(", ");
     case "endpoint": {
       let output = value.segments.join(".");
       if (value.side) {
@@ -1673,6 +1712,8 @@ var STYLE_ORDER = [
   "dash",
   "shadow",
   "opacity",
+  "blur",
+  "blend",
   "icon",
   "route",
   "marker",
@@ -1851,6 +1892,353 @@ function isSwimlaneObject(canvasObject) {
   return canvasObject.objectType === "swimlane" && canvasObject.swimlane !== void 0;
 }
 
+// src/sflLanguage/expansion/repeat.ts
+var RESERVED = /* @__PURE__ */ new Set(["columns", "rows", "count", "step", "origin", "seed", "jitter", "chance", "order", "where"]);
+var MAX_CELLS = 2e4;
+var MAX_VALUES = 1e6;
+var Random = class {
+  state;
+  constructor(seed) {
+    this.state = seed >>> 0;
+  }
+  // mulberry32: a small generator that gives the same numbers for the same seed, on every machine.
+  next() {
+    this.state = this.state + 1831565813 >>> 0;
+    let t = this.state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+};
+function fail(scope, message) {
+  throw new Error(`Repeat ${scope.repeat}: ${message}`);
+}
+function numberOf(scope, value, what) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    fail(scope, `${what} needs a number`);
+  }
+  return value;
+}
+function rgbOf(scope, value) {
+  const match = typeof value === "string" ? /^#([0-9a-f]{6})$/i.exec(value) : null;
+  if (!match) {
+    fail(scope, 'a color has to be written as "#rrggbb"');
+  }
+  const n = Number.parseInt(match[1], 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+var hexOf = (rgb) => `#${rgb.map(
+  (channel) => Math.round(Math.max(0, Math.min(255, channel))).toString(16).padStart(2, "0")
+).join("")}`;
+function callFunction(scope, name, args) {
+  const number = (index) => numberOf(scope, args[index], `${name}()`);
+  switch (name) {
+    case "random": {
+      if (args.length === 0) {
+        return scope.random.next();
+      }
+      const low = args.length === 1 ? 0 : number(0);
+      const high = args.length === 1 ? number(0) : number(1);
+      return low + scope.random.next() * (high - low);
+    }
+    case "pick": {
+      if (args.length === 0) {
+        fail(scope, "pick() needs at least one value");
+      }
+      return args[Math.floor(scope.random.next() * args.length)];
+    }
+    case "exp":
+      return Math.exp(number(0));
+    case "pow":
+      return number(0) ** number(1);
+    case "dist":
+      return Math.hypot(number(0) - number(2), number(1) - number(3));
+    case "mix": {
+      const from = rgbOf(scope, args[0]);
+      const to = rgbOf(scope, args[1]);
+      const amount = Math.max(0, Math.min(1, number(2)));
+      return hexOf(from.map((channel, index) => channel + (to[index] - channel) * amount));
+    }
+    case "shade": {
+      const factor = number(1);
+      return hexOf(rgbOf(scope, args[0]).map((channel) => channel * factor));
+    }
+    case "floor":
+      return Math.floor(number(0));
+    case "ceil":
+      return Math.ceil(number(0));
+    case "round":
+      return Math.round(number(0));
+    case "abs":
+      return Math.abs(number(0));
+    case "sqrt":
+      return Math.sqrt(number(0));
+    case "sin":
+      return Math.sin(number(0));
+    case "cos":
+      return Math.cos(number(0));
+    case "min":
+      return Math.min(...args.map((_, index) => number(index)));
+    case "max":
+      return Math.max(...args.map((_, index) => number(index)));
+    case "when":
+      return args[0] ? args[1] : args[2];
+    default:
+      return fail(scope, `unknown function ${name}()`);
+  }
+}
+function evaluate(scope, expr) {
+  switch (expr.kind) {
+    case "number":
+    case "string":
+    case "boolean":
+      return expr.value;
+    case "ref": {
+      const name = expr.path.join(".");
+      const value = scope.vars.get(name);
+      if (value === void 0) {
+        fail(scope, `unknown name ${name}`);
+      }
+      return value;
+    }
+    case "unary": {
+      const operand = evaluate(scope, expr.operand);
+      return expr.operator === "-" ? -numberOf(scope, operand, "a minus") : !operand;
+    }
+    case "call":
+      return callFunction(
+        scope,
+        expr.callee.join("."),
+        expr.args.map((arg) => evaluate(scope, arg))
+      );
+    case "binary": {
+      const left = evaluate(scope, expr.left);
+      const right = evaluate(scope, expr.right);
+      switch (expr.operator) {
+        case "+":
+          return typeof left === "string" || typeof right === "string" ? `${left}${right}` : numberOf(scope, left, "+") + numberOf(scope, right, "+");
+        case "-":
+          return numberOf(scope, left, "-") - numberOf(scope, right, "-");
+        case "*":
+          return numberOf(scope, left, "*") * numberOf(scope, right, "*");
+        case "/":
+          return numberOf(scope, left, "/") / numberOf(scope, right, "/");
+        case ">":
+          return numberOf(scope, left, ">") > numberOf(scope, right, ">");
+        case "<":
+          return numberOf(scope, left, "<") < numberOf(scope, right, "<");
+        case ">=":
+          return numberOf(scope, left, ">=") >= numberOf(scope, right, ">=");
+        case "<=":
+          return numberOf(scope, left, "<=") <= numberOf(scope, right, "<=");
+        case "==":
+          return left === right;
+        case "!=":
+          return left !== right;
+        case "&&":
+          return Boolean(left) && Boolean(right);
+        case "||":
+          return Boolean(left) || Boolean(right);
+      }
+    }
+  }
+}
+var round2 = (value) => Math.round(value * 1e3) / 1e3;
+function resolveValue(scope, value) {
+  if (value.type !== "expr") {
+    return value;
+  }
+  const results = value.items.map((item) => evaluate(scope, item));
+  if (results.length === 1) {
+    const [only] = results;
+    if (typeof only === "number") {
+      return { type: "number", value: round2(numberOf(scope, only, "a value")) };
+    }
+    if (typeof only === "string") {
+      return { type: "string", value: only };
+    }
+    return { type: "ident", segments: [String(only)] };
+  }
+  return { type: "tuple", values: results.map((result) => round2(numberOf(scope, result, "a tuple"))) };
+}
+function propertiesOf(scope, properties) {
+  return properties.map((property) => ({ key: property.key, value: resolveValue(scope, property.value) }));
+}
+function entryOf(scope, entry, suffix) {
+  switch (entry.type) {
+    case "property":
+      return {
+        type: "property",
+        property: { key: entry.property.key, value: resolveValue(scope, entry.property.value) }
+      };
+    case "layout":
+      return { type: "layout", layout: { properties: propertiesOf(scope, entry.layout.properties) } };
+    case "style":
+      return { type: "style", style: { ...entry.style, properties: propertiesOf(scope, entry.style.properties) } };
+    case "block":
+      return { type: "block", block: instance(scope, entry.block, suffix) };
+    default:
+      return entry;
+  }
+}
+function instance(scope, block2, suffix) {
+  return {
+    ...block2,
+    name: `${block2.name}${suffix}`,
+    entries: block2.entries.map((entry) => entryOf(scope, entry, suffix))
+  };
+}
+function propertyOf(block2, key) {
+  for (const entry of block2.entries) {
+    if (entry.type === "property" && entry.property.key === key) {
+      return entry.property.value;
+    }
+  }
+  return void 0;
+}
+function numbersOf(block2, key) {
+  for (const entry of block2.entries) {
+    if (entry.type === "property" && entry.property.key === key) {
+      const value = entry.property.value;
+      if (value.type === "number") {
+        return [value.value];
+      }
+      if (value.type === "tuple") {
+        return value.values;
+      }
+    }
+  }
+  return void 0;
+}
+function expandRepeat(block2) {
+  const scope = { vars: /* @__PURE__ */ new Map(), random: new Random(0), repeat: block2.name };
+  const count = numbersOf(block2, "count")?.[0];
+  const columns = Math.max(1, Math.floor(count ?? numbersOf(block2, "columns")?.[0] ?? 1));
+  const rows = count === void 0 ? Math.max(1, Math.floor(numbersOf(block2, "rows")?.[0] ?? 1)) : 1;
+  const total = columns * rows;
+  if (total > MAX_CELLS) {
+    fail(scope, `${total} cells are too many, the limit is ${MAX_CELLS}`);
+  }
+  const [stepX = 0, stepY = stepX] = numbersOf(block2, "step") ?? [];
+  const [originX = 0, originY = 0] = numbersOf(block2, "origin") ?? [];
+  const seed = numbersOf(block2, "seed")?.[0] ?? 0;
+  const jitter = numbersOf(block2, "jitter")?.[0] ?? 0;
+  const chance = numbersOf(block2, "chance")?.[0] ?? 1;
+  const diagonal = propertyOf(block2, "order")?.type === "ident" && propertyOf(block2, "order").segments[0] === "diagonal";
+  const condition = propertyOf(block2, "where");
+  const helpers = block2.entries.flatMap(
+    (entry) => entry.type === "property" && entry.property.value.type === "expr" && !RESERVED.has(entry.property.key) ? [entry.property] : []
+  );
+  const templates = block2.entries.flatMap((entry) => entry.type === "block" ? [entry.block] : []);
+  if (templates.some((template) => template.kind === "Repeat")) {
+    fail(scope, "a Repeat cannot hold another Repeat");
+  }
+  if (total * Math.max(1, templates.length) > MAX_VALUES) {
+    fail(scope, "too many blocks");
+  }
+  const cells = [];
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < columns; col++) {
+      cells.push([col, row]);
+    }
+  }
+  if (diagonal) {
+    cells.sort((a, b) => a[0] + a[1] - (b[0] + b[1]) || a[0] - b[0]);
+  }
+  const out = [];
+  for (const [col, row] of cells) {
+    {
+      const index = row * columns + col;
+      scope.random = new Random(Math.imul(seed + 1, 2654435761) ^ Math.imul(index + 1, 2246822507));
+      if (chance < 1 && scope.random.next() >= chance) {
+        continue;
+      }
+      const spread = () => jitter > 0 ? (scope.random.next() * 2 - 1) * jitter : 0;
+      scope.vars = /* @__PURE__ */ new Map([
+        ["col", col],
+        ["row", row],
+        ["index", index],
+        ["count", total],
+        ["columns", columns],
+        ["rows", rows],
+        ["x", round2(originX + col * stepX + spread())],
+        ["y", round2(originY + row * stepY + spread())]
+      ]);
+      for (const helper of helpers) {
+        const value = resolveValue(scope, helper.value);
+        if (value.type === "number" || value.type === "string") {
+          scope.vars.set(helper.key, value.value);
+        } else if (value.type === "ident") {
+          scope.vars.set(helper.key, value.segments[0] === "true" ? 1 : 0);
+        } else {
+          fail(scope, `${helper.key} needs a number`);
+        }
+      }
+      if (condition && condition.type === "expr") {
+        const result = condition.items.map((item) => evaluate(scope, item))[0];
+        if (!result) {
+          continue;
+        }
+      }
+      const suffix = rows === 1 ? `_${col}` : `_${col}_${row}`;
+      for (const template of templates) {
+        out.push(instance(scope, template, suffix));
+      }
+    }
+  }
+  return out;
+}
+function expandBlocks(blocks) {
+  return blocks.flatMap((block2) => {
+    if (block2.kind === "Repeat") {
+      return expandRepeat(block2);
+    }
+    if (!block2.entries.some((entry) => entry.type === "block")) {
+      return [block2];
+    }
+    return [
+      {
+        ...block2,
+        entries: block2.entries.flatMap(
+          (entry) => entry.type === "block" ? (entry.block.kind === "Repeat" ? expandRepeat(entry.block) : expandBlocks([entry.block])).map((child) => ({
+            type: "block",
+            block: child
+          })) : [entry]
+        )
+      }
+    ];
+  });
+}
+function checkNoComputed(blocks) {
+  for (const block2 of blocks) {
+    for (const entry of block2.entries) {
+      const properties = entry.type === "property" ? [entry.property] : entry.type === "layout" ? entry.layout.properties : entry.type === "style" ? entry.style.properties : [];
+      for (const property of properties) {
+        if (property.value.type === "expr") {
+          throw new Error(
+            `${block2.kind} ${block2.name}: ${property.key} is computed, and only a Repeat can work out a computed value`
+          );
+        }
+      }
+      if (entry.type === "block") {
+        checkNoComputed([entry.block]);
+      }
+    }
+  }
+}
+function expandRepeats(doc) {
+  const has = (blocks) => blocks.some(
+    (block2) => block2.kind === "Repeat" || block2.entries.some((entry) => entry.type === "block" ? has([entry.block]) : false)
+  );
+  if (!has(doc.blocks)) {
+    checkNoComputed(doc.blocks);
+    return doc;
+  }
+  const expanded = { ...doc, blocks: expandBlocks(doc.blocks) };
+  checkNoComputed(expanded.blocks);
+  return expanded;
+}
+
 // src/sflSemantic/ast/valueAccess.ts
 function asString(value) {
   if (!value) {
@@ -3155,7 +3543,7 @@ function resolveCanvasState(document) {
 
 // src/sflSemantic/sflToCanvasState.ts
 function sflToCanvasState(source) {
-  return resolveCanvasState(parseSource(source));
+  return resolveCanvasState(expandRepeats(parseSource(source)));
 }
 
 // src/svg/domContract/version.ts
@@ -5412,6 +5800,7 @@ exports.elementCenter = elementCenter;
 exports.ellipsizeToWidth = ellipsizeToWidth;
 exports.errorBarRange = errorBarRange;
 exports.estimateTextWidth = estimateTextWidth;
+exports.expandRepeats = expandRepeats;
 exports.extrudeFootprint = extrudeFootprint;
 exports.finite = finite;
 exports.flattenPath = flattenPath;
@@ -5503,5 +5892,5 @@ exports.tokenizeSource = tokenizeSource;
 exports.topRoundedRectPath = topRoundedRectPath;
 exports.wrapText = wrapText;
 exports.zoneColorAtValue = zoneColorAtValue;
-//# sourceMappingURL=chunk-LNW5VIEA.cjs.map
-//# sourceMappingURL=chunk-LNW5VIEA.cjs.map
+//# sourceMappingURL=chunk-QL7MNEMT.cjs.map
+//# sourceMappingURL=chunk-QL7MNEMT.cjs.map