@blankdotpage/cake 0.1.8 → 0.1.10

package/dist/cake/extensions/link/link.js

@@ -0,0 +1,202 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { defineExtension, } from "../../core/runtime";
+import { CursorSourceBuilder } from "../../core/mapping/cursor-source-map";
+import { CakeLinkPopover } from "./link-popover";
+import { getDocLines } from "../../engine/selection/selection-layout";
+import { cursorOffsetToVisibleOffset, getVisibleText, } from "../../engine/selection/visible-text";
+import { ensureHttpsProtocol, isUrl } from "../../shared/url";
+const LINK_KIND = "link";
+export const linkExtension = defineExtension({
+    name: "link",
+    inlineWrapperAffinity: [{ kind: LINK_KIND, inclusive: false }],
+    keybindings: [
+        {
+            key: "u",
+            meta: true,
+            shift: true,
+            command: (state) => {
+                if (state.selection.start === state.selection.end) {
+                    return null;
+                }
+                return { type: "wrap-link", openPopover: true };
+            },
+        },
+        {
+            key: "u",
+            ctrl: true,
+            shift: true,
+            command: (state) => {
+                if (state.selection.start === state.selection.end) {
+                    return null;
+                }
+                return { type: "wrap-link", openPopover: true };
+            },
+        },
+    ],
+    onEdit(command, state) {
+        if (command.type === "unlink") {
+            // Find the link at the given cursor position and remove the link markup
+            const cursorPos = command.start;
+            const sourcePos = state.map.cursorToSource(cursorPos, "forward");
+            const source = state.source;
+            // Search backwards for the opening bracket
+            let linkStart = sourcePos;
+            while (linkStart > 0 && source[linkStart] !== "[") {
+                linkStart--;
+            }
+            if (source[linkStart] !== "[") {
+                return null;
+            }
+            // Find the ]( separator
+            const labelClose = source.indexOf("](", linkStart + 1);
+            if (labelClose === -1) {
+                return null;
+            }
+            // Find the closing )
+            const urlClose = source.indexOf(")", labelClose + 2);
+            if (urlClose === -1) {
+                return null;
+            }
+            // Extract the label (text between [ and ](  )
+            const label = source.slice(linkStart + 1, labelClose);
+            // Replace [label](url) with just label
+            const nextSource = source.slice(0, linkStart) + label + source.slice(urlClose + 1);
+            // Calculate new cursor position - place it at the end of the label
+            const newState = state.runtime.createState(nextSource);
+            const labelEndSource = linkStart + label.length;
+            const newCursor = newState.map.sourceToCursor(labelEndSource, "forward");
+            return {
+                source: nextSource,
+                selection: {
+                    start: newCursor.cursorOffset,
+                    end: newCursor.cursorOffset,
+                    affinity: "forward",
+                },
+            };
+        }
+        if (command.type !== "wrap-link") {
+            return null;
+        }
+        const selection = state.selection;
+        const cursorStart = Math.min(selection.start, selection.end);
+        const cursorEnd = Math.max(selection.start, selection.end);
+        if (cursorStart === cursorEnd) {
+            return null;
+        }
+        const from = state.map.cursorToSource(cursorStart, "forward");
+        const to = state.map.cursorToSource(cursorEnd, "backward");
+        if (from === to) {
+            return null;
+        }
+        const label = state.source.slice(from, to);
+        const url = command.url ?? "";
+        const linkMarkdown = `[${label}](${url})`;
+        const nextSource = state.source.slice(0, from) + linkMarkdown + state.source.slice(to);
+        return {
+            source: nextSource,
+            selection: {
+                start: cursorEnd,
+                end: cursorEnd,
+                affinity: "backward",
+            },
+        };
+    },
+    onPasteText(text, state) {
+        if (!isUrl(text)) {
+            return null;
+        }
+        const url = ensureHttpsProtocol(text.trim());
+        const selection = state.selection;
+        const start = Math.min(selection.start, selection.end);
+        const end = Math.max(selection.start, selection.end);
+        if (start !== end) {
+            const lines = getDocLines(state.doc);
+            const visibleText = getVisibleText(lines);
+            const visibleStart = cursorOffsetToVisibleOffset(lines, start);
+            const visibleEnd = cursorOffsetToVisibleOffset(lines, end);
+            const selectedText = visibleText.slice(visibleStart, visibleEnd);
+            const linkMarkdown = `[${selectedText}](${url})`;
+            return { type: "insert", text: linkMarkdown };
+        }
+        const linkMarkdown = `[${url}](${url})`;
+        return { type: "insert", text: linkMarkdown };
+    },
+    parseInline(source, start, end, context) {
+        if (source[start] !== "[") {
+            return null;
+        }
+        // Don't match image syntax ![...](...)
+        if (start > 0 && source[start - 1] === "!") {
+            return null;
+        }
+        const labelClose = source.indexOf("](", start + 1);
+        if (labelClose === -1 || labelClose >= end) {
+            return null;
+        }
+        const urlClose = source.indexOf(")", labelClose + 2);
+        if (urlClose === -1 || urlClose >= end) {
+            return null;
+        }
+        const labelStart = start + 1;
+        const labelEnd = labelClose;
+        const urlStart = labelClose + 2;
+        const urlEnd = urlClose;
+        const children = context.parseInline(source, labelStart, labelEnd);
+        const url = source.slice(urlStart, urlEnd);
+        return {
+            inline: {
+                type: "inline-wrapper",
+                kind: LINK_KIND,
+                children,
+                data: { url },
+            },
+            nextPos: urlClose + 1,
+        };
+    },
+    serializeInline(inline, context) {
+        if (inline.type !== "inline-wrapper" || inline.kind !== LINK_KIND) {
+            return null;
+        }
+        const builder = new CursorSourceBuilder();
+        builder.appendSourceOnly("[");
+        for (const child of inline.children) {
+            const serialized = context.serializeInline(child);
+            builder.appendSerialized(serialized);
+        }
+        builder.appendSourceOnly("](");
+        const url = typeof inline.data?.url === "string" ? inline.data.url : "";
+        builder.appendSourceOnly(url);
+        builder.appendSourceOnly(")");
+        return builder.build();
+    },
+    normalizeInline(inline) {
+        if (inline.type !== "inline-wrapper" || inline.kind !== LINK_KIND) {
+            return inline;
+        }
+        if (inline.children.length === 0) {
+            return null;
+        }
+        return inline;
+    },
+    renderInline(inline, context) {
+        if (inline.type !== "inline-wrapper" || inline.kind !== LINK_KIND) {
+            return null;
+        }
+        const element = document.createElement("a");
+        element.className = "cake-link";
+        const url = typeof inline.data?.url === "string" ? inline.data.url : "";
+        element.setAttribute("href", url);
+        for (const child of inline.children) {
+            for (const node of context.renderInline(child)) {
+                element.append(node);
+            }
+        }
+        return element;
+    },
+    renderOverlay(context) {
+        if (!context.contentRoot || !context.toOverlayRect) {
+            return null;
+        }
+        return (_jsx(CakeLinkPopover, { container: context.container, contentRoot: context.contentRoot, toOverlayRect: context.toOverlayRect, getSelection: context.getSelection, executeCommand: context.executeCommand }));
+    },
+});

