quicklook-pptx-renderer 0.1.0

package/dist/model/types.d.ts

@@ -0,0 +1,482 @@
+import type { SchemeColorName, ColorMapIndex, ColorTransformType, PresetGeometry, TextAlignment, TextAnchorType, WrapType, FlowType, TextAutoFitType, UnderlineType, StrikeThroughType, CapsType, DashType, LineCapType, LineJoinType, CompoundType, LineEndType, LineEndSize, FontReferenceIndex, PlaceholderType, SlideLayoutType, BulletType, AutoNumberScheme, PatternType, ShadowAlignment } from "./enums.js";
+export interface Presentation {
+    slides: Slide[];
+    slideMasters: SlideMaster[];
+    slideSize: Size;
+    notesSize: Size;
+    defaultTextStyle?: TextListStyle;
+}
+export interface SlideBase {
+    name?: string;
+    background?: Background;
+    drawables: Drawable[];
+}
+export interface SlideMaster extends SlideBase {
+    theme: Theme;
+    colorMap: ColorMap;
+    slideLayouts: SlideLayout[];
+    bodyTextStyle?: TextListStyle;
+    titleTextStyle?: TextListStyle;
+    otherTextStyle?: TextListStyle;
+}
+export interface SlideLayout extends SlideBase {
+    slideMaster: SlideMaster;
+    layoutType?: SlideLayoutType;
+    colorMapOverride?: ColorMap;
+}
+export interface Slide extends SlideBase {
+    slideLayout: SlideLayout;
+    colorMapOverride?: ColorMap;
+}
+export interface Theme {
+    name: string;
+    colorScheme: ColorScheme;
+    fontScheme: FontScheme;
+    styleMatrix: StyleMatrix;
+}
+export interface ColorScheme {
+    name: string;
+    colors: Record<string, Color>;
+}
+export interface ColorMap {
+    mappings: Record<ColorMapIndex, SchemeColorName>;
+}
+export interface FontScheme {
+    name: string;
+    majorFont: FontCollection;
+    minorFont: FontCollection;
+}
+export interface FontCollection {
+    latin: string;
+    eastAsian: string;
+    complexScript: string;
+    scriptFonts: Record<string, string>;
+}
+export interface StyleMatrix {
+    fillStyles: Fill[];
+    lineStyles: Stroke[];
+    effectStyles: Effect[][];
+    bgFillStyles: Fill[];
+}
+export type Color = RgbColor | SchemeColor | SystemColor | HslColor | PresetColor | ScRgbColor;
+export interface RgbColor {
+    type: "rgb";
+    r: number;
+    g: number;
+    b: number;
+    transforms?: ColorTransform[];
+}
+export interface SchemeColor {
+    type: "scheme";
+    val: SchemeColorName;
+    transforms?: ColorTransform[];
+}
+export interface SystemColor {
+    type: "system";
+    val: string;
+    lastClr?: string;
+    transforms?: ColorTransform[];
+}
+export interface HslColor {
+    type: "hsl";
+    hue: number;
+    sat: number;
+    lum: number;
+    transforms?: ColorTransform[];
+}
+export interface PresetColor {
+    type: "preset";
+    val: string;
+    transforms?: ColorTransform[];
+}
+export interface ScRgbColor {
+    type: "scRgb";
+    r: number;
+    g: number;
+    b: number;
+    transforms?: ColorTransform[];
+}
+export interface ColorTransform {
+    type: ColorTransformType;
+    val?: number;
+}
+export type Fill = SolidFill | GradientFill | ImageFill | PatternFill | NullFill | GroupFill | BackgroundFill;
+export interface SolidFill {
+    type: "solid";
+    color: Color;
+}
+export interface GradientFill {
+    type: "gradient";
+    stops: GradientStop[];
+    linear?: {
+        angle: number;
+        scaled: boolean;
+    };
+    path?: {
+        type: "circle" | "rect" | "shape";
+        fillToRect?: RelativeRect;
+    };
+    rotateWithShape?: boolean;
+}
+export interface GradientStop {
+    position: number;
+    color: Color;
+}
+export interface ImageFill {
+    type: "image";
+    blipRId?: string;
+    blipData?: Buffer;
+    stretch?: {
+        fillRect?: RelativeRect;
+    };
+    tile?: {
+        tx: number;
+        ty: number;
+        sx: number;
+        sy: number;
+        flip?: string;
+        algn?: string;
+    };
+}
+export interface PatternFill {
+    type: "pattern";
+    preset: PatternType;
+    foreground?: Color;
+    background?: Color;
+}
+export interface NullFill {
+    type: "noFill";
+}
+export interface GroupFill {
+    type: "grpFill";
+}
+export interface BackgroundFill {
+    type: "bgFill";
+}
+export interface Stroke {
+    width?: number;
+    fill?: Fill;
+    dash?: DashType;
+    cap?: LineCapType;
+    join?: LineJoinType;
+    miterLimit?: number;
+    compound?: CompoundType;
+    headEnd?: LineEnd;
+    tailEnd?: LineEnd;
+}
+export interface LineEnd {
+    type: LineEndType;
+    width?: LineEndSize;
+    length?: LineEndSize;
+}
+export type Effect = OuterShadow | InnerShadow | Glow | Reflection | Blur;
+export interface OuterShadow {
+    type: "outerShdw";
+    blurRad?: number;
+    dist?: number;
+    dir?: number;
+    sx?: number;
+    sy?: number;
+    kx?: number;
+    ky?: number;
+    algn?: ShadowAlignment;
+    rotWithShape?: boolean;
+    color?: Color;
+}
+export interface InnerShadow {
+    type: "innerShdw";
+    blurRad?: number;
+    dist?: number;
+    dir?: number;
+    color?: Color;
+}
+export interface Glow {
+    type: "glow";
+    rad?: number;
+    color?: Color;
+}
+export interface Reflection {
+    type: "reflection";
+    blurRad?: number;
+    stA?: number;
+    endA?: number;
+    dist?: number;
+    dir?: number;
+    fadeDir?: number;
+    sx?: number;
+    sy?: number;
+    kx?: number;
+    ky?: number;
+    algn?: string;
+    rotWithShape?: boolean;
+}
+export interface Blur {
+    type: "blur";
+    rad?: number;
+    grow?: boolean;
+}
+export type Drawable = Shape | Picture | Group | Connector | GraphicFrame;
+export interface DrawableBase {
+    id: number;
+    name: string;
+    description?: string;
+    hidden?: boolean;
+    placeholder?: PlaceholderInfo;
+    hyperlink?: string;
+}
+export interface PlaceholderInfo {
+    type?: PlaceholderType;
+    idx?: number;
+}
+export interface OrientedBounds {
+    x: number;
+    y: number;
+    cx: number;
+    cy: number;
+    rot?: number;
+    flipH?: boolean;
+    flipV?: boolean;
+}
+export interface Shape extends DrawableBase {
+    drawableType: "sp";
+    bounds?: OrientedBounds;
+    geometry?: ShapeGeometry;
+    fill?: Fill;
+    stroke?: Stroke;
+    effects?: Effect[];
+    textBody?: TextBody;
+    shapeStyle?: ShapeStyle;
+}
+export interface Picture extends DrawableBase {
+    drawableType: "pic";
+    bounds?: OrientedBounds;
+    blipRId?: string;
+    blipData?: Buffer;
+    fill?: Fill;
+    geometry?: ShapeGeometry;
+    shapeProperties?: {
+        fill?: Fill;
+        stroke?: Stroke;
+        effects?: Effect[];
+    };
+}
+export interface Group extends DrawableBase {
+    drawableType: "grpSp";
+    bounds?: OrientedBounds;
+    childBounds?: OrientedBounds;
+    children: Drawable[];
+}
+export interface Connector extends DrawableBase {
+    drawableType: "cxnSp";
+    bounds?: OrientedBounds;
+    geometry?: ShapeGeometry;
+    stroke?: Stroke;
+    fill?: Fill;
+}
+export interface GraphicFrame extends DrawableBase {
+    drawableType: "graphicFrame";
+    bounds?: OrientedBounds;
+    chartRId?: string;
+    smartArtRId?: string;
+    oleRId?: string;
+    fallbackImageData?: Buffer;
+    chartData?: ChartData;
+    tableData?: TableData;
+}
+export interface ChartSeries {
+    name: string;
+    values: number[];
+}
+export interface ChartData {
+    type: "bar" | "line" | "pie" | "area" | "scatter";
+    direction?: "col" | "bar";
+    grouping?: string;
+    categories: string[];
+    series: ChartSeries[];
+    legendPos?: "r" | "l" | "t" | "b" | "tr";
+}
+export interface ShapeGeometry {
+    preset?: PresetGeometry;
+    adjustValues?: Record<string, string>;
+}
+export interface ShapeStyle {
+    fillRef?: StyleMatrixReference;
+    lnRef?: StyleMatrixReference;
+    effectRef?: StyleMatrixReference;
+    fontRef?: FontReference;
+}
+export interface StyleMatrixReference {
+    idx: number;
+    color?: Color;
+}
+export interface FontReference {
+    idx: FontReferenceIndex;
+    color?: Color;
+}
+export interface TextBody {
+    paragraphs: Paragraph[];
+    properties?: TextBodyProperties;
+    listStyle?: TextListStyle;
+}
+export interface TextBodyProperties {
+    wrap?: WrapType;
+    lIns?: number;
+    tIns?: number;
+    rIns?: number;
+    bIns?: number;
+    anchor?: TextAnchorType;
+    anchorCtr?: boolean;
+    rtlCol?: boolean;
+    autoFit?: TextAutoFitType;
+    fontScale?: number;
+    lnSpcReduction?: number;
+    numCol?: number;
+    spcCol?: number;
+    rot?: number;
+    vert?: FlowType;
+}
+export interface TextListStyle {
+    levels: (ParagraphProperties | undefined)[];
+}
+export interface Paragraph {
+    runs: TextRun[];
+    properties?: ParagraphProperties;
+    endParaRPr?: CharacterProperties;
+}
+export type TextRun = RegularRun | LineBreak | TextField;
+export interface RegularRun {
+    type: "r";
+    text: string;
+    properties?: CharacterProperties;
+}
+export interface LineBreak {
+    type: "br";
+    properties?: CharacterProperties;
+}
+export interface TextField {
+    type: "fld";
+    fieldType?: string;
+    text: string;
+    properties?: CharacterProperties;
+}
+export interface CharacterProperties {
+    latinFont?: string;
+    eastAsianFont?: string;
+    complexScriptFont?: string;
+    hAnsiFont?: string;
+    symbolFont?: string;
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    fill?: Fill;
+    stroke?: Stroke;
+    spacing?: number;
+    kerning?: number;
+    underline?: UnderlineType;
+    underlineFill?: Fill;
+    strikethrough?: StrikeThroughType;
+    caps?: CapsType;
+    baseline?: number;
+    highlight?: Color;
+    effects?: Effect[];
+    hyperlink?: string;
+    lang?: string;
+    opacity?: number;
+    dirty?: boolean;
+}
+export interface ParagraphProperties extends CharacterProperties {
+    level?: number;
+    align?: TextAlignment;
+    marL?: number;
+    marR?: number;
+    indent?: number;
+    lineSpacing?: TextSpacing;
+    spaceBefore?: TextSpacing;
+    spaceAfter?: TextSpacing;
+    bullet?: BulletProperties;
+    bulletColor?: Color;
+    bulletFont?: string;
+    bulletSizePercent?: number;
+    bulletSizePoints?: number;
+    defTabSz?: number;
+    rtl?: boolean;
+}
+export interface TextSpacing {
+    type: "pct" | "pts";
+    val: number;
+}
+export interface BulletProperties {
+    type: BulletType;
+    char?: string;
+    autoNumScheme?: AutoNumberScheme;
+    startAt?: number;
+    blipRId?: string;
+}
+export interface Background {
+    fill?: Fill;
+    shadeToTitle?: boolean;
+}
+export interface TableData {
+    rows: TableRow[];
+    gridCols: number[];
+    properties?: {
+        firstRow?: boolean;
+        lastRow?: boolean;
+        bandRow?: boolean;
+        bandCol?: boolean;
+    };
+    tableStyleId?: string;
+}
+export interface TableRow {
+    height: number;
+    cells: TableCell[];
+}
+export interface TableCell {
+    textBody?: TextBody;
+    fill?: Fill;
+    borders?: {
+        left?: Stroke;
+        right?: Stroke;
+        top?: Stroke;
+        bottom?: Stroke;
+    };
+    gridSpan?: number;
+    rowSpan?: number;
+    hMerge?: boolean;
+    vMerge?: boolean;
+    anchor?: string;
+}
+export interface Size {
+    cx: number;
+    cy: number;
+}
+export interface RelativeRect {
+    l?: number;
+    t?: number;
+    r?: number;
+    b?: number;
+}
+export interface BleedEntry {
+    /** The <img> style value (position:absolute; top:...; ...) */
+    style: string;
+    /** Insert after this many own elements (0-indexed count) */
+    afterOwnElement: number;
+}
+export interface BleedRemoval {
+    pos: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    /** Element type that was replaced */
+    type: "img" | "div" | "table" | "other";
+}
+export interface QLBleedData {
+    /** Bleed entries per slide (0-indexed) — elements to ADD */
+    entries: Map<number, BleedEntry[]>;
+    /** Own elements per slide that were replaced by bleed — elements to REMOVE */
+    removals: Map<number, BleedRemoval[]>;
+    /** PDF buffers keyed by the style string (unique identifier) */
+    pdfs: Map<string, Buffer>;
+}

