dompdf.js 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { ContextOptions } from './core/context';
+import { CloneOptions, WindowOptions } from './dom/document-cloner';
+import { RenderOptions } from './render/canvas/pdf-renderer';
+interface FontConfig {
+    fontFamily: string;
+    fontBase64: string;
+    fontUrl: string;
+    fontWeight: number;
+    fontStyle: string;
+}
+export type Options = CloneOptions & WindowOptions & RenderOptions & ContextOptions & {
+    backgroundColor: string | null;
+    foreignObjectRendering: boolean;
+    removeContainer?: boolean;
+    fontConfig?: FontConfig;
+};
+declare const dompdf: (element: HTMLElement, options?: Partial<Options>) => Promise<HTMLCanvasElement>;
+export default dompdf;

package/dist/invariant.d.ts

@@ -0,0 +1 @@
+export declare const invariant: (assertion: boolean, error: string) => void;

package/dist/render/background.d.ts

@@ -0,0 +1,16 @@
+import { Bounds } from '../css/layout/bounds';
+import { BACKGROUND_ORIGIN } from '../css/property-descriptors/background-origin';
+import { ElementContainer } from '../dom/element-container';
+import { BackgroundSizeInfo } from '../css/property-descriptors/background-size';
+import { Vector } from './vector';
+import { BACKGROUND_REPEAT } from '../css/property-descriptors/background-repeat';
+import { CSSValue } from '../css/syntax/parser';
+import { Path } from './path';
+import { BACKGROUND_CLIP } from '../css/property-descriptors/background-clip';
+export declare const calculateBackgroundPositioningArea: (backgroundOrigin: BACKGROUND_ORIGIN, element: ElementContainer) => Bounds;
+export declare const calculateBackgroundPaintingArea: (backgroundClip: BACKGROUND_CLIP, element: ElementContainer) => Bounds;
+export declare const calculateBackgroundRendering: (container: ElementContainer, index: number, intrinsicSize: [number | null, number | null, number | null]) => [Path[], number, number, number, number];
+export declare const isAuto: (token: CSSValue) => boolean;
+export declare const calculateBackgroundSize: (size: BackgroundSizeInfo[], [intrinsicWidth, intrinsicHeight, intrinsicProportion]: [number | null, number | null, number | null], bounds: Bounds) => [number, number];
+export declare const getBackgroundValueForIndex: <T>(values: T[], index: number) => T;
+export declare const calculateBackgroundRepeatPath: (repeat: BACKGROUND_REPEAT, [x, y]: [number, number], [width, height]: [number, number], backgroundPositioningArea: Bounds, backgroundPaintingArea: Bounds) => [Vector, Vector, Vector, Vector];

package/dist/render/bezier-curve.d.ts

@@ -0,0 +1,14 @@
+import { Vector } from './vector';
+import { IPath, PathType, Path } from './path';
+export declare class BezierCurve implements IPath {
+    type: PathType;
+    start: Vector;
+    startControl: Vector;
+    endControl: Vector;
+    end: Vector;
+    constructor(start: Vector, startControl: Vector, endControl: Vector, end: Vector);
+    subdivide(t: number, firstHalf: boolean): BezierCurve;
+    add(deltaX: number, deltaY: number): BezierCurve;
+    reverse(): BezierCurve;
+}
+export declare const isBezierCurve: (path: Path) => path is BezierCurve;

package/dist/render/border.d.ts

@@ -0,0 +1,6 @@
+import { Path } from './path';
+import { BoundCurves } from './bound-curves';
+export declare const parsePathForBorder: (curves: BoundCurves, borderSide: number) => Path[];
+export declare const parsePathForBorderDoubleOuter: (curves: BoundCurves, borderSide: number) => Path[];
+export declare const parsePathForBorderDoubleInner: (curves: BoundCurves, borderSide: number) => Path[];
+export declare const parsePathForBorderStroke: (curves: BoundCurves, borderSide: number) => Path[];

package/dist/render/bound-curves.d.ts

