slidemind 0.3.19 → 0.4.0

package/src/builders/concept-lists.mjs

@@ -0,0 +1,270 @@
+// Lists. The reader declares each list the design draws in its top-level
+// `lists` — items with a mark painted in front of every one, the mark's kind
+// (bullet | check | cross | number) and its paint — and the mapping writes
+// `marker` (+ `markerToken`) onto exactly those items (concept-list-decl.ts).
+// No text is an item because a field defaulted to "bullet" (x110 GTM 3: all
+// 25 texts marked, every KPI label bulleted). Older reads typed the
+// glyph into the text ("• Revenue grew") or listed the mark beside the line
+// as a disc, a tick stroke or an icon; a live read still does both now and
+// then (x102: declared `check` items AND their tick strokes). Each of those is
+// the same declaration in another spelling, and all end here as one thing: a
+// text element with `marker` (+ `markerToken`), its words without the glyph,
+// no mark drawn as an element, the items of one list sharing one `block`.
+// foldTextBlocks then makes the block one element with `paragraphs`, the
+// transcriber writes the items as one native list (list-jsx.mjs) and the
+// export ships native bullets — never a typed glyph, never a mark shape.
+import { bulletItems, markerOfLine, stripMarker, textLines } from "./concept-text.mjs";
+import { glyphMarkOf } from "./concept-marks.mjs";
+
+const MARKER_KINDS = new Set(["bullet", "check", "cross", "number"]);
+// A dot drawn as its own shape is at most this big (slot px) and no taller
+// than the line it marks; anything larger is a disc of the design.
+const DOT_MAX_PX = 12;
+// A mark of a few strokes (a tick, a dash) or a glyph icon is at most this big.
+const MARK_MAX_PX = 28;
+// How far a mark may stand left of its item's words.
+const MARK_GAP_PX = 40;
+const DOT_SHAPES = new Set([null, undefined, "circle", "ellipse", "rounded", "rect"]);
+const ITEM_KEYS = ["role", "weight", "color", "colorHex", "colorToken", "ground", "groundHex", "align", "markerToken", "markerHex"];
+
+const isText = (e) => e.kind === "text" && typeof e.text === "string" && e.text.trim();
+const wordless = (e) => e.text == null || e.textSource !== "visible";
+const small = (e, max) => e.w > 0 && e.h > 0 && e.w <= max && e.h <= max;
+
+// An element whose every line opens with the same glyph holds a whole list:
+// it becomes its own block, one paragraph per item.
+function splitItems(e, list, marker) {
+  e.paragraphs = list.items.map((text, i) => ({
+    id: `${e.id}-${i + 1}`, kind: "text", text, marker,
+    ...Object.fromEntries(ITEM_KEYS.filter((k) => e[k] != null).map((k) => [k, e[k]])),
+  }));
+  e.text = list.items.join("\n");
+  delete e.marker;
+}
+
+// A heading is never an item: the reader declares the structure of a block
+// with `role` (a title over its items), and a marker on the title contradicts
+// it (x105: five card titles read as bullet items, the first draft bulleted
+// them, the agent flattened the whole list). The heading keeps its words
+// without any typed glyph and without a marker.
+const HEADING_ROLES = new Set(["title", "section", "subtitle"]);
+
+// What the reader wrote on and into the texts: a declared marker, or the
+// glyph it typed, becomes `marker` and leaves the words.
+function declareFromText(elements) {
+  for (const e of elements) {
+    if (e.marker != null && (e.kind !== "text" || !MARKER_KINDS.has(e.marker) || HEADING_ROLES.has(e.role))) {
+      delete e.marker;
+      delete e.markerToken;
+      delete e.markerHex;
+    }
+    if (e.markerToken != null && !e.marker) delete e.markerToken;
+    if (!isText(e) || e.paragraphs) continue;
+    if (HEADING_ROLES.has(e.role)) {
+      const lines = textLines(e.text).map((l) => (markerOfLine(l) ? stripMarker(l, markerOfLine(l)) : l));
+      if (lines.every((l) => l.trim())) e.text = lines.join("\n");
+      continue;
+    }
+    const list = bulletItems(e.text);
+    if (list) { splitItems(e, list, e.marker ?? markerOfLine(`${list.marker} x`)); continue; }
+    const lines = textLines(e.text);
+    const typed = markerOfLine(lines[0]);
+    const marker = e.marker ?? typed;
+    if (!marker) continue;
+    if (typed || marker === "number") lines[0] = stripMarker(lines[0], marker);
+    if (!lines[0].trim()) continue;
+    e.text = lines.join("\n");
+    e.marker = marker;
+  }
+}
+
+// The glyph a mark element draws — a tick, a cross, a dot, a few strokes —
+// as a marker kind, else null (a pictogram, a carrier, a shape of the design).
+function glyphOf(e) {
+  if (e.kind === "icon") {
+    const mark = glyphMarkOf(e.icon?.query, e.icon?.keywords ?? []);
+    if (mark === "check" || mark === "cross") return mark;
+    if (mark === "dots") return "bullet";
+    const query = String(e.icon?.query ?? "").toLowerCase().replace(/\b(?:icon|outline|outlined|small|blue|black|white|green|glyph|symbol)\b/g, "").replace(/\s+/g, " ").trim();
+    return /^(?:check(?: ?mark)?|tick(?: mark)?)$/.test(query) ? "check" : /^(?:bullet|bullet point|dot)$/.test(query) ? "bullet" : null;
+  }
+  if (e.kind === "path" || e.kind === "rule") return wordless(e) && small(e, MARK_MAX_PX) ? "bullet" : null;
+  if (["disc", "shape", "badge"].includes(e.kind)) return wordless(e) && small(e, DOT_MAX_PX) && DOT_SHAPES.has(e.shape) ? "bullet" : null;
+  return null;
+}
+
+// The mark's paint, for the item's native bullet.
+const paintOf = (e) => ({
+  token: (e.kind === "disc" || e.kind === "shape" || e.kind === "badge" ? e.fillToken : e.colorToken ?? e.stroke?.colorToken) ?? null,
+  hex: (e.kind === "disc" || e.kind === "shape" || e.kind === "badge" ? e.fillHex : e.colorHex ?? e.stroke?.colorHex) ?? null,
+});
+
+// Does `e` stand directly in front of the first line of `text`?
+const inFront = (e, text, gap = MARK_GAP_PX) => text.x >= e.x + e.w - 2 && text.x - e.x - e.w <= gap
+  && e.y + e.h / 2 >= text.y - 4 && e.y + e.h / 2 <= text.y + Math.max(Math.min(text.h, 24), 12) + 4;
+
+// The element the reader drew in front of each declared item. A glyph — a
+// tick stroke, a dot, a "check" icon — IS the item's marker: it goes, its
+// paint stays on the item. A painted carrier (a numbered badge, a disc with a
+// pictogram) or a pictogram is an icon row: it stays, and the item's marker
+// goes instead, so nothing is marked twice.
+function foldDeclaredMarks(elements, linked, used) {
+  const byParent = new Map();
+  for (const e of elements) {
+    const key = e.parent ?? "";
+    if (!byParent.has(key)) byParent.set(key, []);
+    byParent.get(key).push(e);
+  }
+  const hasKids = new Set(elements.map((e) => e.parent).filter(Boolean));
+  for (const item of elements) {
+    if (!item.marker || !isText(item) || item.paragraphs) continue;
+    const marks = (byParent.get(item.parent ?? "") ?? []).filter((e) => e !== item && !isText(e) && e.kind !== "text" && !linked.has(e.id) && !used.has(e.id)
+      && !e.image?.assetUseId && (e.kind === "image" || small(e, 48)) && inFront(e, item));
+    if (!marks.length) continue;
+    const mark = marks.sort((a, b) => (item.x - b.x - b.w) - (item.x - a.x - a.w))[0];
+    const glyph = glyphOf(mark);
+    if (glyph && !hasKids.has(mark.id)) {
+      const paint = paintOf(mark);
+      if (item.markerToken == null && paint.token) item.markerToken = paint.token;
+      if (item.markerHex == null && paint.hex) item.markerHex = paint.hex;
+      used.add(mark.id);
+    } else {
+      delete item.marker;
+      delete item.markerToken;
+      delete item.markerHex;
+    }
+  }
+}
+
+// The pairs the reader declared as rows of one set: a dot and its text.
+function declaredPairs(repeats) {
+  const pairs = new Set();
+  for (const g of repeats ?? []) for (const m of g.members ?? []) {
+    if (!Array.isArray(m)) continue;
+    for (const a of m) for (const b of m) if (a !== b) pairs.add(`${a}>${b}`);
+  }
+  return pairs;
+}
+
+// A tick or cross glyph beside a text the reader did NOT declare an item: a
+// check or cross marker when the two are one row of a declared set, or the
+// parent repeats the same mark — same glyph, same paint — before another line.
+// A tick or a cross before a line is a list's mark by what it is. A dot is
+// not: equal dots before lines are a timeline's stations, a legend's swatches
+// or status lights as often as bullets (x110 GTM 3: the handoff timeline's two
+// dots made its two lines a bulleted list), so a dot is a bullet only where
+// the reader declared the list (`lists`) and otherwise stays a shape.
+function foldUndeclaredDots(elements, linked, used, repeats) {
+  const byId = new Map(elements.map((e) => [e.id, e]));
+  const declared = declaredPairs(repeats);
+  const pairs = [];
+  for (const dot of elements) {
+    if (used.has(dot.id) || linked.has(dot.id) || dot.image?.assetUseId) continue;
+    const glyph = dot.kind === "path" || dot.kind === "rule" ? null : glyphOf(dot);
+    if (glyph !== "check" && glyph !== "cross") continue;
+    if (dot.kind === "icon" && !small(dot, MARK_MAX_PX)) continue;
+    // A marker may sit in its own small painted carrier. Keep that shape,
+    // but compare the adjacent copy against the carrier's enclosing list.
+    const carrier = byId.get(dot.parent);
+    const inCarrier = carrier && !linked.has(carrier.id) && !carrier.text?.trim() &&
+      ["badge", "disc"].includes(carrier.kind) && carrier.w <= 32 && carrier.h <= 32 &&
+      dot.x >= carrier.x && dot.y >= carrier.y &&
+      dot.x + dot.w <= carrier.x + carrier.w && dot.y + dot.h <= carrier.y + carrier.h;
+    const parent = inCarrier ? carrier.parent : dot.parent;
+    const candidates = elements.filter((e) => isText(e) && !e.paragraphs && !e.marker && e.parent === parent && !linked.has(e.id)
+      && inFront(dot, e, 24) && dot.h <= e.h + 2);
+    if (candidates.length === 1) pairs.push({ dot, text: candidates[0], glyph, parent, carrier: inCarrier ? carrier : null });
+  }
+  for (const pair of pairs) {
+    const { dot, text, glyph } = pair;
+    if (pairs.filter((p) => p.text.id === text.id).length !== 1) continue;
+    const paint = (d) => d.fillToken ?? d.fillHex ?? d.fill ?? null;
+    const alike = pairs.filter((p) => p.parent === pair.parent && p.glyph === glyph && paint(p.dot) === paint(dot)).length >= 2;
+    if (!declared.has(`${dot.id}>${text.id}`) && !alike) continue;
+    if (pair.carrier) {
+      // A painted badge owns its glyph. Native shape text preserves both
+      // its center and its colour; an outside list marker would drift away.
+      Object.assign(pair.carrier, { text: glyph === "check" ? "✓" : "✗", textSource: "visible",
+        role: "body", colorToken: dot.colorToken, colorHex: dot.colorHex,
+        color: dot.icon?.color === "white" ? "light" : dot.icon?.color ?? dot.color,
+        align: "center", valign: "middle", placement: "center" });
+    } else {
+      text.marker = glyph;
+      const own = paintOf(dot);
+      if (own.token) text.markerToken = own.token;
+      if (own.hex) text.markerHex = own.hex;
+    }
+    used.add(dot.id);
+  }
+}
+
+// The horizontal dividers the reader drew: rules still read as elements, and
+// the free lines applyLines made of them (`fromPoint`/`toPoint`, `points`).
+function dividers(elements, connectors) {
+  const out = [];
+  for (const e of elements) if (e.kind === "rule" && e.w > e.h) out.push({ x: e.x, w: e.w, y: e.y + e.h / 2 });
+  for (const c of connectors) {
+    const a = c.fromPoint ?? c.points?.[0];
+    const b = c.toPoint ?? c.points?.at(-1);
+    if (!a || !b || c.from || c.to || Math.abs(a.y - b.y) > 2) continue;
+    out.push({ x: Math.min(a.x, b.x), w: Math.abs(b.x - a.x), y: (a.y + b.y) / 2 });
+  }
+  return out;
+}
+
+// Consecutive items of one parent are one list: they share a block, so
+// foldTextBlocks writes them as one element. The reader's own block ids win
+// (a title with its items); an item it left alone joins the items around it.
+// A divider the reader drew between two items ends the list (x105 GTM 03:
+// three cells of a card, a rule between each, became one list in the first
+// cell): items on either side of a rule are separate lists or cells.
+function groupItems(elements, connectors) {
+  const rules = dividers(elements, connectors);
+  const divided = (a, b) => rules.some((r) => r.y > a.y + a.h - 1 && r.y < b.y + 1
+    && r.x < Math.max(a.x + a.w, b.x + b.w) && r.x + r.w > Math.min(a.x, b.x));
+  const ids = new Set(elements.map((e) => e.id));
+  const byParent = new Map();
+  for (const e of elements) {
+    if (!isText(e) || e.paragraphs) continue;
+    const key = e.parent ?? "";
+    if (!byParent.has(key)) byParent.set(key, []);
+    byParent.get(key).push(e);
+  }
+  for (const texts of byParent.values()) {
+    texts.sort((a, b) => a.y - b.y || a.x - b.x);
+    let run = [];
+    const close = () => {
+      if (run.length >= 2) {
+        let id = `${run[0].id}-list`;
+        while (ids.has(id)) id = `${id}-text`;
+        ids.add(id);
+        for (const e of run) e.block = id;
+      }
+      run = [];
+    };
+    for (const e of texts) {
+      const prev = run.at(-1);
+      const joins = prev && e.marker && !e.block && e.marker === prev.marker
+        && e.y >= prev.y + prev.h / 2 && e.x < prev.x + prev.w && prev.x < e.x + e.w && !divided(prev, e);
+      if (!joins) close();
+      if (e.marker && !e.block) run.push(e);
+    }
+    close();
+  }
+  return elements;
+}
+
+/**
+ * Every list the reader read, in one form: items carry `marker` (and the
+ * mark's paint), their words carry no glyph, no mark is an element, the
+ * items of one list share a block. Idempotent: a spec folded once is left as
+ * it is.
+ */
+export function foldListMarkers(elements, connectors = [], repeats = []) {
+  const linked = new Set(connectors.flatMap((c) => [c.from, c.to]));
+  const used = new Set();
+  declareFromText(elements);
+  foldDeclaredMarks(elements, linked, used);
+  foldUndeclaredDots(elements, linked, used, repeats);
+  return groupItems(elements.filter((e) => !used.has(e.id)), connectors);
+}

