quicklook-pptx-renderer 0.1.0

package/dist/reader/drawing.d.ts

@@ -0,0 +1,17 @@
+import type { Drawable, Shape, Picture, Group, Connector, GraphicFrame } from "../model/types.js";
+export declare function readShape(sp: any): Shape;
+export declare function readPicture(pic: any): Picture;
+export declare function readGroup(grpSp: any): Group;
+export declare function readConnector(cxnSp: any): Connector;
+export declare function readGraphicFrame(gf: any): GraphicFrame;
+/**
+ * Recover XML document order for spTree children.
+ *
+ * fast-xml-parser groups elements by tag name, losing the interleaving order.
+ * OfficeImport uses XML document order for z-ordering. We recover it by scanning
+ * the raw XML with a regex to extract the sequence of child tag names, then
+ * pick from each tag's parsed array in that order.
+ *
+ * If rawXml is not provided, falls back to ID sort (less accurate for non-sequential IDs).
+ */
+export declare function readDrawables(spTree: any, rawXml?: string): Drawable[];

package/dist/reader/drawing.js

@@ -0,0 +1,403 @@
+import { readColor } from "./color.js";
+import { readFill } from "./fill.js";
+import { readTransform } from "./transform.js";
+import { readEffects } from "./effects.js";
+import { readTextBody } from "./text.js";
+function toArray(val) {
+    return val == null ? [] : Array.isArray(val) ? val : [val];
+}
+function toNum(val) {
+    return val == null ? undefined : Number(val);
+}
+// ── Common helpers ─────────────────────────────────
+function readNonVisual(nvPr) {
+    const cNvPr = nvPr?.cNvPr ?? {};
+    const base = {
+        id: Number(cNvPr["@_id"] ?? 0),
+        name: cNvPr["@_name"] ?? "",
+    };
+    if (cNvPr["@_descr"])
+        base.description = cNvPr["@_descr"];
+    if (cNvPr["@_hidden"] === "1" || cNvPr["@_hidden"] === "true")
+        base.hidden = true;
+    if (cNvPr.hlinkClick?.["@_id"])
+        base.hyperlink = cNvPr.hlinkClick["@_id"];
+    const ph = nvPr?.nvPr?.ph;
+    if (ph != null) {
+        const info = {};
+        if (ph["@_type"])
+            info.type = ph["@_type"];
+        if (ph["@_idx"] != null)
+            info.idx = Number(ph["@_idx"]);
+        base.placeholder = info;
+    }
+    return base;
+}
+function readLineEnd(node) {
+    if (node == null)
+        return undefined;
+    const type = node["@_type"];
+    if (!type)
+        return undefined;
+    const end = { type };
+    if (node["@_w"])
+        end.width = node["@_w"];
+    if (node["@_len"])
+        end.length = node["@_len"];
+    return end;
+}
+function readStroke(node) {
+    if (node == null)
+        return undefined;
+    const s = {};
+    if (node["@_w"] != null)
+        s.width = Number(node["@_w"]);
+    if (node["@_cap"])
+        s.cap = node["@_cap"];
+    if (node["@_cmpd"])
+        s.compound = node["@_cmpd"];
+    const fill = readFill(node);
+    if (fill)
+        s.fill = fill;
+    if (node.prstDash?.["@_val"])
+        s.dash = node.prstDash["@_val"];
+    if (node.round != null)
+        s.join = "round";
+    else if (node.bevel != null)
+        s.join = "bevel";
+    else if (node.miter != null) {
+        s.join = "miter";
+        if (node.miter["@_lim"] != null)
+            s.miterLimit = Number(node.miter["@_lim"]);
+    }
+    const head = readLineEnd(node.headEnd);
+    const tail = readLineEnd(node.tailEnd);
+    if (head)
+        s.headEnd = head;
+    if (tail)
+        s.tailEnd = tail;
+    return s;
+}
+function readGeometry(spPr) {
+    const prstGeom = spPr.prstGeom;
+    if (prstGeom == null)
+        return undefined;
+    const geom = {};
+    if (prstGeom["@_prst"])
+        geom.preset = prstGeom["@_prst"];
+    const gds = toArray(prstGeom.avLst?.gd);
+    if (gds.length) {
+        const adj = {};
+        for (const gd of gds) {
+            if (gd["@_name"] && gd["@_fmla"])
+                adj[gd["@_name"]] = gd["@_fmla"];
+        }
+        if (Object.keys(adj).length)
+            geom.adjustValues = adj;
+    }
+    return geom;
+}
+function readStyleRef(node) {
+    if (node == null)
+        return undefined;
+    const ref = { idx: Number(node["@_idx"] ?? 0) };
+    const color = readColor(node);
+    if (color)
+        ref.color = color;
+    return ref;
+}
+function readShapeStyle(style) {
+    if (style == null)
+        return undefined;
+    const ss = {};
+    const lnRef = readStyleRef(style.lnRef);
+    if (lnRef)
+        ss.lnRef = lnRef;
+    const fillRef = readStyleRef(style.fillRef);
+    if (fillRef)
+        ss.fillRef = fillRef;
+    const effectRef = readStyleRef(style.effectRef);
+    if (effectRef)
+        ss.effectRef = effectRef;
+    if (style.fontRef) {
+        const fr = {
+            idx: (style.fontRef["@_idx"] ?? "none"),
+        };
+        const color = readColor(style.fontRef);
+        if (color)
+            fr.color = color;
+        ss.fontRef = fr;
+    }
+    return ss;
+}
+// ── Shape readers ──────────────────────────────────
+export function readShape(sp) {
+    const base = readNonVisual(sp.nvSpPr);
+    const spPr = sp.spPr ?? {};
+    const shape = { ...base, drawableType: "sp" };
+    shape.bounds = readTransform(spPr.xfrm);
+    shape.geometry = readGeometry(spPr);
+    const fill = readFill(spPr);
+    if (fill)
+        shape.fill = fill;
+    const stroke = readStroke(spPr.ln);
+    if (stroke)
+        shape.stroke = stroke;
+    const effects = readEffects(spPr.effectLst);
+    if (effects.length)
+        shape.effects = effects;
+    if (sp.txBody)
+        shape.textBody = readTextBody(sp.txBody);
+    const style = readShapeStyle(sp.style);
+    if (style)
+        shape.shapeStyle = style;
+    return shape;
+}
+export function readPicture(pic) {
+    const base = readNonVisual(pic.nvPicPr);
+    const spPr = pic.spPr ?? {};
+    const p = { ...base, drawableType: "pic" };
+    p.bounds = readTransform(spPr.xfrm);
+    // blipFill
+    const bf = pic.blipFill;
+    if (bf) {
+        if (bf.blip?.["@_embed"])
+            p.blipRId = bf.blip["@_embed"];
+        const imgFill = readFill({ blipFill: bf });
+        if (imgFill)
+            p.fill = imgFill;
+    }
+    p.geometry = readGeometry(spPr);
+    // shape-level properties
+    const shapeFill = readFill(spPr);
+    const shapeStroke = readStroke(spPr.ln);
+    const shapeEffects = readEffects(spPr.effectLst);
+    if (shapeFill || shapeStroke || shapeEffects.length) {
+        p.shapeProperties = {};
+        if (shapeFill)
+            p.shapeProperties.fill = shapeFill;
+        if (shapeStroke)
+            p.shapeProperties.stroke = shapeStroke;
+        if (shapeEffects.length)
+            p.shapeProperties.effects = shapeEffects;
+    }
+    return p;
+}
+export function readGroup(grpSp) {
+    const base = readNonVisual(grpSp.nvGrpSpPr);
+    const grpSpPr = grpSp.grpSpPr ?? {};
+    const g = { ...base, drawableType: "grpSp", children: [] };
+    const xfrm = grpSpPr.xfrm;
+    if (xfrm) {
+        g.bounds = readTransform(xfrm);
+        // child offset/extent
+        const chOff = xfrm.chOff;
+        const chExt = xfrm.chExt;
+        if (chOff && chExt) {
+            g.childBounds = {
+                x: Number(chOff["@_x"] ?? 0),
+                y: Number(chOff["@_y"] ?? 0),
+                cx: Number(chExt["@_cx"] ?? 0),
+                cy: Number(chExt["@_cy"] ?? 0),
+            };
+        }
+    }
+    g.children = readChildDrawables(grpSp);
+    return g;
+}
+export function readConnector(cxnSp) {
+    const base = readNonVisual(cxnSp.nvCxnSpPr);
+    const spPr = cxnSp.spPr ?? {};
+    const c = { ...base, drawableType: "cxnSp" };
+    c.bounds = readTransform(spPr.xfrm);
+    c.geometry = readGeometry(spPr);
+    const fill = readFill(spPr);
+    if (fill)
+        c.fill = fill;
+    const stroke = readStroke(spPr.ln);
+    if (stroke)
+        c.stroke = stroke;
+    return c;
+}
+export function readGraphicFrame(gf) {
+    const base = readNonVisual(gf.nvGraphicFramePr);
+    const f = { ...base, drawableType: "graphicFrame" };
+    f.bounds = readTransform(gf.xfrm);
+    const graphicData = gf.graphic?.graphicData;
+    // chart relationship
+    const chart = graphicData?.chart;
+    if (chart?.["@_id"])
+        f.chartRId = chart["@_id"];
+    // SmartArt/diagram relationship
+    const relIds = graphicData?.relIds;
+    if (relIds?.["@_dm"])
+        f.smartArtRId = relIds["@_dm"];
+    // OLE object
+    const oleObj = graphicData?.oleObj;
+    if (oleObj?.["@_id"])
+        f.oleRId = oleObj["@_id"];
+    // table
+    const tbl = graphicData?.tbl;
+    if (tbl)
+        f.tableData = readTable(tbl);
+    return f;
+}
+function readTable(tbl) {
+    const gridCols = toArray(tbl.tblGrid?.gridCol).map((gc) => Number(gc["@_w"] ?? 0));
+    const tblPr = tbl.tblPr;
+    const props = tblPr ? {
+        firstRow: tblPr["@_firstRow"] === "1",
+        lastRow: tblPr["@_lastRow"] === "1",
+        bandRow: tblPr["@_bandRow"] === "1",
+        bandCol: tblPr["@_bandCol"] === "1",
+    } : undefined;
+    const rows = toArray(tbl.tr).map((tr) => {
+        const height = Number(tr["@_h"] ?? 0);
+        const cells = toArray(tr.tc).map((tc) => {
+            const cell = {};
+            if (tc.txBody)
+                cell.textBody = readTextBody(tc.txBody);
+            // gridSpan, hMerge, vMerge are attributes of <a:tc>, not <a:tcPr>
+            if (tc["@_gridSpan"] != null)
+                cell.gridSpan = Number(tc["@_gridSpan"]);
+            if (tc["@_rowSpan"] != null)
+                cell.rowSpan = Number(tc["@_rowSpan"]);
+            if (tc["@_hMerge"] === "1")
+                cell.hMerge = true;
+            if (tc["@_vMerge"] === "1")
+                cell.vMerge = true;
+            const tcPr = tc.tcPr;
+            if (tcPr) {
+                const fill = readFill(tcPr);
+                if (fill)
+                    cell.fill = fill;
+                const borders = {};
+                let hasBorder = false;
+                for (const side of ["left", "right", "top", "bottom"]) {
+                    const tag = side === "left" ? "lnL" : side === "right" ? "lnR" : side === "top" ? "lnT" : "lnB";
+                    const ln = tcPr[tag];
+                    if (ln) {
+                        borders[side] = readStroke(ln);
+                        hasBorder = true;
+                    }
+                }
+                if (hasBorder)
+                    cell.borders = borders;
+                if (tcPr["@_anchor"])
+                    cell.anchor = tcPr["@_anchor"];
+            }
+            return cell;
+        });
+        return { height, cells };
+    });
+    const td = { rows, gridCols };
+    if (props)
+        td.properties = props;
+    const styleId = tblPr?.tableStyleId;
+    if (styleId)
+        td.tableStyleId = String(styleId);
+    return td;
+}
+// ── Tree reader ────────────────────────────────────
+function readChildDrawables(parent) {
+    const drawables = [];
+    for (const sp of toArray(parent.sp))
+        drawables.push(readShape(sp));
+    for (const pic of toArray(parent.pic))
+        drawables.push(readPicture(pic));
+    for (const grp of toArray(parent.grpSp))
+        drawables.push(readGroup(grp));
+    for (const cxn of toArray(parent.cxnSp))
+        drawables.push(readConnector(cxn));
+    for (const gf of toArray(parent.graphicFrame))
+        drawables.push(readGraphicFrame(gf));
+    // mc:AlternateContent: extract drawables from Fallback child (Choice requires features
+    // the reader may not support, e.g. chart rendering). OfficeImport uses the fallback
+    // which typically contains a pre-rendered image (<p:pic>) or simplified shape.
+    for (const ac of toArray(parent.AlternateContent)) {
+        const fallback = ac.Fallback ?? ac.Choice;
+        if (fallback) {
+            const fallbackDrawables = readChildDrawables(fallback);
+            drawables.push(...fallbackDrawables);
+        }
+    }
+    return drawables;
+}
+/**
+ * Recover XML document order for spTree children.
+ *
+ * fast-xml-parser groups elements by tag name, losing the interleaving order.
+ * OfficeImport uses XML document order for z-ordering. We recover it by scanning
+ * the raw XML with a regex to extract the sequence of child tag names, then
+ * pick from each tag's parsed array in that order.
+ *
+ * If rawXml is not provided, falls back to ID sort (less accurate for non-sequential IDs).
+ */
+export function readDrawables(spTree, rawXml) {
+    if (spTree == null)
+        return [];
+    const drawables = readChildDrawables(spTree);
+    if (rawXml) {
+        return reorderByXml(drawables, rawXml);
+    }
+    // Fallback: sort by ID (works when IDs are sequential)
+    drawables.sort((a, b) => a.id - b.id);
+    return drawables;
+}
+const DRAWABLE_TAGS = new Set(["sp", "pic", "grpSp", "cxnSp", "graphicFrame"]);
+function reorderByXml(drawables, rawXml) {
+    // Extract the tag order from spTree children in the raw XML.
+    // Match opening tags: <p:sp, <p:pic, <p:grpSp, <p:cxnSp, <p:graphicFrame
+    // Also match without namespace prefix (after removeNSPrefix processing, but raw XML has them).
+    const tagOrder = [];
+    const tagRegex = /<(?:p:|wsp:)?(?:mc:)?(?:AlternateContent|sp|pic|grpSp|cxnSp|graphicFrame)\b/g;
+    let m;
+    // Find the spTree region in the raw XML
+    const spTreeStart = rawXml.indexOf("<p:spTree");
+    const spTreeEnd = rawXml.indexOf("</p:spTree>");
+    if (spTreeStart === -1 || spTreeEnd === -1) {
+        drawables.sort((a, b) => a.id - b.id);
+        return drawables;
+    }
+    const spTreeXml = rawXml.substring(spTreeStart, spTreeEnd);
+    // Track nesting depth to only capture direct children of spTree
+    // Simple approach: just capture all tag names in order and skip non-drawable tags
+    while ((m = tagRegex.exec(spTreeXml)) !== null) {
+        const tag = m[0];
+        // Extract tag name after prefix
+        const nameMatch = tag.match(/(?:p:|wsp:)?(sp|pic|grpSp|cxnSp|graphicFrame|AlternateContent)$/);
+        if (nameMatch && DRAWABLE_TAGS.has(nameMatch[1])) {
+            tagOrder.push(nameMatch[1]);
+        }
+    }
+    // Build per-tag queues from the drawables array
+    const queues = new Map();
+    for (const d of drawables) {
+        const tag = d.drawableType === "grpSp" ? "grpSp" : d.drawableType;
+        const q = queues.get(tag) ?? [];
+        q.push(d);
+        queues.set(tag, q);
+    }
+    // Per-tag index pointers
+    const ptrs = new Map();
+    for (const [tag] of queues)
+        ptrs.set(tag, 0);
+    // Rebuild in XML document order
+    const ordered = [];
+    for (const tag of tagOrder) {
+        const q = queues.get(tag);
+        const ptr = ptrs.get(tag) ?? 0;
+        if (q && ptr < q.length) {
+            ordered.push(q[ptr]);
+            ptrs.set(tag, ptr + 1);
+        }
+    }
+    // Append any remaining drawables not matched (safety net)
+    for (const [tag, q] of queues) {
+        const ptr = ptrs.get(tag) ?? 0;
+        for (let i = ptr; i < q.length; i++) {
+            ordered.push(q[i]);
+        }
+    }
+    return ordered;
+}