@@ -0,0 +1,32 @@
+import { ElementContainer } from '../dom/element-container';
+import { Path } from './path';
+export declare class BoundCurves {
+    readonly topLeftBorderDoubleOuterBox: Path;
+    readonly topRightBorderDoubleOuterBox: Path;
+    readonly bottomRightBorderDoubleOuterBox: Path;
+    readonly bottomLeftBorderDoubleOuterBox: Path;
+    readonly topLeftBorderDoubleInnerBox: Path;
+    readonly topRightBorderDoubleInnerBox: Path;
+    readonly bottomRightBorderDoubleInnerBox: Path;
+    readonly bottomLeftBorderDoubleInnerBox: Path;
+    readonly topLeftBorderStroke: Path;
+    readonly topRightBorderStroke: Path;
+    readonly bottomRightBorderStroke: Path;
+    readonly bottomLeftBorderStroke: Path;
+    readonly topLeftBorderBox: Path;
+    readonly topRightBorderBox: Path;
+    readonly bottomRightBorderBox: Path;
+    readonly bottomLeftBorderBox: Path;
+    readonly topLeftPaddingBox: Path;
+    readonly topRightPaddingBox: Path;
+    readonly bottomRightPaddingBox: Path;
+    readonly bottomLeftPaddingBox: Path;
+    readonly topLeftContentBox: Path;
+    readonly topRightContentBox: Path;
+    readonly bottomRightContentBox: Path;
+    readonly bottomLeftContentBox: Path;
+    constructor(element: ElementContainer);
+}
+export declare const calculateBorderBoxPath: (curves: BoundCurves) => Path[];
+export declare const calculateContentBoxPath: (curves: BoundCurves) => Path[];
+export declare const calculatePaddingBoxPath: (curves: BoundCurves) => Path[];

package/dist/render/box-sizing.d.ts

@@ -0,0 +1,4 @@
+import { Bounds } from '../css/layout/bounds';
+import { ElementContainer } from '../dom/element-container';
+export declare const paddingBox: (element: ElementContainer) => Bounds;
+export declare const contentBox: (element: ElementContainer) => Bounds;

package/dist/render/canvas/canvas-renderer2.d.ts

@@ -0,0 +1,81 @@
+import { Context } from '../../core/context';
+import { CSSParsedDeclaration } from '../../css';
+import { TextBounds } from '../../css/layout/text';
+import { BORDER_STYLE } from '../../css/property-descriptors/border-style';
+import { Color } from '../../css/types/color';
+import { ElementContainer } from '../../dom/element-container';
+import { ReplacedElementContainer } from '../../dom/replaced-elements';
+import { TextContainer } from '../../dom/text-container';
+import { BoundCurves } from '../bound-curves';
+import { IElementEffect } from '../effects';
+import { Path } from '../path';
+import { Renderer } from '../renderer';
+import { ElementPaint, StackingContext } from '../stacking-context';
+interface FontConfig {
+    fontFamily: string;
+    fontBase64: string;
+    fontUrl: string;
+    fontWeight: number;
+    fontStyle: string;
+}
+export type RenderConfigurations = RenderOptions & {
+    backgroundColor: Color | null;
+    fontConfig: FontConfig;
+};
+export interface RenderOptions {
+    scale: number;
+    canvas?: HTMLCanvasElement;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pdfFileName?: string;
+}
+export declare class CanvasRenderer extends Renderer {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    readonly jspdfCtx: any;
+    private readonly _activeEffects;
+    private readonly fontMetrics;
+    private readonly pxToPt;
+    constructor(context: Context, options: RenderConfigurations);
+    loadFont(): Promise<void>;
+    loadFontFromURL(url: string): Promise<unknown>;
+    addFontToJsPDF(fontData: string): void;
+    applyEffects(effects: IElementEffect[]): void;
+    pxToMm(px: number): number;
+    applyEffect(effect: IElementEffect): void;
+    popEffect(): void;
+    renderStack(stack: StackingContext): Promise<void>;
+    renderNode(paint: ElementPaint): Promise<void>;
+    renderTextWithLetterSpacing(text: TextBounds, letterSpacing: number, baseline: number): void;
+    private createFontStyle;
+    private convertColor;
+    renderTextNode(text: TextContainer, styles: CSSParsedDeclaration): Promise<void>;
+    renderReplacedElement(container: ReplacedElementContainer, curves: BoundCurves, image: HTMLImageElement | HTMLCanvasElement, type: 'image' | 'svg' | 'canvas'): void;
+    renderNodeContent(paint: ElementPaint): Promise<void>;
+    renderStackContent(stack: StackingContext): Promise<void>;
+    mask(paths: Path[]): void;
+    path(paths: Path[]): void;
+    formatPath(paths: Path[]): void;
+    renderRepeat(path: Path[], pattern: CanvasPattern | CanvasGradient, offsetX: number, offsetY: number): void;
+    resizeImage(image: HTMLImageElement, width: number, height: number): HTMLCanvasElement | HTMLImageElement;
+    renderBackgroundImage(container: ElementContainer): Promise<void>;
+    /**
+     * 渲染实线边框
+     * @param color - 边框颜色
+     * @param side - 边的位置(0-3,分别代表上右下左)
+     * @param curvePoints - 边框曲线点
+     */
+    renderSolidBorder(color: Color, side: number, curvePoints: BoundCurves): Promise<void>;
+    renderDoubleBorder(color: Color, width: number, side: number, curvePoints: BoundCurves): Promise<void>;
+    renderNodeBackgroundAndBorders(paint: ElementPaint): Promise<void>;
+    drawBoxWithGradientShadow(x: number, y: number, width: number, height: number, color: Color): void;
+    renderDashedDottedBorder(color: Color, // 边框颜色
+    width: number, // 边框宽度
+    side: number, // 边的位置(0-3,分别代表上右下左)
+    curvePoints: BoundCurves, // 边框曲线点
+    style: BORDER_STYLE): Promise<void>;
+    render(element: ElementContainer): Promise<HTMLCanvasElement>;
+}
+export {};

