@a3s-lab/office 0.2.2 → 0.4.0

package/dist/0~work-pptx-export.js

@@ -1,6 +1,7 @@
 import jszip from "jszip";
 import { normalizeRadarStyle, presentationChartShowsLegend, presentationChartAxes, presentationChartBubbleSizes, normalizePresentationBubbleScale, presentationChartUsesNumericXAxis, normalizePresentationBubbleSizeRepresents, normalizePresentationChartLegendPosition, presentationChartXValues, normalizeDoughnutHoleSize, presentationChartSupportsAxisTitles, normalizePresentationScatterStyle } from "./0~work-presentation-charts.js";
-import { directChildren, xmlNamespacePrefix, parseXml, firstDescendant, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartAxisIsValueAxis, directChild, descendants, childPath, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, attribute, workSpreadsheetChartAxisIsCategoryAxis } from "./8715.js";
+import { directChildren, xmlNamespacePrefix, parseXml, firstDescendant, directChild, descendants, childPath, attribute } from "./5184.js";
+import { workSpreadsheetChartAxisShowsMajorGridlinesByDefault, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartAxisIsCategoryAxis, workSpreadsheetChartAxisIsValueAxis } from "./8715.js";
 import { presentationGroupPath, withPresentationDesign } from "./0~1403.js";
 import { patchPptxChartLayoutAndSeriesStyles, patchPptxTransitions, patchPptxComments, patchPptxChartDataLabels, patchPptxChartSeriesAnalysis } from "./0~7614.js";
 const DRAWING_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';

package/dist/0~work-pptx-import.js

@@ -1,8 +1,7 @@
-import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage, firstDescendant, descendants, directChild, childPath, attribute } from "./8715.js";
+import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage, firstDescendant, descendants, directChild, childPath, attribute, createOfficeId as createWorkId } from "./5184.js";
 import { normalizeRadarStyle, normalizePresentationChartLegendPosition, presentationChartUsesNumericXAxis, normalizePresentationBubbleScale, normalizePresentationBubbleSizeRepresents, withPresentationChartLayout, normalizeDoughnutHoleSize, normalizePresentationScatterStyle } from "./0~work-presentation-charts.js";
 import { loadPptxCommentAuthors, readPptxSlideComments, readPptxChartLayoutAndSeriesStyles, readPptxTransition, readPptxChartSeriesAnalysis, readPptxChartDataLabels } from "./0~7614.js";
 import { parseXlsxChartAxes } from "./4104.js";
