@blankdotpage/cake 0.1.7 → 0.1.10

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

@@ -1 +1,2 @@
 export declare const scrollbarExtension: import("../../..").CakeExtension;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cake/extensions/scrollbar/index.tsx"],"names":[],"mappings":"AA2RA,eAAO,MAAM,kBAAkB,kCAK7B,CAAC"}

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

@@ -0,0 +1,216 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { defineExtension } from "../../core/runtime";
+const THUMB_MIN_HEIGHT = 30;
+const SCROLL_HIDE_DELAY = 500;
+const TRACK_PADDING = 8;
+function ScrollbarOverlay({ container }) {
+    const [state, setState] = useState({
+        scrollTop: 0,
+        scrollHeight: 0,
+        clientHeight: 0,
+    });
+    const [isDragging, setIsDragging] = useState(false);
+    const [isHovered, setIsHovered] = useState(false);
+    const [isScrolling, setIsScrolling] = useState(false);
+    const [isDarkMode, setIsDarkMode] = useState(false);
+    const dragStartRef = useRef(null);
+    const scrollTimeoutRef = useRef(null);
+    const { scrollTop, scrollHeight, clientHeight } = state;
+    const hasOverflow = scrollHeight > clientHeight;
+    const trackHeight = clientHeight - TRACK_PADDING * 2;
+    const rawThumbHeight = hasOverflow
+        ? (clientHeight / scrollHeight) * trackHeight
+        : 0;
+    const thumbHeight = Math.min(trackHeight, Math.max(THUMB_MIN_HEIGHT, rawThumbHeight));
+    const maxScrollTop = scrollHeight - clientHeight;
+    const thumbTop = maxScrollTop > 0
+        ? TRACK_PADDING + (scrollTop / maxScrollTop) * (trackHeight - thumbHeight)
+        : TRACK_PADDING;
+    useEffect(() => {
+        function checkDarkMode() {
+            // Check for explicit dark class - blank page adds "dark" class when in dark mode
+            // When in light mode, there's no explicit class, so default to light
+            const html = document.documentElement;
+            setIsDarkMode(html.classList.contains("dark"));
+        }
+        checkDarkMode();
+        const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+        mediaQuery.addEventListener("change", checkDarkMode);
+        const observer = new MutationObserver(checkDarkMode);
+        observer.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ["class"],
+        });
+        return () => {
+            mediaQuery.removeEventListener("change", checkDarkMode);
+            observer.disconnect();
+        };
+    }, []);
+    useEffect(() => {
+        function update() {
+            setState({
+                scrollTop: container.scrollTop,
+                scrollHeight: container.scrollHeight,
+                clientHeight: container.clientHeight,
+            });
+        }
+        function handleScroll() {
+            update();
+            setIsScrolling(true);
+            if (scrollTimeoutRef.current) {
+                clearTimeout(scrollTimeoutRef.current);
+            }
+            scrollTimeoutRef.current = setTimeout(() => {
+                setIsScrolling(false);
+            }, SCROLL_HIDE_DELAY);
+        }
+        update();
+        container.addEventListener("scroll", handleScroll);
+        window.addEventListener("resize", update);
+        let resizeObserver = null;
+        let mutationObserver = null;
+        let observedContent = null;
+        const observeContent = () => {
+            if (!resizeObserver) {
+                return;
+            }
+            const nextContent = container.querySelector(".cake-content");
+            if (nextContent === observedContent) {
+                return;
+            }
+            if (observedContent) {
+                resizeObserver.unobserve(observedContent);
+            }
+            observedContent = nextContent;
+            if (observedContent) {
+                resizeObserver.observe(observedContent);
+            }
+        };
+        if (typeof ResizeObserver !== "undefined") {
+            resizeObserver = new ResizeObserver(update);
+            resizeObserver.observe(container);
+            observeContent();
+        }
+        if (typeof MutationObserver !== "undefined") {
+            mutationObserver = new MutationObserver(() => {
+                observeContent();
+                update();
+            });
+            mutationObserver.observe(container, {
+                childList: true,
+                subtree: true,
+                characterData: true,
+            });
+        }
+        return () => {
+            container.removeEventListener("scroll", handleScroll);
+            window.removeEventListener("resize", update);
+            resizeObserver?.disconnect();
+            mutationObserver?.disconnect();
+            if (scrollTimeoutRef.current) {
+                clearTimeout(scrollTimeoutRef.current);
+            }
+        };
+    }, [container]);
+    const handleTrackClick = useCallback((event) => {
+        if (event.target !== event.currentTarget) {
+            return;
+        }
+        const trackRect = event.currentTarget.getBoundingClientRect();
+        const clickY = event.clientY - trackRect.top;
+        const clickRatio = clickY / trackHeight;
+        const targetScrollTop = clickRatio * maxScrollTop;
+        container.scrollTop = Math.max(0, Math.min(targetScrollTop, maxScrollTop));
+    }, [container, trackHeight, maxScrollTop]);
+    const handleThumbMouseDown = useCallback((event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        setIsDragging(true);
+        dragStartRef.current = {
+            scrollTop: container.scrollTop,
+            clientY: event.clientY,
+        };
+    }, [container]);
+    useEffect(() => {
+        if (!isDragging) {
+            return;
+        }
+        const originalUserSelect = document.body.style.userSelect;
+        document.body.style.userSelect = "none";
+        function handleMouseMove(event) {
+            event.preventDefault();
+            event.stopPropagation();
+            if (!dragStartRef.current) {
+                return;
+            }
+            const deltaY = event.clientY - dragStartRef.current.clientY;
+            const scrollableTrack = trackHeight - thumbHeight;
+            const scrollRatio = scrollableTrack > 0 ? deltaY / scrollableTrack : 0;
+            const deltaScroll = scrollRatio * maxScrollTop;
+            container.scrollTop = Math.max(0, Math.min(dragStartRef.current.scrollTop + deltaScroll, maxScrollTop));
+        }
+        function handleMouseUp(event) {
+            event.preventDefault();
+            event.stopPropagation();
+            setIsDragging(false);
+            dragStartRef.current = null;
+        }
+        document.addEventListener("mousemove", handleMouseMove, { capture: true });
+        document.addEventListener("mouseup", handleMouseUp, { capture: true });
+        return () => {
+            document.removeEventListener("mousemove", handleMouseMove, {
+                capture: true,
+            });
+            document.removeEventListener("mouseup", handleMouseUp, {
+                capture: true,
+            });
+            document.body.style.userSelect = originalUserSelect;
+        };
+    }, [isDragging, container, trackHeight, thumbHeight, maxScrollTop]);
+    if (!hasOverflow || trackHeight < THUMB_MIN_HEIGHT) {
+        return null;
+    }
+    const isVisible = isDragging || isHovered || isScrolling;
+    const wrapperStyle = {
+        position: "absolute",
+        inset: 0,
+        pointerEvents: "none",
+        overflow: "hidden",
+        zIndex: 50,
+    };
+    const trackStyle = {
+        position: "absolute",
+        top: 0,
+        right: 0,
+        bottom: 0,
+        width: "12px",
+        height: clientHeight,
+        pointerEvents: "auto",
+    };
+    const getThumbColor = () => {
+        if (isDarkMode) {
+            return isDragging ? "rgba(255, 255, 255, 0.5)" : "rgba(255, 255, 255, 0.3)";
+        }
+        return isDragging ? "rgba(0, 0, 0, 0.5)" : "rgba(0, 0, 0, 0.3)";
+    };
+    const thumbStyle = {
+        position: "absolute",
+        right: "2px",
+        width: "6px",
+        borderRadius: "9999px",
+        height: thumbHeight,
+        top: thumbTop,
+        opacity: isVisible ? 1 : 0,
+        backgroundColor: getThumbColor(),
+        transition: "opacity 150ms",
+        cursor: "pointer",
+    };
+    return (_jsx("div", { style: wrapperStyle, children: _jsx("div", { "data-testid": "custom-scrollbar", "aria-hidden": "true", style: trackStyle, onClick: handleTrackClick, onMouseEnter: () => setIsHovered(true), onMouseLeave: () => setIsHovered(false), children: _jsx("div", { "data-testid": "scrollbar-thumb", style: thumbStyle, onMouseDown: handleThumbMouseDown }) }) }));
+}
+export const scrollbarExtension = defineExtension({
+    name: "scrollbar",
+    renderOverlay(context) {
+        return _jsx(ScrollbarOverlay, { container: context.container });
+    },
+});

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

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

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

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

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

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

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

