@bendyline/squisq-editor-react 2.0.1 → 2.2.0

package/src/asciiDiagram/asciiDiagramData.ts

@@ -1,149 +0,0 @@
-/**
- * Read direction of the ASCII diagram loop: fence text → canvas data.
- *
- * `useAsciiDiagramData` re-derives on every editor transaction (mirroring
- * the philosophy of the old heading-based `useDiagramData`: no store, so
- * nothing to invalidate). Parsing is memoized per PMNode instance by the
- * extension's WeakMap caches, so untouched fences cost nothing.
- */
-
-import { useEffect, useMemo, useState } from 'react';
-import type { Editor } from '@tiptap/react';
-import {
-  asciiCellToCanvas,
-  asciiDiagramToTemplateData,
-  ASCII_CHAR_H,
-  ASCII_CHAR_W,
-  type AsciiDiagram,
-} from '@bendyline/squisq/doc';
-import type { DiagramEdge, DiagramNode } from '../diagram/types';
-import { findAsciiDiagramBlockPos, parseAsciiDiagramForNode } from './AsciiDiagramExtension';
-import { translateDiagramOp } from './asciiDiagramOps';
-
-/** Persisted grid space reserved north/west of legacy origin-hugging art. */
-export const ASCII_DIAGRAM_GUTTER_COLS = 8;
-export const ASCII_DIAGRAM_GUTTER_ROWS = 2;
-
-export interface AsciiDiagramCanvasOffset {
-  col: number;
-  row: number;
-}
-
-export interface AsciiDiagramView {
-  /** Canvas nodes, containers ordered first so their cards paint behind. */
-  nodes: DiagramNode[];
-  edges: DiagramEdge[];
-  warnings: string[];
-  style: 'unicode' | 'ascii';
-  /** The current fence text. */
-  text: string;
-  /** The parse behind `nodes`/`edges` (grid units) — ops operate on this. */
-  diagram: AsciiDiagram;
-}
-
-/**
- * Offset needed to give an existing diagram the same editing gutter as a
- * newly inserted one. The widget applies this virtually until the first real
- * canvas edit, which then writes the shifted coordinates into the fence.
- */
-export function initialAsciiDiagramCanvasOffset(diagram: AsciiDiagram): AsciiDiagramCanvasOffset {
-  if (diagram.nodes.length === 0) return { col: 0, row: 0 };
-  const minCol = Math.min(...diagram.nodes.map((node) => node.col));
-  const minRow = Math.min(...diagram.nodes.map((node) => node.row));
-  return {
-    col: Math.max(0, ASCII_DIAGRAM_GUTTER_COLS - minCol),
-    row: Math.max(0, ASCII_DIAGRAM_GUTTER_ROWS - minRow),
-  };
-}
-
-/** Apply a canvas-only origin offset to a parsed grid model. */
-export function offsetAsciiDiagram(
-  diagram: AsciiDiagram,
-  offset: AsciiDiagramCanvasOffset,
-): AsciiDiagram {
-  return translateDiagramOp(diagram, offset.col, offset.row);
-}
-
-/** Grid model → canvas model, containers-first for paint order. */
-export function asciiDiagramToCanvas(
-  diagram: AsciiDiagram,
-): Pick<AsciiDiagramView, 'nodes' | 'edges'> {
-  const containerIds = new Set(
-    diagram.nodes.map((n) => n.containerId).filter((id): id is string => id !== undefined),
-  );
-  const depthOf = (id: string | undefined): number => {
-    let depth = 0;
-    let current = diagram.nodes.find((n) => n.id === id);
-    while (current?.containerId) {
-      depth++;
-      current = diagram.nodes.find((n) => n.id === current?.containerId);
-      if (depth > diagram.nodes.length) break;
-    }
-    return depth;
-  };
-  const ordered = [...diagram.nodes].sort((a, b) => {
-    const aContainer = containerIds.has(a.id) ? 0 : 1;
-    const bContainer = containerIds.has(b.id) ? 0 : 1;
-    return aContainer - bContainer || depthOf(a.id) - depthOf(b.id);
-  });
-  const nodes: DiagramNode[] = ordered.map((n) => ({
-    id: n.id,
-    position: asciiCellToCanvas(n.col, n.row),
-    data: { label: n.label },
-    width: n.wCols * ASCII_CHAR_W,
-    height: n.hRows * ASCII_CHAR_H,
-    ...(containerIds.has(n.id) ? { kind: 'container' as const } : {}),
-  }));
-  const templateEdges = asciiDiagramToTemplateData(diagram).edges;
-  const edges: DiagramEdge[] = diagram.edges.map((e, index) => ({
-    id: e.label ? `${e.source}->${e.target}:${e.label}` : `${e.source}->${e.target}`,
-    source: e.source,
-    target: e.target,
-    ...(e.label ? { label: e.label } : {}),
-    ...(e.directed ? {} : { directed: false }),
-    ...(templateEdges[index]?.sourceAnchor
-      ? { sourceAnchor: templateEdges[index].sourceAnchor }
-      : {}),
-    ...(templateEdges[index]?.targetAnchor
-      ? { targetAnchor: templateEdges[index].targetAnchor }
-      : {}),
-    ...(templateEdges[index]?.routing ? { routing: templateEdges[index].routing } : {}),
-  }));
-  return { nodes, edges };
-}
-
-/**
- * Live view of one registered ASCII diagram block. Returns null when the
- * block no longer exists or no longer parses (the extension will drop the
- * widget on its next pass).
- */
-export function useAsciiDiagramData(editor: Editor, blockId: string): AsciiDiagramView | null {
-  const [version, setVersion] = useState(0);
-  useEffect(() => {
-    const onUpdate = () => setVersion((v) => v + 1);
-    editor.on('transaction', onUpdate);
-    return () => {
-      editor.off('transaction', onUpdate);
-    };
-  }, [editor]);
-
-  return useMemo(() => {
-    const pos = findAsciiDiagramBlockPos(editor, blockId);
-    if (pos === null) return null;
-    const node = editor.state.doc.nodeAt(pos);
-    if (!node || node.type.name !== 'codeBlock') return null;
-    const diagram = parseAsciiDiagramForNode(node);
-    if (!diagram) return null;
-    const { nodes, edges } = asciiDiagramToCanvas(diagram);
-    return {
-      nodes,
-      edges,
-      warnings: diagram.warnings,
-      style: diagram.style,
-      text: node.textContent,
-      diagram,
-    };
-    // `version` tracks transactions; editor/blockId are stable.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [editor, blockId, version]);
-}

package/src/asciiDiagram/asciiDiagramOps.ts

@@ -1,238 +0,0 @@
-/**
- * Pure data operations over the ASCII diagram model — the write-direction
- * half of the fence-is-source-of-truth loop:
- *
- *   fence text → parseAsciiDiagram → op → renderAsciiDiagram → fence text
- *
- * Every op returns a new AsciiDiagram (inputs are never mutated) and
- * maintains the invariants the renderer/parser fixpoint relies on:
- * container moves translate whole subtrees, removals promote children and
- * drop incident edges, sizes never fall below what a label needs.
- */
-
-import type { AsciiDiagram, AsciiDiagramEdge, AsciiDiagramNode } from '@bendyline/squisq/doc';
-
-/**
- * Make arbitrary (rename-dialog) input safe as a box label: box-drawing /
- * arrow glyphs would corrupt the art, and the Scene's inline editor is
- * single-line, so newlines collapse to spaces.
- */
-export function sanitizeAsciiLabel(label: string): string {
-  return label
-    .replace(/[─-╿▲▼◀-◄▶-►←-↓`]/gu, ' ') // backticks would terminate the fence
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function descendantsOf(diagram: AsciiDiagram, nodeId: string): Set<string> {
-  const out = new Set<string>();
-  let grew = true;
-  while (grew) {
-    grew = false;
-    for (const n of diagram.nodes) {
-      if (out.has(n.id)) continue;
-      if (n.containerId === nodeId || (n.containerId && out.has(n.containerId))) {
-        out.add(n.id);
-        grew = true;
-      }
-    }
-  }
-  return out;
-}
-
-/** Translate every node by the same grid delta (edges/containment are unchanged). */
-export function translateDiagramOp(
-  diagram: AsciiDiagram,
-  dCol: number,
-  dRow: number,
-): AsciiDiagram {
-  const colDelta = Math.round(dCol);
-  const rowDelta = Math.round(dRow);
-  if (colDelta === 0 && rowDelta === 0) return diagram;
-  return {
-    ...diagram,
-    nodes: diagram.nodes.map((node) => ({
-      ...node,
-      col: Math.max(0, node.col + colDelta),
-      row: Math.max(0, node.row + rowDelta),
-    })),
-  };
-}
-
-/** Move a node to (col, row); a container drags its whole subtree along. */
-export function moveNodeOp(
-  diagram: AsciiDiagram,
-  nodeId: string,
-  col: number,
-  row: number,
-): AsciiDiagram {
-  const node = diagram.nodes.find((n) => n.id === nodeId);
-  if (!node) return diagram;
-  const dCol = Math.max(0, col) - node.col;
-  const dRow = Math.max(0, row) - node.row;
-  if (dCol === 0 && dRow === 0) return diagram;
-  const moving = descendantsOf(diagram, nodeId);
-  moving.add(nodeId);
-  return {
-    ...diagram,
-    nodes: diagram.nodes.map((n) =>
-      moving.has(n.id)
-        ? { ...n, col: Math.max(0, n.col + dCol), row: Math.max(0, n.row + dRow) }
-        : n,
-    ),
-  };
-}
-
-/** Resize a node (grid cells). Clamped so the label always fits. */
-export function resizeNodeOp(
-  diagram: AsciiDiagram,
-  nodeId: string,
-  wCols: number,
-  hRows: number,
-): AsciiDiagram {
-  const node = diagram.nodes.find((n) => n.id === nodeId);
-  if (!node) return diagram;
-  const labelLines = node.label.length > 0 ? node.label.split('\n') : [];
-  const minW = Math.max(3, labelLines.reduce((w, l) => Math.max(w, l.length), 0) + 4);
-  const minH = Math.max(3, labelLines.length + 2);
-  return {
-    ...diagram,
-    nodes: diagram.nodes.map((n) =>
-      n.id === nodeId
-        ? {
-            ...n,
-            wCols: Math.max(minW, Math.round(wCols)),
-            hRows: Math.max(minH, Math.round(hRows)),
-          }
-        : n,
-    ),
-  };
-}
-
-/** Add a directed edge; duplicates (same source/target/label) are no-ops. */
-export function addEdgeOp(
-  diagram: AsciiDiagram,
-  source: string,
-  target: string,
-  label?: string,
-): AsciiDiagram {
-  const ids = new Set(diagram.nodes.map((n) => n.id));
-  if (!ids.has(source) || !ids.has(target) || source === target) return diagram;
-  const exists = diagram.edges.some(
-    (e) => e.source === source && e.target === target && (e.label ?? '') === (label ?? ''),
-  );
-  if (exists) return diagram;
-  const edge: AsciiDiagramEdge = {
-    source,
-    target,
-    ...(label ? { label } : {}),
-    directed: true,
-  };
-  return { ...diagram, edges: [...diagram.edges, edge] };
-}
-
-/**
- * Remove an edge. A label-qualified call removes the exact match; without
- * a label the first (source, target) match goes — mirroring the legacy
- * `removeConnection` semantics.
- */
-export function removeEdgeOp(
-  diagram: AsciiDiagram,
-  source: string,
-  target: string,
-  label?: string,
-): AsciiDiagram {
-  let removed = false;
-  const edges = diagram.edges.filter((e) => {
-    if (removed) return true;
-    const match =
-      e.source === source &&
-      e.target === target &&
-      (label !== undefined ? (e.label ?? '') === label : true);
-    if (match) {
-      removed = true;
-      return false;
-    }
-    return true;
-  });
-  return removed ? { ...diagram, edges } : diagram;
-}
-
-/**
- * Rename a node. The label drives the node's parse-derived id, so edges
- * and containment references are rewritten to the id the next parse will
- * produce. (Selection in the canvas drops after a rename — documented.)
- */
-export function renameNodeOp(diagram: AsciiDiagram, nodeId: string, label: string): AsciiDiagram {
-  const node = diagram.nodes.find((n) => n.id === nodeId);
-  if (!node) return diagram;
-  const clean = sanitizeAsciiLabel(label);
-  if (clean.length === 0 || clean === node.label) return diagram;
-  return {
-    ...diagram,
-    nodes: diagram.nodes.map((n) => (n.id === nodeId ? { ...n, label: clean } : n)),
-  };
-}
-
-/** Add a node at (col, row). Inherits a container when placed inside one. */
-export function addNodeOp(
-  diagram: AsciiDiagram,
-  opts: { col: number; row: number; label?: string },
-): { diagram: AsciiDiagram; label: string } {
-  // First free "Node N" label.
-  let label = opts.label;
-  if (!label) {
-    let i = 1;
-    const labels = new Set(diagram.nodes.map((n) => n.label.split('\n')[0]));
-    while (labels.has(`Node ${i}`)) i++;
-    label = `Node ${i}`;
-  }
-  const clean = sanitizeAsciiLabel(label) || 'Node';
-  const col = Math.max(0, Math.round(opts.col));
-  const row = Math.max(0, Math.round(opts.row));
-  const wCols = clean.length + 4;
-  const hRows = 3;
-  // Container inheritance: the new box's center falls inside a container.
-  const centerCol = col + wCols / 2;
-  const centerRow = row + hRows / 2;
-  const containers = diagram.nodes
-    .filter((n) => diagram.nodes.some((m) => m.containerId === n.id))
-    .filter(
-      (n) =>
-        centerCol > n.col &&
-        centerCol < n.col + n.wCols &&
-        centerRow > n.row &&
-        centerRow < n.row + n.hRows,
-    )
-    .sort((a, b) => a.wCols * a.hRows - b.wCols * b.hRows);
-  const node: AsciiDiagramNode = {
-    id: `__new-${diagram.nodes.length}`, // provisional; the re-parse derives the real slug id
-    label: clean,
-    col,
-    row,
-    wCols,
-    hRows,
-    ...(containers[0] ? { containerId: containers[0].id } : {}),
-  };
-  return { diagram: { ...diagram, nodes: [...diagram.nodes, node] }, label: clean };
-}
-
-/**
- * Remove a node: incident edges (both directions) drop, direct children
- * are promoted to the removed node's own container (or top level).
- */
-export function removeNodeOp(diagram: AsciiDiagram, nodeId: string): AsciiDiagram {
-  const node = diagram.nodes.find((n) => n.id === nodeId);
-  if (!node) return diagram;
-  const nodes = diagram.nodes
-    .filter((n) => n.id !== nodeId)
-    .map((n) => {
-      if (n.containerId !== nodeId) return n;
-      const promoted = { ...n };
-      if (node.containerId) promoted.containerId = node.containerId;
-      else delete promoted.containerId;
-      return promoted;
-    });
-  const edges = diagram.edges.filter((e) => e.source !== nodeId && e.target !== nodeId);
-  return { ...diagram, nodes, edges };
-}

package/src/asciiDiagram/asciiPaste.ts

@@ -1,19 +0,0 @@
-/**
- * Paste gate for bare (unfenced) ASCII diagram art.
- *
- * `+--+ | |` art pasted as plain text is otherwise mangled: its `| x |`
- * rows match the GFM table-row pattern in `detectMarkdown`, so the paste
- * handler routes it through the markdown converter, fails table
- * validation, and emits one broken paragraph per line. When this gate
- * matches, the paste handler inserts the text verbatim into a fresh code
- * block instead — which the AsciiDiagramExtension then picks up as an
- * interactive diagram.
- */
-
-import { detectAsciiDiagram } from '@bendyline/squisq/doc';
-
-export function shouldPasteAsAsciiFence(text: string): boolean {
-  if (!text || text.includes('```')) return false;
-  const detection = detectAsciiDiagram(text);
-  return detection.isDiagram && (detection.diagram?.nodes.length ?? 0) >= 2;
-}

package/src/blockProperties.ts

@@ -1,88 +0,0 @@
-/**
- * blockProperties
- *
- * Generic read/write of a single block-meta key on a heading's Pandoc `{…}`
- * attribute block (stored as the `dataBlockAttrs` inner string in the WYSIWYG
- * heading node — no braces, matching `tiptapBridge`).
- *
- * The transition family (which spans three coupled keys) has its own helpers
- * in `headingTransition.ts`; this module covers the standalone scalar keys the
- * block-properties palette edits — `duration`, `startTime`, `x`, `y`, … — all
- * of which are plain `key=value` params. Parse/serialize is delegated to the
- * shared core helpers so quoting and ordering match the parser exactly.
- */
-
-import {
-  parsePandocAttrTokens,
-  serializePandocAttributes,
-  parseTimeSeconds,
-  type HeadingAttributes,
-} from '@bendyline/squisq/markdown';
-import { normalizeTransitionType } from '@bendyline/squisq/schemas';
-import { readBlockAttrsTransition } from './headingTransition';
-import { transitionLabel } from './transitionCatalog';
-
-/** Parse a `dataBlockAttrs` inner string into its flat `key → value` map. */
-export function readBlockAttrsParams(inner: string | null | undefined): Record<string, string> {
-  return inner ? (parsePandocAttrTokens(inner).params ?? {}) : {};
-}
-
-/** Read a single block-meta param, or '' when unset. */
-export function readBlockAttrsValue(inner: string | null | undefined, key: string): string {
-  return readBlockAttrsParams(inner)[key] ?? '';
-}
-
-/**
- * Set (or, when `value` is empty, remove) a single param in a `dataBlockAttrs`
- * inner string. Returns the new inner (no braces), or null when the block is
- * left with no attributes at all — matching how `tiptapBridge` stores an
- * absent attribute (null, not `{}`).
- */
-export function setBlockAttrsValue(
-  inner: string | null | undefined,
-  key: string,
-  value: string,
-): string | null {
-  const attrs: HeadingAttributes = inner ? parsePandocAttrTokens(inner) : {};
-  const params: Record<string, string> = { ...(attrs.params ?? {}) };
-  const trimmed = value.trim();
-  if (trimmed === '') delete params[key];
-  else params[key] = trimmed;
-  attrs.params = params;
-  const raw = serializePandocAttributes(attrs);
-  return raw == null || raw === '{}' ? null : raw.slice(1, -1);
-}
-
-/**
- * A concise, human-readable summary of a block's authored properties for the
- * on-canvas badge — e.g. `Doors · 1:30 start · 3:20 long`. Returns '' when no
- * properties are set (the badge then shows just its icon). Reads transition
- * from both the Pandoc block and the `{[…]}` params; timing from the block.
- */
-export function summarizeBlockProps(
-  blockAttrs: string | null | undefined,
-  templateParams: string | null | undefined,
-): string {
-  const parts: string[] = [];
-
-  const transition = readBlockAttrsTransition(blockAttrs, templateParams);
-  if (transition.type) {
-    parts.push(transitionLabel(normalizeTransitionType(transition.type) ?? transition.type));
-  }
-
-  const params = readBlockAttrsParams(blockAttrs);
-  if (params.startTime) parts.push(`${formatClock(params.startTime)} start`);
-  if (params.duration) parts.push(`${formatClock(params.duration)} long`);
-
-  return parts.join(' · ');
-}
-
-/** Format a raw time value (`90`, `1:30`, `1500ms`) as `m:ss`, or pass through. */
-function formatClock(raw: string): string {
-  const seconds = parseTimeSeconds(raw);
-  if (seconds == null) return raw;
-  const total = Math.round(seconds);
-  const minutes = Math.floor(total / 60);
-  const secs = total % 60;
-  return `${minutes}:${String(secs).padStart(2, '0')}`;
-}

package/src/blockRange.ts

@@ -1,132 +0,0 @@
-/**
- * blockRange
- *
- * Source-text-range slicing for the block-at-a-time editing view. Splits a
- * full markdown document into ordered, contiguous slices — one per
- * heading-defined block plus an optional leading preamble — so a single
- * block can be shown in isolation and edits spliced back into the parent.
- *
- * A block runs from its heading line through the character just before the
- * next heading at ANY depth (or EOF). Sub-headings therefore start their own
- * slices — they are NOT folded into their parent — which matches the
- * "don't see child blocks" requirement and the `slicePastHeading` boundary
- * in `blockSlice.ts`. Ranges are half-open `[startOffset, endOffset)` and
- * line-aligned, so trailing blank lines stay with the current block and
- * `spliceBlock(src, range, getBlockSlices(src)[i].text) === src` for every i.
- *
- * These are pure functions over a markdown string — no React, no editor
- * coupling — so any host can reuse them.
- */
-
-import { parseMarkdown } from '@bendyline/squisq/markdown';
-import type { MarkdownDocument } from '@bendyline/squisq/markdown';
-import { frontmatterEndOffset } from './frontmatter';
-
-/** Half-open character range into the full source: `[startOffset, endOffset)`. */
-export interface BlockRange {
-  startOffset: number;
-  endOffset: number;
-}
-
-/** One block's source text plus the range it occupies in the full document. */
-export interface BlockSlice {
-  text: string;
-  range: BlockRange;
-}
-
-/** Map every line start to its character offset (`lineStarts[line - 1]`). */
-function computeLineStarts(source: string): number[] {
-  const starts = [0];
-  for (let i = 0; i < source.length; i++) {
-    if (source[i] === '\n') starts.push(i + 1);
-  }
-  return starts;
-}
-
-function makeSlice(source: string, startOffset: number, endOffset: number): BlockSlice {
-  return { text: source.slice(startOffset, endOffset), range: { startOffset, endOffset } };
-}
-
-/**
- * Split `fullSource` into ordered block slices.
- *
- * - With no headings, the entire post-frontmatter body is a single slice
- *   (so an empty or heading-less document still shows one editable card).
- * - With headings, a leading preamble slice is included only when the text
- *   before the first heading has non-whitespace content. Each heading then
- *   yields one slice spanning up to the next heading (any depth) or EOF.
- *
- * Frontmatter is never part of any slice — slices start at the body offset.
- */
-export function getBlockSlices(fullSource: string): BlockSlice[] {
-  const bodyStart = frontmatterEndOffset(fullSource);
-
-  let doc: MarkdownDocument;
-  try {
-    doc = parseMarkdown(fullSource);
-  } catch {
-    // Unparseable mid-edit — treat the whole body as one slice rather than
-    // dropping the user into an empty card.
-    return [makeSlice(fullSource, bodyStart, fullSource.length)];
-  }
-
-  const lineStarts = computeLineStarts(fullSource);
-  const headingOffsets: number[] = [];
-  for (const node of doc.children) {
-    if (node.type !== 'heading') continue;
-    const line = node.position?.start.line;
-    if (typeof line !== 'number') continue;
-    const off = lineStarts[line - 1];
-    if (typeof off === 'number') headingOffsets.push(off);
-  }
-
-  if (headingOffsets.length === 0) {
-    return [makeSlice(fullSource, bodyStart, fullSource.length)];
-  }
-
-  const slices: BlockSlice[] = [];
-  const firstHeading = headingOffsets[0];
-  if (fullSource.slice(bodyStart, firstHeading).trim().length > 0) {
-    slices.push(makeSlice(fullSource, bodyStart, firstHeading));
-  }
-  for (let i = 0; i < headingOffsets.length; i++) {
-    const start = headingOffsets[i];
-    const end = i + 1 < headingOffsets.length ? headingOffsets[i + 1] : fullSource.length;
-    slices.push(makeSlice(fullSource, start, end));
-  }
-  return slices;
-}
-
-/** Replace the text in `range` with `newText`, returning the new full source. */
-export function spliceBlock(fullSource: string, range: BlockRange, newText: string): string {
-  return fullSource.slice(0, range.startOffset) + newText + fullSource.slice(range.endOffset);
-}
-
-/** Character offset of the start of 1-based `line` (clamps past EOF). */
-export function lineToOffset(source: string, line: number): number {
-  const starts = computeLineStarts(source);
-  return starts[Math.max(0, line - 1)] ?? source.length;
-}
-
-/** 1-based line number containing `offset`. */
-export function offsetToLine(source: string, offset: number): number {
-  const starts = computeLineStarts(source);
-  let lo = 0;
-  let hi = starts.length - 1;
-  let ans = 0;
-  while (lo <= hi) {
-    const mid = (lo + hi) >> 1;
-    if (starts[mid] <= offset) {
-      ans = mid;
-      lo = mid + 1;
-    } else {
-      hi = mid - 1;
-    }
-  }
-  return ans + 1;
-}
-
-/** Index of the slice whose range contains `offset`, or -1. */
-export function sliceIndexAtOffset(slices: BlockSlice[], offset: number): number {
-  return slices.findIndex((s) => offset >= s.range.startOffset && offset < s.range.endOffset);
-}

package/src/blockSlice.ts

@@ -1,75 +0,0 @@
-/**
- * Helpers for extracting the immediate body of the heading-defined block
- * that's currently being edited. The template picker uses this slice to
- * decide which templates to surface as "Recommended for this block".
- *
- * Block boundary: from the target heading's position, take subsequent
- * top-level siblings up to (but not including) the next heading at any
- * depth. This matches the doc model where each heading owns its
- * immediate `contents` and subheadings become nested blocks.
- */
-
-import { parseMarkdown } from '@bendyline/squisq/markdown';
-import type {
-  MarkdownBlockNode,
-  MarkdownDocument,
-  MarkdownHeading,
-} from '@bendyline/squisq/markdown';
-
-function slicePastHeading(
-  doc: MarkdownDocument,
-  headingNode: MarkdownHeading,
-): MarkdownBlockNode[] {
-  const children = doc.children;
-  const startIdx = children.indexOf(headingNode);
-  if (startIdx < 0) return [];
-  const out: MarkdownBlockNode[] = [];
-  for (let i = startIdx + 1; i < children.length; i++) {
-    const node = children[i];
-    if (node.type === 'heading') break;
-    out.push(node);
-  }
-  return out;
-}
-
-/**
- * Parse `source` and return the body of the heading whose source range
- * covers `lineNumber` (1-indexed). Returns `null` if `lineNumber` isn't
- * on a heading line.
- */
-export function findBlockSliceAtLine(
-  source: string,
-  lineNumber: number,
-): MarkdownBlockNode[] | null {
-  const doc = parseMarkdown(source);
-  for (const node of doc.children) {
-    if (node.type !== 'heading') continue;
-    const pos = node.position;
-    if (!pos) continue;
-    if (pos.start.line <= lineNumber && pos.end.line >= lineNumber) {
-      return slicePastHeading(doc, node);
-    }
-  }
-  return null;
-}
-
-/**
- * Parse `source` and return the body of the Nth top-level heading
- * (0-indexed). Used by the WYSIWYG path, which knows the heading's
- * index in the Tiptap doc but not its source line.
- */
-export function findBlockSliceByHeadingIndex(
-  source: string,
-  headingIndex: number,
-): MarkdownBlockNode[] | null {
-  const doc = parseMarkdown(source);
-  let seen = 0;
-  for (const node of doc.children) {
-    if (node.type !== 'heading') continue;
-    if (seen === headingIndex) {
-      return slicePastHeading(doc, node);
-    }
-    seen++;
-  }
-  return null;
-}