pptx-angular-viewer 1.1.61 → 1.1.62

package/fesm2022/pptx-angular-viewer.mjs

@@ -4946,15 +4946,15 @@ function convertOmmlToLatex(omml) {
 }
 
 /**
- * Framework-agnostic chart helpers — a focused Vue port of the React package's
+ * Framework-agnostic chart helpers, a focused Vue port of the React package's
  * `viewer/utils/chart-helpers.ts`, `chart-layout.ts`, and
  * `chart-style-palettes.ts`.
  *
- * Only the pieces the common-type renderers (bar / column / stacked / line /
- * area / pie / doughnut) and the shared chrome need are ported here. Advanced
- * features (log axes, secondary axes, display units, data tables, overlays)
- * are intentionally omitted — see the `// TODO(vue):` markers in
- * `ChartRenderer.vue`.
+ * This module only covers the common-type renderers (bar / column / stacked /
+ * line / area / pie / doughnut) and the shared chrome. Advanced axis/overlay
+ * features (log axes, secondary axes, display units, trendlines, error bars,
+ * data tables) live in `chart-axis.ts` / `chart-axis-render.ts` /
+ * `chart-cartesian.ts` and are consumed via `chart/ChartViewModelSvg.vue`.
  *
  * These small pure helpers are an extraction candidate: long-term they (and
  * their React counterparts) should live in a shared, framework-agnostic
@@ -22992,6 +22992,164 @@ function observeYDocSlides(ydoc, onChange) {
     return () => arr.unobserveDeep(onChange);
 }
 
+/**
+ * collaboration-text-merge.ts: character-level in-place merging of a desired
+ * text state into a live Y.Text.
+ *
+ * `reconcileTextBody` used to replace the whole Y.Text whenever the canonical
+ * decoded form differed, which made concurrent edits to the SAME text element
+ * collide at element granularity (last writer wins). This module instead
+ * applies a minimal edit script to the existing Y.Text:
+ *
+ *  - plain-text diff via common prefix/suffix (surrogate-pair safe): one
+ *    delete + attributed inserts for the changed middle span
+ *  - attribute reconcile: walk the current and desired attribute runs by
+ *    position and `format()` only the ranges whose attributes differ
+ *
+ * Because each peer submits a minimal delta, Yjs merges concurrent edits to
+ * the same run at character granularity (e.g. one peer prepends while another
+ * appends, both survive).
+ */
+function isYTextEditable(value) {
+    return (isYTextLike(value) &&
+        typeof value.delete === 'function' &&
+        typeof value.format === 'function');
+}
+const isHighSurrogate = (code) => code >= 0xd800 && code <= 0xdbff;
+const isLowSurrogate = (code) => code >= 0xdc00 && code <= 0xdfff;
+function opsText(ops) {
+    let text = '';
+    for (const op of ops) {
+        if (typeof op.insert === 'string') {
+            text += op.insert;
+        }
+    }
+    return text;
+}
+function commonPrefixLength(a, b) {
+    const max = Math.min(a.length, b.length);
+    let i = 0;
+    while (i < max && a.charCodeAt(i) === b.charCodeAt(i)) {
+        i++;
+    }
+    // Never cut between a surrogate pair.
+    if (i > 0 && isHighSurrogate(a.charCodeAt(i - 1))) {
+        i--;
+    }
+    return i;
+}
+function commonSuffixLength(a, b, prefix) {
+    const max = Math.min(a.length, b.length) - prefix;
+    let i = 0;
+    while (i < max && a.charCodeAt(a.length - i - 1) === b.charCodeAt(b.length - i - 1)) {
+        i++;
+    }
+    if (i > 0 && isLowSurrogate(a.charCodeAt(a.length - i))) {
+        i--;
+    }
+    return i;
+}
+/**
+ * Insert the desired-text span [from, to) into `ytext`, carrying each desired
+ * op's attributes so no character inherits formatting from its neighbour.
+ */
+function insertSpanWithAttrs(ytext, desiredOps, from, to) {
+    let opStart = 0;
+    let index = from;
+    for (const op of desiredOps) {
+        if (typeof op.insert !== 'string') {
+            continue;
+        }
+        const opEnd = opStart + op.insert.length;
+        const start = Math.max(opStart, from);
+        const end = Math.min(opEnd, to);
+        if (start < end) {
+            const chunk = op.insert.slice(start - opStart, end - opStart);
+            // Explicit attrs always: attribute-less inserts inherit the previous
+            // character's formatting in Yjs (the style-bleed bug).
+            ytext.insert(index, chunk, (op.attributes ?? {}));
+            index += chunk.length;
+        }
+        opStart = opEnd;
+    }
+}
+function attrsEqual(a, b) {
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length) {
+        return false;
+    }
+    return aKeys.every((k) => a[k] === b[k]);
+}
+/**
+ * Bring the attribute runs of `ytext` (whose plain text already matches the
+ * desired ops) in line with the desired attributes, formatting only the
+ * ranges that differ.
+ */
+function reconcileAttributeRuns(ytext, desiredOps) {
+    const currentOps = ytext.toDelta().filter((op) => typeof op.insert === 'string');
+    let ci = 0;
+    let cOff = 0;
+    let pos = 0;
+    for (const dop of desiredOps) {
+        if (typeof dop.insert !== 'string') {
+            continue;
+        }
+        const dAttrs = (dop.attributes ?? {});
+        let remaining = dop.insert.length;
+        while (remaining > 0 && ci < currentOps.length) {
+            const cText = currentOps[ci].insert;
+            const len = Math.min(cText.length - cOff, remaining);
+            const cAttrs = (currentOps[ci].attributes ?? {});
+            if (!attrsEqual(cAttrs, dAttrs)) {
+                const patch = {};
+                for (const key of Object.keys(dAttrs)) {
+                    if (cAttrs[key] !== dAttrs[key]) {
+                        patch[key] = dAttrs[key];
+                    }
+                }
+                for (const key of Object.keys(cAttrs)) {
+                    if (!(key in dAttrs)) {
+                        patch[key] = null;
+                    }
+                }
+                ytext.format(pos, len, patch);
+            }
+            pos += len;
+            remaining -= len;
+            cOff += len;
+            if (cOff >= cText.length) {
+                ci++;
+                cOff = 0;
+            }
+        }
+    }
+}
+/**
+ * Apply the minimal edit script that turns the live `ytext` into the state
+ * described by `desiredOps`. Returns false (leaving the caller to fall back
+ * to wholesale replacement) if the text diff did not converge.
+ *
+ * Must be called inside a Y.Doc transaction when the text is integrated.
+ */
+function mergeDeltaIntoYText(ytext, desiredOps) {
+    const currentText = opsText(ytext.toDelta());
+    const desiredText = opsText(desiredOps);
+    if (currentText !== desiredText) {
+        const prefix = commonPrefixLength(currentText, desiredText);
+        const suffix = commonSuffixLength(currentText, desiredText, prefix);
+        const deleteLen = currentText.length - prefix - suffix;
+        if (deleteLen > 0) {
+            ytext.delete(prefix, deleteLen);
+        }
+        insertSpanWithAttrs(ytext, desiredOps, prefix, desiredText.length - suffix);
+        if (opsText(ytext.toDelta()) !== desiredText) {
+            return false;
+        }
+    }
+    reconcileAttributeRuns(ytext, desiredOps);
+    return true;
+}
+
 /**
  * collaboration-reconcile.ts: Granular Y.Doc reconciliation for collaborative
  * editing.
@@ -23004,7 +23162,9 @@ function observeYDocSlides(ydoc, onChange) {
  *  - slides and elements are matched by `id`; unchanged ones keep their Y.Map
  *    instance so concurrent field edits merge via Yjs
  *  - scalar / complex fields are compared and only set when different
- *  - textBody is only replaced when its canonical decoded form differs
+ *  - textBody is edited in place (minimal char-level diff via
+ *    collaboration-text-merge.ts) when its canonical decoded form differs;
+ *    wholesale replacement is only a fallback
  *  - removed items are deleted, new ones inserted at their position; moves
  *    are delete+reinsert (Yjs has no move primitive)
  *
@@ -23053,11 +23213,17 @@ function reconcileTextBody(ymap, rec, factories) {
         }
         return;
     }
-    const desired = decodeDelta(encodeSegmentsToDelta(segments));
+    const desiredDelta = encodeSegmentsToDelta(segments);
+    const desired = decodeDelta(desiredDelta);
     const existing = isYTextLike(current) ? decodeDelta(current.toDelta()) : undefined;
     if (existing !== undefined && jsonEqual(existing, desired)) {
         return;
     }
+    // Prefer an in-place minimal edit so concurrent edits to the same text
+    // element merge at character granularity instead of element-level LWW.
+    if (isYTextEditable(current) && mergeDeltaIntoYText(current, desiredDelta)) {
+        return;
+    }
     const ytext = factories.createText();
     encodeTextBody(segments, ytext);
     ymap.set('textBody', ytext);
@@ -80258,6 +80424,8 @@ const translationsEn = {
     'pptx.inspector.fill': 'Fill',
     'pptx.inspector.line': 'Line',
     'pptx.inspector.effects': 'Effects',
+    'pptx.inspector.softEdge': 'Soft Edge',
+    'pptx.inspector.softEdgeRadius': 'Soft Edge Radius',
     'pptx.arrange.positionSize': 'Position & Size',
     'pptx.arrange.lockElement': 'Lock element',
     'pptx.arrange.unlockElement': 'Unlock element',
@@ -80279,6 +80447,9 @@ const translationsEn = {
     'pptx.media.trimEndTime': 'End (mm:ss)',
     'pptx.media.trimmedDuration': 'Trimmed duration',
     'pptx.media.resetTrim': 'Reset trim',
+    'pptx.media.trimErrorNegative': 'Trim times cannot be negative.',
+    'pptx.media.trimErrorStartAfterEnd': 'Trim start must be before trim end.',
+    'pptx.media.trimErrorBeyondDuration': 'Trim times cannot exceed the clip duration.',
     'pptx.media.playback': 'Playback',
     'pptx.media.volume': 'Volume',
     'pptx.media.speed': 'Speed',
@@ -81513,13 +81684,18 @@ const translationsEn = {
     'pptx.documentProperties.custom.typeNumber': 'Number',
     'pptx.documentProperties.custom.typeText': 'Text',
     'pptx.documentProperties.custom.typeYesNo': 'Yes or No',
+    'pptx.documentProperties.statistics.application': 'Application',
+    'pptx.documentProperties.statistics.appVersion': 'Application Version',
     'pptx.documentProperties.statistics.elements': 'Elements',
     'pptx.documentProperties.statistics.hiddenSlides': 'Hidden Slides',
     'pptx.documentProperties.statistics.lastModifiedBy': 'Last Modified By',
     'pptx.documentProperties.statistics.notes': 'Notes',
     'pptx.documentProperties.statistics.paragraphs': 'Paragraphs',
+    'pptx.documentProperties.statistics.presentationFormat': 'Presentation Format',
     'pptx.documentProperties.statistics.revision': 'Revision',
     'pptx.documentProperties.statistics.slides': 'Slides',
+    'pptx.documentProperties.statistics.template': 'Template',
+    'pptx.documentProperties.statistics.totalTime': 'Total Editing Time',
     'pptx.documentProperties.statistics.words': 'Words',
     'pptx.documentProperties.summary.category': 'Category',
     'pptx.documentProperties.summary.description': 'Description',