@a3s-lab/office 0.1.0

package/dist/0~work-document-links.js

@@ -0,0 +1,14 @@
+const DOCUMENT_LINK_VALIDATION_MESSAGE = '请输入完整的 http、https、mailto 或 # 文档内地址。';
+function normalizeDocumentHref(value) {
+    const href = value.trim();
+    if (/^#[^\s#]+$/u.test(href)) return href;
+    if (/^mailto:[^\s@]+@[^\s@]+$/iu.test(href)) return href;
+    if (!/^https?:/iu.test(href)) return null;
+    try {
+        const url = new URL(href);
+        return url.hostname && ('http:' === url.protocol || 'https:' === url.protocol) ? href : null;
+    } catch  {
+        return null;
+    }
+}
+export { DOCUMENT_LINK_VALIDATION_MESSAGE, normalizeDocumentHref };

package/dist/0~work-document-model-codec.js

@@ -0,0 +1,42 @@
+import { generateHTML, getSchema } from "@tiptap/core";
+import { DOMParser as model_DOMParser } from "@tiptap/pm/model";
+import { createWorkDocumentModel, syncDocumentContentFromHtml, documentModelForContent, documentHtmlFingerprint } from "./4704.js";
+import { createWorkDocumentExtensions } from "./0~work-document-extensions.js";
+let schema = null;
+let extensions = null;
+function createWorkDocumentModelFromContent(content) {
+    const previous = content.model;
+    const synchronized = syncDocumentContentFromHtml(content, content.html);
+    const document = new DOMParser().parseFromString(synchronized.html, 'text/html');
+    schema ??= getSchema(documentExtensions());
+    const root = model_DOMParser.fromSchema(schema).parse(document.body).toJSON();
+    return {
+        ...synchronized,
+        model: createWorkDocumentModel(synchronized.html, root, previous)
+    };
+}
+function materializeWorkDocumentContent(content) {
+    const model = documentModelForContent(content);
+    if (!model) return content;
+    let html;
+    try {
+        html = generateHTML(model.root, documentExtensions());
+    } catch (error) {
+        throw new Error('The structured document model cannot be serialized by this Office schema.', {
+            cause: error
+        });
+    }
+    const synchronized = syncDocumentContentFromHtml(content, html);
+    return {
+        ...synchronized,
+        model: {
+            ...model,
+            htmlFingerprint: documentHtmlFingerprint(synchronized.html)
+        }
+    };
+}
+function documentExtensions() {
+    extensions ??= createWorkDocumentExtensions();
+    return extensions;
+}
+export { createWorkDocumentModelFromContent, materializeWorkDocumentContent };

package/dist/0~work-document-page-color.js

@@ -0,0 +1,11 @@
+const DEFAULT_DOCUMENT_PAGE_COLOR = '#ffffff';
+function normalizeDocumentPageColor(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) return;
+    if (/^#[0-9a-f]{3}$/i.test(trimmed)) return `#${trimmed.slice(1).split('').map((part)=>`${part}${part}`).join('')}`.toLowerCase();
+    return /^#[0-9a-f]{6}$/i.test(trimmed) ? trimmed.toLowerCase() : void 0;
+}
+function documentPageColor(value) {
+    return normalizeDocumentPageColor(value) ?? DEFAULT_DOCUMENT_PAGE_COLOR;
+}
+export { DEFAULT_DOCUMENT_PAGE_COLOR, documentPageColor, normalizeDocumentPageColor };

package/dist/0~work-document-paragraph-formatting.js

@@ -0,0 +1,425 @@
+import { Extension } from "@tiptap/core";
+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 DocumentParagraphFormatting = Extension.create({
+    name: 'documentParagraphFormatting',
+    addGlobalAttributes () {
+        return [
+            {
+                types: [
+                    'paragraph',
+                    'heading'
+                ],
+                attributes: {
+                    lineHeight: {
+                        default: null,
+                        parseHTML: (element)=>normalizedLineHeight(element.style.lineHeight),
+                        renderHTML: (attributes)=>{
+                            const lineHeight = normalizedLineHeight(attributes.lineHeight);
+                            return lineHeight ? {
+                                style: `line-height: ${lineHeight}`
+                            } : {};
+                        }
+                    },
+                    lineRule: {
+                        default: null,
+                        parseHTML: (element)=>normalizedLineRule(element.dataset.officeLineRule),
+                        renderHTML: (attributes)=>{
+                            const lineRule = normalizedLineRule(attributes.lineRule);
+                            return lineRule ? {
+                                'data-office-line-rule': lineRule
+                            } : {};
+                        }
+                    },
+                    spaceBefore: pointSpacingAttribute('spaceBefore', 'officeSpaceBefore', 'data-office-space-before', 'margin-top'),
+                    spaceAfter: pointSpacingAttribute('spaceAfter', 'officeSpaceAfter', 'data-office-space-after', 'margin-bottom'),
+                    indentLevel: {
+                        default: 0,
+                        parseHTML: (element)=>parsedIndentLevel(element.dataset.officeIndentLevel, element.style.marginLeft),
+                        renderHTML: (attributes)=>{
+                            const indentLevel = normalizedIndentLevel(attributes.indentLevel);
+                            return indentLevel ? {
+                                'data-office-indent-level': String(indentLevel),
+                                style: `margin-left: ${indentLevel * DOCUMENT_INDENT_STEP_PX}px`
+                            } : {};
+                        }
+                    },
+                    rightIndent: {
+                        default: 0,
+                        parseHTML: (element)=>parsedIndentPixels(element.dataset.officeIndentRight, element.style.marginRight),
+                        renderHTML: (attributes)=>{
+                            const rightIndent = normalizedIndentPixels(attributes.rightIndent);
+                            return rightIndent ? {
+                                'data-office-indent-right': formatPixelValue(rightIndent),
+                                style: `margin-right: ${rightIndent}px`
+                            } : {};
+                        }
+                    },
+                    firstLineIndent: {
+                        default: 0,
+                        parseHTML: (element)=>{
+                            const left = parsedIndentLevel(element.dataset.officeIndentLevel, element.style.marginLeft);
+                            return normalizedFirstLineIndent(parsedSignedIndentPixels(element.dataset.officeIndentFirstLine, element.style.textIndent), left * DOCUMENT_INDENT_STEP_PX);
+                        },
+                        renderHTML: (attributes)=>{
+                            const left = normalizedIndentLevel(attributes.indentLevel) * DOCUMENT_INDENT_STEP_PX;
+                            const firstLineIndent = normalizedFirstLineIndent(attributes.firstLineIndent, left);
+                            return firstLineIndent ? {
+                                'data-office-indent-first-line': formatPixelValue(firstLineIndent),
+                                style: `text-indent: ${firstLineIndent}px`
+                            } : {};
+                        }
+                    },
+                    keepLines: directBooleanAttribute('keepLines', 'officeKeepLines', 'data-office-keep-lines'),
+                    keepWithNext: directBooleanAttribute('keepWithNext', 'officeKeepWithNext', 'data-office-keep-with-next'),
+                    pageBreakBefore: directBooleanAttribute('pageBreakBefore', 'officePageBreakBefore', 'data-office-page-break-before'),
+                    widowControl: directBooleanAttribute('widowControl', 'officeWidowControl', 'data-office-widow-control')
+                }
+            },
+            {
+                types: [
+                    'paragraph',
+                    'heading',
+                    'listItem'
+                ],
+                attributes: {
+                    paragraphDirection: paragraphDirectionAttribute()
+                }
+            }
+        ];
+    },
+    addCommands () {
+        return {
+            changeDocumentIndent: (direction)=>(props)=>changeDocumentIndentCommand(props, direction),
+            clearDocumentParagraphPagination: (options = {})=>(props)=>clearDocumentParagraphPaginationCommand(props, options),
+            clearDocumentFormatting: ()=>(props)=>clearDocumentFormattingCommand(props),
+            setDocumentIndentLevel: (indentLevel, options = {})=>(props)=>setDocumentIndentLevelCommand(props, indentLevel, options),
+            setDocumentLineHeight: (lineHeight)=>(props)=>setDocumentLineHeightCommand(props, lineHeight),
+            setDocumentParagraphDirection: (direction, options = {})=>(props)=>setDocumentParagraphDirectionCommand(props, direction, options),
+            setDocumentParagraphIndent: (indent, options = {})=>(props)=>setDocumentParagraphIndentCommand(props, indent, options),
+            setDocumentParagraphPagination: (pagination, options = {})=>(props)=>setDocumentParagraphPaginationCommand(props, pagination, options),
+            setDocumentParagraphSpacing: (spacing, options = {})=>(props)=>setDocumentParagraphSpacingCommand(props, spacing, options)
+        };
+    }
+});
+function canChangeDocumentIndent(editor, direction) {
+    if (editor.isActive('listItem')) {
+        const canChangeListLevel = direction > 0 ? editor.can().chain().focus().sinkListItem('listItem').run() : editor.can().chain().focus().liftListItem('listItem').run();
+        if (canChangeListLevel) return true;
+    }
+    const current = documentIndentLevel(editor);
+    return direction > 0 ? current < MAX_DOCUMENT_INDENT_LEVEL : current > 0;
+}
+function documentIndentLevel(editor) {
+    return documentParagraphIndent(editor).left / DOCUMENT_INDENT_STEP_PX;
+}
+function documentParagraphIndent(editor) {
+    const attributes = editor.isActive('heading') ? editor.getAttributes('heading') : editor.getAttributes('paragraph');
+    return normalizeDocumentParagraphIndent({
+        left: normalizedIndentLevel(attributes.indentLevel) * DOCUMENT_INDENT_STEP_PX,
+        right: normalizedIndentPixels(attributes.rightIndent),
+        firstLine: normalizedSignedIndentPixels(attributes.firstLineIndent)
+    });
+}
+function documentParagraphPagination(editor) {
+    const attributes = activeParagraphAttributes(editor);
+    return {
+        keepLines: directBoolean(attributes.keepLines) ?? false,
+        keepWithNext: directBoolean(attributes.keepWithNext) ?? editor.isActive('heading'),
+        pageBreakBefore: directBoolean(attributes.pageBreakBefore) ?? false,
+        widowControl: directBoolean(attributes.widowControl) ?? true
+    };
+}
+function documentParagraphDirection(editor) {
+    const attributes = editor.isActive('listItem') ? editor.getAttributes('listItem') : activeParagraphAttributes(editor);
+    return normalizeDocumentParagraphDirection(attributes.paragraphDirection) ?? 'ltr';
+}
+function documentParagraphSpacing(editor) {
+    const attributes = activeParagraphAttributes(editor);
+    return {
+        before: normalizedPointSpacing(attributes.spaceBefore),
+        after: normalizedPointSpacing(attributes.spaceAfter),
+        lineHeight: normalizedLineHeight(attributes.lineHeight),
+        lineRule: normalizedLineRule(attributes.lineRule)
+    };
+}
+function normalizeDocumentParagraphIndent(indent) {
+    const left = normalizedIndentLevel(indent.left / DOCUMENT_INDENT_STEP_PX) * DOCUMENT_INDENT_STEP_PX;
+    return {
+        left,
+        right: normalizedIndentPixels(indent.right),
+        firstLine: normalizedFirstLineIndent(indent.firstLine, left)
+    };
+}
+function normalizeDocumentParagraphDirection(value) {
+    if ('string' != typeof value) return null;
+    const normalized = value.trim().toLowerCase();
+    return 'ltr' === normalized || 'rtl' === normalized ? normalized : null;
+}
+function setDocumentLineHeightCommand({ chain }, lineHeight) {
+    const value = normalizedLineHeight(lineHeight);
+    const attributes = {
+        lineHeight: value,
+        lineRule: value ? lineRuleForLineHeight(value) : null
+    };
+    return chain().focus().updateAttributes('paragraph', attributes).updateAttributes('heading', attributes).run();
+}
+function changeDocumentIndentCommand(props, direction) {
+    const { can, chain, editor } = props;
+    if (editor.isActive('listItem')) {
+        const canChangeListLevel = direction > 0 ? can().chain().focus().sinkListItem('listItem').run() : can().chain().focus().liftListItem('listItem').run();
+        if (canChangeListLevel) return direction > 0 ? chain().focus().sinkListItem('listItem').run() : chain().focus().liftListItem('listItem').run();
+    }
+    const current = documentIndentLevel(editor);
+    const next = normalizedIndentLevel(current + direction);
+    if (next === current) return false;
+    return setDocumentIndentLevelCommand(props, next, {});
+}
+function setDocumentIndentLevelCommand(props, indentLevel, options) {
+    const current = documentParagraphIndent(props.editor);
+    return setDocumentParagraphIndentCommand(props, {
+        ...current,
+        left: normalizedIndentLevel(indentLevel) * DOCUMENT_INDENT_STEP_PX
+    }, options);
+}
+function setDocumentParagraphIndentCommand({ chain, editor }, indent, options) {
+    const nodeTypes = activeParagraphNodeTypes(editor);
+    if (!nodeTypes.length) return false;
+    const normalized = normalizeDocumentParagraphIndent(indent);
+    const attributes = {
+        indentLevel: normalized.left / DOCUMENT_INDENT_STEP_PX,
+        rightIndent: normalized.right,
+        firstLineIndent: normalized.firstLine
+    };
+    let commandChain = chain();
+    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, attributes);
+    return commandChain.run();
+}
+function setDocumentParagraphDirectionCommand({ chain, editor }, direction, options) {
+    const nodeTypes = activeParagraphDirectionNodeTypes(editor);
+    const value = normalizeDocumentParagraphDirection(direction);
+    if (!nodeTypes.length || !value) return false;
+    let commandChain = chain();
+    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, {
+        paragraphDirection: value
+    });
+    return commandChain.run();
+}
+function setDocumentParagraphPaginationCommand({ chain, editor }, pagination, options) {
+    const nodeTypes = activeParagraphNodeTypes(editor);
+    if (!nodeTypes.length) return false;
+    const attributes = {};
+    for (const key of documentParagraphPaginationKeys)if (Object.hasOwn(pagination, key)) attributes[key] = Boolean(pagination[key]);
+    if (!Object.keys(attributes).length) return false;
+    let commandChain = chain();
+    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, attributes);
+    return commandChain.run();
+}
+function clearDocumentParagraphPaginationCommand({ chain, editor }, options) {
+    const nodeTypes = activeParagraphNodeTypes(editor);
+    if (!nodeTypes.length) return false;
+    const attributes = {
+        keepLines: null,
+        keepWithNext: null,
+        pageBreakBefore: null,
+        widowControl: null
+    };
+    let commandChain = chain();
+    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, attributes);
+    return commandChain.run();
+}
+function setDocumentParagraphSpacingCommand({ chain, editor }, spacing, options) {
+    const nodeTypes = activeParagraphNodeTypes(editor);
+    if (!nodeTypes.length) return false;
+    const lineHeight = normalizedLineHeight(spacing.lineHeight);
+    const attributes = {
+        spaceBefore: normalizedPointSpacing(spacing.before),
+        spaceAfter: normalizedPointSpacing(spacing.after),
+        lineHeight,
+        lineRule: normalizedLineRule(spacing.lineRule) ?? (lineHeight ? lineRuleForLineHeight(lineHeight) : null)
+    };
+    let commandChain = chain();
+    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, attributes);
+    return commandChain.run();
+}
+function clearDocumentFormattingCommand({ chain, editor }) {
+    let commandChain = chain().focus().unsetAllMarks();
+    if (!editor.isActive('listItem')) commandChain = commandChain.setParagraph();
+    return commandChain.unsetTextAlign().updateAttributes('paragraph', {
+        indentLevel: 0,
+        rightIndent: 0,
+        firstLineIndent: 0,
+        lineHeight: null,
+        lineRule: null,
+        paragraphDirection: null,
+        spaceBefore: null,
+        spaceAfter: null,
+        keepLines: null,
+        keepWithNext: null,
+        pageBreakBefore: null,
+        widowControl: null,
+        tabStops: null
+    }).updateAttributes('listItem', {
+        paragraphDirection: null
+    }).run();
+}
+function parsedIndentLevel(dataValue, marginLeft) {
+    if (dataValue) return normalizedIndentLevel(dataValue);
+    const pixels = cssPixels(marginLeft);
+    return normalizedIndentLevel(pixels ? Math.round(pixels / DOCUMENT_INDENT_STEP_PX) : 0);
+}
+function normalizedIndentLevel(value) {
+    const number = Number(value);
+    if (!Number.isFinite(number)) return 0;
+    return Math.min(MAX_DOCUMENT_INDENT_LEVEL, Math.max(0, Math.round(4 * number) / 4));
+}
+function normalizedLineHeight(value) {
+    if ('string' != typeof value) return null;
+    const normalized = value.trim();
+    if (!normalized || 'normal' === normalized) return null;
+    return /^(?:\d+(?:\.\d+)?|\d+(?:\.\d+)?(?:px|pt|%))$/i.test(normalized) ? normalized : null;
+}
+function normalizedLineRule(value) {
+    if ('auto' === value || 'exact' === value || 'atLeast' === value) return value;
+    if ('exactly' === value) return 'exact';
+    return null;
+}
+function lineRuleForLineHeight(value) {
+    return /(?:px|pt)$/i.test(value) ? 'exact' : 'auto';
+}
+function pointSpacingAttribute(modelKey, datasetKey, htmlName, cssProperty) {
+    return {
+        default: null,
+        parseHTML: (element)=>parsedPointSpacing(element.dataset[datasetKey], 'margin-top' === cssProperty ? element.style.marginTop : element.style.marginBottom),
+        renderHTML: (attributes)=>{
+            const value = normalizedPointSpacing(attributes[modelKey]);
+            if (null === value) return {};
+            const formatted = formatPointValue(value);
+            return {
+                [htmlName]: formatted,
+                style: `${cssProperty}: ${formatted}pt`
+            };
+        }
+    };
+}
+function parsedPointSpacing(dataValue, cssValue) {
+    if (void 0 !== dataValue) return normalizedPointSpacing(dataValue);
+    const match = /^(-?\d+(?:\.\d+)?)(px|pt|mm|cm|in)?$/i.exec(cssValue.trim());
+    if (!match) return null;
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount)) return null;
+    const unit = match[2]?.toLowerCase() ?? 'px';
+    const points = 'pt' === unit ? amount : 'mm' === unit ? 72 * amount / 25.4 : 'cm' === unit ? 72 * amount / 2.54 : 'in' === unit ? 72 * amount : 0.75 * amount;
+    return normalizedPointSpacing(points);
+}
+function normalizedPointSpacing(value) {
+    if (null == value || '' === value) return null;
+    const number = Number(value);
+    if (!Number.isFinite(number)) return null;
+    return Math.min(720, Math.max(0, Math.round(4 * number) / 4));
+}
+function formatPointValue(value) {
+    return Number(value.toFixed(2)).toString();
+}
+function cssPixels(value) {
+    const match = /^(-?\d+(?:\.\d+)?)(px|pt)?$/i.exec(value.trim());
+    if (!match) return 0;
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount)) return 0;
+    return match[2]?.toLowerCase() === 'pt' ? amount / 0.75 : amount;
+}
+function parsedIndentPixels(dataValue, cssValue) {
+    return normalizedIndentPixels(void 0 === dataValue ? cssPixels(cssValue) : dataValue);
+}
+function parsedSignedIndentPixels(dataValue, cssValue) {
+    return normalizedSignedIndentPixels(void 0 === dataValue ? cssPixels(cssValue) : dataValue);
+}
+function normalizedIndentPixels(value) {
+    const number = Number(value);
+    if (!Number.isFinite(number)) return 0;
+    return Math.min(MAX_DOCUMENT_INDENT_PX, Math.max(0, Math.round(number)));
+}
+function normalizedSignedIndentPixels(value) {
+    const number = Number(value);
+    if (!Number.isFinite(number)) return 0;
+    return Math.min(MAX_DOCUMENT_INDENT_PX, Math.max(-MAX_DOCUMENT_INDENT_PX, Math.round(number)));
+}
+function normalizedFirstLineIndent(value, leftIndent) {
+    return Math.max(-leftIndent, Math.min(MAX_DOCUMENT_INDENT_PX, normalizedSignedIndentPixels(value)));
+}
+function formatPixelValue(value) {
+    return Number(value.toFixed(2)).toString();
+}
+function activeParagraphAttributes(editor) {
+    return editor.isActive('heading') ? editor.getAttributes('heading') : editor.getAttributes('paragraph');
+}
+function paragraphDirectionAttribute() {
+    return {
+        default: null,
+        parseHTML: (element)=>normalizeDocumentParagraphDirection(element.getAttribute('dir') ?? element.style.direction),
+        renderHTML: (attributes)=>{
+            const direction = normalizeDocumentParagraphDirection(attributes.paragraphDirection);
+            return direction ? {
+                dir: direction
+            } : {};
+        }
+    };
+}
+function directBooleanAttribute(modelKey, datasetKey, htmlName) {
+    return {
+        default: null,
+        parseHTML: (element)=>directBoolean(element.dataset[datasetKey]),
+        renderHTML: (attributes)=>{
+            const value = directBoolean(attributes[modelKey]);
+            return null === value ? {} : {
+                [htmlName]: String(value)
+            };
+        }
+    };
+}
+const documentParagraphPaginationKeys = [
+    'keepLines',
+    'keepWithNext',
+    'pageBreakBefore',
+    'widowControl'
+];
+function directBoolean(value) {
+    if (true === value || 'true' === value || '1' === value) return true;
+    if (false === value || 'false' === value || '0' === value) return false;
+    return null;
+}
+function activeParagraphNodeTypes(editor) {
+    const nodeTypes = new Set();
+    if (editor.isActive('paragraph')) nodeTypes.add('paragraph');
+    if (editor.isActive('heading')) nodeTypes.add('heading');
+    const { from, to } = editor.state.selection;
+    if (from !== to) editor.state.doc.nodesBetween(from, to, (node)=>{
+        if ('paragraph' === node.type.name) nodeTypes.add('paragraph');
+        if ('heading' === node.type.name) nodeTypes.add('heading');
+    });
+    return [
+        ...nodeTypes
+    ];
+}
+function activeParagraphDirectionNodeTypes(editor) {
+    const { from, to } = editor.state.selection;
+    if (from === to) return editor.isActive('listItem') ? [
+        'listItem'
+    ] : activeParagraphNodeTypes(editor);
+    const nodeTypes = new Set();
+    editor.state.doc.nodesBetween(from, to, (node, _position, parent)=>{
+        if ('listItem' === node.type.name) nodeTypes.add('listItem');
+        if ('paragraph' === node.type.name && parent?.type.name !== 'listItem') nodeTypes.add('paragraph');
+        if ('heading' === node.type.name) nodeTypes.add('heading');
+    });
+    return [
+        ...nodeTypes
+    ];
+}
+export { DocumentParagraphFormatting, canChangeDocumentIndent, documentParagraphDirection, documentParagraphIndent, documentParagraphPagination, documentParagraphSpacing, normalizeDocumentParagraphIndent };