@@ -1 +1,2 @@
 export declare const strikethroughExtension: import("../../..").CakeExtension;
+//# sourceMappingURL=strikethrough.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strikethrough.d.ts","sourceRoot":"","sources":["../../../../src/cake/extensions/strikethrough/strikethrough.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,sBAAsB,kCAuFjC,CAAC"}

package/dist/cake/extensions/strikethrough/strikethrough.js

@@ -0,0 +1,84 @@
+import { defineExtension, } from "../../core/runtime";
+import { CursorSourceBuilder } from "../../core/mapping/cursor-source-map";
+const STRIKE_KIND = "strikethrough";
+export const strikethroughExtension = defineExtension({
+    name: "strikethrough",
+    toggleInline: { kind: STRIKE_KIND, markers: ["~~"] },
+    keybindings: [
+        {
+            key: "x",
+            meta: true,
+            shift: true,
+            command: { type: "toggle-strikethrough" },
+        },
+        {
+            key: "x",
+            ctrl: true,
+            shift: true,
+            command: { type: "toggle-strikethrough" },
+        },
+    ],
+    inlineWrapperAffinity: [{ kind: STRIKE_KIND, inclusive: true }],
+    onEdit(command) {
+        // Handle semantic command by delegating to toggle-inline
+        if (command.type === "toggle-strikethrough") {
+            return { type: "toggle-inline", marker: "~~" };
+        }
+        return null;
+    },
+    parseInline(source, start, end, context) {
+        if (source.slice(start, start + 2) !== "~~") {
+            return null;
+        }
+        const close = source.indexOf("~~", start + 2);
+        if (close === -1 || close >= end) {
+            return null;
+        }
+        if (close === start + 2 && close + 2 < end) {
+            return null;
+        }
+        const children = context.parseInline(source, start + 2, close);
+        return {
+            inline: {
+                type: "inline-wrapper",
+                kind: STRIKE_KIND,
+                children,
+            },
+            nextPos: close + 2,
+        };
+    },
+    serializeInline(inline, context) {
+        if (inline.type !== "inline-wrapper" || inline.kind !== STRIKE_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("~~");
+        return builder.build();
+    },
+    normalizeInline(inline) {
+        if (inline.type !== "inline-wrapper" || inline.kind !== STRIKE_KIND) {
+            return inline;
+        }
+        if (inline.children.length === 0) {
+            return null;
+        }
+        return inline;
+    },
+    renderInline(inline, context) {
+        if (inline.type !== "inline-wrapper" || inline.kind !== STRIKE_KIND) {
+            return null;
+        }
+        const element = document.createElement("s");
+        for (const child of inline.children) {
+            for (const node of context.renderInline(child)) {
+                element.append(node);
+            }
+        }
+        return element;
+    },
+});

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

@@ -3,3 +3,4 @@ export type CakeExtensionBundle = {
     name: string;
     extensions: CakeExtension[];
 };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cake/extensions/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B,CAAC"}

package/dist/cake/extensions/types.js

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

package/dist/cake/index.d.ts

@@ -1,3 +1,4 @@
 export { CakeEditor } from "./react/CakeEditor";
 export type { CakeEditorProps, CakeEditorRef, CakeEditorSelection, CakeEditorUpdate, } from "./react/CakeEditor";
 export type { EditCommand, CoreEditCommand, ExtensionCommand } from "./core/runtime";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cake/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,YAAY,EACV,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAG5B,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/cake/index.js

@@ -0,0 +1 @@
+export { CakeEditor } from "./react/CakeEditor";

package/dist/cake/react/CakeEditor.d.ts

@@ -56,3 +56,4 @@ export interface CakeEditorRef {
     replaceText: (oldText: string, newText: string) => void;
 }
 export declare const CakeEditor: import("react").ForwardRefExoticComponent<CakeEditorProps & import("react").RefAttributes<CakeEditorRef | null>>;
+//# sourceMappingURL=CakeEditor.d.ts.map

package/dist/cake/react/CakeEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CakeEditor.d.ts","sourceRoot":"","sources":["../../../src/cake/react/CakeEditor.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EAEZ,MAAM,iBAAiB,CAAC;AAkBzB,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACnC,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,iBAAiB,CAAC,EAAE,CAClB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,UAAU,GAAG,SAAS,KAC9B,IAAI,CAAC;IACV,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5B,KAAK,EAAE,CAAC,SAAS,CAAC,EAAE,mBAAmB,KAAK,IAAI,CAAC;IACjD,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB;;;;;;;;;;;;OAYG;IACH,cAAc,EAAE,CACd,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,KACjC,OAAO,CAAC;IACb,WAAW,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAChD,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC1D,eAAe,EAAE,MAAM,MAAM,CAAC;IAC9B,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACzD;AAED,eAAO,MAAM,UAAU,kHAwQrB,CAAC"}

package/dist/cake/react/CakeEditor.js

@@ -0,0 +1,233 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment, forwardRef, useEffect, useImperativeHandle, useRef, useState, } from "react";
+import { CakeEngine } from "../engine/cake-engine";
+import { bundledExtensions, bundledExtensionsWithoutImage, } from "../extensions";
+function toEngineSelection(selection) {
+    if (!selection) {
+        return { start: 0, end: 0, affinity: "forward" };
+    }
+    return {
+        start: selection.start,
+        end: selection.end,
+        affinity: selection.affinity,
+    };
+}
+export const CakeEditor = forwardRef(function CakeEditor(props, outerRef) {
+    const containerRef = useRef(null);
+    const engineRef = useRef(null);
+    const onChangeRef = useRef(props.onChange);
+    const onSelectionChangeRef = useRef(props.onSelectionChange);
+    const lastEmittedValueRef = useRef(null);
+    const lastEmittedSelectionRef = useRef(null);
+    const [contentRoot, setContentRoot] = useState(null);
+    // Merge bundled extensions with custom extensions
+    const baseExtensions = props.disableImageExtension
+        ? bundledExtensionsWithoutImage
+        : bundledExtensions;
+    const allExtensionsRef = useRef([
+        ...baseExtensions,
+        ...(props.extensions ?? []),
+    ]);
+    const hasOverlayExtensions = allExtensionsRef.current.some((ext) => ext.renderOverlay);
+    useEffect(() => {
+        onChangeRef.current = props.onChange;
+        onSelectionChangeRef.current = props.onSelectionChange;
+    }, [props.onChange, props.onSelectionChange]);
+    useEffect(() => {
+        engineRef.current?.syncPlaceholder();
+    }, [props.placeholder]);
+    useEffect(() => {
+        const container = containerRef.current;
+        if (!container) {
+            return;
+        }
+        const engine = new CakeEngine({
+            container,
+            value: props.value,
+            selection: props.selection ?? undefined,
+            extensions: allExtensionsRef.current,
+            readOnly: props.disabled ?? false,
+            spellCheckEnabled: props.spellCheck ?? false,
+            onChange: (value, selection) => {
+                lastEmittedValueRef.current = value;
+                lastEmittedSelectionRef.current = selection;
+                onChangeRef.current(value);
+                onSelectionChangeRef.current?.(selection.start, selection.end, selection.affinity);
+            },
+            onSelectionChange: (selection) => {
+                lastEmittedSelectionRef.current = selection;
+                onSelectionChangeRef.current?.(selection.start, selection.end, selection.affinity);
+            },
+        });
+        engineRef.current = engine;
+        setContentRoot(engine.getContentRoot());
+        return () => {
+            engine.destroy();
+            engineRef.current = null;
+            setContentRoot(null);
+        };
+    }, []);
+    useEffect(() => {
+        const engine = engineRef.current;
+        if (!engine) {
+            return;
+        }
+        engine.setReadOnly(props.disabled ?? false);
+    }, [props.disabled]);
+    useEffect(() => {
+        const engine = engineRef.current;
+        if (!engine) {
+            return;
+        }
+        engine.setSpellCheckEnabled(props.spellCheck ?? false);
+    }, [props.spellCheck]);
+    useEffect(() => {
+        const engine = engineRef.current;
+        if (!engine) {
+            return;
+        }
+        const nextValue = props.value;
+        const nextSelection = props.selection
+            ? toEngineSelection(props.selection)
+            : undefined;
+        const lastEmittedValue = lastEmittedValueRef.current;
+        // If the value matches what we emitted, don't accept selection changes from props.
+        // This prevents stale selection props (from React batching during fast typing)
+        // from resetting the engine's selection.
+        if (lastEmittedValue === nextValue) {
+            return;
+        }
+        engine.setValue({
+            value: nextValue,
+            selection: nextSelection,
+        });
+    }, [props.value, props.selection]);
+    useImperativeHandle(outerRef, () => {
+        return {
+            element: containerRef.current,
+            focus: (selection) => {
+                const sel = selection ? toEngineSelection(selection) : undefined;
+                engineRef.current?.focus(sel);
+            },
+            blur: () => {
+                engineRef.current?.blur();
+            },
+            hasFocus: () => {
+                return engineRef.current?.hasFocus() ?? false;
+            },
+            selectAll: () => {
+                engineRef.current?.selectAll();
+            },
+            executeCommand: (command, options) => {
+                if (!engineRef.current) {
+                    return false;
+                }
+                return engineRef.current.executeCommand(command, options);
+            },
+            applyUpdate: (update) => {
+                if (!engineRef.current) {
+                    return;
+                }
+                const engine = engineRef.current;
+                const selection = update.selection
+                    ? toEngineSelection(update.selection)
+                    : undefined;
+                if (update.value !== undefined) {
+                    engine.setValue({
+                        value: update.value,
+                        selection,
+                    });
+                    if (update.focus) {
+                        engine.focus(selection);
+                    }
+                    return;
+                }
+                if (update.selection) {
+                    if (!selection) {
+                        return;
+                    }
+                    engine.setSelection(selection);
+                    if (update.focus) {
+                        engine.focus(selection);
+                    }
+                    return;
+                }
+                if (update.focus) {
+                    engine.focus();
+                }
+            },
+            getValue: () => engineRef.current?.getValue() ?? props.value,
+            getSelection: () => {
+                const selection = engineRef.current?.getSelection();
+                if (!selection) {
+                    return null;
+                }
+                return { start: selection.start, end: selection.end };
+            },
+            getCursorLength: () => engineRef.current?.getCursorLength() ?? 0,
+            insertText: (text) => {
+                engineRef.current?.insertText(text);
+            },
+            replaceText: (oldText, newText) => {
+                engineRef.current?.replaceText(oldText, newText);
+            },
+        };
+    }, [props.value]);
+    const containerStyle = props.style
+        ? { ...props.style }
+        : {};
+    if (!containerStyle.position) {
+        containerStyle.position = "relative";
+    }
+    const containerClassName = props.className
+        ? `cake ${props.className}`
+        : "cake";
+    const overlayContext = containerRef.current && contentRoot
+        ? {
+            container: containerRef.current,
+            contentRoot,
+            toOverlayRect: (rect) => {
+                const containerRect = containerRef.current?.getBoundingClientRect();
+                if (!containerRect) {
+                    return {
+                        top: rect.top,
+                        left: rect.left,
+                        width: rect.width,
+                        height: rect.height,
+                    };
+                }
+                return {
+                    top: rect.top - containerRect.top,
+                    left: rect.left - containerRect.left,
+                    width: rect.width,
+                    height: rect.height,
+                };
+            },
+            insertText: (text) => {
+                engineRef.current?.insertText(text);
+            },
+            replaceText: (oldText, newText) => {
+                engineRef.current?.replaceText(oldText, newText);
+            },
+            getSelection: () => {
+                const selection = engineRef.current?.getSelection();
+                if (!selection) {
+                    return null;
+                }
+                const focus = selection.start === selection.end
+                    ? selection.start
+                    : Math.max(selection.start, selection.end);
+                return { start: focus, end: focus };
+            },
+            executeCommand: (command) => {
+                return engineRef.current?.executeCommand(command) ?? false;
+            },
+        }
+        : null;
+    return (_jsxs("div", { style: { position: "relative", height: "100%" }, children: [_jsx("div", { ref: containerRef, className: containerClassName, style: containerStyle, "data-placeholder": props.placeholder, onBlur: (event) => {
+                    props.onBlur?.(event.nativeEvent);
+                } }), overlayContext && hasOverlayExtensions
+                ? allExtensionsRef.current.map((extension) => extension.renderOverlay ? (_jsx(Fragment, { children: extension.renderOverlay(overlayContext) }, extension.name)) : null)
+                : null] }));
+});
+CakeEditor.displayName = "CakeEditor";

