@blankdotpage/cake 0.1.8 → 0.1.11

package/dist/cake/core/types.d.ts

@@ -40,3 +40,4 @@ export type InlineAtom = {
     kind: string;
     data?: Record<string, unknown>;
 };
+//# sourceMappingURL=types.d.ts.map

package/dist/cake/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cake/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;AAE9C,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,GAAG,GAAG;IAChB,IAAI,EAAE,KAAK,CAAC;IACZ,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,cAAc,GAAG,iBAAiB,GAAG,SAAS,CAAC;AAEnE,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,aAAa,GAAG,UAAU,CAAC;AAE7D,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC"}

package/dist/cake/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cake/dom/dom-map.d.ts

@@ -19,3 +19,4 @@ export type DomMap = {
 };
 export declare function createTextRun(node: Text, cursorStart: number): TextRun;
 export declare function createDomMap(runs: TextRun[]): DomMap;
+//# sourceMappingURL=dom-map.d.ts.map

package/dist/cake/dom/dom-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-map.d.ts","sourceRoot":"","sources":["../../../src/cake/dom/dom-map.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,IAAI,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAAC;IACvE,WAAW,CACT,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,GACb;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAA;KAAE,GAAG,IAAI,CAAC;CACxD,CAAC;AASF,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAqBtE;AAqDD,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CA2GpD"}

package/dist/cake/dom/dom-map.js

