@a3s-lab/office 0.1.0

package/dist/0~1403.js

@@ -0,0 +1,245 @@
+import { createOfficeId as createWorkId } from "./1134.js";
+function expandPresentationGroupSelection(elements, selectedIds) {
+    const byId = new Map();
+    const membersByGroupId = new Map();
+    for (const element of elements){
+        byId.set(element.id, element);
+        const groupId = topPresentationGroupId(element);
+        if (!groupId) continue;
+        const members = membersByGroupId.get(groupId) ?? [];
+        members.push(element);
+        membersByGroupId.set(groupId, members);
+    }
+    const requested = new Set(selectedIds);
+    const result = [];
+    const seen = new Set();
+    for (const selectedId of selectedIds){
+        const selected = byId.get(selectedId);
+        if (!selected) continue;
+        const groupId = topPresentationGroupId(selected);
+        const members = groupId ? membersByGroupId.get(groupId) ?? [
+            selected
+        ] : [
+            selected
+        ];
+        if (!members.every((member)=>requested.has(member.id))) {
+            for (const member of members)if (!(member.id === selectedId || seen.has(member.id))) {
+                seen.add(member.id);
+                result.push(member.id);
+            }
+        }
+        if (!seen.has(selectedId)) {
+            seen.add(selectedId);
+            result.push(selectedId);
+        }
+    }
+    return result;
+}
+function presentationSelectionUnits(elements, selectedIds) {
+    const expanded = new Set(expandPresentationGroupSelection(elements, selectedIds));
+    const units = new Map();
+    for (const element of elements){
+        if (!expanded.has(element.id)) continue;
+        const groupId = topPresentationGroupId(element);
+        const key = groupId ? `group:${groupId}` : `element:${element.id}`;
+        const unit = units.get(key) ?? {
+            key,
+            groupId,
+            elements: [],
+            elementIds: []
+        };
+        unit.elements.push(element);
+        unit.elementIds.push(element.id);
+        units.set(key, unit);
+    }
+    return [
+        ...units.values()
+    ];
+}
+function presentationSelectionUnitCount(elements, selectedIds) {
+    return presentationSelectionUnits(elements, selectedIds).length;
+}
+function canGroupPresentationElements(elements, selectedIds) {
+    return presentationSelectionUnitCount(elements, selectedIds) >= 2;
+}
+function canUngroupPresentationElements(elements, selectedIds) {
+    const selected = new Set(expandPresentationGroupSelection(elements, selectedIds));
+    return elements.some((element)=>selected.has(element.id) && presentationGroupPath(element).length > 0);
+}
+function groupPresentationElements(elements, selectedIds, groupId) {
+    const normalizedGroupId = groupId.trim();
+    if (!normalizedGroupId || !canGroupPresentationElements(elements, selectedIds)) return [
+        ...elements
+    ];
+    const selected = new Set(expandPresentationGroupSelection(elements, selectedIds));
+    return elements.map((element)=>selected.has(element.id) ? {
+            ...element,
+            groupIds: [
+                normalizedGroupId,
+                ...presentationGroupPath(element)
+            ]
+        } : element);
+}
+function ungroupPresentationElements(elements, selectedIds) {
+    const selected = new Set(expandPresentationGroupSelection(elements, selectedIds));
+    const selectedGroups = new Set(elements.filter((element)=>selected.has(element.id)).map(topPresentationGroupId).filter((groupId)=>Boolean(groupId)));
+    if (!selectedGroups.size) return [
+        ...elements
+    ];
+    return elements.map((element)=>{
+        const path = presentationGroupPath(element);
+        if (!path.length || !selectedGroups.has(path[0])) return element;
+        const remaining = path.slice(1);
+        return {
+            ...element,
+            groupIds: remaining.length ? remaining : void 0
+        };
+    });
+}
+function remapPresentationGroupPaths(elements) {
+    const replacements = new Map();
+    return elements.map((element)=>{
+        const path = presentationGroupPath(element);
+        if (!path.length) return element;
+        return {
+            ...element,
+            groupIds: path.map((groupId)=>{
+                const replacement = replacements.get(groupId) ?? createWorkId('element-group');
+                replacements.set(groupId, replacement);
+                return replacement;
+            })
+        };
+    });
+}
+function topPresentationGroupId(element) {
+    return presentationGroupPath(element)[0];
+}
+function presentationGroupPath(element) {
+    const seen = new Set();
+    return (element.groupIds ?? []).map((groupId)=>groupId.trim()).filter((normalized)=>{
+        if (!normalized || seen.has(normalized)) return false;
+        seen.add(normalized);
+        return true;
+    });
+}
+const DEFAULT_PRESENTATION_MASTER_ID = 'presentation-master-default';
+const DEFAULT_PRESENTATION_LAYOUT_ID = 'presentation-layout-default';
+function withPresentationDesign(content) {
+    const masters = content.masters?.length ? content.masters : [
+        {
+            id: DEFAULT_PRESENTATION_MASTER_ID,
+            name: 'Default master',
+            background: '#ffffff',
+            elements: []
+        }
+    ];
+    const masterIds = new Set(masters.map((master)=>master.id));
+    const firstMasterId = masters[0].id;
+    const layouts = content.layouts?.length ? content.layouts.map((layout)=>({
+            ...layout,
+            masterId: masterIds.has(layout.masterId) ? layout.masterId : firstMasterId
+        })) : [
+        {
+            id: DEFAULT_PRESENTATION_LAYOUT_ID,
+            name: 'Blank',
+            masterId: firstMasterId,
+            elements: []
+        }
+    ];
+    const layoutIds = new Set(layouts.map((layout)=>layout.id));
+    const firstLayoutId = layouts[0].id;
+    return {
+        ...content,
+        masters,
+        layouts,
+        slides: content.slides.map((slide)=>({
+                ...slide,
+                layoutId: slide.layoutId && layoutIds.has(slide.layoutId) ? slide.layoutId : firstLayoutId,
+                useLayoutBackground: slide.useLayoutBackground ?? false
+            }))
+    };
+}
+function presentationSlideView(content, slide) {
+    const normalized = withPresentationDesign(content);
+    const layout = normalized.layouts?.find((candidate)=>candidate.id === slide.layoutId) ?? normalized.layouts?.[0];
+    const master = normalized.masters?.find((candidate)=>candidate.id === layout?.masterId) ?? normalized.masters?.[0];
+    const showMasterElements = false !== slide.showMasterElements && layout?.showMasterElements !== false;
+    const masterElements = showMasterElements ? master?.elements ?? [] : [];
+    const layoutElements = layout?.elements ?? [];
+    const placeholderElements = mergedPlaceholders(masterElements, layoutElements);
+    return {
+        background: true === slide.useLayoutBackground ? layout?.background ?? master?.background ?? slide.background : slide.background,
+        inheritedElements: [
+            ...masterElements,
+            ...layoutElements
+        ].filter((element)=>!element.placeholder),
+        placeholderElements,
+        master,
+        layout
+    };
+}
+function applyPresentationLayout(content, slideId, layoutId) {
+    const normalized = withPresentationDesign(content);
+    const layout = normalized.layouts?.find((candidate)=>candidate.id === layoutId);
+    if (!layout) return normalized;
+    const definitions = layout.elements.filter((element)=>Boolean(element.placeholder));
+    return {
+        ...normalized,
+        slides: normalized.slides.map((slide)=>{
+            if (slide.id !== slideId) return slide;
+            const matched = new Set();
+            const elements = slide.elements.map((element)=>{
+                const key = element.placeholder?.key;
+                if (!key) return element;
+                const definition = definitions.find((candidate)=>candidate.placeholder.key === key);
+                if (!definition) return {
+                    ...element,
+                    placeholder: void 0
+                };
+                matched.add(key);
+                return applyPlaceholderDefinition(element, definition);
+            });
+            for (const definition of definitions)if (!matched.has(definition.placeholder.key)) elements.push({
+                ...structuredCopy(definition),
+                id: createWorkId('element'),
+                text: '',
+                textRuns: void 0
+            });
+            return {
+                ...slide,
+                layoutId,
+                elements
+            };
+        })
+    };
+}
+function mergedPlaceholders(masterElements, layoutElements) {
+    const placeholders = new Map();
+    for (const element of [
+        ...masterElements,
+        ...layoutElements
+    ])if (element.placeholder) placeholders.set(element.placeholder.key, element);
+    return Array.from(placeholders.values());
+}
+function applyPlaceholderDefinition(element, definition) {
+    return {
+        ...structuredCopy(definition),
+        id: element.id,
+        type: element.type,
+        text: element.text,
+        textRuns: element.textRuns,
+        image: element.image,
+        table: element.table,
+        chart: element.chart,
+        href: element.href,
+        altText: element.altText,
+        placeholder: definition.placeholder ? {
+            ...definition.placeholder
+        } : element.placeholder
+    };
+}
+function structuredCopy(value) {
+    if ('function' == typeof structuredClone) return structuredClone(value);
+    return JSON.parse(JSON.stringify(value));
+}
+export { applyPresentationLayout, canGroupPresentationElements, canUngroupPresentationElements, expandPresentationGroupSelection, groupPresentationElements, presentationGroupPath, presentationSelectionUnits, presentationSlideView, remapPresentationGroupPaths, ungroupPresentationElements, withPresentationDesign };