package/dist/reader/effects.d.ts

@@ -0,0 +1,2 @@
+import type { Effect } from "../model/types.js";
+export declare function readEffects(effectLst: any): Effect[];

package/dist/reader/effects.js

@@ -0,0 +1,83 @@
+import { readColor } from "./color.js";
+function toBool(val) {
+    if (val == null)
+        return undefined;
+    return val === "1" || val === "true";
+}
+function toNum(val) {
+    return val == null ? undefined : Number(val);
+}
+function readOuterShadow(node) {
+    const e = { type: "outerShdw" };
+    e.blurRad = toNum(node["@_blurRad"]);
+    e.dist = toNum(node["@_dist"]);
+    e.dir = toNum(node["@_dir"]);
+    e.sx = toNum(node["@_sx"]);
+    e.sy = toNum(node["@_sy"]);
+    e.kx = toNum(node["@_kx"]);
+    e.ky = toNum(node["@_ky"]);
+    if (node["@_algn"])
+        e.algn = node["@_algn"];
+    e.rotWithShape = toBool(node["@_rotWithShape"]);
+    const color = readColor(node);
+    if (color)
+        e.color = color;
+    return e;
+}
+function readInnerShadow(node) {
+    const e = { type: "innerShdw" };
+    e.blurRad = toNum(node["@_blurRad"]);
+    e.dist = toNum(node["@_dist"]);
+    e.dir = toNum(node["@_dir"]);
+    const color = readColor(node);
+    if (color)
+        e.color = color;
+    return e;
+}
+function readGlow(node) {
+    const e = { type: "glow" };
+    e.rad = toNum(node["@_rad"]);
+    const color = readColor(node);
+    if (color)
+        e.color = color;
+    return e;
+}
+function readReflection(node) {
+    const e = { type: "reflection" };
+    e.blurRad = toNum(node["@_blurRad"]);
+    e.stA = toNum(node["@_stA"]);
+    e.endA = toNum(node["@_endA"]);
+    e.dist = toNum(node["@_dist"]);
+    e.dir = toNum(node["@_dir"]);
+    e.fadeDir = toNum(node["@_fadeDir"]);
+    e.sx = toNum(node["@_sx"]);
+    e.sy = toNum(node["@_sy"]);
+    e.kx = toNum(node["@_kx"]);
+    e.ky = toNum(node["@_ky"]);
+    if (node["@_algn"])
+        e.algn = node["@_algn"];
+    e.rotWithShape = toBool(node["@_rotWithShape"]);
+    return e;
+}
+function readBlur(node) {
+    const e = { type: "blur" };
+    e.rad = toNum(node["@_rad"]);
+    e.grow = toBool(node["@_grow"]);
+    return e;
+}
+export function readEffects(effectLst) {
+    if (effectLst == null)
+        return [];
+    const effects = [];
+    if (effectLst.outerShdw)
+        effects.push(readOuterShadow(effectLst.outerShdw));
+    if (effectLst.innerShdw)
+        effects.push(readInnerShadow(effectLst.innerShdw));
+    if (effectLst.glow)
+        effects.push(readGlow(effectLst.glow));
+    if (effectLst.reflection)
+        effects.push(readReflection(effectLst.reflection));
+    if (effectLst.blur)
+        effects.push(readBlur(effectLst.blur));
+    return effects;
+}