@@ -0,0 +1,151 @@
+import { graphemeSegments } from "../shared/segmenter";
+const graphemeCache = new WeakMap();
+export function createTextRun(node, cursorStart) {
+    const data = node.data;
+    const cached = graphemeCache.get(node);
+    if (cached && cached.data === data) {
+        const segmentCount = Math.max(0, cached.boundaryOffsets.length - 1);
+        return {
+            node,
+            cursorStart,
+            cursorEnd: cursorStart + segmentCount,
+            boundaryOffsets: cached.boundaryOffsets,
+        };
+    }
+    const segments = graphemeSegments(data);
+    const boundaryOffsets = [0];
+    for (const segment of segments) {
+        boundaryOffsets.push(segment.index + segment.segment.length);
+    }
+    const cursorEnd = cursorStart + segments.length;
+    graphemeCache.set(node, { data, boundaryOffsets });
+    return { node, cursorStart, cursorEnd, boundaryOffsets };
+}
+function boundaryIndexForOffset(boundaryOffsets, offset) {
+    if (offset <= 0) {
+        return 0;
+    }
+    const lastIndex = boundaryOffsets.length - 1;
+    if (lastIndex <= 0) {
+        return 0;
+    }
+    const lastBoundary = boundaryOffsets[lastIndex];
+    if (offset >= lastBoundary) {
+        return lastIndex;
+    }
+    // Find first boundary >= offset (lower_bound).
+    let low = 1;
+    let high = lastIndex;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        const boundary = boundaryOffsets[mid];
+        if (boundary < offset) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    const boundary = boundaryOffsets[low];
+    return boundary === offset ? low : low - 1;
+}
+function firstRunStartingAfterCursor(runs, cursorOffset) {
+    let low = 0;
+    let high = runs.length;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (runs[mid].cursorStart <= cursorOffset) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return low;
+}
+export function createDomMap(runs) {
+    const runForNode = new Map();
+    const runIndexForNode = new Map();
+    runs.forEach((run, index) => {
+        runIndexForNode.set(run.node, index);
+    });
+    for (const run of runs) {
+        runForNode.set(run.node, run);
+    }
+    function domAtCursor(cursorOffset, affinity) {
+        if (runs.length === 0) {
+            return null;
+        }
+        const nextIndex = firstRunStartingAfterCursor(runs, cursorOffset);
+        const runIndex = nextIndex - 1;
+        if (runIndex < 0) {
+            const first = runs[0];
+            return { node: first.node, offset: first.boundaryOffsets[0] };
+        }
+        const run = runs[runIndex];
+        const previous = runIndex > 0 ? runs[runIndex - 1] : null;
+        const next = nextIndex < runs.length ? runs[nextIndex] : null;
+        if (cursorOffset === run.cursorStart && previous && affinity === "backward") {
+            return {
+                node: previous.node,
+                offset: previous.boundaryOffsets[previous.boundaryOffsets.length - 1],
+            };
+        }
+        // Cursor lies within this run
+        if (cursorOffset <= run.cursorEnd) {
+            if (cursorOffset === run.cursorEnd &&
+                affinity === "forward" &&
+                next &&
+                next.cursorStart === cursorOffset) {
+                return { node: next.node, offset: next.boundaryOffsets[0] };
+            }
+            const index = Math.max(0, cursorOffset - run.cursorStart);
+            const boundedIndex = Math.min(index, run.boundaryOffsets.length - 1);
+            return { node: run.node, offset: run.boundaryOffsets[boundedIndex] };
+        }
+        // Cursor lies in a gap between runs (e.g., block boundary/newline)
+        if (next) {
+            const runEndOffset = run.boundaryOffsets[run.boundaryOffsets.length - 1];
+            return affinity === "backward"
+                ? { node: run.node, offset: runEndOffset }
+                : { node: next.node, offset: next.boundaryOffsets[0] };
+        }
+        // Cursor lies after final run
+        const last = run;
+        return {
+            node: last.node,
+            offset: last.boundaryOffsets[last.boundaryOffsets.length - 1],
+        };
+    }
+    function cursorAtDom(node, offset) {
+        const run = runForNode.get(node);
+        if (!run) {
+            return null;
+        }
+        const runIndex = runIndexForNode.get(node);
+        const index = boundaryIndexForOffset(run.boundaryOffsets, offset);
+        const cursorOffset = run.cursorStart + index;
+        const atStart = offset === 0;
+        const atEnd = offset === run.boundaryOffsets[run.boundaryOffsets.length - 1];
+        const isNonEmptyRun = run.boundaryOffsets.length > 1;
+        // Determine affinity based on position in text run and adjacent runs.
+        // Only use "backward" affinity at the end of a run if there's a next run,
+        // matching v1 behavior where backward affinity keeps the caret in the
+        // current formatting context (e.g., inside a link).
+        const hasNextRun = runIndex !== undefined && runIndex + 1 < runs.length;
+        const hasPrevRun = runIndex !== undefined && runIndex > 0;
+        let affinity = "forward";
+        if (atEnd && isNonEmptyRun && hasNextRun) {
+            // At end of a run with a next run: use backward affinity to stay
+            // in the current run's context (e.g., inside bold/link)
+            affinity = "backward";
+        }
+        else if (atStart && hasPrevRun) {
+            // At start of a run with a previous run: use forward affinity
+            // to stay in the current run's context
+            affinity = "forward";
+        }
+        return { cursorOffset, affinity };
+    }
+    return { runs, domAtCursor, cursorAtDom };
+}

package/dist/cake/dom/dom-selection.d.ts

@@ -2,3 +2,4 @@ import type { Selection } from "../core/types";
 import type { DomMap } from "./dom-map";
 export declare function applyDomSelection(selection: Selection, map: DomMap): void;
 export declare function readDomSelection(map: DomMap): Selection | null;
+//# sourceMappingURL=dom-selection.d.ts.map

package/dist/cake/dom/dom-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-selection.d.ts","sourceRoot":"","sources":["../../../src/cake/dom/dom-selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAgHzE;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CA+C9D"}

package/dist/cake/dom/dom-selection.js

