@shbernal/ts-pptx 0.0.1

package/dist/package-CaOLXSNi.d.ts

@@ -0,0 +1,193 @@
+import { Document, Element } from "@xmldom/xmldom";
+//#region src/read/opc/content-types.d.ts
+/**
+ * Overlay over `[Content_Types].xml`, used to resolve part content types at
+ * load and to register new ones when parts are added. While clean, the original
+ * bytes pass through verbatim on save (byte-identical); once a mutation marks it
+ * dirty, `OpcPackage.save()` writes `serialize()` instead.
+ */
+declare class ContentTypes {
+  #private;
+  static parse(xml: string): ContentTypes;
+  /** Exact `Override` match first, else `Default` by lowercased extension. */
+  contentTypeFor(partName: string): string | undefined;
+  /** True once a registration changed the overlay; `serialize()` is then authoritative. */
+  get isDirty(): boolean;
+  /**
+   * Ensure `partName` resolves to `contentType`, adding the minimum needed.
+   * A no-op when an existing `Default`/`Override` already resolves it to the
+   * same type; otherwise an `Override` is added (always valid, never conflicts
+   * with a differing `Default`).
+   */
+  ensureRegistered(partName: string, contentType: string): void;
+  /**
+   * Drop the `Override` for `partName` if present (e.g. when a part is removed).
+   * `Default` rules by extension are left untouched — they may still serve other
+   * parts. Marks the overlay dirty when something was removed.
+   */
+  removeOverride(partName: string): void;
+  /** Register a `Default` content type for a (lowercased) extension if absent. */
+  ensureDefault(extension: string, contentType: string): void;
+  serialize(): string;
+}
+//#endregion
+//#region src/read/opc/part.d.ts
+/**
+ * One OPC part. Holds the original bytes from the zip for its whole life;
+ * parses to a DOM only on demand; serializes back to the original bytes
+ * unless something mutated the DOM and called `markDirty()`.
+ *
+ * Untouched parts therefore round-trip byte-identically.
+ */
+declare class Part {
+  #private;
+  readonly partName: string;
+  readonly contentType: string;
+  constructor(partName: string, contentType: string, bytes: Uint8Array);
+  /** Whether this part's body is XML (by content type). */
+  get isXmlPart(): boolean;
+  /** True once the body has been materialized as a DOM. */
+  get isParsed(): boolean;
+  /** The original bytes from the package. Do not mutate. */
+  get bytes(): Uint8Array;
+  /**
+   * Lazily parsed DOM for XML parts. Parsing alone does not mark the part
+   * dirty; call `markDirty()` after mutating the tree.
+   */
+  get dom(): Document;
+  /** Call after mutating the DOM so `serialize()` reserializes this part. */
+  markDirty(): void;
+  get isDirty(): boolean;
+  /**
+   * Bytes to write on save: the original bytes when clean (byte-identical),
+   * the serialized DOM when dirty (semantically equivalent, schema-valid).
+   */
+  serialize(): Uint8Array;
+}
+//#endregion
+//#region src/read/opc/relationships.d.ts
+interface Relationship {
+  id: string;
+  type: string;
+  target: string;
+  targetMode?: 'Internal' | 'External';
+}
+/**
+ * Overlay over one `.rels` part, keyed by relationship id. While clean, the
+ * `.rels` bytes pass through verbatim on save (byte-identical); once `add()`
+ * (or another mutation) marks it dirty, `OpcPackage.save()` writes
+ * `serialize()` into the owning `.rels` part instead.
+ */
+declare class Relationships {
+  #private;
+  /** Partname of the part owning these relationships ('/' for package-level). */
+  readonly sourcePartName: string;
+  private constructor();
+  /**
+   * @param xml body of the `.rels` part
+   * @param sourcePartName partname of the owning part ('/' for `/_rels/.rels`)
+   */
+  static parse(xml: string, sourcePartName: string): Relationships;
+  /** Empty relationship set (for parts that have no `.rels`). */
+  static empty(sourcePartName: string): Relationships;
+  get size(): number;
+  /** True once a relationship was added/changed; `serialize()` is then authoritative. */
+  get isDirty(): boolean;
+  /**
+   * Add a relationship and return it. Allocates an id `rId<n>` with `n` one
+   * past the highest existing numeric id. `target` is relative to the source
+   * part's directory for internal targets (e.g. `../media/image1.png`), or an
+   * absolute URI for external ones. Marks this set dirty.
+   */
+  add(type: string, target: string, targetMode?: 'Internal' | 'External'): Relationship;
+  /**
+   * Add a relationship under a caller-chosen id and return it. Used when
+   * rebuilding a copied part's relationships across a package boundary: keeping
+   * each source id lets the copied part body's `r:id`/`r:embed` references stay
+   * valid without rewriting the body. Throws if the id is already present.
+   * Marks this set dirty.
+   */
+  addWithId(id: string, type: string, target: string, targetMode?: 'Internal' | 'External'): Relationship;
+  /**
+   * Remove the relationship with `id` and return whether one was present. Used
+   * when a referenced part is deleted (e.g. removing a slide drops the
+   * presentation→slide relationship). Marks this set dirty when it removes one.
+   */
+  remove(id: string): boolean;
+  get(id: string): Relationship | undefined;
+  byType(type: string): Relationship[];
+  [Symbol.iterator](): IterableIterator<Relationship>;
+  /** Resolve an internal relationship's target to an absolute partname. */
+  resolveTarget(id: string): string;
+  serialize(): string;
+}
+//#endregion
+//#region src/read/opc/package.d.ts
+/**
+ * Input to {@link OpcPackage.load}. A `string` is a **filesystem path** (Node)
+ * read from disk; pass `Uint8Array`/`ArrayBuffer`/`Blob`/`number[]` for an
+ * in-memory archive. (A string is a path, not JSZip's latin1 binary content.)
+ */
+type OpcInput = string | number[] | Uint8Array | ArrayBuffer | Blob;
+/**
+ * An OPC package loaded from `.pptx` bytes.
+ *
+ * Fidelity contract: parts that are never mutated (`Part.markDirty()`) are
+ * written back byte-identically by `save()`. Whole-zip byte-identity is not
+ * promised — zip metadata and compression may differ — but part bodies, the
+ * part-name set, and part order are preserved.
+ */
+declare class OpcPackage {
+  #private;
+  /** Content-type resolution + registration overlay. */
+  readonly contentTypes: ContentTypes;
+  private constructor();
+  /** All parts, keyed by partname, in zip/add order. */
+  get parts(): ReadonlyMap<string, Part>;
+  static load(input: OpcInput): Promise<OpcPackage>;
+  part(partName: string): Part | undefined;
+  partsByContentType(contentType: string): Part[];
+  /**
+   * Relationships owned by a part ('/' for the package-level
+   * `/_rels/.rels`). Parts without a `.rels` part get an empty set.
+   */
+  relationshipsFor(sourcePartName?: string): Relationships;
+  /**
+   * Add a new part and register its content type (`ensureRegistered`), so the
+   * package stays consistent. Throws if the partname is already taken.
+   */
+  addPart(partName: string, contentType: string, bytes: Uint8Array): Part;
+  /**
+   * Remove a part and return whether it existed. Drops its `Override` content-type
+   * registration and any cached relationship set it owned, so a later `save()`
+   * neither re-emits it nor flushes a stale `.rels` for it. Low-level: it does not
+   * touch references *to* this part (dangling rels are the caller's concern) nor
+   * cascade to parts this one referenced — see {@link Presentation.removeSlide}
+   * for the slide-aware variant that unwires the presentation and prunes orphans.
+   */
+  removePart(partName: string): boolean;
+  /**
+   * Reserve an unused media partname `/ppt/media/<base><n>.<ext>` (n one past
+   * the highest existing index for that base). Does not create the part.
+   */
+  reserveMediaPartName(extension: string, base?: string): string;
+  /**
+   * Reserve an unused partname in the same directory and naming family as
+   * `templatePartName`, with a fresh index one past the highest existing one.
+   * The template's filename is split into a base (its stem minus any trailing
+   * digits) and an extension, e.g. `/ppt/slideLayouts/slideLayout1.xml` →
+   * `/ppt/slideLayouts/slideLayout<n>.xml`, `/ppt/media/image1.png` →
+   * `/ppt/media/image<n>.png`. Used when copying a part in from another package.
+   * Does not create the part.
+   */
+  reservePartNameLike(templatePartName: string): string;
+  /**
+   * Re-emit the package. Clean parts are written from their original bytes;
+   * dirty parts from their DOM. Dirty relationship sets and content types are
+   * flushed first. Part order is preserved from load; added parts append.
+   */
+  save(): Promise<Uint8Array>;
+}
+//#endregion
+export { Part as a, Relationships as i, OpcPackage as n, Element as o, Relationship as r, ContentTypes as s, OpcInput as t };
+//# sourceMappingURL=package-CaOLXSNi.d.ts.map