package/dist/reader/fill.d.ts

@@ -0,0 +1,2 @@
+import type { Fill } from "../model/types.js";
+export declare function readFill(node: any): Fill | undefined;

package/dist/reader/fill.js

@@ -0,0 +1,94 @@
+import { readColor } from "./color.js";
+function toArray(val) {
+    return val == null ? [] : Array.isArray(val) ? val : [val];
+}
+function readRelativeRect(node) {
+    if (node == null)
+        return undefined;
+    const r = {};
+    if (node["@_l"] != null)
+        r.l = Number(node["@_l"]);
+    if (node["@_t"] != null)
+        r.t = Number(node["@_t"]);
+    if (node["@_r"] != null)
+        r.r = Number(node["@_r"]);
+    if (node["@_b"] != null)
+        r.b = Number(node["@_b"]);
+    return r;
+}
+function readSolidFill(node) {
+    const color = readColor(node);
+    return color ? { type: "solid", color } : undefined;
+}
+function readGradientFill(node) {
+    const stops = toArray(node.gsLst?.gs).map((gs) => ({
+        position: Number(gs["@_pos"] ?? 0),
+        color: readColor(gs),
+    })).filter((s) => s.color);
+    const fill = { type: "gradient", stops };
+    if (node.lin) {
+        fill.linear = {
+            angle: Number(node.lin["@_ang"] ?? 5400000),
+            scaled: node.lin["@_scaled"] === "1" || node.lin["@_scaled"] === "true",
+        };
+    }
+    if (node.path) {
+        fill.path = {
+            type: node.path["@_path"] ?? "shape",
+            fillToRect: readRelativeRect(node.path.fillToRect),
+        };
+    }
+    if (node["@_rotWithShape"] != null) {
+        fill.rotateWithShape = node["@_rotWithShape"] === "1" || node["@_rotWithShape"] === "true";
+    }
+    return fill;
+}
+function readImageFill(node) {
+    const fill = { type: "image" };
+    if (node.blip?.["@_embed"])
+        fill.blipRId = node.blip["@_embed"];
+    if (node.stretch) {
+        fill.stretch = { fillRect: readRelativeRect(node.stretch.fillRect) };
+    }
+    if (node.tile) {
+        const t = node.tile;
+        fill.tile = {
+            tx: Number(t["@_tx"] ?? 0),
+            ty: Number(t["@_ty"] ?? 0),
+            sx: Number(t["@_sx"] ?? 100000),
+            sy: Number(t["@_sy"] ?? 100000),
+        };
+        if (t["@_flip"])
+            fill.tile.flip = t["@_flip"];
+        if (t["@_algn"])
+            fill.tile.algn = t["@_algn"];
+    }
+    return fill;
+}
+function readPatternFill(node) {
+    const fill = { type: "pattern", preset: node["@_prst"] ?? "solid" };
+    const fg = readColor(node.fgClr);
+    const bg = readColor(node.bgClr);
+    if (fg)
+        fill.foreground = fg;
+    if (bg)
+        fill.background = bg;
+    return fill;
+}
+export function readFill(node) {
+    if (node == null)
+        return undefined;
+    if (node.solidFill)
+        return readSolidFill(node.solidFill);
+    if (node.gradFill)
+        return readGradientFill(node.gradFill);
+    if (node.blipFill)
+        return readImageFill(node.blipFill);
+    if (node.pattFill)
+        return readPatternFill(node.pattFill);
+    if (node.noFill != null)
+        return { type: "noFill" };
+    if (node.grpFill != null)
+        return { type: "grpFill" };
+    return undefined;
+}

package/dist/reader/presentation.d.ts

@@ -0,0 +1,5 @@
+import type { Presentation } from "../model/types.js";
+import type { PptxPackage } from "../package/package.js";
+import { readTextListStyle } from "./text-list-style.js";
+export { readTextListStyle };
+export declare function readPresentation(pkg: PptxPackage): Promise<Presentation>;