package/dist/0~152.js

@@ -0,0 +1,94 @@
+import { descendants, attribute } from "./8715.js";
+function docxCaptionSequenceKind(instruction) {
+    const identifier = /^\s*SEQ\s+([^\s\\]+)/i.exec(instruction)?.[1]?.toLowerCase();
+    if (!identifier) return null;
+    if ('table' === identifier || '表' === identifier) return 'table';
+    if ('figure' === identifier || 'fig' === identifier || '图' === identifier) return 'figure';
+    return null;
+}
+function docxCaptionReferenceTarget(instruction) {
+    return /^\s*REF\s+([^\s\\]+)/i.exec(instruction)?.[1] ?? null;
+}
+function docxCaptionBookmark(paragraph, field) {
+    const bookmarks = descendants(paragraph, 'bookmarkStart').filter((bookmark)=>!/^_(?:GoBack|Toc)/i.test(attribute(bookmark, 'name') ?? ''));
+    const enclosing = bookmarks.filter((bookmark)=>bookmarkContains(paragraph, bookmark, field));
+    if (enclosing.length) return enclosing.at(-1);
+    return bookmarks.filter((bookmark)=>precedes(bookmark, field.start)).at(-1) ?? bookmarks[0];
+}
+function bookmarkContains(paragraph, start, field) {
+    const id = attribute(start, 'id');
+    if (!id) return false;
+    const end = descendants(paragraph, 'bookmarkEnd').find((bookmark)=>attribute(bookmark, 'id') === id);
+    return Boolean(end && precedes(start, field.start) && precedes(field.end, end));
+}
+function precedes(candidate, target) {
+    return Boolean(candidate.compareDocumentPosition(target) & Node.DOCUMENT_POSITION_FOLLOWING);
+}
+function docxFieldInstructions(root) {
+    return docxFieldOccurrences(root).map((field)=>field.instruction);
+}
+function docxFieldOccurrences(root) {
+    const fields = descendants(root, 'fldSimple').map((field)=>({
+            instruction: attribute(field, 'instr') ?? '',
+            start: field,
+            end: field
+        }));
+    const stack = [];
+    for (const element of Array.from(root.querySelectorAll('*'))){
+        if ('fldChar' === element.localName) {
+            const fieldType = attribute(element, 'fldCharType');
+            if ('begin' === fieldType) stack.push({
+                instruction: '',
+                start: element
+            });
+            else if ('end' === fieldType && stack.length) {
+                const field = stack.pop();
+                if (field) fields.push({
+                    ...field,
+                    end: element
+                });
+            }
+            continue;
+        }
+        if ('instrText' === element.localName && stack.length) stack[stack.length - 1].instruction += element.textContent ?? '';
+        else if ('instrText' === element.localName) fields.push({
+            instruction: element.textContent ?? '',
+            start: element,
+            end: element
+        });
+    }
+    fields.push(...stack.map((field)=>({
+            ...field,
+            end: field.start
+        })));
+    return fields.map((field)=>({
+            ...field,
+            instruction: field.instruction.trim()
+        })).filter((field)=>Boolean(field.instruction));
+}
+function docxFieldResultText(field) {
+    if ('fldSimple' === field.start.localName) return descendants(field.start, 't').map((element)=>element.textContent ?? '').join('');
+    const root = closestAncestor(field.start, 'p') ?? field.start.ownerDocument?.documentElement;
+    if (!root) return '';
+    let inside = false;
+    let separated = false;
+    const values = [];
+    for (const element of Array.from(root.querySelectorAll('*'))){
+        if (element === field.start) inside = true;
+        if (inside) {
+            if ('fldChar' === element.localName && 'separate' === attribute(element, 'fldCharType')) separated = true;
+            else if (separated && ('t' === element.localName || 'delText' === element.localName)) values.push(element.textContent ?? '');
+            if (element === field.end) break;
+        }
+    }
+    return values.join('');
+}
+function closestAncestor(element, localName) {
+    let current = element;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+export { docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxFieldInstructions, docxFieldOccurrences, docxFieldResultText };