package/dist/package-CaOLXSNi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-CaOLXSNi.d.ts","names":[],"sources":["../src/read/opc/content-types.ts","../src/read/opc/part.ts","../src/read/opc/relationships.ts","../src/read/opc/package.ts"],"mappings":";;;;;;;;cAUa;;SAKL,MAAM,cAAc;;EAgC3B,eAAe;;MAKX;;;;;;;EAUJ,iBAAiB,kBAAkB;;;;;;EAWnC,eAAe;;EAKf,cAAc,mBAAmB;EAOjC;;;;;;;;;;;cCtEY;;WACH;WACA;EAKG,YAAA,kBAAkB,qBAAqB,OAAO;;MAOtD;;MAOA;;MAKA,SAAS;;;;;MAQT,OAAO;;EAWX;MASI;;;;;EAQJ,aAAa;;;;UCzEG;EAChB;EACA;EACA;EACA;;;;;;;;cASY;;;WAEH;UAIF;;;;;SAQA,MAAM,aAAa,yBAAyB;;SAuC5C,MAAM,yBAAyB;MAIlC;;MAKA;;;;;;;EAUJ,IAAI,cAAc,gBAAgB,uCAAuC;;;;;;;;EAqBzE,UAAU,YAAY,cAAc,gBAAgB,uCAAuC;;;;;;EAkB3F,OAAO;EAMP,IAAI,aAAa;EAIjB,OAAO,eAAe;GAIrB,OAAO,aAAa,iBAAiB;;EAKtC,cAAc;EAgBd;;;;;;;;;KCvJW,+BAA+B,aAAa,cAAc;;;;;;;;;cAgBzD;;;WAIH,cAAc;UAIhB;;MAOH,SAAS,oBAAoB;SAIpB,KAAK,OAAO,WAAW,QAAQ;EA4B5C,KAAK,mBAAmB;EAIxB,mBAAmB,sBAAsB;;;;;EAQzC,iBAAiB,0BAAuB;;;;;EAexC,QAAQ,kBAAkB,qBAAqB,OAAO,aAAa;;;;;;;;;EAoBnE,WAAW;;;;;EAYX,qBAAqB,mBAAmB;;;;;;;;;;EAoBxC,oBAAoB;;;;;;EAuBd,QAAQ,QAAQ"}