package/dist/cake/extensions/list/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./list";
+//# sourceMappingURL=index.d.ts.map

package/dist/cake/extensions/list/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cake/extensions/list/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/dist/cake/extensions/list/index.js

@@ -0,0 +1 @@
+export * from "./list";

package/dist/cake/extensions/list/list-ast.d.ts

@@ -48,3 +48,4 @@ export declare function isListLine(line: string): boolean;
 export declare function parseListItem(line: string): ListItem | null;
 export declare function countNumberedItemsBefore(source: string, beforeLineIndex: number): number;
 export {};
+//# sourceMappingURL=list-ast.d.ts.map

package/dist/cake/extensions/list/list-ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-ast.d.ts","sourceRoot":"","sources":["../../../../src/cake/extensions/list/list-ast.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,KAAK,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAC;AAExC,UAAU,QAAQ;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,SAAS;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,KAAK,QAAQ,GAAG,SAAS,GAAG,YAAY,CAAC;AAEzC,UAAU,SAAS;IACjB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AA0BD,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,SAAS,CAMX;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,WAAW,GAAE,MAAU,GACtB,MAAM,CAqCR;AAID,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,QAAQ,GACb,SAAS,CAIX;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,CAIzE;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,GAChB,SAAS,CASX;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,CAYzE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,CAiB1E;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,SAAS,CAYX;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,EAChB,eAAe,EAAE,MAAM,EACvB,eAAe,EAAE,MAAM,GACtB,SAAS,CAeX;AAGD,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA4DtE;AAGD,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CA4BA;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM/D;AAGD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAGD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAM3D;AAGD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,GACtB,MAAM,CAUR"}

package/dist/cake/extensions/list/list-ast.js