package/dist/model/types.js

@@ -0,0 +1,7 @@
+// Domain model — mirrors Apple's OAD*/PD* class hierarchy from OfficeImport.framework
+// All measurements in OOXML native units unless noted:
+//   positions/sizes: EMU (914400 EMU = 1 inch)
+//   font sizes: hundredths of a point (1800 = 18pt)
+//   angles: 60000ths of a degree (5400000 = 90°)
+//   color transform values: 1000ths of a percent (100000 = 100%)
+export {};

package/dist/package/content-types.d.ts

@@ -0,0 +1 @@
+export declare function parseContentTypes(_xml: string): Map<string, string>;

package/dist/package/content-types.js

@@ -0,0 +1,4 @@
+// Stub — will be fleshed out when needed.
+export function parseContentTypes(_xml) {
+    return new Map();
+}

package/dist/package/package.d.ts

@@ -0,0 +1,10 @@
+import { type Relationship } from "./relationships.js";
+export declare class PptxPackage {
+    private zip;
+    private constructor();
+    static open(data: Buffer | ArrayBuffer): Promise<PptxPackage>;
+    getPartXml(path: string): Promise<any>;
+    getPartBuffer(path: string): Promise<Buffer | null>;
+    getRelationships(partPath: string): Promise<Map<string, Relationship>>;
+    resolveRelTarget(partPath: string, relTarget: string): string;
+}