package/dist/pres-5x1bjCzk.d.ts

@@ -0,0 +1,202 @@
+import { y as WRITE_OUTPUT_TYPE } from "./enums-D3aF4QGb.js";
+import { Z as HexColor, a as Slide } from "./slide-B6mDaM-P.js";
+//#region src/types/theme.d.ts
+/**
+ * Theme color scheme overrides. Each slot maps to one `<a:clrScheme>` entry in `theme1.xml`;
+ * any slot left unset keeps the default Office value. Provide 6-digit hex (no `#`).
+ *
+ * Slot names use the OOXML scheme names. The PowerPoint UI labels them as:
+ * `dk1`=Text/Dark 1, `lt1`=Background/Light 1, `dk2`=Text/Dark 2, `lt2`=Background/Light 2,
+ * `accent1`-`accent6`=Accent 1-6, `hlink`=Hyperlink, `folHlink`=Followed Hyperlink.
+ * @example { accent1: 'C00000', dk2: '1F3864', hlink: '0070C0' }
+ */
+interface ThemeColorScheme {
+  /** Text/Dark 1 (default Office: black via `windowText`) */
+  dk1?: HexColor;
+  /** Background/Light 1 (default Office: white via `window`) */
+  lt1?: HexColor;
+  /** Text/Dark 2 (default Office: `44546A`) */
+  dk2?: HexColor;
+  /** Background/Light 2 (default Office: `E7E6E6`) */
+  lt2?: HexColor;
+  /** Accent 1 (default Office: `4472C4`) */
+  accent1?: HexColor;
+  /** Accent 2 (default Office: `ED7D31`) */
+  accent2?: HexColor;
+  /** Accent 3 (default Office: `A5A5A5`) */
+  accent3?: HexColor;
+  /** Accent 4 (default Office: `FFC000`) */
+  accent4?: HexColor;
+  /** Accent 5 (default Office: `5B9BD5`) */
+  accent5?: HexColor;
+  /** Accent 6 (default Office: `70AD47`) */
+  accent6?: HexColor;
+  /** Hyperlink (default Office: `0563C1`) */
+  hlink?: HexColor;
+  /** Followed Hyperlink (default Office: `954F72`) */
+  folHlink?: HexColor;
+}
+interface ThemeProps {
+  /**
+   * Headings font face name
+   * @example 'Arial Narrow'
+   * @default 'Calibri Light'
+   */
+  headFontFace?: string;
+  /**
+   * Body font face name
+   * @example 'Arial'
+   * @default 'Calibri'
+   */
+  bodyFontFace?: string;
+  /**
+   * Headings East Asian font face — theme `<a:ea>` slot of the major font.
+   * Used for CJK (Chinese/Japanese/Korean) runs that fall back to the theme font.
+   * - leave unset to keep PowerPoint's empty default (auto-resolved per script)
+   * @example 'Yu Gothic'
+   */
+  headFontFaceEA?: string;
+  /**
+   * Body East Asian font face — theme `<a:ea>` slot of the minor font.
+   * Used for CJK (Chinese/Japanese/Korean) runs that fall back to the theme font.
+   * - leave unset to keep PowerPoint's empty default (auto-resolved per script)
+   * @example 'Yu Gothic'
+   */
+  bodyFontFaceEA?: string;
+  /**
+   * Headings complex-script font face — theme `<a:cs>` slot of the major font.
+   * Used for complex scripts such as Arabic, Hebrew, Thai, and Devanagari.
+   * - leave unset to keep PowerPoint's empty default (auto-resolved per script)
+   * @example 'Arial'
+   */
+  headFontFaceCS?: string;
+  /**
+   * Body complex-script font face — theme `<a:cs>` slot of the minor font.
+   * Used for complex scripts such as Arabic, Hebrew, Thai, and Devanagari.
+   * - leave unset to keep PowerPoint's empty default (auto-resolved per script)
+   * @example 'Arial'
+   */
+  bodyFontFaceCS?: string;
+  /**
+   * Theme color scheme overrides written to `ppt/theme/theme1.xml`.
+   * - any unset slot keeps its default Office value
+   * - references such as `SchemeColor.accent1` resolve against these values
+   * @example { accent1: 'C00000', accent2: '00B050', hlink: '0070C0' }
+   */
+  colorScheme?: ThemeColorScheme;
+}
+//#endregion
+//#region src/types/pres.d.ts
+interface WriteBaseProps {
+  /**
+   * Whether to DEFLATE-compress the package (PowerPoint itself always compresses;
+   * set `false` only if export time matters more than file size)
+   * @default true
+   */
+  compression?: boolean;
+  /**
+   * How to handle a media asset (image/audio/video) that fails to load during export.
+   * - `'throw'` (default): reject the export with an error naming the failing asset. A deck
+   *   that silently embeds a broken-image placeholder is a degenerate result, so failing
+   *   loudly is the safe default.
+   * - `'placeholder'`: substitute a broken-image placeholder, emit a `media/load-failed`
+   *   diagnostic (see `setDiagnosticHandler`), and
+   *   continue. Useful for best-effort/batch jobs where one missing asset should not abort
+   *   the whole deck.
+   * @default 'throw'
+   */
+  onMediaError?: 'throw' | 'placeholder';
+}
+interface WriteProps extends WriteBaseProps {
+  /**
+   * Output type
+   * - values: 'arraybuffer' | 'base64' | 'binarystring' | 'blob' | 'nodebuffer' | 'uint8array' | 'STREAM'
+   * @default 'blob'
+   */
+  outputType?: WRITE_OUTPUT_TYPE;
+}
+interface WriteFileProps extends WriteBaseProps {
+  /**
+   * Export file name
+   * @default 'Presentation.pptx'
+   */
+  fileName?: string;
+}
+/**
+ * One emitted OOXML package part: its full slash-path and already-encoded bytes. Returned by
+ * {@link TsPptx.toParts} for callers that want the raw parts of the `.pptx` OPC package without
+ * zipping (custom containers, streaming, part-level inspection). The bytes are byte-identical to
+ * what `write()` would compress for the same part;
+ * XML parts are UTF-8 (decode with `new TextDecoder().decode(part.data)`), media/font parts are
+ * their raw binary.
+ */
+interface PackagePart {
+  /** Full OOXML package part path, e.g. `ppt/slides/slide1.xml`. */
+  readonly path: string;
+  /** The part's already-encoded bytes: a fresh view per call, safe to keep or transfer. */
+  readonly data: Uint8Array;
+}
+/**
+ * Options for {@link TsPptx.toParts}. A deliberately narrow subset of {@link WriteProps}:
+ * `compression` and `outputType` are zip concerns and do not apply when parts are returned
+ * unzipped, so only media-error handling is exposed.
+ */
+interface PartsProps {
+  /**
+   * How to handle a media asset (image/audio/video) that fails to load. Same semantics as
+   * {@link WriteBaseProps.onMediaError}.
+   * @default 'throw'
+   */
+  onMediaError?: 'throw' | 'placeholder';
+}
+interface SectionProps {
+  /**
+   * Section title
+   */
+  title: string;
+  /**
+   * Section order - uses to add section at any index
+   * - values: 1-n
+   */
+  order?: number;
+}
+interface PresLayout {
+  _sizeW?: number;
+  _sizeH?: number;
+  /**
+   * Layout Name
+   * @example 'LAYOUT_WIDE'
+   */
+  name: string;
+  width: number;
+  height: number;
+}
+type CustomPropertyValue = string | number | boolean | Date;
+interface PresentationProps {
+  author: string;
+  company: string;
+  layout: string;
+  masterSlide: Slide;
+  /**
+   * Presentation's layout
+   * read-only
+   */
+  presLayout: PresLayout;
+  revision: string;
+  /**
+   * Slide number to assign to the first slide (affects the slide-number field displayed in placeholders).
+   * @default 1
+   */
+  firstSlideNum: number;
+  /**
+   * Whether to enable right-to-left mode
+   * @default false
+   */
+  rtlMode: boolean;
+  subject: string;
+  theme: ThemeProps;
+  title: string;
+}
+//#endregion
+export { PresentationProps as a, WriteFileProps as c, ThemeProps as d, PresLayout as i, WriteProps as l, PackagePart as n, SectionProps as o, PartsProps as r, WriteBaseProps as s, CustomPropertyValue as t, ThemeColorScheme as u };
+//# sourceMappingURL=pres-5x1bjCzk.d.ts.map

