@a3s-lab/office 0.1.0 → 0.2.2

package/dist/{0~work-document-paragraph-formatting.js → 0~5861.js}

@@ -1,7 +1,10 @@
 import { Extension } from "@tiptap/core";
+import font_family from "@tiptap/extension-text-style/font-family";
+import { TextStyle } from "@tiptap/extension-text-style";
 const DOCUMENT_INDENT_STEP_PX = 24;
 const MAX_DOCUMENT_INDENT_LEVEL = 8;
 const MAX_DOCUMENT_INDENT_PX = DOCUMENT_INDENT_STEP_PX * MAX_DOCUMENT_INDENT_LEVEL;
+const DOCUMENT_WORD_SINGLE_LINE_HEIGHT = 1.15;
 const DocumentParagraphFormatting = Extension.create({
     name: 'documentParagraphFormatting',
     addGlobalAttributes () {
@@ -32,6 +35,11 @@ const DocumentParagraphFormatting = Extension.create({
                             } : {};
                         }
                     },
+                    autoLineHeight: {
+                        default: null,
+                        parseHTML: (element)=>normalizedAutoLineHeight(element.dataset.officeAutoLineHeight),
+                        renderHTML: (attributes)=>'auto' === normalizedLineRule(attributes.lineRule) ? renderDocumentAutoLineHeight(attributes.lineHeight, attributes.autoLineHeight) : {}
+                    },
                     spaceBefore: pointSpacingAttribute('spaceBefore', 'officeSpaceBefore', 'data-office-space-before', 'margin-top'),
                     spaceAfter: pointSpacingAttribute('spaceAfter', 'officeSpaceAfter', 'data-office-space-after', 'margin-bottom'),
                     indentLevel: {
@@ -159,9 +167,11 @@ function normalizeDocumentParagraphDirection(value) {
 }
 function setDocumentLineHeightCommand({ chain }, lineHeight) {
     const value = normalizedLineHeight(lineHeight);
+    const lineRule = value ? lineRuleForLineHeight(value) : null;
     const attributes = {
         lineHeight: value,
-        lineRule: value ? lineRuleForLineHeight(value) : null
+        lineRule,
+        autoLineHeight: 'auto' === lineRule ? documentAutoLineHeight(value) : null
     };
     return chain().focus().updateAttributes('paragraph', attributes).updateAttributes('heading', attributes).run();
 }
@@ -237,11 +247,13 @@ function setDocumentParagraphSpacingCommand({ chain, editor }, spacing, options)
     const nodeTypes = activeParagraphNodeTypes(editor);
     if (!nodeTypes.length) return false;
     const lineHeight = normalizedLineHeight(spacing.lineHeight);
+    const lineRule = normalizedLineRule(spacing.lineRule) ?? (lineHeight ? lineRuleForLineHeight(lineHeight) : null);
     const attributes = {
         spaceBefore: normalizedPointSpacing(spacing.before),
         spaceAfter: normalizedPointSpacing(spacing.after),
         lineHeight,
-        lineRule: normalizedLineRule(spacing.lineRule) ?? (lineHeight ? lineRuleForLineHeight(lineHeight) : null)
+        lineRule,
+        autoLineHeight: 'auto' === lineRule ? documentAutoLineHeight(lineHeight) : null
     };
     let commandChain = chain();
     if (false !== options.restoreFocus) commandChain = commandChain.focus();
@@ -257,6 +269,7 @@ function clearDocumentFormattingCommand({ chain, editor }) {
         firstLineIndent: 0,
         lineHeight: null,
         lineRule: null,
+        autoLineHeight: null,
         paragraphDirection: null,
         spaceBefore: null,
         spaceAfter: null,
@@ -285,6 +298,49 @@ function normalizedLineHeight(value) {
     if (!normalized || 'normal' === normalized) return null;
     return /^(?:\d+(?:\.\d+)?|\d+(?:\.\d+)?(?:px|pt|%))$/i.test(normalized) ? normalized : null;
 }
+function documentAutoLineHeight(value) {
+    const multiple = lineHeightMultiple(value);
+    if (null === multiple) return null;
+    return formatLineMetric(multiple * DOCUMENT_WORD_SINGLE_LINE_HEIGHT);
+}
+function documentAutoLineLeadingShift(value) {
+    const multiple = lineHeightMultiple(value);
+    if (null === multiple) return null;
+    return formatLineMetric((1 - multiple) * DOCUMENT_WORD_SINGLE_LINE_HEIGHT / 2);
+}
+function renderDocumentAutoLineHeight(lineHeight, autoLineHeight = documentAutoLineHeight(lineHeight)) {
+    const renderedLineHeight = normalizedAutoLineHeight(autoLineHeight) ?? documentAutoLineHeight(lineHeight);
+    if (null === renderedLineHeight) return {};
+    const multiple = lineHeightMultiple(lineHeight);
+    const shift = documentAutoLineLeadingShift(lineHeight);
+    return {
+        'data-office-auto-line-height': String(formatLineMetric(renderedLineHeight)),
+        style: [
+            `--work-document-office-auto-line-height: ${formatLineMetric(renderedLineHeight)}`,
+            ...null === multiple ? [] : [
+                `--work-document-office-auto-line-multiple: ${formatLineMetric(multiple)}`
+            ],
+            ...null === shift ? [] : [
+                `--work-document-office-auto-line-shift: ${formatLineMetric(shift)}em`
+            ]
+        ].join('; ')
+    };
+}
+function lineHeightMultiple(value) {
+    const normalized = normalizedLineHeight(value);
+    if (!normalized) return null;
+    const percentage = /^(\d+(?:\.\d+)?)%$/.exec(normalized);
+    const multiple = percentage ? Number(percentage[1]) / 100 : /^\d+(?:\.\d+)?$/.test(normalized) ? Number(normalized) : NaN;
+    return Number.isFinite(multiple) && multiple > 0 ? multiple : null;
+}
+function normalizedAutoLineHeight(value) {
+    if (null == value || '' === value) return null;
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 && number <= 20 ? formatLineMetric(number) : null;
+}
+function formatLineMetric(value) {
+    return Number(value.toFixed(4));
+}
 function normalizedLineRule(value) {
     if ('auto' === value || 'exact' === value || 'atLeast' === value) return value;
     if ('exactly' === value) return 'exact';
@@ -422,4 +478,119 @@ function activeParagraphDirectionNodeTypes(editor) {
         ...nodeTypes
     ];
 }
-export { DocumentParagraphFormatting, canChangeDocumentIndent, documentParagraphDirection, documentParagraphIndent, documentParagraphPagination, documentParagraphSpacing, normalizeDocumentParagraphIndent };
+const DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT = 1.15;
+const DOCUMENT_WORD_LINE_HEIGHT_FACTORS = new Map([
+    [
+        'arial',
+        1.15
+    ],
+    [
+        'times new roman',
+        1.15
+    ],
+    [
+        'calibri',
+        1.2207
+    ],
+    [
+        'segoe ui',
+        1.3301
+    ],
+    [
+        'microsoft yahei',
+        1.7143
+    ],
+    [
+        'microsoft yahei ui',
+        1.7143
+    ],
+    [
+        'simsun',
+        1.2976
+    ],
+    [
+        'simhei',
+        1.2976
+    ],
+    [
+        'fangsong',
+        1.2976
+    ],
+    [
+        'kaiti',
+        1.2976
+    ],
+    [
+        'dengxian',
+        1.3548
+    ]
+]);
+function documentWordLineHeightFactor(fontFamily) {
+    if ('string' != typeof fontFamily) return DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT;
+    const family = firstCssFontFamily(fontFamily).toLocaleLowerCase();
+    return DOCUMENT_WORD_LINE_HEIGHT_FACTORS.get(family) ?? DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT;
+}
+function normalizedDocumentWordLineHeightFactor(value) {
+    if (null == value || '' === value) return null;
+    const factor = Number(value);
+    if (!Number.isFinite(factor) || factor < 0.5 || factor > 4) return null;
+    return Number(factor.toFixed(4));
+}
+const DocumentTextStyle = TextStyle.extend({
+    addAttributes () {
+        return {
+            wordLineHeightFactor: {
+                default: null,
+                parseHTML: (element)=>normalizedDocumentWordLineHeightFactor(element.dataset.officeWordLineHeightFactor ?? element.style.getPropertyValue('--work-document-word-line-height-factor')),
+                renderHTML: (attributes)=>{
+                    const factor = normalizedDocumentWordLineHeightFactor(attributes.wordLineHeightFactor);
+                    if (null === factor) return {};
+                    return {
+                        'data-office-word-line-height-factor': String(factor),
+                        style: `--work-document-word-line-height-factor: ${factor}`
+                    };
+                }
+            },
+            wordSnapToGrid: {
+                default: null,
+                parseHTML: (element)=>normalizedBoolean(element.dataset.officeWordSnapToGrid),
+                renderHTML: (attributes)=>{
+                    const value = normalizedBoolean(attributes.wordSnapToGrid);
+                    return null === value ? {} : {
+                        'data-office-word-snap-to-grid': String(value)
+                    };
+                }
+            }
+        };
+    }
+});
+const DocumentFontFamily = font_family.extend({
+    addCommands () {
+        return {
+            setFontFamily: (fontFamily)=>({ chain })=>chain().setMark('textStyle', {
+                        fontFamily,
+                        wordLineHeightFactor: documentWordLineHeightFactor(fontFamily)
+                    }).run(),
+            unsetFontFamily: ()=>({ chain })=>chain().setMark('textStyle', {
+                        fontFamily: null,
+                        wordLineHeightFactor: null
+                    }).removeEmptyTextStyle().run()
+        };
+    }
+});
+function firstCssFontFamily(value) {
+    const source = value.trim();
+    if (!source) return '';
+    const quote = source[0];
+    if ('"' === quote || "'" === quote) {
+        const end = source.indexOf(quote, 1);
+        if (end > 0) return source.slice(1, end).trim();
+    }
+    return (source.split(',')[0] ?? source).trim().replace(/^(['"])(.*)\1$/, '$2');
+}
+function normalizedBoolean(value) {
+    if (true === value || 'true' === value || '1' === value) return true;
+    if (false === value || 'false' === value || '0' === value) return false;
+    return null;
+}
+export { DocumentFontFamily, DocumentParagraphFormatting, DocumentTextStyle, canChangeDocumentIndent, documentAutoLineHeight, documentParagraphDirection, documentParagraphIndent, documentParagraphPagination, documentParagraphSpacing, documentWordLineHeightFactor, normalizeDocumentParagraphIndent, renderDocumentAutoLineHeight };

package/dist/0~7048.js

@@ -51,11 +51,11 @@ function useOfficeTaskPaneEscape(active, onClose) {
         onClose
     ]);
 }
-function useOfficeTaskPaneModal() {
-    const [matches, setMatches] = useState(officeTaskPaneModalMatches);
+function useOfficeTaskPaneModal(query = OFFICE_TASK_PANE_MODAL_QUERY) {
+    const [matches, setMatches] = useState(()=>officeTaskPaneModalMatches(query));
     useEffect(()=>{
         if ("u" < typeof window || 'function' != typeof window.matchMedia) return;
-        const mediaQuery = window.matchMedia(OFFICE_TASK_PANE_MODAL_QUERY);
+        const mediaQuery = window.matchMedia(query);
         const update = ()=>setMatches(mediaQuery.matches);
         update();
         if ('function' == typeof mediaQuery.addEventListener) {
@@ -64,12 +64,14 @@ function useOfficeTaskPaneModal() {
         }
         mediaQuery.addListener(update);
         return ()=>mediaQuery.removeListener(update);
-    }, []);
+    }, [
+        query
+    ]);
     return matches;
 }
-function officeTaskPaneModalMatches() {
+function officeTaskPaneModalMatches(query) {
     if ("u" < typeof window || 'function' != typeof window.matchMedia) return false;
-    return window.matchMedia(OFFICE_TASK_PANE_MODAL_QUERY).matches;
+    return window.matchMedia(query).matches;
 }
 function useOfficeDialog() {
     const [request, setRequest] = useState(null);

package/dist/0~9512.js

@@ -194,16 +194,19 @@ function isAvailable(element) {
 }
 function officeOverlayPortalRoot(ownerDocument, ...anchors) {
     for (const anchor of anchors){
-        const officeRoot = anchor?.closest('[data-a3s-office]');
-        if (officeRoot) return officeRoot;
+        const portalRoot = closestOfficeOverlayRoot(anchor);
+        if (portalRoot) return portalRoot;
     }
     const activeElement = ownerDocument.activeElement;
     if (activeElement instanceof Element) {
-        const officeRoot = activeElement.closest('[data-a3s-office]');
-        if (officeRoot) return officeRoot;
+        const portalRoot = closestOfficeOverlayRoot(activeElement);
+        if (portalRoot) return portalRoot;
     }
     return ownerDocument.body;
 }
+function closestOfficeOverlayRoot(anchor) {
+    return anchor?.closest('[role="dialog"][aria-modal="true"]') ?? anchor?.closest('[data-a3s-office]') ?? null;
+}
 function matchesOfficeEditorKeyboardShortcut(event, shortcut) {
     return matchesKeyboardShortcut(event, shortcutParts(shortcut, '-'));
 }