package/dist/render/canvas/foreignobject-renderer.d.ts

@@ -0,0 +1,11 @@
+import { Context } from '../../core/context';
+import { Renderer } from '../renderer';
+import { RenderConfigurations } from './pdf-renderer';
+export declare class ForeignObjectRenderer extends Renderer {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    options: RenderConfigurations;
+    constructor(context: Context, options: RenderConfigurations);
+    render(element: HTMLElement): Promise<HTMLCanvasElement>;
+}
+export declare const loadSerializedSVG: (svg: Node) => Promise<HTMLImageElement>;

package/dist/render/canvas/pdf-renderer.d.ts

@@ -0,0 +1,82 @@
+import { Context } from '../../core/context';
+import { CSSParsedDeclaration } from '../../css';
+import { TextBounds } from '../../css/layout/text';
+import { BORDER_STYLE } from '../../css/property-descriptors/border-style';
+import { Color } from '../../css/types/color';
+import { ElementContainer } from '../../dom/element-container';
+import { ReplacedElementContainer } from '../../dom/replaced-elements';
+import { TextContainer } from '../../dom/text-container';
+import 'svg2pdf.js';
+import { BoundCurves } from '../bound-curves';
+import { IElementEffect } from '../effects';
+import { Path } from '../path';
+import { Renderer } from '../renderer';
+import { ElementPaint, StackingContext } from '../stacking-context';
+interface FontConfig {
+    fontFamily: string;
+    fontBase64: string;
+    fontUrl: string;
+    fontWeight: number;
+    fontStyle: string;
+}
+export type RenderConfigurations = RenderOptions & {
+    backgroundColor: Color | null;
+    fontConfig: FontConfig;
+};
+export interface RenderOptions {
+    scale: number;
+    canvas?: HTMLCanvasElement;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pdfFileName?: string;
+}
+export declare class CanvasRenderer extends Renderer {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    readonly jspdfCtx: any;
+    readonly context2dCtx: any;
+    private readonly _activeEffects;
+    private readonly fontMetrics;
+    private readonly pxToPt;
+    constructor(context: Context, options: RenderConfigurations);
+    loadFont(): Promise<void>;
+    loadFontFromURL(url: string): Promise<unknown>;
+    addFontToJsPDF(fontData: string): void;
+    applyEffects(effects: IElementEffect[]): void;
+    pxToMm(px: number): number;
+    applyEffect(effect: IElementEffect): void;
+    popEffect(): void;
+    renderStack(stack: StackingContext): Promise<void>;
+    renderNode(paint: ElementPaint): Promise<void>;
+    renderTextWithLetterSpacing(text: TextBounds, letterSpacing: number, baseline: number): void;
+    private createFontStyle;
+    private convertColor;
+    renderTextNode(text: TextContainer, styles: CSSParsedDeclaration): Promise<void>;
+    renderReplacedElement(container: ReplacedElementContainer, curves: BoundCurves, image: HTMLImageElement | HTMLCanvasElement): void;
+    renderNodeContent(paint: ElementPaint): Promise<void>;
+    renderStackContent(stack: StackingContext): Promise<void>;
+    mask(paths: Path[]): void;
+    path(paths: Path[]): void;
+    formatPath(paths: Path[]): void;
+    renderRepeat(path: Path[], pattern: CanvasPattern | CanvasGradient, offsetX: number, offsetY: number): void;
+    resizeImage(image: HTMLImageElement, width: number, height: number): HTMLCanvasElement | HTMLImageElement;
+    renderBackgroundImage(container: ElementContainer): Promise<void>;
+    /**
+     * 渲染实线边框
+     * @param color - 边框颜色
+     * @param side - 边的位置(0-3,分别代表上右下左)
+     * @param curvePoints - 边框曲线点
+     */
+    renderSolidBorder(color: Color, side: number, curvePoints: BoundCurves): Promise<void>;
+    renderDoubleBorder(color: Color, width: number, side: number, curvePoints: BoundCurves): Promise<void>;
+    renderNodeBackgroundAndBorders(paint: ElementPaint): Promise<void>;
+    renderDashedDottedBorder(color: Color, // 边框颜色
+    width: number, // 边框宽度
+    side: number, // 边的位置(0-3,分别代表上右下左)
+    curvePoints: BoundCurves, // 边框曲线点
+    style: BORDER_STYLE): Promise<void>;
+    render(element: ElementContainer): Promise<HTMLCanvasElement>;
+}
+export {};

