ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/chunk-NTXHQHCS.cjs

@@ -0,0 +1,327 @@
+'use strict';
+
+// src/pptx/render/ink-curve-sampling.ts
+function distance(a, b) {
+  return Math.hypot(b.x - a.x, b.y - a.y);
+}
+var CURVE_SAMPLE_SPACING_PX = 4;
+var CURVE_MIN_SAMPLES = 4;
+var CURVE_MAX_SAMPLES = 24;
+function curveSampleCount(hullLength) {
+  const raw = Math.ceil(hullLength / CURVE_SAMPLE_SPACING_PX);
+  return Math.max(CURVE_MIN_SAMPLES, Math.min(CURVE_MAX_SAMPLES, raw));
+}
+function cubicBezierAt(p0, p1, p2, p3, t) {
+  const mt = 1 - t;
+  const a = { x: mt * p0.x + t * p1.x, y: mt * p0.y + t * p1.y };
+  const b = { x: mt * p1.x + t * p2.x, y: mt * p1.y + t * p2.y };
+  const c = { x: mt * p2.x + t * p3.x, y: mt * p2.y + t * p3.y };
+  const ab = { x: mt * a.x + t * b.x, y: mt * a.y + t * b.y };
+  const bc = { x: mt * b.x + t * c.x, y: mt * b.y + t * c.y };
+  return { x: mt * ab.x + t * bc.x, y: mt * ab.y + t * bc.y };
+}
+function quadBezierAt(p0, p1, p2, t) {
+  const mt = 1 - t;
+  const a = { x: mt * p0.x + t * p1.x, y: mt * p0.y + t * p1.y };
+  const b = { x: mt * p1.x + t * p2.x, y: mt * p1.y + t * p2.y };
+  return { x: mt * a.x + t * b.x, y: mt * a.y + t * b.y };
+}
+var ARC_LENGTH_LUT_STEPS = 64;
+function buildArcLengthLut(evalAt) {
+  const ts = [0];
+  const lengths = [0];
+  let prev = evalAt(0);
+  let total = 0;
+  for (let i = 1; i <= ARC_LENGTH_LUT_STEPS; i++) {
+    const t = i / ARC_LENGTH_LUT_STEPS;
+    const pt = evalAt(t);
+    total += distance(prev, pt);
+    ts.push(t);
+    lengths.push(total);
+    prev = pt;
+  }
+  return { ts, lengths };
+}
+function tAtArcLength(lut, targetLength) {
+  const { ts, lengths } = lut;
+  const total = lengths[lengths.length - 1];
+  if (total <= 0) {
+    return 1;
+  }
+  const clamped = Math.max(0, Math.min(total, targetLength));
+  for (let i = 1; i < lengths.length; i++) {
+    if (lengths[i] >= clamped) {
+      const segmentLength = lengths[i] - lengths[i - 1];
+      const frac = segmentLength > 0 ? (clamped - lengths[i - 1]) / segmentLength : 0;
+      return ts[i - 1] + (ts[i] - ts[i - 1]) * frac;
+    }
+  }
+  return 1;
+}
+function sampleByArcLength(evalAt, count) {
+  const lut = buildArcLengthLut(evalAt);
+  const total = lut.lengths[lut.lengths.length - 1];
+  const samples = [];
+  for (let i = 1; i <= count; i++) {
+    const t = tAtArcLength(lut, i / count * total);
+    samples.push(evalAt(t));
+  }
+  return samples;
+}
+function sampleCubicSegment(points, current, p1, p2, end) {
+  if (!current) {
+    points.push(p1, p2, end);
+    return end;
+  }
+  const hull = distance(current, p1) + distance(p1, p2) + distance(p2, end);
+  const samples = curveSampleCount(hull);
+  points.push(...sampleByArcLength((t) => cubicBezierAt(current, p1, p2, end, t), samples));
+  return end;
+}
+function sampleQuadSegment(points, current, cp, end) {
+  if (!current) {
+    points.push(cp, end);
+    return end;
+  }
+  const hull = distance(current, cp) + distance(cp, end);
+  const samples = curveSampleCount(hull);
+  points.push(...sampleByArcLength((t) => quadBezierAt(current, cp, end, t), samples));
+  return end;
+}
+
+// src/pptx/render/ink-replay-timeline.ts
+var DEFAULT_STROKE_DURATION_MS = 600;
+var DEFAULT_STROKE_DELAY_MS = 200;
+var MIN_REAL_STROKE_DURATION_MS = 60;
+function fixedCascadeTimeline(strokeCount, duration, delay) {
+  return Array.from({ length: strokeCount }, (_, strokeIndex) => ({
+    strokeIndex,
+    startOffsetMs: strokeIndex * (duration + delay),
+    durationMs: duration
+  }));
+}
+function buildInkReplayTimeline(strokeTimestamps, config = {}) {
+  const duration = config.strokeDurationMs ?? DEFAULT_STROKE_DURATION_MS;
+  const delay = config.strokeDelayMs ?? DEFAULT_STROKE_DELAY_MS;
+  const hasFullRealTiming = strokeTimestamps.length > 0 && strokeTimestamps.every((timestamps) => timestamps !== void 0 && timestamps.length > 0);
+  if (!hasFullRealTiming) {
+    return fixedCascadeTimeline(strokeTimestamps.length, duration, delay);
+  }
+  const timed = strokeTimestamps;
+  const starts = timed.map((timestamps) => Math.min(...timestamps));
+  const ends = timed.map((timestamps) => Math.max(...timestamps));
+  const t0 = Math.min(...starts);
+  return timed.map((_, strokeIndex) => ({
+    strokeIndex,
+    startOffsetMs: Math.max(0, starts[strokeIndex] - t0),
+    durationMs: Math.max(MIN_REAL_STROKE_DURATION_MS, ends[strokeIndex] - starts[strokeIndex])
+  }));
+}
+
+// src/pptx/render/ink-rendering.ts
+var PATH_COMMAND_ARITY = { M: 2, L: 2, C: 6, Q: 4, Z: 0 };
+function tokenizeSvgPath(d) {
+  const tokens = [];
+  const partRegex = /([MLCQZmlcqz])|(-?\d+(?:\.\d+)?(?:e[+-]?\d+)?)/giu;
+  let cmd = null;
+  let nums = [];
+  let match;
+  const flush = () => {
+    if (cmd) {
+      tokens.push({ cmd: cmd.toUpperCase(), nums });
+    }
+  };
+  while ((match = partRegex.exec(d)) !== null) {
+    if (match[1]) {
+      flush();
+      cmd = match[1];
+      nums = [];
+    } else if (match[2] !== void 0 && cmd) {
+      nums.push(parseFloat(match[2]));
+    }
+  }
+  flush();
+  return tokens;
+}
+function extractPathPoints(d) {
+  const points = [];
+  let current;
+  for (const { cmd, nums } of tokenizeSvgPath(d)) {
+    const arity = PATH_COMMAND_ARITY[cmd];
+    if (cmd === "Z" || arity === void 0) {
+      continue;
+    }
+    for (let offset = 0; offset + arity <= nums.length; offset += arity) {
+      const chunk = nums.slice(offset, offset + arity);
+      const effective = cmd === "M" && offset > 0 ? "L" : cmd;
+      if (effective === "M" || effective === "L") {
+        const pt = { x: chunk[0], y: chunk[1] };
+        points.push(pt);
+        current = pt;
+      } else if (effective === "C") {
+        current = sampleCubicSegment(
+          points,
+          current,
+          { x: chunk[0], y: chunk[1] },
+          { x: chunk[2], y: chunk[3] },
+          { x: chunk[4], y: chunk[5] }
+        );
+      } else if (effective === "Q") {
+        current = sampleQuadSegment(
+          points,
+          current,
+          { x: chunk[0], y: chunk[1] },
+          {
+            x: chunk[2],
+            y: chunk[3]
+          }
+        );
+      }
+    }
+  }
+  return points;
+}
+function interpolateWidth(widths, t) {
+  if (widths.length === 0) {
+    return 1;
+  }
+  if (widths.length === 1) {
+    return widths[0];
+  }
+  const clampedT = Math.max(0, Math.min(1, t));
+  const index = clampedT * (widths.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.min(lower + 1, widths.length - 1);
+  const frac = index - lower;
+  return widths[lower] * (1 - frac) + widths[upper] * frac;
+}
+function generatePressureCircles(points, widths, config) {
+  if (points.length === 0) {
+    return [];
+  }
+  const minR = config.minRadius ?? 0.5;
+  const maxR = config.maxRadius ?? config.baseWidth;
+  return points.map((pt, i) => {
+    const t = points.length === 1 ? 0.5 : i / (points.length - 1);
+    const w = interpolateWidth(widths, t);
+    const ratio = config.baseWidth > 0 ? w / config.baseWidth : 1;
+    const r = Math.max(minR, Math.min(maxR, config.baseWidth / 2 * ratio));
+    return { cx: pt.x, cy: pt.y, r };
+  });
+}
+function hasPressureVariation(widths) {
+  if (widths.length <= 1) {
+    return false;
+  }
+  const first = widths[0];
+  return widths.some((w) => Math.abs(w - first) > 0.01);
+}
+function pressuresToWidths(pressures, baseWidth, minScale = 0.3, maxScale = 1.8) {
+  return pressures.map((p) => {
+    const clamped = Math.max(0, Math.min(1, p));
+    return baseWidth * (minScale + clamped * (maxScale - minScale));
+  });
+}
+function estimatePathLength(points) {
+  if (points.length < 2) {
+    return 0;
+  }
+  let length = 0;
+  for (let i = 1; i < points.length; i++) {
+    const dx = points[i].x - points[i - 1].x;
+    const dy = points[i].y - points[i - 1].y;
+    length += Math.sqrt(dx * dx + dy * dy);
+  }
+  return length;
+}
+var INK_REPLAY_KEYFRAME_NAME = "pptx-ink-replay";
+var INK_REPLAY_KEYFRAMES = `@keyframes ${INK_REPLAY_KEYFRAME_NAME} {
+  from { stroke-dashoffset: var(--ink-path-length); }
+  to { stroke-dashoffset: 0; }
+}`;
+function formatInkStrokeReplayStyle(step, pathLength, easing) {
+  const len = Math.max(pathLength, 1);
+  return {
+    pathLength: len,
+    animationDelay: `${step.startOffsetMs}ms`,
+    animationDuration: `${step.durationMs}ms`,
+    animation: `${INK_REPLAY_KEYFRAME_NAME} ${step.durationMs}ms ${easing} ${step.startOffsetMs}ms forwards`,
+    strokeDasharray: `${len}`,
+    strokeDashoffset: `${len}`
+  };
+}
+function getInkStrokeReplayStyle(strokeIndex, pathLength, config = {}) {
+  const duration = config.strokeDurationMs ?? DEFAULT_STROKE_DURATION_MS;
+  const delay = config.strokeDelayMs ?? DEFAULT_STROKE_DELAY_MS;
+  const easing = config.easing ?? "ease-in-out";
+  const startOffsetMs = strokeIndex * (duration + delay);
+  return formatInkStrokeReplayStyle({ startOffsetMs, durationMs: duration }, pathLength, easing);
+}
+function getInkReplayStyles(el, config = {}) {
+  const easing = config.easing ?? "ease-in-out";
+  const steps = buildInkReplayTimeline(
+    el.inkPaths.map(() => void 0),
+    config
+  );
+  return el.inkPaths.map((d, i) => {
+    const pathLen = estimatePathLength(extractPathPoints(d));
+    return formatInkStrokeReplayStyle(steps[i], pathLen, easing);
+  });
+}
+function getContentPartReplayStyles(strokes, config = {}) {
+  const easing = config.easing ?? "ease-in-out";
+  const steps = buildInkReplayTimeline(
+    strokes.map((stroke) => stroke.pointTimestamps),
+    config
+  );
+  return strokes.map((stroke, i) => {
+    const pathLen = estimatePathLength(extractPathPoints(stroke.path));
+    return formatInkStrokeReplayStyle(steps[i], pathLen, easing);
+  });
+}
+function getTotalReplayDuration(strokeCount, config = {}) {
+  if (strokeCount <= 0) {
+    return 0;
+  }
+  const duration = config.strokeDurationMs ?? DEFAULT_STROKE_DURATION_MS;
+  const delay = config.strokeDelayMs ?? DEFAULT_STROKE_DELAY_MS;
+  return (strokeCount - 1) * (duration + delay) + duration;
+}
+function resolveInkOpacity(opacities, index) {
+  if (!opacities || index >= opacities.length) {
+    return 1;
+  }
+  return Math.max(0, Math.min(1, opacities[index]));
+}
+function resolveInkColor(colors, index, fallback = "#000") {
+  if (!colors || index >= colors.length) {
+    return fallback;
+  }
+  return colors[index] || fallback;
+}
+function resolveInkWidth(widths, index, fallback = 3) {
+  if (!widths || index >= widths.length) {
+    return fallback;
+  }
+  return widths[index] > 0 ? widths[index] : fallback;
+}
+
+exports.DEFAULT_STROKE_DELAY_MS = DEFAULT_STROKE_DELAY_MS;
+exports.DEFAULT_STROKE_DURATION_MS = DEFAULT_STROKE_DURATION_MS;
+exports.INK_REPLAY_KEYFRAMES = INK_REPLAY_KEYFRAMES;
+exports.INK_REPLAY_KEYFRAME_NAME = INK_REPLAY_KEYFRAME_NAME;
+exports.MIN_REAL_STROKE_DURATION_MS = MIN_REAL_STROKE_DURATION_MS;
+exports.buildInkReplayTimeline = buildInkReplayTimeline;
+exports.estimatePathLength = estimatePathLength;
+exports.extractPathPoints = extractPathPoints;
+exports.generatePressureCircles = generatePressureCircles;
+exports.getContentPartReplayStyles = getContentPartReplayStyles;
+exports.getInkReplayStyles = getInkReplayStyles;
+exports.getInkStrokeReplayStyle = getInkStrokeReplayStyle;
+exports.getTotalReplayDuration = getTotalReplayDuration;
+exports.hasPressureVariation = hasPressureVariation;
+exports.interpolateWidth = interpolateWidth;
+exports.pressuresToWidths = pressuresToWidths;
+exports.resolveInkColor = resolveInkColor;
+exports.resolveInkOpacity = resolveInkOpacity;
+exports.resolveInkWidth = resolveInkWidth;

package/dist/pptx/chunk-NVYVHNPD.mjs

@@ -0,0 +1,90 @@
+import { textStylePatch } from './chunk-VD7HRMTA.mjs';
+import { hasShapeProperties, hasTextProperties } from 'ooxml-core/pptx';
+
+function copyFormatFromElement(element) {
+  const result = {};
+  if (hasShapeProperties(element) && element.shapeStyle) {
+    const s = element.shapeStyle;
+    result.shapeStyle = {
+      fillColor: s.fillColor,
+      fillMode: s.fillMode,
+      fillGradient: s.fillGradient,
+      fillGradientStops: s.fillGradientStops ? [...s.fillGradientStops] : void 0,
+      fillGradientAngle: s.fillGradientAngle,
+      fillGradientType: s.fillGradientType,
+      fillOpacity: s.fillOpacity,
+      fillPatternPreset: s.fillPatternPreset,
+      fillPatternBackgroundColor: s.fillPatternBackgroundColor,
+      strokeColor: s.strokeColor,
+      strokeWidth: s.strokeWidth,
+      strokeOpacity: s.strokeOpacity,
+      strokeDash: s.strokeDash,
+      lineJoin: s.lineJoin,
+      lineCap: s.lineCap,
+      shadowColor: s.shadowColor,
+      shadowBlur: s.shadowBlur,
+      shadowOffsetX: s.shadowOffsetX,
+      shadowOffsetY: s.shadowOffsetY,
+      shadowOpacity: s.shadowOpacity,
+      glowColor: s.glowColor,
+      glowRadius: s.glowRadius,
+      glowOpacity: s.glowOpacity,
+      softEdgeRadius: s.softEdgeRadius
+    };
+  }
+  if (hasTextProperties(element) && element.textStyle) {
+    const t = element.textStyle;
+    result.textStyle = {
+      fontFamily: t.fontFamily,
+      fontSize: t.fontSize,
+      bold: t.bold,
+      italic: t.italic,
+      underline: t.underline,
+      underlineStyle: t.underlineStyle,
+      strikethrough: t.strikethrough,
+      color: t.color,
+      align: t.align,
+      lineSpacing: t.lineSpacing,
+      paragraphSpacingBefore: t.paragraphSpacingBefore,
+      paragraphSpacingAfter: t.paragraphSpacingAfter,
+      textCaps: t.textCaps
+    };
+  }
+  return result;
+}
+function definedEntries(obj) {
+  const out = {};
+  for (const key in obj) {
+    if (obj[key] !== void 0) {
+      out[key] = obj[key];
+    }
+  }
+  return out;
+}
+function applyFormatToElement(element, format) {
+  let updated = { ...element };
+  if (format.shapeStyle && hasShapeProperties(updated)) {
+    updated = {
+      ...updated,
+      shapeStyle: {
+        ...updated.shapeStyle,
+        ...definedEntries(format.shapeStyle)
+      }
+    };
+  }
+  if (format.textStyle && hasTextProperties(updated)) {
+    updated = {
+      ...updated,
+      ...textStylePatch(updated, definedEntries(format.textStyle))
+    };
+  }
+  return updated;
+}
+function hasCopyableFormat(element) {
+  if (!element) {
+    return false;
+  }
+  return hasShapeProperties(element) || hasTextProperties(element);
+}
+
+export { applyFormatToElement, copyFormatFromElement, hasCopyableFormat };

package/dist/pptx/chunk-OGJRSAGH.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+// src/pptx/render/update-text-segment-style.ts
+function updateTextSegmentStyle(segment, updates, options = {}) {
+  return {
+    ...segment,
+    ...options.updateBodyStyle === false ? {} : { style: { ...segment.style, ...updates } },
+    ...segment.paragraphInsertionStyle ? { paragraphInsertionStyle: { ...segment.paragraphInsertionStyle, ...updates } } : {}
+  };
+}
+
+exports.updateTextSegmentStyle = updateTextSegmentStyle;