package/dist/package/package.js

@@ -0,0 +1,52 @@
+import { XMLParser } from "fast-xml-parser";
+import { openZip } from "./zip.js";
+import { parseRelationships } from "./relationships.js";
+import { posix } from "node:path";
+const ARRAY_ELEMENTS = new Set([
+    "sldId", "sldMasterId", "notesMasterId",
+    "sp", "pic", "grpSp", "cxnSp", "graphicFrame",
+    "AlternateContent",
+    "p", "r", "br", "fld",
+    "tr", "tc", "gridCol",
+    "gs", "gd", "font",
+    "effectStyle",
+    "Relationship", "Default", "Override",
+]);
+const xmlParser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    removeNSPrefix: true,
+    parseTagValue: false, // Don't coerce "04" → 4
+    parseAttributeValue: false, // Don't coerce attribute values
+    trimValues: false, // Preserve whitespace in text
+    isArray: (name) => ARRAY_ELEMENTS.has(name),
+});
+export class PptxPackage {
+    zip;
+    constructor(zip) {
+        this.zip = zip;
+    }
+    static async open(data) {
+        return new PptxPackage(await openZip(data));
+    }
+    async getPartXml(path) {
+        const xml = await this.zip.getText(path);
+        return xml ? xmlParser.parse(xml) : null;
+    }
+    async getPartBuffer(path) {
+        return this.zip.getBuffer(path);
+    }
+    async getRelationships(partPath) {
+        const dir = posix.dirname(partPath);
+        const base = posix.basename(partPath);
+        const relsPath = `${dir}/_rels/${base}.rels`;
+        const xml = await this.zip.getText(relsPath);
+        return xml ? parseRelationships(xml) : new Map();
+    }
+    resolveRelTarget(partPath, relTarget) {
+        if (relTarget.startsWith("/"))
+            return relTarget.slice(1);
+        const dir = posix.dirname(partPath);
+        return posix.normalize(`${dir}/${relTarget}`);
+    }
+}