package/dist/cake/shared/platform.d.ts

@@ -1,2 +1,3 @@
 export declare const currentPlatform: "mac" | "windows" | "linux";
 export declare function isMacPlatform(): boolean;
+//# sourceMappingURL=platform.d.ts.map

package/dist/cake/shared/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../src/cake/shared/platform.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,eAAe,6BAAmB,CAAC;AAIhD,wBAAgB,aAAa,IAAI,OAAO,CAEvC"}

package/dist/cake/shared/platform.js

@@ -0,0 +1,19 @@
+function detectPlatform() {
+    if (typeof navigator === "undefined") {
+        return "linux";
+    }
+    const platform = navigator.platform;
+    if (/Mac|iPhone|iPad|iPod/.test(platform)) {
+        return "mac";
+    }
+    if (/Win/.test(platform)) {
+        return "windows";
+    }
+    return "linux";
+}
+export const currentPlatform = detectPlatform();
+// Do not compute platform at module-load time for behavior decisions that depend
+// on the current browser environment (tests may override `navigator.platform`).
+export function isMacPlatform() {
+    return detectPlatform() === "mac";
+}

package/dist/cake/shared/segmenter.d.ts

@@ -10,3 +10,4 @@ export declare function graphemeSegments(text: string): GraphemeSegment[];
 export declare function wordSegments(text: string, locale?: string): WordSegment[];
 export declare function graphemeClusterLengthBefore(text: string, offset: number): number;
 export declare function graphemeClusterLengthAfter(text: string, offset: number): number;
+//# sourceMappingURL=segmenter.d.ts.map

package/dist/cake/shared/segmenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmenter.d.ts","sourceRoot":"","sources":["../../../src/cake/shared/segmenter.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,eAAe,GAAG;IAC1C,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAMF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,EAAE,CAEhE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAAO,GAAG,WAAW,EAAE,CAMvE;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,MAAM,CAqBR;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,MAAM,CAmBR"}