@@ -0,0 +1,216 @@
+export function applyDomSelection(selection, map) {
+    const domSelection = window.getSelection();
+    if (!domSelection) {
+        return;
+    }
+    const isCollapsed = selection.start === selection.end;
+    let anchorCursor = selection.start;
+    let focusCursor = selection.end;
+    let isForward = true;
+    if (!isCollapsed) {
+        // Selection values come from two sources:
+        // - engine/model helpers (often normalized start<=end with `affinity` as direction)
+        // - DOM reads (anchor/focus order, possibly start>end)
+        //
+        // Reconstruct anchor/focus in a way that preserves direction while keeping
+        // the mapping extension-agnostic.
+        if (selection.start > selection.end) {
+            // DOM-style anchor/focus (start=end? handled above)
+            anchorCursor = selection.start;
+            focusCursor = selection.end;
+            isForward = false;
+        }
+        else if (selection.affinity === "backward") {
+            // Model-style backward selection: anchor is the higher edge.
+            anchorCursor = selection.end;
+            focusCursor = selection.start;
+            isForward = false;
+        }
+        else {
+            // Model-style forward selection (default)
+            anchorCursor = selection.start;
+            focusCursor = selection.end;
+            isForward = true;
+        }
+    }
+    const baseAnchorAffinity = isCollapsed
+        ? (selection.affinity ?? "forward")
+        : isForward
+            ? "forward"
+            : "backward";
+    const baseFocusAffinity = isCollapsed
+        ? (selection.affinity ?? "forward")
+        : isForward
+            ? "backward"
+            : "forward";
+    const anchorAffinity = normalizeAffinityForBlockBoundary(map, anchorCursor, baseAnchorAffinity, isCollapsed);
+    const focusAffinity = normalizeAffinityForBlockBoundary(map, focusCursor, baseFocusAffinity, isCollapsed);
+    const anchorPoint = map.domAtCursor(anchorCursor, anchorAffinity);
+    const focusPoint = map.domAtCursor(focusCursor, focusAffinity);
+    if (!anchorPoint || !focusPoint) {
+        return;
+    }
+    if (domSelection.rangeCount > 0 &&
+        domSelection.anchorNode === anchorPoint.node &&
+        domSelection.anchorOffset === anchorPoint.offset &&
+        domSelection.focusNode === focusPoint.node &&
+        domSelection.focusOffset === focusPoint.offset) {
+        return;
+    }
+    if (isCollapsed) {
+        domSelection.collapse(anchorPoint.node, anchorPoint.offset);
+        return;
+    }
+    // Prefer APIs that preserve direction (anchor/focus).
+    const selectionWithExtent = domSelection;
+    if (typeof selectionWithExtent.setBaseAndExtent === "function") {
+        selectionWithExtent.setBaseAndExtent(anchorPoint.node, anchorPoint.offset, focusPoint.node, focusPoint.offset);
+        return;
+    }
+    if (typeof domSelection.extend === "function") {
+        domSelection.collapse(anchorPoint.node, anchorPoint.offset);
+        domSelection.extend(focusPoint.node, focusPoint.offset);
+        return;
+    }
+    // Fallback: apply the selection as a range in document order.
+    domSelection.removeAllRanges();
+    const range = document.createRange();
+    const rangeStart = isForward ? anchorPoint : focusPoint;
+    const rangeEnd = isForward ? focusPoint : anchorPoint;
+    range.setStart(rangeStart.node, rangeStart.offset);
+    range.setEnd(rangeEnd.node, rangeEnd.offset);
+    domSelection.addRange(range);
+}
+export function readDomSelection(map) {
+    const domSelection = window.getSelection();
+    if (!domSelection || domSelection.rangeCount === 0) {
+        return null;
+    }
+    const anchorPoint = resolveTextPoint(domSelection.anchorNode, domSelection.anchorOffset);
+    const focusPoint = resolveTextPoint(domSelection.focusNode, domSelection.focusOffset);
+    if (!anchorPoint || !focusPoint) {
+        return null;
+    }
+    const anchor = map.cursorAtDom(anchorPoint.node, anchorPoint.offset);
+    const focus = map.cursorAtDom(focusPoint.node, focusPoint.offset);
+    if (!anchor || !focus) {
+        return null;
+    }
+    // Model selection contract:
+    // - Always normalize to start <= end
+    // - Encode direction in `affinity` for range selections
+    // - Preserve caret-side affinity only for collapsed selections
+    if (anchor.cursorOffset === focus.cursorOffset) {
+        return {
+            start: anchor.cursorOffset,
+            end: anchor.cursorOffset,
+            affinity: focus.affinity,
+        };
+    }
+    if (anchor.cursorOffset < focus.cursorOffset) {
+        return {
+            start: anchor.cursorOffset,
+            end: focus.cursorOffset,
+            affinity: "forward",
+        };
+    }
+    return {
+        start: focus.cursorOffset,
+        end: anchor.cursorOffset,
+        affinity: "backward",
+    };
+}
+function resolveTextPoint(node, offset) {
+    if (!node) {
+        return null;
+    }
+    if (node instanceof Text) {
+        return { node, offset };
+    }
+    if (!(node instanceof Element)) {
+        return null;
+    }
+    const children = node.childNodes;
+    if (children.length === 0) {
+        return null;
+    }
+    if (offset <= 0) {
+        const first = findTextNodeAtOrAfter(children, 0);
+        return first ? { node: first, offset: 0 } : null;
+    }
+    if (offset >= children.length) {
+        const last = findTextNodeAtOrBefore(children, children.length - 1);
+        return last ? { node: last, offset: last.data.length } : null;
+    }
+    const exact = findFirstTextNode(children[offset]);
+    if (exact) {
+        return { node: exact, offset: 0 };
+    }
+    const previous = findTextNodeAtOrBefore(children, offset - 1);
+    if (previous) {
+        return { node: previous, offset: previous.data.length };
+    }
+    const next = findTextNodeAtOrAfter(children, offset + 1);
+    return next ? { node: next, offset: 0 } : null;
+}
+function normalizeAffinityForBlockBoundary(map, cursorOffset, affinity, isCollapsed) {
+    if (isCollapsed || affinity !== "backward") {
+        return affinity;
+    }
+    if (!isBlockBoundaryOffset(map, cursorOffset)) {
+        return affinity;
+    }
+    return "forward";
+}
+function isBlockBoundaryOffset(map, cursorOffset) {
+    const runs = map.runs;
+    for (let i = 1; i < runs.length; i += 1) {
+        const run = runs[i];
+        const previous = runs[i - 1];
+        if (cursorOffset > previous.cursorEnd && cursorOffset <= run.cursorStart) {
+            return run.cursorStart > previous.cursorEnd;
+        }
+    }
+    return false;
+}
+function findFirstTextNode(node) {
+    if (node instanceof Text) {
+        return node;
+    }
+    const walker = document.createTreeWalker(node, NodeFilter.SHOW_TEXT);
+    const next = walker.nextNode();
+    return next instanceof Text ? next : null;
+}
+function findLastTextNode(node) {
+    if (node instanceof Text) {
+        return node;
+    }
+    const walker = document.createTreeWalker(node, NodeFilter.SHOW_TEXT);
+    let last = null;
+    let current = walker.nextNode();
+    while (current) {
+        if (current instanceof Text) {
+            last = current;
+        }
+        current = walker.nextNode();
+    }
+    return last;
+}
+function findTextNodeAtOrAfter(nodes, start) {
+    for (let i = Math.max(0, start); i < nodes.length; i += 1) {
+        const found = findFirstTextNode(nodes[i]);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+function findTextNodeAtOrBefore(nodes, start) {
+    for (let i = Math.min(nodes.length - 1, start); i >= 0; i -= 1) {
+        const found = findLastTextNode(nodes[i]);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}

package/dist/cake/dom/render.d.ts

@@ -12,3 +12,4 @@ export type RenderContentResult = {
 export declare function renderDocContent(doc: Doc, extensions: CakeExtension[], root?: HTMLElement): RenderContentResult;
 export declare function renderDoc(doc: Doc, extensions: CakeExtension[]): RenderResult;
 export declare function mergeInlineForRender(inlines: Inline[]): Inline[];
+//# sourceMappingURL=render.d.ts.map

package/dist/cake/dom/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/cake/dom/render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,GAAG,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EACL,YAAY,EAGb,MAAM,WAAW,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,IAAI,EAAE,CAAC;IAChB,GAAG,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;CACtC,CAAC;AASF,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,GAAG,EACR,UAAU,EAAE,aAAa,EAAE,EAC3B,IAAI,CAAC,EAAE,WAAW,GACjB,mBAAmB,CAmXrB;AAED,wBAAgB,SAAS,CACvB,GAAG,EAAE,GAAG,EACR,UAAU,EAAE,aAAa,EAAE,GAC1B,YAAY,CAkJd;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAiChE"}