ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/chunk-UPN5FFKP.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+// src/pptx/export/html-escape.ts
+var TRANSPARENT_PNG = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNgAAIAAAUAAen63NgAAAAASUVORK5CYII=";
+function escapeHtml(value) {
+  return value.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;").split('"').join("&quot;").split("'").join("&#39;");
+}
+function safeDataImageSrc(src) {
+  if (typeof src !== "string" || !src.startsWith("data:image/")) {
+    return TRANSPARENT_PNG;
+  }
+  return escapeHtml(src);
+}
+
+exports.escapeHtml = escapeHtml;
+exports.safeDataImageSrc = safeDataImageSrc;

package/dist/pptx/chunk-USBRSEJK.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+// src/pptx/render/animation-preset-labels.ts
+var ANIMATION_PRESET_VALUES = [
+  // Entrance
+  "appear",
+  "fadeIn",
+  "flyIn",
+  "zoomIn",
+  "bounceIn",
+  "wipeIn",
+  "splitIn",
+  "dissolveIn",
+  "wheelIn",
+  "blindsIn",
+  "boxIn",
+  "floatIn",
+  "riseUp",
+  "swivel",
+  "expandIn",
+  "checkerboardIn",
+  "flashIn",
+  "peekIn",
+  "randomBarsIn",
+  "spinnerIn",
+  "growTurnIn",
+  // Exit
+  "fadeOut",
+  "flyOut",
+  "zoomOut",
+  "bounceOut",
+  "wipeOut",
+  "shrinkOut",
+  "dissolveOut",
+  "disappear",
+  // Emphasis
+  "spin",
+  "pulse",
+  "colorWave",
+  "bounce",
+  "flash",
+  "growShrink",
+  "teeter",
+  "transparency",
+  "boldFlash",
+  "wave"
+];
+function animationPresetLabelKey(preset) {
+  return `pptx.animation.preset.${preset}`;
+}
+function animationCatalogPresetSlug(presetId) {
+  return presetId.split(".").map((part, index) => index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function animationCatalogPresetLabelKey(presetId) {
+  return `pptx.animation.catalogPreset.${animationCatalogPresetSlug(presetId)}`;
+}
+function isAnimationCatalogPresetId(token) {
+  return token.includes(".");
+}
+function animationEffectLabelKey(anim) {
+  const token = anim.entrance ?? anim.emphasis ?? anim.exit;
+  if (!token || token === "none") {
+    return anim.motionPath ? "pptx.animation.motionPath.label" : "pptx.animation.animation";
+  }
+  return isAnimationCatalogPresetId(token) ? animationCatalogPresetLabelKey(token) : animationPresetLabelKey(token);
+}
+function animationEffectLabel(anim, translate) {
+  return translate(animationEffectLabelKey(anim));
+}
+
+exports.ANIMATION_PRESET_VALUES = ANIMATION_PRESET_VALUES;
+exports.animationCatalogPresetLabelKey = animationCatalogPresetLabelKey;
+exports.animationCatalogPresetSlug = animationCatalogPresetSlug;
+exports.animationEffectLabel = animationEffectLabel;
+exports.animationEffectLabelKey = animationEffectLabelKey;
+exports.animationPresetLabelKey = animationPresetLabelKey;
+exports.isAnimationCatalogPresetId = isAnimationCatalogPresetId;

package/dist/pptx/chunk-V4YMLIGL.mjs

@@ -0,0 +1,19 @@
+// src/pptx/render/context-menu-target.ts
+var INLINE_EDITOR_SELECTOR = "[data-inline-editor]";
+function isInsideInlineEditor(target) {
+  if (!target || !("closest" in target) || typeof target.closest !== "function") {
+    return false;
+  }
+  return target.closest(INLINE_EDITOR_SELECTOR) !== null;
+}
+function resolveContextMenuElementId(directId, target, inlineEditingElementId) {
+  if (directId) {
+    return directId;
+  }
+  if (!inlineEditingElementId) {
+    return null;
+  }
+  return isInsideInlineEditor(target) ? inlineEditingElementId : null;
+}
+
+export { INLINE_EDITOR_SELECTOR, isInsideInlineEditor, resolveContextMenuElementId };

package/dist/pptx/chunk-VD7HRMTA.mjs

@@ -0,0 +1,137 @@
+import { textFontSizePxToPt } from './chunk-SMSCEGAE.mjs';
+import { updateTextSegmentStyle } from './chunk-CENGE3TZ.mjs';
+import { hasTextProperties, hasShapeProperties } from 'ooxml-core/pptx';
+import { isBulletMarkerSegment } from 'ooxml-core/pptx/editor/render/bullet-toggle';
+export { DEFAULT_AUTONUM_TYPE, DEFAULT_BULLET_CHAR, bulletInfoForKind, elementBulletKind, isBulletMarkerSegment, paragraphBulletKind, paragraphsBulletKind, resolveBulletSegments, setElementBullets, splitBulletParagraphs, toggleElementBullets, toggleParagraphBullet, withoutListType } from 'ooxml-core/pptx/editor/render/bullet-toggle';
+
+// src/pptx/render/selection-format-state.ts
+var TEXT_DECORATION_FLAGS = [
+  "bold",
+  "italic",
+  "underline",
+  "strikethrough"
+];
+function isContentSegment(segment) {
+  return !segment.isParagraphBreak && segment.text !== "\n" && segment.text.length > 0 && !isBulletMarkerSegment(segment);
+}
+function contentSegmentsInSelection(segments, selection) {
+  if (!segments) {
+    return [];
+  }
+  return segments.filter((segment, index) => {
+    if (!isContentSegment(segment)) {
+      return false;
+    }
+    if (!selection) {
+      return true;
+    }
+    if (index < selection.startSegIdx || index > selection.endSegIdx) {
+      return false;
+    }
+    if (selection.startSegIdx === selection.endSegIdx && selection.startOffset === selection.endOffset) {
+      return true;
+    }
+    const start = index === selection.startSegIdx ? selection.startOffset : 0;
+    const end = index === selection.endSegIdx ? selection.endOffset : segment.text.length;
+    return end > start;
+  });
+}
+function flagState(values) {
+  if (values.every((value) => value)) {
+    return "on";
+  }
+  return values.some((value) => value) ? "mixed" : "off";
+}
+function getSelectionTextStyleFlags(segments, selection, elementTextStyle) {
+  const runs = contentSegmentsInSelection(segments, selection);
+  const flags = {};
+  for (const flag of TEXT_DECORATION_FLAGS) {
+    const body = elementTextStyle?.[flag] ?? false;
+    flags[flag] = runs.length === 0 ? flagState([body]) : flagState(runs.map((run) => run.style?.[flag] ?? body));
+  }
+  return flags;
+}
+function nextToggleValue(state) {
+  return state !== "on";
+}
+function textStyleFlagsOf(element, selection = null, segments) {
+  if (!element || !hasTextProperties(element)) {
+    return { bold: "off", italic: "off", underline: "off", strikethrough: "off" };
+  }
+  return getSelectionTextStyleFlags(segments ?? element.textSegments, selection, element.textStyle);
+}
+
+// src/pptx/render/inspector-helpers.ts
+var DEFAULT_FILL = "#ffffff";
+var DEFAULT_STROKE = "#000000";
+var DEFAULT_TEXT_COLOR = "#000000";
+var DEFAULT_FONT_SIZE = 18;
+function fillColorOf(el) {
+  if (hasShapeProperties(el)) {
+    return el.shapeStyle?.fillColor ?? DEFAULT_FILL;
+  }
+  return DEFAULT_FILL;
+}
+function strokeColorOf(el) {
+  if (hasShapeProperties(el)) {
+    return el.shapeStyle?.strokeColor ?? DEFAULT_STROKE;
+  }
+  return DEFAULT_STROKE;
+}
+function textColorOf(el) {
+  if (hasTextProperties(el)) {
+    return el.textStyle?.color ?? DEFAULT_TEXT_COLOR;
+  }
+  return DEFAULT_TEXT_COLOR;
+}
+function fontSizeOf(el, presentationDefault) {
+  if (hasTextProperties(el) && el.textStyle?.fontSize !== void 0) {
+    return textFontSizePxToPt(el.textStyle.fontSize);
+  }
+  const deckDefault = presentationDefault?.levelStyles?.[0]?.fontSize;
+  return deckDefault === void 0 ? DEFAULT_FONT_SIZE : textFontSizePxToPt(deckDefault);
+}
+function isBold(el) {
+  return textStyleFlagsOf(el).bold === "on";
+}
+function isItalic(el) {
+  return textStyleFlagsOf(el).italic === "on";
+}
+function isUnderline(el) {
+  return textStyleFlagsOf(el).underline === "on";
+}
+function shapeStylePatch(el, changes) {
+  const base = hasShapeProperties(el) ? el.shapeStyle ?? {} : {};
+  return {
+    shapeStyle: {
+      ...base,
+      ...changes
+    }
+  };
+}
+function textStylePatch(el, changes) {
+  const base = hasTextProperties(el) ? el.textStyle ?? {} : {};
+  return {
+    ...hasTextProperties(el) && el.textSegments?.some((segment) => segment.paragraphInsertionStyle) ? {
+      textSegments: el.textSegments.map(
+        (segment) => updateTextSegmentStyle(segment, changes, { updateBodyStyle: false })
+      )
+    } : {},
+    textStyle: {
+      ...base,
+      ...changes
+    }
+  };
+}
+function textFontSizePatch(el, fontSize) {
+  const patch = textStylePatch(el, { fontSize });
+  if (!hasTextProperties(el) || !el.textSegments) {
+    return patch;
+  }
+  return {
+    ...patch,
+    textSegments: el.textSegments.map((segment) => updateTextSegmentStyle(segment, { fontSize }))
+  };
+}
+
+export { DEFAULT_FONT_SIZE, TEXT_DECORATION_FLAGS, contentSegmentsInSelection, fillColorOf, fontSizeOf, getSelectionTextStyleFlags, isBold, isContentSegment, isItalic, isUnderline, nextToggleValue, shapeStylePatch, strokeColorOf, textColorOf, textFontSizePatch, textStyleFlagsOf, textStylePatch };

package/dist/pptx/chunk-W3X2UVYQ.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+// src/pptx/render/layout-gallery.ts
+function scopeLayoutOptionsToSlide(options, activeLayoutPath) {
+  if (!activeLayoutPath || !options.some((option) => option.masterPath)) {
+    return options;
+  }
+  const activeMaster = options.find((option) => option.path === activeLayoutPath)?.masterPath;
+  if (!activeMaster) {
+    return options;
+  }
+  const scoped = options.filter((option) => option.masterPath === activeMaster);
+  const chosenByName = /* @__PURE__ */ new Map();
+  for (const option of scoped) {
+    const isActive = option.path === activeLayoutPath;
+    if (isActive || !chosenByName.has(option.name)) {
+      chosenByName.set(option.name, option);
+    }
+  }
+  const chosenPaths = new Set([...chosenByName.values()].map((option) => option.path));
+  const emitted = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const option of scoped) {
+    if (!chosenPaths.has(option.path) || emitted.has(option.name)) {
+      continue;
+    }
+    emitted.add(option.name);
+    result.push(option);
+  }
+  return result;
+}
+function isCurrentLayout(option, activeLayoutPath) {
+  return Boolean(activeLayoutPath) && option.path === activeLayoutPath;
+}
+
+exports.isCurrentLayout = isCurrentLayout;
+exports.scopeLayoutOptionsToSlide = scopeLayoutOptionsToSlide;

package/dist/pptx/chunk-WB25PCHQ.cjs

@@ -0,0 +1,116 @@
+'use strict';
+
+// src/pptx/render/text-format-presets.ts
+function textFontSizePxToPt(fontSizePx) {
+  return Math.round(fontSizePx * (72 / 96) * 100) / 100;
+}
+function textFontSizePtToPx(fontSizePt) {
+  return fontSizePt * (96 / 72);
+}
+var COMMON_FONT_FAMILIES = [
+  "Abadi",
+  "Aptos",
+  "Aptos Display",
+  "Arial",
+  "Arial Black",
+  "Arial Narrow",
+  "Bahnschrift",
+  "Book Antiqua",
+  "Bookman Old Style",
+  "Calibri",
+  "Calibri Light",
+  "Cambria",
+  "Candara",
+  "Century Gothic",
+  "Comic Sans MS",
+  "Consolas",
+  "Corbel",
+  "Courier New",
+  "Franklin Gothic Book",
+  "Franklin Gothic Medium",
+  "Garamond",
+  "Georgia",
+  "Gill Sans MT",
+  "Helvetica",
+  "Impact",
+  "Inter",
+  "Lucida Console",
+  "Lucida Sans Unicode",
+  "Microsoft Sans Serif",
+  "Montserrat",
+  "Noto Sans",
+  "Open Sans",
+  "Palatino Linotype",
+  "Poppins",
+  "Roboto",
+  "Rockwell",
+  "Segoe UI",
+  "Source Sans Pro",
+  "Tahoma",
+  "Times New Roman",
+  "Trebuchet MS",
+  "Tw Cen MT",
+  "Verdana"
+];
+var COMMON_FONT_SIZES = [
+  8,
+  9,
+  10,
+  11,
+  12,
+  14,
+  16,
+  18,
+  20,
+  24,
+  28,
+  32,
+  36,
+  40,
+  44,
+  48,
+  54,
+  60,
+  72,
+  96
+];
+function stepFontSizePt(currentPt, direction) {
+  if (direction === "increase") {
+    const next = COMMON_FONT_SIZES.find((size) => size > currentPt);
+    return next ?? COMMON_FONT_SIZES[COMMON_FONT_SIZES.length - 1];
+  }
+  const rungs = [...COMMON_FONT_SIZES].reverse();
+  const prev = rungs.find((size) => size < currentPt);
+  return prev ?? COMMON_FONT_SIZES[0];
+}
+var CHARACTER_SPACING_OPTIONS = [
+  { label: "Very Tight", i18nKey: "pptx.text.characterSpacingVeryTight", value: -150 },
+  { label: "Tight", i18nKey: "pptx.text.characterSpacingTight", value: -75 },
+  { label: "Normal", i18nKey: "pptx.text.characterSpacingNormal", value: 0 },
+  { label: "Loose", i18nKey: "pptx.text.characterSpacingLoose", value: 75 },
+  { label: "Very Loose", i18nKey: "pptx.text.characterSpacingVeryLoose", value: 150 }
+];
+var LINE_SPACING_OPTIONS = [
+  { label: "1.0", value: 1 },
+  { label: "1.15", value: 1.15 },
+  { label: "1.5", value: 1.5 },
+  { label: "2.0", value: 2 },
+  { label: "2.5", value: 2.5 },
+  { label: "3.0", value: 3 }
+];
+var CHANGE_CASE_OPTIONS = [
+  { value: "sentence", i18nKey: "pptx.text.changeCaseSentence" },
+  { value: "lower", i18nKey: "pptx.text.changeCaseLower" },
+  { value: "upper", i18nKey: "pptx.text.changeCaseUpper" },
+  { value: "capitalize", i18nKey: "pptx.text.changeCaseCapitalize" },
+  { value: "toggle", i18nKey: "pptx.text.changeCaseToggle" }
+];
+
+exports.CHANGE_CASE_OPTIONS = CHANGE_CASE_OPTIONS;
+exports.CHARACTER_SPACING_OPTIONS = CHARACTER_SPACING_OPTIONS;
+exports.COMMON_FONT_FAMILIES = COMMON_FONT_FAMILIES;
+exports.COMMON_FONT_SIZES = COMMON_FONT_SIZES;
+exports.LINE_SPACING_OPTIONS = LINE_SPACING_OPTIONS;
+exports.stepFontSizePt = stepFontSizePt;
+exports.textFontSizePtToPx = textFontSizePtToPx;
+exports.textFontSizePxToPt = textFontSizePxToPt;

package/dist/pptx/chunk-WHUMPYEM.mjs

@@ -0,0 +1,118 @@
+// src/pptx/export/handout-layout.ts
+var A4_PORTRAIT = {
+  width: 210,
+  height: 297,
+  marginTop: 12,
+  marginRight: 12,
+  marginBottom: 12,
+  marginLeft: 12
+};
+var A4_LANDSCAPE = {
+  width: 297,
+  height: 210,
+  marginTop: 12,
+  marginRight: 12,
+  marginBottom: 12,
+  marginLeft: 12
+};
+var HANDOUT_OPTIONS = [1, 2, 3, 4, 6, 9];
+function isHandoutSlidesPerPage(value) {
+  return HANDOUT_OPTIONS.includes(value);
+}
+var CELL_GAP = 4;
+var THREE_PER_PAGE_SLIDE_FRACTION = 0.45;
+var GRID_MAP = {
+  1: { rows: 1, columns: 1 },
+  2: { rows: 2, columns: 1 },
+  3: { rows: 3, columns: 1 },
+  4: { rows: 2, columns: 2 },
+  6: { rows: 3, columns: 2 },
+  9: { rows: 3, columns: 3 }
+};
+function getHandoutGrid(slidesPerPage) {
+  return GRID_MAP[slidesPerPage] ?? { rows: 3, columns: 2 };
+}
+function computePageCount(slideCount, slidesPerPage) {
+  if (slideCount <= 0) {
+    return 0;
+  }
+  return Math.ceil(slideCount / slidesPerPage);
+}
+function computePageCells(pageIndex, slidesPerPage, totalSlides, startSlideIndex, page = A4_PORTRAIT) {
+  const grid = getHandoutGrid(slidesPerPage);
+  const printableWidth = page.width - page.marginLeft - page.marginRight;
+  const printableHeight = page.height - page.marginTop - page.marginBottom;
+  const isThreePerPage = slidesPerPage === 3;
+  const cells = [];
+  if (isThreePerPage) {
+    const slideAreaWidth = printableWidth * THREE_PER_PAGE_SLIDE_FRACTION;
+    const cellHeight = (printableHeight - CELL_GAP * (grid.rows - 1)) / grid.rows;
+    for (let row = 0; row < grid.rows; row++) {
+      const slideIdx = startSlideIndex + row;
+      cells.push({
+        slideIndex: slideIdx < totalSlides ? slideIdx : -1,
+        row,
+        col: 0,
+        x: 0,
+        y: row * (cellHeight + CELL_GAP),
+        width: slideAreaWidth,
+        height: cellHeight
+      });
+    }
+  } else {
+    const cellWidth = (printableWidth - CELL_GAP * (grid.columns - 1)) / grid.columns;
+    const cellHeight = (printableHeight - CELL_GAP * (grid.rows - 1)) / grid.rows;
+    let cellIndex = 0;
+    for (let row = 0; row < grid.rows; row++) {
+      for (let col = 0; col < grid.columns; col++) {
+        const slideIdx = startSlideIndex + cellIndex;
+        cells.push({
+          slideIndex: slideIdx < totalSlides ? slideIdx : -1,
+          row,
+          col,
+          x: col * (cellWidth + CELL_GAP),
+          y: row * (cellHeight + CELL_GAP),
+          width: cellWidth,
+          height: cellHeight
+        });
+        cellIndex++;
+      }
+    }
+  }
+  return {
+    pageIndex,
+    cells,
+    hasNoteLines: isThreePerPage
+  };
+}
+function computeHandoutLayout(slideIndices, slidesPerPage, orientation = "portrait") {
+  const totalSlides = slideIndices.length;
+  if (totalSlides === 0) {
+    return [];
+  }
+  const pageDimensions = orientation === "landscape" ? A4_LANDSCAPE : A4_PORTRAIT;
+  const pageCount = computePageCount(totalSlides, slidesPerPage);
+  const pages = [];
+  for (let p = 0; p < pageCount; p++) {
+    const startSlideIndex = p * slidesPerPage;
+    const page = computePageCells(p, slidesPerPage, totalSlides, startSlideIndex, pageDimensions);
+    const remappedCells = page.cells.map((cell) => ({
+      ...cell,
+      slideIndex: cell.slideIndex >= 0 && cell.slideIndex < totalSlides ? slideIndices[cell.slideIndex] : -1
+    }));
+    pages.push({ ...page, cells: remappedCells });
+  }
+  return pages;
+}
+function getPrintableArea(orientation = "portrait") {
+  const page = orientation === "landscape" ? A4_LANDSCAPE : A4_PORTRAIT;
+  return {
+    width: page.width - page.marginLeft - page.marginRight,
+    height: page.height - page.marginTop - page.marginBottom
+  };
+}
+function generateNoteLineCount() {
+  return 8;
+}
+
+export { A4_LANDSCAPE, A4_PORTRAIT, HANDOUT_OPTIONS, computeHandoutLayout, computePageCells, computePageCount, generateNoteLineCount, getHandoutGrid, getPrintableArea, isHandoutSlidesPerPage };

package/dist/pptx/chunk-WSR2S2MY.mjs

@@ -0,0 +1,23 @@
+// src/pptx/render/presentation-print-settings.ts
+var HANDOUT_SLIDES_PER_PAGE = [1, 2, 3, 4, 6, 9];
+function printPropertiesSlidesPerPage(printProperties) {
+  const match = printProperties?.printWhat?.match(/^handouts([123469])$/u);
+  return match ? Number.parseInt(match[1], 10) : 1;
+}
+function printPropertiesFrameSlides(printProperties) {
+  return Boolean(printProperties?.frameSlides);
+}
+function nearestHandoutCount(value) {
+  return HANDOUT_SLIDES_PER_PAGE.reduce(
+    (best, candidate) => Math.abs(candidate - value) < Math.abs(best - value) ? candidate : best
+  );
+}
+function withFrameSlides(printProperties, value) {
+  return { ...printProperties ?? {}, frameSlides: value };
+}
+function withSlidesPerPage(printProperties, value) {
+  const count = nearestHandoutCount(value);
+  return { ...printProperties ?? {}, printWhat: `handouts${count}` };
+}
+
+export { printPropertiesFrameSlides, printPropertiesSlidesPerPage, withFrameSlides, withSlidesPerPage };

package/dist/pptx/chunk-WSTWYZFM.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+// src/pptx/render/layout-preview.ts
+var FALLBACK_SLIDE_WIDTH = 960;
+var FALLBACK_SLIDE_HEIGHT = 540;
+var FRAME_BORDER_PX = 1.5;
+var FALLBACK_BACKGROUND = "#ffffff";
+function buildLayoutPreviewGeometry(layout, boxWidth, boxHeight) {
+  const surfaceWidth = positive(layout?.width, FALLBACK_SLIDE_WIDTH);
+  const surfaceHeight = positive(layout?.height, FALLBACK_SLIDE_HEIGHT);
+  const scale = Math.min(boxWidth / surfaceWidth, boxHeight / surfaceHeight);
+  return {
+    boxWidth,
+    boxHeight,
+    surfaceWidth,
+    surfaceHeight,
+    scale,
+    backgroundColor: layout?.backgroundColor || FALLBACK_BACKGROUND,
+    frameBorderWidth: scale > 0 ? FRAME_BORDER_PX / scale : FRAME_BORDER_PX,
+    frames: buildLayoutPreviewFrames(layout?.placeholders)
+  };
+}
+function buildLayoutPreviewFrames(placeholders) {
+  const frames = [];
+  placeholders?.forEach((placeholder, index) => {
+    const { x, y, width, height } = placeholder;
+    if (!isFiniteNumber(x) || !isFiniteNumber(y) || !isFiniteNumber(width) || !isFiniteNumber(height) || width <= 0 || height <= 0) {
+      return;
+    }
+    frames.push({
+      key: `${placeholder.type}-${placeholder.idx ?? index}`,
+      type: placeholder.type,
+      left: x,
+      top: y,
+      width,
+      height
+    });
+  });
+  return frames;
+}
+function positive(value, fallback) {
+  return isFiniteNumber(value) && value > 0 ? value : fallback;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+exports.buildLayoutPreviewFrames = buildLayoutPreviewFrames;
+exports.buildLayoutPreviewGeometry = buildLayoutPreviewGeometry;