package/dist/pres-5x1bjCzk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pres-5x1bjCzk.d.ts","names":[],"sources":["../src/types/theme.ts","../src/types/pres.ts"],"mappings":";;;;;;;;;;;;UAgBiB;;EAEhB,MAAM;;EAEN,MAAM;;EAEN,MAAM;;EAEN,MAAM;;EAEN,UAAU;;EAEV,UAAU;;EAEV,UAAU;;EAEV,UAAU;;EAEV,UAAU;;EAEV,UAAU;;EAEV,QAAQ;;EAER,WAAW;;UAEK;;;;;;EAMhB;;;;;;EAMA;;;;;;;EAOA;;;;;;;EAOA;;;;;;;EAOA;;;;;;;EAOA;;;;;;;EAOA,cAAc;;;;UC/EE;;;;;;EAMhB;;;;;;;;;;;;EAYA;;UAEgB,mBAAmB;;;;;;EAMnC,aAAa;;UAEG,uBAAuB;;;;;EAKvC;;;;;;;;;;UAUgB;;WAEP;;WAEA,MAAM;;;;;;;UAOC;;;;;;EAMhB;;UAEgB;;;;EAIhB;;;;;EAKA;;UAEgB;EAChB;EACA;;;;;EAMA;EACA;EACA;;KAEW,kDAAkD;UAE7C;EAChB;EACA;EACA;EACA,aAAa;;;;;EAKb,YAAY;EACZ;;;;;EAKA;;;;;EAKA;EACA;EACA,OAAO;EACP"}