@@ -0,0 +1,248 @@
+/**
+ * List AST - a structured representation of list content that can be
+ * transformed and serialized back to text with correct numbering.
+ */
+// Match list lines - capture exactly one space after marker, rest goes to content
+const LIST_LINE_REGEX = /^(\s*)([-*+]|\d+\.)( )(.*)$/;
+const INDENT_SIZE = 2;
+function parseMarkerType(marker) {
+    return /^\d+\.$/.test(marker) ? "numbered" : "bullet";
+}
+function parseLine(line) {
+    const match = line.match(LIST_LINE_REGEX);
+    if (!match) {
+        return { type: "plain", content: line };
+    }
+    const indent = Math.floor(match[1].length / INDENT_SIZE);
+    const markerType = parseMarkerType(match[2]);
+    const content = match[4] ?? "";
+    return {
+        type: "list-item",
+        item: { indent, markerType, content },
+    };
+}
+export function parseListRange(source, startOffset, endOffset) {
+    const text = source.slice(startOffset, endOffset);
+    const rawLines = text.split("\n");
+    const lines = rawLines.map(parseLine);
+    return { lines, startOffset, endOffset };
+}
+export function serializeListRange(range, startNumber = 1) {
+    // Track current number at each indent level
+    const numbersByIndent = new Map();
+    numbersByIndent.set(0, startNumber);
+    return range.lines
+        .map((line) => {
+        if (line.type === "plain") {
+            // Only blank lines reset numbering
+            if (line.content.trim() === "") {
+                numbersByIndent.clear();
+            }
+            return line.content;
+        }
+        const { item } = line;
+        const indentStr = " ".repeat(item.indent * INDENT_SIZE);
+        if (item.markerType === "bullet") {
+            // Bullet doesn't affect numbering
+            return `${indentStr}- ${item.content}`;
+        }
+        // Numbered: get current number at this indent level
+        const currentNum = numbersByIndent.get(item.indent) ?? 1;
+        numbersByIndent.set(item.indent, currentNum + 1);
+        // Reset numbering for deeper indent levels
+        for (const [indent] of numbersByIndent) {
+            if (indent > item.indent) {
+                numbersByIndent.delete(indent);
+            }
+        }
+        return `${indentStr}${currentNum}. ${item.content}`;
+    })
+        .join("\n");
+}
+// AST Operations
+export function insertItemAfter(range, lineIndex, item) {
+    const newLines = [...range.lines];
+    newLines.splice(lineIndex + 1, 0, { type: "list-item", item });
+    return { ...range, lines: newLines };
+}
+export function removeItem(range, lineIndex) {
+    const newLines = [...range.lines];
+    newLines.splice(lineIndex, 1);
+    return { ...range, lines: newLines };
+}
+export function convertToPlainText(range, lineIndex) {
+    const line = range.lines[lineIndex];
+    if (line.type !== "list-item") {
+        return range;
+    }
+    const newLines = [...range.lines];
+    newLines[lineIndex] = { type: "plain", content: line.item.content };
+    return { ...range, lines: newLines };
+}
+export function indentItem(range, lineIndex) {
+    const line = range.lines[lineIndex];
+    if (line.type !== "list-item") {
+        return range;
+    }
+    const newLines = [...range.lines];
+    newLines[lineIndex] = {
+        type: "list-item",
+        item: { ...line.item, indent: line.item.indent + 1 },
+    };
+    return { ...range, lines: newLines };
+}
+export function outdentItem(range, lineIndex) {
+    const line = range.lines[lineIndex];
+    if (line.type !== "list-item") {
+        return range;
+    }
+    if (line.item.indent === 0) {
+        // Top-level item: convert to plain text
+        return convertToPlainText(range, lineIndex);
+    }
+    const newLines = [...range.lines];
+    newLines[lineIndex] = {
+        type: "list-item",
+        item: { ...line.item, indent: line.item.indent - 1 },
+    };
+    return { ...range, lines: newLines };
+}
+export function updateItemContent(range, lineIndex, content) {
+    const line = range.lines[lineIndex];
+    if (line.type !== "list-item") {
+        return range;
+    }
+    const newLines = [...range.lines];
+    newLines[lineIndex] = {
+        type: "list-item",
+        item: { ...line.item, content },
+    };
+    return { ...range, lines: newLines };
+}
+export function mergeItems(range, targetLineIndex, sourceLineIndex) {
+    const targetLine = range.lines[targetLineIndex];
+    const sourceLine = range.lines[sourceLineIndex];
+    if (targetLine.type !== "list-item" || sourceLine.type !== "list-item") {
+        return range;
+    }
+    const mergedContent = targetLine.item.content +
+        (sourceLine.item.content ? " " + sourceLine.item.content : "");
+    let result = updateItemContent(range, targetLineIndex, mergedContent);
+    result = removeItem(result, sourceLineIndex);
+    return result;
+}
+// Helper to find list range boundaries from a cursor position
+export function findListRangeBoundaries(source, cursorOffset) {
+    const lines = source.split("\n");
+    let offset = 0;
+    let cursorLineIndex = 0;
+    // Find which line the cursor is on
+    for (let i = 0; i < lines.length; i++) {
+        const lineEnd = offset + lines[i].length;
+        if (cursorOffset >= offset && cursorOffset <= lineEnd) {
+            cursorLineIndex = i;
+            break;
+        }
+        offset = lineEnd + 1;
+    }
+    // Check if current line is a list item
+    const currentLine = lines[cursorLineIndex];
+    if (!LIST_LINE_REGEX.test(currentLine)) {
+        return null;
+    }
+    // Expand backwards to find start of list
+    let startLineIndex = cursorLineIndex;
+    while (startLineIndex > 0) {
+        const prevLine = lines[startLineIndex - 1];
+        if (prevLine.trim() === "" || !LIST_LINE_REGEX.test(prevLine)) {
+            break;
+        }
+        startLineIndex--;
+    }
+    // Expand forwards to find end of list
+    let endLineIndex = cursorLineIndex;
+    while (endLineIndex < lines.length - 1) {
+        const nextLine = lines[endLineIndex + 1];
+        if (nextLine.trim() === "" || !LIST_LINE_REGEX.test(nextLine)) {
+            break;
+        }
+        endLineIndex++;
+    }
+    // Calculate offsets
+    let startOffset = 0;
+    for (let i = 0; i < startLineIndex; i++) {
+        startOffset += lines[i].length + 1;
+    }
+    let endOffset = startOffset;
+    for (let i = startLineIndex; i <= endLineIndex; i++) {
+        endOffset += lines[i].length;
+        if (i < endLineIndex) {
+            endOffset += 1;
+        }
+    }
+    return {
+        startOffset,
+        endOffset,
+        lineIndex: cursorLineIndex - startLineIndex,
+    };
+}
+// Get line info at a specific offset
+export function getLineInfo(source, offset) {
+    const lines = source.split("\n");
+    let pos = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const lineStart = pos;
+        const lineEnd = pos + lines[i].length;
+        if (offset >= lineStart && offset <= lineEnd) {
+            return {
+                lineIndex: i,
+                lineStart,
+                lineEnd,
+                line: lines[i],
+                offsetInLine: offset - lineStart,
+            };
+        }
+        pos = lineEnd + 1;
+    }
+    const lastLine = lines[lines.length - 1] ?? "";
+    const lastLineStart = source.length - lastLine.length;
+    return {
+        lineIndex: lines.length - 1,
+        lineStart: lastLineStart,
+        lineEnd: source.length,
+        line: lastLine,
+        offsetInLine: offset - lastLineStart,
+    };
+}
+// Get the prefix length for a list line (indent + marker + space)
+export function getListPrefixLength(line) {
+    const match = line.match(LIST_LINE_REGEX);
+    if (!match) {
+        return null;
+    }
+    return match[1].length + match[2].length + match[3].length;
+}
+// Check if a line is a list item
+export function isListLine(line) {
+    return LIST_LINE_REGEX.test(line);
+}
+// Parse a single line and return the list item if it is one
+export function parseListItem(line) {
+    const parsed = parseLine(line);
+    if (parsed.type !== "list-item") {
+        return null;
+    }
+    return parsed.item;
+}
+// Count numbered items at top level (indent 0) before a given line index
+export function countNumberedItemsBefore(source, beforeLineIndex) {
+    const lines = source.split("\n");
+    let count = 0;
+    for (let i = 0; i < beforeLineIndex && i < lines.length; i++) {
+        const item = parseListItem(lines[i]);
+        if (item && item.markerType === "numbered" && item.indent === 0) {
+            count++;
+        }
+    }
+    return count;
+}

package/dist/cake/extensions/list/list.d.ts

@@ -9,3 +9,4 @@ export type ToggleNumberedListCommand = {
 /** All list extension commands */
 export type ListCommand = ToggleBulletListCommand | ToggleNumberedListCommand;
 export declare const listExtension: import("../../..").CakeExtension;
+//# sourceMappingURL=list.d.ts.map

package/dist/cake/extensions/list/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/cake/extensions/list/list.ts"],"names":[],"mappings":"AAygCA,+CAA+C;AAC/C,MAAM,MAAM,uBAAuB,GAAG;IAAE,IAAI,EAAE,oBAAoB,CAAA;CAAE,CAAC;AAErE,iDAAiD;AACjD,MAAM,MAAM,yBAAyB,GAAG;IAAE,IAAI,EAAE,sBAAsB,CAAA;CAAE,CAAC;AAEzE,kCAAkC;AAClC,MAAM,MAAM,WAAW,GAAG,uBAAuB,GAAG,yBAAyB,CAAC;AAE9E,eAAO,MAAM,aAAa,kCAmGxB,CAAC"}