-import { createOfficeId as createWorkId } from "./1134.js";
 import { scaledPresentationVisuals } from "./0~work-presentation-visual-scale.js";
 async function loadPptxTheme(archive, presentationRelationships) {
     const defaults = {

package/dist/0~work-presentation-charts.js

@@ -1,5 +1,5 @@
 import { workSpreadsheetChartSupportsErrorBars, normalizeWorkSpreadsheetChartAxes, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetChartLayout, workSpreadsheetChartSupportsTrendlines, workSpreadsheetChartSupportsSeriesAnalysis, normalizeWorkSpreadsheetChartSeriesStyle, normalizeWorkSpreadsheetTrendline } from "./8715.js";
-import { createOfficeId as createWorkId } from "./1134.js";
+import { createOfficeId as createWorkId } from "./5184.js";
 function chartTypeWithAxes(type) {
     return 'pie' === type || 'doughnut' === type ? 'column' : type;
 }

package/dist/2591.js

@@ -0,0 +1,197 @@
+import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
+import * as __rspack_external_yjs from "yjs";
+const MARKDOWN_SOURCE_ROOT = 'markdown.source';
+function initializeWorkOfficeMarkdownCollaboration(session, content) {
+    assertMarkdownSession(session);
+    assertWorkOfficeCollaborationEditable(session);
+    const initialMarkdown = validatedMarkdown(content);
+    const existing = readWorkOfficeCollaborationMetadata(session);
+    if (existing?.initialized) return {
+        initialized: false,
+        content: readWorkOfficeMarkdownCollaboration(session)
+    };
+    const source = markdownSource(session);
+    if (source.length > 0) throw new WorkOfficeCollaborationError('office.collaboration.bootstrap_ambiguous', 'The Markdown collaboration source contains data without initialized metadata.');
+    const origin = session.createOrigin('bootstrap');
+    session.transact(()=>{
+        const metadata = initializeWorkOfficeCollaborationMetadata(session);
+        if (metadata.initialized) return;
+        registerWorkOfficeCollaborationInitializer(session);
+        if (initialMarkdown) source.insert(0, initialMarkdown);
+        markWorkOfficeCollaborationInitialized(session);
+    }, origin);
+    return {
+        initialized: true,
+        content: readWorkOfficeMarkdownCollaboration(session)
+    };
+}
+function readWorkOfficeMarkdownCollaboration(session) {
+    assertInitializedMarkdownSession(session);
+    return {
+        type: 'markdown',
+        markdown: markdownSource(session).toString()
+    };
+}
+function replaceWorkOfficeMarkdownCollaboration(session, markdown, origin = session.localOrigin) {
+    assertInitializedMarkdownSession(session);
+    assertWorkOfficeCollaborationEditable(session);
+    const source = markdownSource(session);
+    const current = source.toString();
+    if (current === markdown) return false;
+    const replacement = markdownReplacement(current, markdown);
+    session.transact(()=>{
+        if (replacement.deleteLength > 0) source.delete(replacement.index, replacement.deleteLength);
+        if (replacement.insert) source.insert(replacement.index, replacement.insert);
+    }, origin);
+    return true;
+}
+function createWorkOfficeMarkdownCollaborationBinding(session, options = {}) {
+    assertInitializedMarkdownSession(session);
+    return new WorkOfficeMarkdownCollaborationBindingImpl(session, options);
+}
+class WorkOfficeMarkdownCollaborationBindingImpl {
+    origin;
+    #session;
+    #source;
+    #undoManager;
+    #listeners = new Set();
+    #historyListeners = new Set();
+    #destroyed = false;
+    constructor(session, options){
+        this.#session = session;
+        this.#source = markdownSource(session);
+        this.origin = options.origin ?? session.createOrigin(session.localOrigin.kind);
+        assertWorkOfficeCollaborationOrigin(this.origin);
+        this.#undoManager = new __rspack_external_yjs.UndoManager(this.#source, {
+            captureTimeout: options.captureTimeoutMs ?? 1000,
+            trackedOrigins: new Set([
+                this.origin
+            ])
+        });
+        this.#source.observe(this.#onSourceChange);
+        this.#undoManager.on('stack-item-added', this.#onHistoryChange);
+        this.#undoManager.on('stack-item-popped', this.#onHistoryChange);
+        this.#undoManager.on('stack-item-updated', this.#onHistoryChange);
+    }
+    content() {
+        this.ensureActive();
+        return {
+            type: 'markdown',
+            markdown: this.#source.toString()
+        };
+    }
+    replace(markdown) {
+        this.ensureActive();
+        return replaceWorkOfficeMarkdownCollaboration(this.#session, markdown, this.origin);
+    }
+    canUndo() {
+        this.ensureActive();
+        return this.#undoManager.undoStack.length > 0;
+    }
+    canRedo() {
+        this.ensureActive();
+        return this.#undoManager.redoStack.length > 0;
+    }
+    undo() {
+        this.ensureActive();
+        assertWorkOfficeCollaborationEditable(this.#session);
+        if (!this.canUndo()) return false;
+        this.#undoManager.undo();
+        return true;
+    }
+    redo() {
+        this.ensureActive();
+        assertWorkOfficeCollaborationEditable(this.#session);
+        if (!this.canRedo()) return false;
+        this.#undoManager.redo();
+        return true;
+    }
+    stopCapturing() {
+        this.ensureActive();
+        this.#undoManager.stopCapturing();
+    }
+    subscribe(listener) {
+        this.ensureActive();
+        this.#listeners.add(listener);
+        return ()=>this.#listeners.delete(listener);
+    }
+    subscribeHistory(listener) {
+        this.ensureActive();
+        this.#historyListeners.add(listener);
+        return ()=>this.#historyListeners.delete(listener);
+    }
+    destroy() {
+        if (this.#destroyed) return;
+        this.#destroyed = true;
+        this.#source.unobserve(this.#onSourceChange);
+        this.#undoManager.off('stack-item-added', this.#onHistoryChange);
+        this.#undoManager.off('stack-item-popped', this.#onHistoryChange);
+        this.#undoManager.off('stack-item-updated', this.#onHistoryChange);
+        this.#undoManager.destroy();
+        this.#listeners.clear();
+        this.#historyListeners.clear();
+    }
+    #onSourceChange = (event)=>{
+        const change = {
+            content: {
+                type: 'markdown',
+                markdown: this.#source.toString()
+            },
+            local: event.transaction.origin === this.origin,
+            origin: event.transaction.origin
+        };
+        for (const listener of this.#listeners)listener(change);
+    };
+    #onHistoryChange = ()=>{
+        for (const listener of this.#historyListeners)listener();
+    };
+    ensureActive() {
+        if (!this.#destroyed) return;
+        throw new WorkOfficeCollaborationError('office.collaboration.binding_destroyed', 'The Markdown collaboration binding has been destroyed.');
+    }
+}
+function markdownSource(session) {
+    return session.document.getText(session.rootName(MARKDOWN_SOURCE_ROOT));
+}
+function assertMarkdownSession(session) {
+    if ('markdown' === session.kind) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.kind_mismatch', `A Markdown collaboration binding cannot use a '${session.kind}' session.`);
+}
+function validatedMarkdown(content) {
+    if (content?.type === 'markdown' && 'string' == typeof content.markdown) return content.markdown;
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', 'Markdown collaboration initialization requires a valid Markdown content value.');
+}
+function assertInitializedMarkdownSession(session) {
+    assertMarkdownSession(session);
+    const metadata = readWorkOfficeCollaborationMetadata(session);
+    if (metadata?.initialized) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.not_initialized', 'The Markdown collaboration session has not been initialized.');
+}
+function markdownReplacement(current, next) {
+    let prefix = 0;
+    const maximumPrefix = Math.min(current.length, next.length);
+    while(prefix < maximumPrefix && current[prefix] === next[prefix])prefix += 1;
+    prefix = safeUtf16Boundary(current, prefix);
+    prefix = safeUtf16Boundary(next, prefix);
+    let suffix = 0;
+    const maximumSuffix = Math.min(current.length - prefix, next.length - prefix);
+    while(suffix < maximumSuffix && current[current.length - suffix - 1] === next[next.length - suffix - 1])suffix += 1;
+    const currentEnd = safeUtf16Boundary(current, current.length - suffix);
+    const nextEnd = safeUtf16Boundary(next, next.length - suffix);
+    return {
+        index: prefix,
+        deleteLength: Math.max(0, currentEnd - prefix),
+        insert: next.slice(prefix, nextEnd)
+    };
+}
+function safeUtf16Boundary(value, index) {
+    if (index > 0 && index < value.length && isHighSurrogate(value.charCodeAt(index - 1)) && isLowSurrogate(value.charCodeAt(index))) return index - 1;
+    return index;
+}
+function isHighSurrogate(value) {
+    return value >= 0xd800 && value <= 0xdbff;
+}
+function isLowSurrogate(value) {
+    return value >= 0xdc00 && value <= 0xdfff;
+}
+export { createWorkOfficeMarkdownCollaborationBinding as createOfficeMarkdownCollaborationBinding, initializeWorkOfficeMarkdownCollaboration as initializeOfficeMarkdownCollaboration, readWorkOfficeMarkdownCollaboration as readOfficeMarkdownCollaboration, replaceWorkOfficeMarkdownCollaboration as replaceOfficeMarkdownCollaboration };