package/dist/package/relationships.d.ts

@@ -0,0 +1,6 @@
+export interface Relationship {
+    id: string;
+    type: string;
+    target: string;
+}
+export declare function parseRelationships(xml: string): Map<string, Relationship>;

package/dist/package/relationships.js

@@ -0,0 +1,25 @@
+import { XMLParser } from "fast-xml-parser";
+const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    isArray: (name) => name === "Relationship",
+});
+function shortType(typeUrl) {
+    const last = typeUrl.split("/").pop() ?? typeUrl;
+    // handle camelCase names like "slideLayout" directly
+    return last;
+}
+export function parseRelationships(xml) {
+    const doc = parser.parse(xml);
+    const rels = doc?.Relationships?.Relationship ?? [];
+    const map = new Map();
+    for (const r of rels) {
+        const rel = {
+            id: r["@_Id"],
+            type: shortType(r["@_Type"]),
+            target: r["@_Target"],
+        };
+        map.set(rel.id, rel);
+    }
+    return map;
+}

package/dist/package/zip.d.ts

@@ -0,0 +1,6 @@
+export interface ZipPackage {
+    getText(path: string): Promise<string | null>;
+    getBuffer(path: string): Promise<Buffer | null>;
+    paths(): string[];
+}
+export declare function openZip(data: Buffer | ArrayBuffer): Promise<ZipPackage>;