package/dist/render/effects.d.ts

@@ -0,0 +1,38 @@
+import { Matrix } from '../css/property-descriptors/transform';
+import { Path } from './path';
+export declare const enum EffectType {
+    TRANSFORM = 0,
+    CLIP = 1,
+    OPACITY = 2
+}
+export declare const enum EffectTarget {
+    BACKGROUND_BORDERS = 2,
+    CONTENT = 4
+}
+export interface IElementEffect {
+    readonly type: EffectType;
+    readonly target: number;
+}
+export declare class TransformEffect implements IElementEffect {
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly matrix: Matrix;
+    readonly type: EffectType;
+    readonly target: number;
+    constructor(offsetX: number, offsetY: number, matrix: Matrix);
+}
+export declare class ClipEffect implements IElementEffect {
+    readonly path: Path[];
+    readonly target: EffectTarget;
+    readonly type: EffectType;
+    constructor(path: Path[], target: EffectTarget);
+}
+export declare class OpacityEffect implements IElementEffect {
+    readonly opacity: number;
+    readonly type: EffectType;
+    readonly target: number;
+    constructor(opacity: number);
+}
+export declare const isTransformEffect: (effect: IElementEffect) => effect is TransformEffect;
+export declare const isClipEffect: (effect: IElementEffect) => effect is ClipEffect;
+export declare const isOpacityEffect: (effect: IElementEffect) => effect is OpacityEffect;

package/dist/render/font-metrics.d.ts

@@ -0,0 +1,11 @@
+export interface FontMetric {
+    baseline: number;
+    middle: number;
+}
+export declare class FontMetrics {
+    private readonly _data;
+    private readonly _document;
+    constructor(document: Document);
+    private parseMetrics;
+    getMetrics(fontFamily: string, fontSize: string): FontMetric;
+}

package/dist/render/path.d.ts

@@ -0,0 +1,13 @@
+import { BezierCurve } from './bezier-curve';
+import { Vector } from './vector';
+export declare const enum PathType {
+    VECTOR = 0,
+    BEZIER_CURVE = 1
+}
+export interface IPath {
+    type: PathType;
+    add(deltaX: number, deltaY: number): IPath;
+}
+export declare const equalPath: (a: Path[], b: Path[]) => boolean;
+export declare const transformPath: (path: Path[], deltaX: number, deltaY: number, deltaW: number, deltaH: number) => Path[];
+export type Path = Vector | BezierCurve;

package/dist/render/renderer.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '../core/context';
+import { RenderConfigurations } from './canvas/pdf-renderer';
+export declare class Renderer {
+    protected readonly context: Context;
+    protected readonly options: RenderConfigurations;
+    constructor(context: Context, options: RenderConfigurations);
+}

package/dist/render/stacking-context.d.ts

@@ -0,0 +1,24 @@
+import { ElementContainer } from '../dom/element-container';
+import { BoundCurves } from './bound-curves';
+import { EffectTarget, IElementEffect } from './effects';
+export declare class StackingContext {
+    element: ElementPaint;
+    negativeZIndex: StackingContext[];
+    zeroOrAutoZIndexOrTransformedOrOpacity: StackingContext[];
+    positiveZIndex: StackingContext[];
+    nonPositionedFloats: StackingContext[];
+    nonPositionedInlineLevel: StackingContext[];
+    inlineLevel: ElementPaint[];
+    nonInlineLevel: ElementPaint[];
+    constructor(container: ElementPaint);
+}
+export declare class ElementPaint {
+    readonly container: ElementContainer;
+    readonly parent: ElementPaint | null;
+    readonly effects: IElementEffect[];
+    readonly curves: BoundCurves;
+    listValue?: string;
+    constructor(container: ElementContainer, parent: ElementPaint | null);
+    getEffects(target: EffectTarget): IElementEffect[];
+}
+export declare const parseStackingContexts: (container: ElementContainer) => StackingContext;

package/dist/render/vector.d.ts

@@ -0,0 +1,9 @@
+import { IPath, Path, PathType } from './path';
+export declare class Vector implements IPath {
+    type: PathType;
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    add(deltaX: number, deltaY: number): Vector;
+}
+export declare const isVector: (path: Path) => path is Vector;