@a3s-lab/office 0.1.0

package/dist/0~8155.js

@@ -0,0 +1,299 @@
+import { Extension, ResizableNodeView, mergeAttributes } from "@tiptap/core";
+import extension_image from "@tiptap/extension-image";
+const DEFAULT_IMAGE_LAYOUT = 'inline';
+const DEFAULT_IMAGE_ALIGNMENT = 'center';
+const DEFAULT_WRAP_DISTANCE_MILLIMETERS = 3;
+const MAX_WRAP_DISTANCE_MILLIMETERS = 25;
+const DocumentImage = extension_image.extend({
+    addCommands () {
+        return {
+            ...this.parent?.() ?? {},
+            setDocumentImageAlternativeText: (alternativeText, options = {})=>({ chain, editor })=>{
+                    if (!editor.isActive('image')) return false;
+                    const normalized = alternativeText.trim();
+                    let commandChain = chain();
+                    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+                    return commandChain.updateAttributes('image', {
+                        alt: normalized || null,
+                        title: normalized || null
+                    }).run();
+                },
+            setDocumentImageLayoutOptions: (value, options = {})=>({ chain, editor })=>{
+                    if (!editor.isActive('image')) return false;
+                    const current = documentImageLayoutOptions(editor);
+                    const next = normalizeDocumentImageLayoutOptions({
+                        ...current,
+                        ...value
+                    });
+                    let commandChain = chain();
+                    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+                    return commandChain.updateAttributes('image', next).run();
+                }
+        };
+    },
+    addAttributes () {
+        return {
+            ...this.parent?.(),
+            layout: {
+                default: DEFAULT_IMAGE_LAYOUT,
+                parseHTML: (element)=>normalizeDocumentImageLayout(element.getAttribute('data-office-image-layout')),
+                renderHTML: (attributes)=>({
+                        'data-office-image-layout': normalizeDocumentImageLayout(attributes.layout)
+                    })
+            },
+            alignment: {
+                default: DEFAULT_IMAGE_ALIGNMENT,
+                parseHTML: (element)=>normalizeDocumentImageAlignment(element.getAttribute('data-office-image-alignment')),
+                renderHTML: (attributes)=>({
+                        'data-office-image-alignment': normalizeDocumentImageAlignment(attributes.alignment)
+                    })
+            },
+            wrapDistance: {
+                default: DEFAULT_WRAP_DISTANCE_MILLIMETERS,
+                parseHTML: (element)=>normalizeDocumentImageWrapDistance(element.getAttribute('data-office-image-wrap-distance')),
+                renderHTML: (attributes)=>{
+                    const distance = normalizeDocumentImageWrapDistance(attributes.wrapDistance);
+                    return {
+                        'data-office-image-wrap-distance': formatImageLayoutNumber(distance),
+                        style: `--work-document-image-wrap-distance:${formatImageLayoutNumber(distance)}mm`
+                    };
+                }
+            }
+        };
+    },
+    addNodeView () {
+        const resize = this.options.resize;
+        if (false === resize || !resize.enabled || "u" < typeof document) return null;
+        const { directions, minWidth, minHeight, alwaysPreserveAspectRatio } = resize;
+        return ({ node, getPos, HTMLAttributes, editor })=>{
+            const element = document.createElement('img');
+            element.draggable = false;
+            applyInitialImageHtmlAttributes(element, HTMLAttributes);
+            element.style.visibility = 'hidden';
+            element.style.pointerEvents = 'none';
+            const reveal = ()=>{
+                element.style.visibility = '';
+                element.style.pointerEvents = '';
+            };
+            element.addEventListener('load', reveal);
+            element.addEventListener('error', reveal);
+            let container = null;
+            const sync = (updatedNode)=>{
+                syncDocumentImageNodeView(element, container, updatedNode.attrs);
+            };
+            const nodeView = new ResizableNodeView({
+                element,
+                editor,
+                node,
+                getPos,
+                onResize: (width, height)=>{
+                    element.style.width = `${width}px`;
+                    element.style.height = `${height}px`;
+                },
+                onCommit: (width, height)=>{
+                    const position = getPos();
+                    if (void 0 === position) return;
+                    editor.chain().setNodeSelection(position).updateAttributes(this.name, {
+                        width,
+                        height
+                    }).run();
+                },
+                onUpdate: (updatedNode)=>{
+                    if (updatedNode.type !== node.type) return false;
+                    sync(updatedNode);
+                    return true;
+                },
+                options: {
+                    directions,
+                    min: {
+                        width: minWidth,
+                        height: minHeight
+                    },
+                    preserveAspectRatio: true === alwaysPreserveAspectRatio
+                }
+            });
+            container = nodeView.dom;
+            sync(node);
+            if (element.complete) reveal();
+            return nodeView;
+        };
+    }
+});
+function documentImageLayoutOptions(editor) {
+    const attributes = editor.getAttributes('image');
+    return normalizeDocumentImageLayoutOptions(attributes);
+}
+function documentImageAlternativeText(editor) {
+    if (!editor.isActive('image')) return '';
+    const attributes = editor.getAttributes('image');
+    const value = 'string' == typeof attributes.alt ? attributes.alt : 'string' == typeof attributes.title ? attributes.title : '';
+    return value.trim();
+}
+function documentImageLayoutFromElement(element) {
+    return normalizeDocumentImageLayoutOptions({
+        layout: element.getAttribute('data-office-image-layout'),
+        alignment: element.getAttribute('data-office-image-alignment'),
+        wrapDistance: element.getAttribute('data-office-image-wrap-distance')
+    });
+}
+function normalizeDocumentImageLayoutOptions(value) {
+    return {
+        layout: normalizeDocumentImageLayout(value.layout),
+        alignment: normalizeDocumentImageAlignment(value.alignment),
+        wrapDistance: normalizeDocumentImageWrapDistance(value.wrapDistance)
+    };
+}
+function normalizeDocumentImageLayout(value) {
+    return 'square' === value || 'topBottom' === value ? value : DEFAULT_IMAGE_LAYOUT;
+}
+function normalizeDocumentImageAlignment(value) {
+    return 'left' === value || 'right' === value ? value : DEFAULT_IMAGE_ALIGNMENT;
+}
+function normalizeDocumentImageWrapDistance(value) {
+    const number = 'number' == typeof value ? value : 'string' == typeof value && value.trim() ? Number(value) : DEFAULT_WRAP_DISTANCE_MILLIMETERS;
+    if (!Number.isFinite(number)) return DEFAULT_WRAP_DISTANCE_MILLIMETERS;
+    return Math.round(2 * Math.min(MAX_WRAP_DISTANCE_MILLIMETERS, Math.max(0, number))) / 2;
+}
+function formatImageLayoutNumber(value) {
+    return Number(value.toFixed(2)).toString();
+}
+function applyInitialImageHtmlAttributes(element, attributes) {
+    const merged = mergeAttributes(attributes);
+    for (const [name, value] of Object.entries(merged))if (null != value && 'width' !== name && 'height' !== name) element.setAttribute(name, String(value));
+}
+function syncDocumentImageNodeView(element, container, attributes) {
+    const layout = normalizeDocumentImageLayout(attributes.layout);
+    const alignment = normalizeDocumentImageAlignment(attributes.alignment);
+    const wrapDistance = normalizeDocumentImageWrapDistance(attributes.wrapDistance);
+    setOptionalImageAttribute(element, 'src', attributes.src);
+    setOptionalImageAttribute(element, 'alt', attributes.alt);
+    setOptionalImageAttribute(element, 'title', attributes.title);
+    element.dataset.officeImageLayout = layout;
+    element.dataset.officeImageAlignment = alignment;
+    element.dataset.officeImageWrapDistance = formatImageLayoutNumber(wrapDistance);
+    element.style.setProperty('--work-document-image-wrap-distance', `${formatImageLayoutNumber(wrapDistance)}mm`);
+    syncImageDimension(element, 'width', attributes.width);
+    syncImageDimension(element, 'height', attributes.height);
+    if (!container) return;
+    container.dataset.officeImageLayout = layout;
+    container.dataset.officeImageAlignment = alignment;
+    container.dataset.officeImageWrapDistance = formatImageLayoutNumber(wrapDistance);
+    container.style.setProperty('--work-document-image-wrap-distance', `${formatImageLayoutNumber(wrapDistance)}mm`);
+}
+function setOptionalImageAttribute(element, name, value) {
+    if ('string' == typeof value && value) element.setAttribute(name, value);
+    else element.removeAttribute(name);
+}
+function syncImageDimension(element, dimension, value) {
+    const pixels = 'number' == typeof value ? value : Number(value);
+    if (Number.isFinite(pixels) && pixels > 0) {
+        element.style[dimension] = `${pixels}px`;
+        element.setAttribute(dimension, String(Math.round(pixels)));
+        return;
+    }
+    element.style.removeProperty(dimension);
+    element.removeAttribute(dimension);
+}
+const MAX_DOCUMENT_TAB_POSITION_PX = 4096;
+const MAX_DOCUMENT_TAB_STOPS = 64;
+const DocumentParagraphTabStops = Extension.create({
+    name: 'documentParagraphTabStops',
+    addGlobalAttributes () {
+        return [
+            {
+                types: [
+                    'paragraph',
+                    'heading'
+                ],
+                attributes: {
+                    tabStops: {
+                        default: null,
+                        parseHTML: (element)=>normalizeDocumentTabStops(element.dataset.officeTabStops),
+                        renderHTML: (attributes)=>{
+                            const tabStops = normalizeDocumentTabStops(attributes.tabStops);
+                            return tabStops.length ? {
+                                'data-office-tab-stops': serializeDocumentTabStops(tabStops)
+                            } : {};
+                        }
+                    }
+                }
+            }
+        ];
+    },
+    addCommands () {
+        return {
+            setDocumentParagraphTabStops: (tabStops, options = {})=>({ chain, editor })=>{
+                    const nodeTypes = activeParagraphNodeTypes(editor);
+                    if (!nodeTypes.length) return false;
+                    const normalized = normalizeDocumentTabStops(tabStops);
+                    let commandChain = chain();
+                    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+                    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, {
+                        tabStops: normalized.length ? normalized : null
+                    });
+                    return commandChain.run();
+                }
+        };
+    }
+});
+function documentParagraphTabStops(editor) {
+    return normalizeDocumentTabStops(activeParagraphAttributes(editor).tabStops);
+}
+function normalizeDocumentTabStops(value) {
+    const source = parsedTabStopSource(value);
+    const byPosition = new Map();
+    for (const candidate of source.slice(0, 4 * MAX_DOCUMENT_TAB_STOPS)){
+        if (!isRecord(candidate)) continue;
+        const rawPosition = Number(candidate.position);
+        if (!Number.isFinite(rawPosition) || rawPosition <= 0) continue;
+        const position = normalizedTabPosition(rawPosition);
+        if (!(position <= 0)) byPosition.set(position, {
+            position,
+            alignment: normalizedTabAlignment(candidate.alignment),
+            leader: normalizedTabLeader(candidate.leader)
+        });
+    }
+    return Array.from(byPosition.values()).sort((left, right)=>left.position - right.position).slice(0, MAX_DOCUMENT_TAB_STOPS);
+}
+function serializeDocumentTabStops(value) {
+    return JSON.stringify(normalizeDocumentTabStops(value));
+}
+function normalizedTabPosition(value) {
+    if (!Number.isFinite(value)) return 0;
+    return Math.min(MAX_DOCUMENT_TAB_POSITION_PX, Math.max(0, Math.round(100 * value) / 100));
+}
+function nextDocumentTabAlignment(alignment) {
+    if ('left' === alignment) return 'center';
+    if ('center' === alignment) return 'right';
+    if ('right' === alignment) return 'decimal';
+    return 'left';
+}
+function parsedTabStopSource(value) {
+    if (Array.isArray(value)) return value;
+    if ('string' != typeof value || !value.trim()) return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    } catch  {
+        return [];
+    }
+}
+function normalizedTabAlignment(value) {
+    return 'center' === value || 'right' === value || 'decimal' === value ? value : 'left';
+}
+function normalizedTabLeader(value) {
+    return 'dot' === value || 'hyphen' === value || 'underscore' === value || 'middleDot' === value ? value : 'none';
+}
+function activeParagraphAttributes(editor) {
+    return editor.isActive('heading') ? editor.getAttributes('heading') : editor.getAttributes('paragraph');
+}
+function activeParagraphNodeTypes(editor) {
+    const types = [];
+    if (editor.isActive('paragraph')) types.push('paragraph');
+    if (editor.isActive('heading')) types.push('heading');
+    return types;
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+export { DocumentImage, DocumentParagraphTabStops, documentImageAlternativeText, documentImageLayoutFromElement, documentImageLayoutOptions, documentParagraphTabStops, nextDocumentTabAlignment, normalizeDocumentImageAlignment, normalizeDocumentImageLayoutOptions, normalizeDocumentTabStops, normalizedTabPosition, serializeDocumentTabStops };

package/dist/0~9445.js

@@ -0,0 +1,283 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Minus, Plus, Table2 } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { materializeWorkFile } from "./9356.js";
+import { Popover } from "./0~9512.js";
+async function readOfficeFileAsDataUrl(file) {
+    const ownedFile = await materializeWorkFile(file);
+    return new Promise((resolve, reject)=>{
+        const reader = new FileReader();
+        reader.addEventListener('load', ()=>resolve(String(reader.result)));
+        reader.addEventListener('error', ()=>reject(reader.error ?? new Error('File could not be read')));
+        reader.readAsDataURL(ownedFile);
+    });
+}
+const TABLE_PICKER_ROWS = 8;
+const TABLE_PICKER_COLUMNS = 10;
+const TABLE_PICKER_COMPACT_QUERY = '(max-width: 520px)';
+function OfficeTableInsertPopover({ className = '', disabled = false, label, onInsert }) {
+    const [open, setOpen] = useState(false);
+    const [position, setPosition] = useState({
+        row: 1,
+        column: 1
+    });
+    const compact = useCompactTablePicker();
+    const cellRefs = useRef([]);
+    const compactRowInputRef = useRef(null);
+    useEffect(()=>{
+        if (!open) return;
+        const frame = requestAnimationFrame(()=>{
+            if (compact) {
+                compactRowInputRef.current?.focus({
+                    preventScroll: true
+                });
+                compactRowInputRef.current?.select();
+            } else cellRefs.current[0]?.focus({
+                preventScroll: true
+            });
+        });
+        return ()=>cancelAnimationFrame(frame);
+    }, [
+        compact,
+        open
+    ]);
+    const focusCell = (next)=>{
+        setPosition(next);
+        cellRefs.current[cellIndex(next)]?.focus({
+            preventScroll: true
+        });
+    };
+    const insert = (dimensions, close)=>{
+        close();
+        onInsert({
+            rows: dimensions.row,
+            columns: dimensions.column
+        });
+    };
+    const updateDimension = (dimension, value)=>{
+        if (!Number.isFinite(value)) return;
+        const maximum = 'row' === dimension ? TABLE_PICKER_ROWS : TABLE_PICKER_COLUMNS;
+        setPosition((current)=>({
+                ...current,
+                [dimension]: clampDimension(value, maximum)
+            }));
+    };
+    const handleCellKeyDown = (event, current, close)=>{
+        let next = current;
+        if ('ArrowLeft' === event.key) next = {
+            ...current,
+            column: Math.max(1, current.column - 1)
+        };
+        else if ('ArrowRight' === event.key) next = {
+            ...current,
+            column: Math.min(TABLE_PICKER_COLUMNS, current.column + 1)
+        };
+        else if ('ArrowUp' === event.key) next = {
+            ...current,
+            row: Math.max(1, current.row - 1)
+        };
+        else if ('ArrowDown' === event.key) next = {
+            ...current,
+            row: Math.min(TABLE_PICKER_ROWS, current.row + 1)
+        };
+        else if ('Home' === event.key) next = {
+            ...current,
+            column: 1
+        };
+        else if ('End' === event.key) next = {
+            ...current,
+            column: TABLE_PICKER_COLUMNS
+        };
+        else {
+            if ('Enter' !== event.key) return;
+            event.preventDefault();
+            event.stopPropagation();
+            insert(current, close);
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        focusCell(next);
+    };
+    return /*#__PURE__*/ jsx(Popover, {
+        label: label,
+        panelLabel: "选择表格大小",
+        panelRole: "dialog",
+        portal: true,
+        open: open,
+        onOpenChange: (nextOpen)=>{
+            setOpen(nextOpen);
+            if (nextOpen) setPosition({
+                row: 1,
+                column: 1
+            });
+        },
+        className: `work-office-table-insert-popover ${className}`.trim(),
+        panelClassName: "work-office-table-picker-panel",
+        trigger: (triggerProps, { open: triggerOpen })=>/*#__PURE__*/ jsxs("button", {
+                ...triggerProps,
+                className: `with-label${triggerOpen ? ' active' : ''}`,
+                "aria-pressed": triggerOpen,
+                disabled: disabled,
+                children: [
+                    /*#__PURE__*/ jsx(Table2, {
+                        size: 19
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        children: label
+                    })
+                ]
+            }),
+        children: (close)=>compact ? /*#__PURE__*/ jsxs("form", {
+                className: "work-office-table-picker-compact",
+                onSubmit: (event)=>{
+                    event.preventDefault();
+                    insert(position, close);
+                },
+                children: [
+                    /*#__PURE__*/ jsx(TableDimensionField, {
+                        inputRef: compactRowInputRef,
+                        label: "行数",
+                        maximum: TABLE_PICKER_ROWS,
+                        value: position.row,
+                        onChange: (value)=>updateDimension('row', value)
+                    }),
+                    /*#__PURE__*/ jsx(TableDimensionField, {
+                        label: "列数",
+                        maximum: TABLE_PICKER_COLUMNS,
+                        value: position.column,
+                        onChange: (value)=>updateDimension('column', value)
+                    }),
+                    /*#__PURE__*/ jsxs("button", {
+                        type: "submit",
+                        className: "work-office-table-picker-submit",
+                        children: [
+                            "插入 ",
+                            position.row,
+                            " \xd7 ",
+                            position.column,
+                            " 表格"
+                        ]
+                    })
+                ]
+            }) : /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsxs("fieldset", {
+                        className: "work-office-table-picker-grid",
+                        children: [
+                            /*#__PURE__*/ jsx("legend", {
+                                className: "sr-only",
+                                children: "选择表格行列"
+                            }),
+                            Array.from({
+                                length: TABLE_PICKER_ROWS * TABLE_PICKER_COLUMNS
+                            }, (_, index)=>{
+                                const current = {
+                                    row: Math.floor(index / TABLE_PICKER_COLUMNS) + 1,
+                                    column: index % TABLE_PICKER_COLUMNS + 1
+                                };
+                                const selected = current.row === position.row && current.column === position.column;
+                                const highlighted = current.row <= position.row && current.column <= position.column;
+                                return /*#__PURE__*/ jsx("button", {
+                                    ref: (element)=>{
+                                        cellRefs.current[index] = element;
+                                    },
+                                    type: "button",
+                                    "aria-label": `${current.row} 行 ${current.column} 列`,
+                                    "aria-pressed": selected,
+                                    "data-highlighted": highlighted ? 'true' : void 0,
+                                    tabIndex: selected ? 0 : -1,
+                                    onFocus: ()=>setPosition(current),
+                                    onMouseEnter: ()=>setPosition(current),
+                                    onKeyDown: (event)=>handleCellKeyDown(event, current, close),
+                                    onClick: ()=>insert(current, close)
+                                }, `${current.row}-${current.column}`);
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs("output", {
+                        className: "work-office-table-picker-size",
+                        "aria-live": "polite",
+                        children: [
+                            position.row,
+                            " \xd7 ",
+                            position.column,
+                            " 表格"
+                        ]
+                    })
+                ]
+            })
+    });
+}
+function TableDimensionField({ inputRef, label, maximum, value, onChange }) {
+    return /*#__PURE__*/ jsxs("fieldset", {
+        className: "work-office-table-picker-dimension",
+        children: [
+            /*#__PURE__*/ jsx("legend", {
+                children: label
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "work-office-table-picker-stepper",
+                children: [
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        "aria-label": `减少${label}`,
+                        disabled: value <= 1,
+                        onClick: ()=>onChange(value - 1),
+                        children: /*#__PURE__*/ jsx(Minus, {
+                            size: 16,
+                            "aria-hidden": "true"
+                        })
+                    }),
+                    /*#__PURE__*/ jsx("input", {
+                        ref: inputRef,
+                        type: "number",
+                        "aria-label": label,
+                        inputMode: "numeric",
+                        min: 1,
+                        max: maximum,
+                        value: value,
+                        onFocus: (event)=>event.currentTarget.select(),
+                        onChange: (event)=>onChange(event.currentTarget.valueAsNumber)
+                    }),
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        "aria-label": `增加${label}`,
+                        disabled: value >= maximum,
+                        onClick: ()=>onChange(value + 1),
+                        children: /*#__PURE__*/ jsx(Plus, {
+                            size: 16,
+                            "aria-hidden": "true"
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+function cellIndex(position) {
+    return (position.row - 1) * TABLE_PICKER_COLUMNS + (position.column - 1);
+}
+function clampDimension(value, maximum) {
+    return Math.min(maximum, Math.max(1, Math.round(value)));
+}
+function useCompactTablePicker() {
+    const [compact, setCompact] = useState(compactTablePickerMatches);
+    useEffect(()=>{
+        if ("u" < typeof window || 'function' != typeof window.matchMedia) return;
+        const mediaQuery = window.matchMedia(TABLE_PICKER_COMPACT_QUERY);
+        const update = ()=>setCompact(mediaQuery.matches);
+        update();
+        if ('function' == typeof mediaQuery.addEventListener) {
+            mediaQuery.addEventListener('change', update);
+            return ()=>mediaQuery.removeEventListener('change', update);
+        }
+        mediaQuery.addListener(update);
+        return ()=>mediaQuery.removeListener(update);
+    }, []);
+    return compact;
+}
+function compactTablePickerMatches() {
+    return "u" > typeof window && 'function' == typeof window.matchMedia && window.matchMedia(TABLE_PICKER_COMPACT_QUERY).matches;
+}
+export { OfficeTableInsertPopover, readOfficeFileAsDataUrl };