package/dist/package/zip.js

@@ -0,0 +1,17 @@
+import JSZip from "jszip";
+export async function openZip(data) {
+    const zip = await JSZip.loadAsync(data);
+    return {
+        async getText(path) {
+            const file = zip.file(path);
+            return file ? file.async("string") : null;
+        },
+        async getBuffer(path) {
+            const file = zip.file(path);
+            return file ? Buffer.from(await file.async("arraybuffer")) : null;
+        },
+        paths() {
+            return Object.keys(zip.files).filter((p) => !zip.files[p].dir);
+        },
+    };
+}

package/dist/reader/color.d.ts

@@ -0,0 +1,3 @@
+import type { Color, ColorTransform } from "../model/types.js";
+export declare function readColorTransforms(node: any): ColorTransform[];
+export declare function readColor(node: any): Color | undefined;

package/dist/reader/color.js

@@ -0,0 +1,79 @@
+function toArray(val) {
+    return val == null ? [] : Array.isArray(val) ? val : [val];
+}
+const TRANSFORM_NAMES = [
+    "tint", "shade", "comp", "inv", "gray",
+    "alpha", "alphaOff", "alphaMod",
+    "hue", "hueOff", "hueMod",
+    "sat", "satOff", "satMod",
+    "lum", "lumOff", "lumMod",
+    "red", "redOff", "redMod",
+    "green", "greenOff", "greenMod",
+    "blue", "blueOff", "blueMod",
+];
+export function readColorTransforms(node) {
+    const transforms = [];
+    for (const name of TRANSFORM_NAMES) {
+        const el = node[name];
+        if (el == null)
+            continue;
+        const t = { type: name };
+        if (el["@_val"] != null)
+            t.val = Number(el["@_val"]);
+        transforms.push(t);
+    }
+    return transforms;
+}
+function withTransforms(color, node) {
+    const t = readColorTransforms(node);
+    if (t.length)
+        color.transforms = t;
+    return color;
+}
+function parseHex(hex) {
+    const n = parseInt(hex, 16);
+    return { r: (n >> 16) & 0xff, g: (n >> 8) & 0xff, b: n & 0xff };
+}
+export function readColor(node) {
+    if (node == null)
+        return undefined;
+    if (node.srgbClr) {
+        const c = node.srgbClr;
+        const { r, g, b } = parseHex(c["@_val"]);
+        return withTransforms({ type: "rgb", r, g, b }, c);
+    }
+    if (node.schemeClr) {
+        const c = node.schemeClr;
+        return withTransforms({ type: "scheme", val: c["@_val"] }, c);
+    }
+    if (node.sysClr) {
+        const c = node.sysClr;
+        const color = { type: "system", val: c["@_val"] };
+        if (c["@_lastClr"])
+            color.lastClr = c["@_lastClr"];
+        return withTransforms(color, c);
+    }
+    if (node.hslClr) {
+        const c = node.hslClr;
+        return withTransforms({
+            type: "hsl",
+            hue: Number(c["@_hue"]),
+            sat: Number(c["@_sat"]),
+            lum: Number(c["@_lum"]),
+        }, c);
+    }
+    if (node.prstClr) {
+        const c = node.prstClr;
+        return withTransforms({ type: "preset", val: c["@_val"] }, c);
+    }
+    if (node.scrgbClr ?? node.scRgbClr) {
+        const c = node.scrgbClr ?? node.scRgbClr;
+        return withTransforms({
+            type: "scRgb",
+            r: Number(c["@_r"]),
+            g: Number(c["@_g"]),
+            b: Number(c["@_b"]),
+        }, c);
+    }
+    return undefined;
+}