reamkit 1.0.0 → 1.0.1

package/dist/esm/core/style-cascade/resolver.js

@@ -5,7 +5,25 @@ var EMPTY_STYLE_SHEET = {
 	defaultParagraphProperties: {},
 	styles: /* @__PURE__ */ new Map()
 };
+var runCascadeCache = /* @__PURE__ */ new WeakMap();
 function resolveRunProperties(runDirect, paragraphDirect, sheet) {
+	let bySheet = runCascadeCache.get(sheet);
+	if (!bySheet) {
+		bySheet = /* @__PURE__ */ new WeakMap();
+		runCascadeCache.set(sheet, bySheet);
+	}
+	let byRun = bySheet.get(runDirect);
+	if (!byRun) {
+		byRun = /* @__PURE__ */ new WeakMap();
+		bySheet.set(runDirect, byRun);
+	}
+	const hit = byRun.get(paragraphDirect);
+	if (hit) return hit;
+	const resolved = computeRunProperties(runDirect, paragraphDirect, sheet);
+	byRun.set(paragraphDirect, resolved);
+	return resolved;
+}
+function computeRunProperties(runDirect, paragraphDirect, sheet) {
 	let acc = mergeRun(DEFAULT_RESOLVED_RUN, sheet.defaultRunProperties);
 	if (paragraphDirect.styleId) {
 		const chain = resolveStyleChain(paragraphDirect.styleId, sheet);
@@ -68,6 +86,7 @@ function mergeRun(base, override) {
 function mergePar(base, override) {
 	const outlineLevel = override.outlineLevel ?? base.outlineLevel;
 	const styleId = override.styleId ?? base.styleId;
+	const numbering = override.numbering ?? base.numbering;
 	return {
 		alignment: override.alignment ?? base.alignment,
 		spacingBefore: override.spacingBefore ?? base.spacingBefore,
@@ -80,7 +99,8 @@ function mergePar(base, override) {
 		pageBreakBefore: override.pageBreakBefore ?? base.pageBreakBefore,
 		bidi: override.bidi ?? base.bidi,
 		...outlineLevel !== void 0 ? { outlineLevel } : {},
-		...styleId !== void 0 ? { styleId } : {}
+		...styleId !== void 0 ? { styleId } : {},
+		...numbering !== void 0 ? { numbering } : {}
 	};
 }
 function mergeRunPartial(base, override) {
@@ -97,5 +117,52 @@ function copyDefined(base, override) {
 	}
 	return out;
 }
+function resolveBodyStyles(body, sheet) {
+	const visitParagraph = (p) => ({
+		...p,
+		properties: resolveParagraphProperties(p.properties, sheet),
+		runs: p.runs.map((r) => ({
+			...r,
+			properties: resolveRunProperties(r.properties, p.properties, sheet)
+		}))
+	});
+	const visit = (el) => {
+		if (el.kind === "paragraph") return {
+			kind: "paragraph",
+			paragraph: visitParagraph(el.paragraph)
+		};
+		if (el.kind === "table") return {
+			kind: "table",
+			table: {
+				...el.table,
+				rows: el.table.rows.map((row) => ({
+					...row,
+					cells: row.cells.map((cell) => ({
+						...cell,
+						content: cell.content.map(visit)
+					}))
+				}))
+			}
+		};
+		if (el.kind === "shape" && el.shape.text) return {
+			kind: "shape",
+			shape: {
+				...el.shape,
+				text: {
+					...el.shape.text,
+					content: el.shape.text.content.map(visit)
+				}
+			}
+		};
+		return el;
+	};
+	return body.map(visit);
+}
+function resolveHeadersFootersStyles(hf, sheet) {
+	if (hf.size === 0) return hf;
+	const out = /* @__PURE__ */ new Map();
+	for (const [key, value] of hf) out.set(key, resolveBodyStyles(value, sheet));
+	return out;
+}
 //#endregion
-export { EMPTY_STYLE_SHEET, resolveParagraphProperties, resolveRunProperties };
+export { EMPTY_STYLE_SHEET, resolveBodyStyles, resolveHeadersFootersStyles, resolveParagraphProperties, resolveRunProperties };

package/dist/esm/core/style-cascade/types.d.ts

@@ -1,4 +1,4 @@
-import { Alignment, FontFamilyMap, UnderlineStyle, VerticalAlign } from '../document-model/index.js';
+import { Alignment, FontFamilyMap, NumberingReference, UnderlineStyle, VerticalAlign } from '../document-model/index.js';
 import { Pt } from '../ir/index.js';
 export interface ResolvedRunProperties {
     readonly bold: boolean;
@@ -25,6 +25,7 @@ export interface ResolvedParagraphProperties {
     readonly bidi: boolean;
     readonly outlineLevel?: number;
     readonly styleId?: string;
+    readonly numbering?: NumberingReference;
 }
 export declare const DEFAULT_RESOLVED_RUN: ResolvedRunProperties;
 export declare const DEFAULT_RESOLVED_PARAGRAPH: ResolvedParagraphProperties;

package/dist/esm/core/vector.d.ts

@@ -0,0 +1,45 @@
+export type PathSegment = {
+    readonly op: 'move';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'line';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'cubic';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'close';
+};
+export interface VectorPath {
+    readonly segments: ReadonlyArray<PathSegment>;
+    readonly fillRule?: 'nonzero' | 'evenodd';
+}
+export interface StrokeStyle {
+    readonly colorHex: string;
+    readonly widthPt: number;
+    readonly cap?: 'butt' | 'round' | 'square';
+    readonly join?: 'miter' | 'round' | 'bevel';
+    readonly dash?: ReadonlyArray<number>;
+}
+export interface VectorShape {
+    readonly paths: ReadonlyArray<VectorPath>;
+    readonly fillColorHex?: string;
+    readonly stroke?: StrokeStyle;
+    readonly transform: readonly [number, number, number, number, number, number];
+}
+export declare class PathBuilder {
+    private readonly segments;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    cubicTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this;
+    append(segments: ReadonlyArray<PathSegment>): this;
+    close(): this;
+    build(fillRule?: 'nonzero' | 'evenodd'): VectorPath;
+}

package/dist/esm/core/vector.js

@@ -0,0 +1,48 @@
+//#region src/core/vector.ts
+var PathBuilder = class {
+	segments = [];
+	moveTo(x, y) {
+		this.segments.push({
+			op: "move",
+			x,
+			y
+		});
+		return this;
+	}
+	lineTo(x, y) {
+		this.segments.push({
+			op: "line",
+			x,
+			y
+		});
+		return this;
+	}
+	cubicTo(x1, y1, x2, y2, x, y) {
+		this.segments.push({
+			op: "cubic",
+			x1,
+			y1,
+			x2,
+			y2,
+			x,
+			y
+		});
+		return this;
+	}
+	append(segments) {
+		for (const s of segments) this.segments.push(s);
+		return this;
+	}
+	close() {
+		this.segments.push({ op: "close" });
+		return this;
+	}
+	build(fillRule) {
+		return {
+			segments: this.segments.slice(),
+			...fillRule ? { fillRule } : {}
+		};
+	}
+};
+//#endregion
+export { PathBuilder };

package/dist/esm/excel/xlsx-reader.js

@@ -1,6 +1,6 @@
 import { ResourceStore } from "../core/ir/resources.js";
 import { FEATURES } from "../core/ir/features.js";
-import { EMPTY_STYLE_SHEET } from "../core/style-cascade/resolver.js";
+import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
 import { bytesInclude } from "../core/bytes.js";
 import { OpcPackage } from "../core/opc/package.js";
@@ -59,7 +59,7 @@ function readXlsx(xlsx) {
 	return {
 		doc: {
 			kind: "flow",
-			body,
+			body: resolveBodyStyles(body, EMPTY_STYLE_SHEET),
 			sections: [],
 			...firstSheetSection ? { section: firstSheetSection } : {},
 			styles: EMPTY_STYLE_SHEET,

package/dist/esm/index.d.ts

@@ -18,10 +18,10 @@ export { Ream } from './core/converter/ream.js';
 export type { ReamConvertOptions, ReamParseOptions, ReamTarget } from './core/converter/ream.js';
 export { createConverter } from './core/converter/facade.js';
 export type { Converter, ConvertOptions, ConvertResult, CreateConverterOptions, } from './core/converter/facade.js';
-export type { PageItem, PageItemBase, TextLineItem, BorderItem, FillItem, ImageItem, ShapeItem, LaidOutPage, } from './pdf/styled-page-renderer.js';
+export type { PageItem, PageItemBase, TextLineItem, BorderItem, FillItem, ImageItem, ShapeItem, LaidOutPage, } from './layout/page-doc.js';
 export { chainProviders, callerFontProvider, embeddedDocFontProvider, remoteFontProvider, localFontProvider, readOs2FsType, isEmbeddingRestricted, NO_FONT, } from './core/fonts/provider.js';
 export type { FontProvider, FontRequest, FontAnswer } from './core/fonts/provider.js';
 export { svgWriter, writeSvg } from './svg/svg-writer.js';
 export type { SvgWriteOptions } from './svg/svg-writer.js';
-export { layoutStyledDocument } from './pdf/styled-page-renderer.js';
-export type { LaidOutDocument } from './pdf/styled-page-renderer.js';
+export { layoutStyledDocument } from './layout/styled-layout.js';
+export type { LaidOutDocument } from './layout/page-doc.js';

package/dist/esm/index.js

@@ -6,8 +6,9 @@ import { eighthPtToPt, emuToPt, halfPtToPt, inchToPt, mmToPt, pt, pxToPt, twipsT
 import { ResourceStore } from "./core/ir/resources.js";
 import { FEATURES } from "./core/ir/features.js";
 import { ConversionLossError, formatLoss } from "./core/ir/loss.js";
+import { layoutStyledDocument } from "./layout/styled-layout.js";
 import { signPdf } from "./pdf/signature.js";
-import { layoutStyledDocument, renderStyledPdf } from "./pdf/styled-page-renderer.js";
+import { renderStyledPdf } from "./pdf/styled-page-renderer.js";
 import "./pdf/index.js";
 import { createHyphenator, splitPatternBundle } from "./core/hyphenation/liang.js";
 import { createLanguageHyphenator, getHyphenator } from "./core/hyphenation/index.js";

package/dist/esm/{pdf → layout}/arc-to-bezier.d.ts

@@ -1,4 +1,4 @@
-import { PathSegment } from './vector-graphics.js';
+import { PathSegment } from '../core/vector.js';
 export declare function arcPoint(cx: number, cy: number, rx: number, ry: number, angleRad: number): readonly [number, number];
 export declare function arcToBeziers(cx: number, cy: number, rx: number, ry: number, startAngleRad: number, sweepAngleRad: number): Array<PathSegment>;
 export declare function ellipseSegments(w: number, h: number): ReadonlyArray<PathSegment>;

package/dist/esm/{pdf → layout}/arc-to-bezier.js

@@ -1,5 +1,5 @@
-import { PathBuilder } from "./vector-graphics.js";
-//#region src/pdf/arc-to-bezier.ts
+import { PathBuilder } from "../core/vector.js";
+//#region src/layout/arc-to-bezier.ts
 function arcPoint(cx, cy, rx, ry, angleRad) {
 	return [cx + rx * Math.cos(angleRad), cy + ry * Math.sin(angleRad)];
 }

package/dist/esm/{pdf → layout}/math-layout.d.ts

@@ -1,5 +1,5 @@
 import { MathNode } from '../core/document-model/index.js';
-import { PathSegment } from './vector-graphics.js';
+import { PathSegment } from '../core/vector.js';
 export type MathVariant = 'regular' | 'italic' | 'bold' | 'boldItalic';
 export interface MathGlyphItem {
     readonly kind: 'glyph';

package/dist/esm/{pdf → layout}/math-layout.js

@@ -1,4 +1,4 @@
-//#region src/pdf/math-layout.ts
+//#region src/layout/math-layout.ts
 var ASCENT = .72;
 var DESCENT = .2;
 var AXIS = .26;

package/dist/esm/layout/page-doc.d.ts

@@ -0,0 +1,133 @@
+import { Pt, ResourceId, ResourceStore } from '../core/ir/index.js';
+import { FontMeasure, ParsedTtf } from '../core/font/index.js';
+import { ResolvedParagraphProperties, ResolvedRunProperties } from '../core/style-cascade/index.js';
+import { PathSegment, VectorShape } from '../core/vector.js';
+import { PreparedImage } from '../core/images.js';
+export interface FontResource {
+    readonly resourceName: string;
+    readonly parsed: ParsedTtf;
+    readonly measure: FontMeasure;
+    readonly gids: ReadonlySet<number>;
+}
+export interface TextToken {
+    readonly kind: 'text';
+    readonly text: string;
+    readonly isSpace: boolean;
+    readonly resolvedRun: ResolvedRunProperties;
+    readonly font: FontResource;
+    readonly fontSizePt: number;
+    readonly widthPt: number;
+    readonly bidiLevel: number;
+}
+export interface ImageToken {
+    readonly kind: 'image';
+    readonly imageResourceName: string;
+    readonly widthPt: number;
+    readonly heightPt: number;
+    readonly isSpace: false;
+    readonly bidiLevel: number;
+}
+export type ResolvedMathItem = {
+    readonly kind: 'glyph';
+    readonly x: number;
+    readonly y: number;
+    readonly text: string;
+    readonly font: FontResource;
+    readonly sizePt: number;
+} | {
+    readonly kind: 'rule';
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+} | {
+    readonly kind: 'path';
+    readonly segments: ReadonlyArray<PathSegment>;
+    readonly strokeWidthPt?: number;
+    readonly fill?: boolean;
+};
+export interface MathToken {
+    readonly kind: 'math';
+    readonly items: ReadonlyArray<ResolvedMathItem>;
+    readonly widthPt: number;
+    readonly ascentPt: number;
+    readonly descentPt: number;
+    readonly isSpace: false;
+    readonly bidiLevel: number;
+}
+export type Token = TextToken | ImageToken | MathToken;
+export interface Line {
+    readonly tokens: ReadonlyArray<Token>;
+    readonly contentWidthPt: number;
+    readonly maxFontSizePt: number;
+    readonly availableWidthPt: number;
+    readonly firstLine: boolean;
+    readonly resolved: ResolvedParagraphProperties;
+    isLastInParagraph: boolean;
+    readonly mathAscentPt?: number;
+    readonly mathDescentPt?: number;
+}
+export interface ImageResource {
+    readonly resourceName: string;
+    readonly prepared: PreparedImage;
+}
+export interface PageItemBase {
+    readonly structId?: number;
+    readonly artifact?: 'pagination';
+}
+export interface TextLineItem extends PageItemBase {
+    readonly type: 'line';
+    readonly line: Line;
+    readonly originX: Pt;
+    readonly baselineY: Pt;
+}
+export interface BorderItem extends PageItemBase {
+    readonly type: 'border';
+    readonly side: 'top' | 'right' | 'bottom' | 'left';
+    readonly x: Pt;
+    readonly y: Pt;
+    readonly width: Pt;
+    readonly height: Pt;
+    readonly borderSizePt: number;
+    readonly borderColorHex: string;
+}
+export interface FillItem extends PageItemBase {
+    readonly type: 'fill';
+    readonly x: Pt;
+    readonly y: Pt;
+    readonly width: Pt;
+    readonly height: Pt;
+    readonly fillColorHex: string;
+}
+export interface ImageItem extends PageItemBase {
+    readonly type: 'image';
+    readonly x: Pt;
+    readonly y: Pt;
+    readonly width: Pt;
+    readonly height: Pt;
+    readonly imageResourceName: string;
+}
+export interface ShapeItem extends PageItemBase {
+    readonly type: 'shape';
+    readonly shape: VectorShape;
+}
+export type PageItem = TextLineItem | BorderItem | FillItem | ImageItem | ShapeItem;
+export interface PagePaintPlan {
+    readonly fills: ReadonlyArray<FillItem>;
+    readonly images: ReadonlyArray<ImageItem>;
+    readonly borders: ReadonlyArray<BorderItem>;
+    readonly shapes: ReadonlyArray<ShapeItem>;
+    readonly lines: ReadonlyArray<TextLineItem>;
+}
+export declare function paintPlan(commands: ReadonlyArray<PageItem>): PagePaintPlan;
+export interface LaidOutDocument {
+    readonly pages: ReadonlyArray<LaidOutPage>;
+    readonly resources: ResourceStore;
+    readonly fontResources: Map<string, FontResource>;
+    readonly imageResources: Map<ResourceId, ImageResource>;
+}
+export interface LaidOutPage {
+    readonly commands: Array<PageItem>;
+    readonly width: Pt;
+    readonly height: Pt;
+}

package/dist/esm/layout/page-doc.js

@@ -0,0 +1,38 @@
+//#region src/layout/page-doc.ts
+function paintPlan(commands) {
+	const fills = [];
+	const images = [];
+	const borders = [];
+	const shapes = [];
+	const lines = [];
+	for (const c of commands) switch (c.type) {
+		case "fill":
+			fills.push(c);
+			break;
+		case "image":
+			images.push(c);
+			break;
+		case "border":
+			borders.push(c);
+			break;
+		case "shape":
+			shapes.push(c);
+			break;
+		case "line":
+			lines.push(c);
+			break;
+		default: assertNeverPageItem(c);
+	}
+	return {
+		fills,
+		images,
+		borders,
+		shapes,
+		lines
+	};
+}
+function assertNeverPageItem(item) {
+	throw new Error(`Unhandled PageItem kind: ${String(item.type)}`);
+}
+//#endregion
+export { paintPlan };

package/dist/esm/{pdf → layout}/preset-geometry.d.ts

@@ -1,5 +1,5 @@
 import { CustomGeometry } from '../core/document-model/index.js';
-import { PathSegment, VectorPath } from './vector-graphics.js';
+import { PathSegment, VectorPath } from '../core/vector.js';
 export declare function rectSegments(w: number, h: number): ReadonlyArray<PathSegment>;
 export declare function rectPath(w: number, h: number): VectorPath;
 export declare function presetPaths(preset: string, w: number, h: number, adjust: ReadonlyMap<string, number>): Array<VectorPath> | null;

package/dist/esm/{pdf → layout}/preset-geometry.js

@@ -1,6 +1,6 @@
-import { PathBuilder } from "./vector-graphics.js";
+import { PathBuilder } from "../core/vector.js";
 import { arcToBeziers, ellipseSegments, roundRectSegments } from "./arc-to-bezier.js";
-//#region src/pdf/preset-geometry.ts
+//#region src/layout/preset-geometry.ts
 function rectSegments(w, h) {
 	return new PathBuilder().moveTo(0, 0).lineTo(w, 0).lineTo(w, h).lineTo(0, h).close().build().segments;
 }

package/dist/esm/layout/styled-layout.d.ts

@@ -0,0 +1,84 @@
+import { BodyElement, Chart, DocumentInfo, Numbering, Section, SectionProperties, StyleSheet } from '../core/document-model/index.js';
+import { FontRegistry } from '../core/font/index.js';
+import { FamilyKey } from '../core/fonts/index.js';
+import { Hyphenator } from '../core/hyphenation/index.js';
+import { LaidOutDocument, PageItem } from './page-doc.js';
+import { AttachedFile } from '../pdf/embedded-file.js';
+import { SignaturePlaceholder } from '../pdf/signature.js';
+import { ResourceStore } from '../core/ir/index.js';
+import { StructTreeBuilder } from '../pdf/struct-tree.js';
+export type PdfALevel = 'PDF/A-1b' | 'PDF/A-1a' | 'PDF/A-2b' | 'PDF/A-2u' | 'PDF/A-2a' | 'PDF/A-3b' | 'PDF/A-3u' | 'PDF/A-3a';
+export interface PdfAProfile {
+    readonly part: 1 | 2 | 3;
+    readonly level: 'a' | 'b' | 'u';
+    readonly tagged: boolean;
+    readonly version: '1.4' | '1.7';
+}
+export interface StyledRenderOptions {
+    readonly registry: FontRegistry;
+    readonly registriesByFamily?: ReadonlyMap<FamilyKey, FontRegistry>;
+    readonly embeddedFonts?: ReadonlyMap<string, FontRegistry>;
+    readonly styles: StyleSheet;
+    readonly numbering?: Numbering;
+    readonly section?: SectionProperties;
+    readonly sections?: ReadonlyArray<Section>;
+    readonly headersFooters?: ReadonlyMap<string, ReadonlyArray<BodyElement>>;
+    readonly resources?: ResourceStore;
+    readonly charts?: ReadonlyMap<string, Chart>;
+    readonly pageWidth?: number;
+    readonly pageHeight?: number;
+    readonly marginLeft?: number;
+    readonly marginRight?: number;
+    readonly marginTop?: number;
+    readonly marginBottom?: number;
+    readonly hyphenator?: Hyphenator;
+    readonly info?: DocumentInfo;
+    readonly pdfA?: PdfALevel;
+    readonly tagged?: boolean;
+    readonly language?: string;
+    readonly attachments?: ReadonlyArray<AttachedFile>;
+    readonly signaturePlaceholder?: SignaturePlaceholder;
+}
+export type { DocumentInfo } from '../core/document-model/index.js';
+export declare const A4_WIDTH = 595;
+export declare const A4_HEIGHT = 842;
+export interface PdfLayoutAux {
+    readonly structBuilder: StructTreeBuilder | undefined;
+    readonly sectionCtxs: ReadonlyArray<SectionRenderCtx>;
+    readonly pdfaProfile: PdfAProfile | undefined;
+    readonly tagged: boolean;
+}
+export interface LaidOutPdfDocument extends LaidOutDocument {
+    readonly pdf: PdfLayoutAux;
+}
+export declare function layoutStyledDocument(body: ReadonlyArray<BodyElement>, options: StyledRenderOptions): LaidOutPdfDocument;
+export interface PageDimensions {
+    readonly pageWidth: number;
+    readonly pageHeight: number;
+    readonly marginLeft: number;
+    readonly marginRight: number;
+    readonly marginTop: number;
+    readonly marginBottom: number;
+    readonly headerOffsetPt: number;
+    readonly footerOffsetPt: number;
+}
+export interface SectionRenderCtx {
+    readonly endIndex: number;
+    readonly properties: SectionProperties;
+    readonly pageWidth: number;
+    readonly pageHeight: number;
+    readonly marginLeft: number;
+    readonly marginTop: number;
+    readonly marginBottom: number;
+    readonly contentWidth: number;
+    readonly pageContentHeight: number;
+    readonly headerSet: HeaderFooterSet;
+    readonly footerSet: HeaderFooterSet;
+    readonly titlePg: boolean;
+    readonly evenAndOddHeaders: boolean;
+}
+interface HeaderFooterSet {
+    readonly default: Array<PageItem>;
+    readonly first: Array<PageItem>;
+    readonly even: Array<PageItem>;
+}