package/src/builders/concept-marks.mjs

@@ -0,0 +1,84 @@
+// Marks the transcriber DRAWS instead of fetching: plain stroke glyphs (tick,
+// cross, chevrons, dots) and the arrow mark. Every stroke of one is a native
+// line piece (the transcriber writes a mark as a chain group with round caps,
+// the arrow as one line with its head); dots are small filled discs.
+export const nameWords = (s) => (String(s).toLowerCase().match(/[a-z]+/g) ?? []).map((w) => (w.length > 3 && w.endsWith("s") && !/(ss|us|is)$/.test(w) ? w.slice(0, -1) : w));
+export const ICON_STYLE_WORDS = new Set(['icon', 'outline', 'outlined', 'filled', 'thin', 'solid', 'symbol', 'sign', 'mark', 'glyph']);
+
+// ---- Plain marks drawn as native geometry.
+// Stroke marks in a unit box, as polylines; dots are circles.
+const MARKS = {
+  check: { square: true, d: [[[0.14, 0.54], [0.4, 0.8], [0.86, 0.22]]] },
+  cross: { square: true, d: [[[0.22, 0.22], [0.78, 0.78]], [[0.78, 0.22], [0.22, 0.78]]] },
+  plus: { square: true, d: [[[0.5, 0.16], [0.5, 0.84]], [[0.16, 0.5], [0.84, 0.5]]] },
+  minus: { square: true, d: [[[0.16, 0.5], [0.84, 0.5]]] },
+  chevron: { square: true, d: [[[0.34, 0.14], [0.68, 0.5], [0.34, 0.86]]] },
+  "double chevron": { d: [[[0.18, 0.14], [0.48, 0.5], [0.18, 0.86]], [[0.52, 0.14], [0.82, 0.5], [0.52, 0.86]]] },
+  arrow: { d: [[[0.08, 0.5], [0.92, 0.5]], [[0.66, 0.22], [0.92, 0.5], [0.66, 0.78]]] },
+  dots: { dots: true },
+};
+const MARK_WORDS = {
+  check: "check checkmark tick", cross: "cross x close times multiply", plus: "plus add",
+  minus: "minus subtract", chevron: "chevron angle caret", arrow: "arrow", dots: "ellipsis dot more",
+};
+const MARK_MODIFIERS = new Set("double single right left up down forward back backward next previous horizontal vertical three small simple plain thin bold pointing straight".split(" "));
+const TURN = { right: (x, y) => [x, y], left: (x, y) => [1 - x, y], up: (x, y) => [y, 1 - x], down: (x, y) => [y, x] };
+
+/** Which plain mark an icon query names, or null for a picture of a thing. */
+export function glyphMarkOf(query, keywords = []) {
+  const words = nameWords(String(query ?? "")).filter((w) => !ICON_STYLE_WORDS.has(w));
+  if (!words.length) return null;
+  const kinds = new Set();
+  for (const w of words) {
+    const kind = Object.keys(MARK_WORDS).find((k) => MARK_WORDS[k].split(" ").includes(w));
+    if (kind) kinds.add(kind);
+    else if (!MARK_MODIFIERS.has(w)) return null; // another object: a composite icon
+  }
+  // The reader's synonyms may name the mark when the query was descriptive.
+  if (!kinds.size) for (const k of keywords.flatMap((x) => nameWords(x))) {
+    const kind = Object.keys(MARK_WORDS).find((m) => MARK_WORDS[m].split(" ").includes(k));
+    if (kind) kinds.add(kind);
+  }
+  if (kinds.size !== 1) return null;
+  const [kind] = kinds;
+  if (kind === "dots" && !words.some((w) => w === "ellipsis" || w === "dot")) return null;
+  const dir = ["left", "up", "down"].find((d) => words.includes(d)) ?? (words.includes("back") || words.includes("backward") || words.includes("previous") ? "left" : "right");
+  return { kind: kind === "chevron" && words.includes("double") ? "double chevron" : kind, dir };
+}
+
+/**
+ * The strokes of a plain mark, in slot px: `{ kind, strokes: [[pt, …], …] }`
+ * (each stroke a polyline — the transcriber writes it as a chain of native
+ * line pieces), `{ kind: "arrow", strokes: [[tail, tip]] }` (one line, head at
+ * the tip) or `{ kind: "dots", dots: [{ x, y, r }] }`. Null for a picture.
+ */
+export function glyphMarkStrokes(e) {
+  const mark = glyphMarkOf(e.icon?.query, e.icon?.keywords ?? []);
+  if (!mark || !(e.w > 0) || !(e.h > 0)) return null;
+  const spec = MARKS[mark.kind];
+  const r2 = (v) => Math.round(v * 100) / 100;
+  if (mark.kind === "arrow") {
+    const cx = e.x + e.w / 2, cy = e.y + e.h / 2;
+    const horizontal = mark.dir === "left" || mark.dir === "right";
+    const half = (horizontal ? e.w : e.h) * 0.42;
+    const sign = mark.dir === "left" || mark.dir === "up" ? -1 : 1;
+    const ends = horizontal
+      ? [{ x: cx - sign * half, y: cy }, { x: cx + sign * half, y: cy }]
+      : [{ x: cx, y: cy - sign * half }, { x: cx, y: cy + sign * half }];
+    return { kind: "arrow", strokes: [ends.map((p) => ({ x: r2(p.x), y: r2(p.y) }))] };
+  }
+  if (spec.dots) {
+    const r = r2(Math.min(e.h * 0.3, e.w / 10));
+    return { kind: "dots", dots: [1, 3, 5].map((k) => ({ x: r2(e.x + (e.w * k) / 6), y: r2(e.y + e.h / 2), r })) };
+  }
+  const side = Math.min(e.w, e.h);
+  const box = spec.square ? { x: (e.w - side) / 2, y: (e.h - side) / 2, w: side, h: side } : { x: 0, y: 0, w: e.w, h: e.h };
+  const turn = TURN[mark.dir] ?? TURN.right;
+  return {
+    kind: mark.kind,
+    strokes: spec.d.map((stroke) => stroke.map(([x, y]) => {
+      const [u, v] = turn(x, y);
+      return { x: r2(e.x + box.x + u * box.w), y: r2(e.y + box.y + v * box.h) };
+    })),
+  };
+}

package/src/builders/concept-relationships.mjs

@@ -0,0 +1,12 @@
+// Which strokes belong to a picture rather than to the slide's relationships.
+// Line topology itself lives in concept-lines.mjs.
+import { nativeChartData } from './concept-geometry.mjs';
+
+/**
+ * The illustration an element is a plot mark of: a chart without readable
+ * values is kept as drawn marks, and every stroke inside it is part of that
+ * picture (tagged `data-sm-plot-owner`), never a line between things.
+ */
+export function illustrationOwner(elements, e) {
+  return elements.find(c => c.kind === 'chart' && !nativeChartData(c.chart) && e.x >= c.x - 2 && e.y >= c.y - 2 && e.x + e.w <= c.x + c.w + 2 && e.y + e.h <= c.y + c.h + 2) ?? null;
+}