@segnavia/format 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 modstudio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/direction.d.ts

@@ -0,0 +1,6 @@
+//#region src/direction.d.ts
+export type TextDirection = 'ltr' | 'rtl';
+export declare function firstStrongDirection(text: string): TextDirection | null;
+export declare function languageDirection(lang: string | undefined): TextDirection | null;
+export declare function resolveDirection(dir: 'ltr' | 'rtl' | 'auto' | undefined, lang: string | undefined, sample: string): TextDirection;
+//#endregion

package/dist/direction.js

@@ -0,0 +1,39 @@
+//#region src/direction.ts
+const RTL_LETTER = /[\p{Script=Hebrew}\p{Script=Arabic}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Nko}\p{Script=Samaritan}\p{Script=Mandaic}\p{Script=Adlam}\p{Script=Hanifi_Rohingya}\p{Script=Mende_Kikakui}\p{Script=Old_Hungarian}\p{Script=Imperial_Aramaic}\p{Script=Phoenician}]/u;
+const LETTER = /\p{L}/u;
+const RTL_LANGUAGES = /* @__PURE__ */ new Set([
+	"ar",
+	"arc",
+	"ckb",
+	"dv",
+	"fa",
+	"he",
+	"iw",
+	"ji",
+	"ks",
+	"ku",
+	"nqo",
+	"ps",
+	"sd",
+	"syr",
+	"ug",
+	"ur",
+	"yi"
+]);
+function firstStrongDirection(text) {
+	for (const char of text) {
+		if (RTL_LETTER.test(char)) return "rtl";
+		if (LETTER.test(char)) return "ltr";
+	}
+	return null;
+}
+function languageDirection(lang) {
+	if (!lang) return null;
+	return RTL_LANGUAGES.has(lang.toLowerCase().split("-")[0] ?? "") ? "rtl" : "ltr";
+}
+function resolveDirection(dir, lang, sample) {
+	if (dir === "ltr" || dir === "rtl") return dir;
+	return languageDirection(lang) ?? firstStrongDirection(sample) ?? "ltr";
+}
+//#endregion
+export { firstStrongDirection, languageDirection, resolveDirection };

package/dist/imposition.d.ts

@@ -0,0 +1,62 @@
+import { PaperBox } from "./paper.js";
+import { Imposition, Page, Print } from "./index.js";
+//#region src/imposition.d.ts
+export interface MillimeterEdges {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+export interface Placement {
+  page: number;
+  paper: number;
+  side: 'front' | 'back';
+  column: number;
+  row: number;
+  trim: PaperBox;
+  bleed: MillimeterEdges;
+  bleedBox: PaperBox;
+  safeBox: PaperBox;
+  clipped: Array<'top' | 'right' | 'bottom' | 'left'>;
+}
+export interface Imposed {
+  paper: {
+    width: number;
+    height: number;
+  };
+  papers: number;
+  sides: 1 | 2;
+  placements: Placement[];
+}
+export interface PageFit {
+  flow: boolean;
+  width: number;
+  height: number | null;
+  scale: number;
+  x: number;
+  y: number;
+  bands: {
+    inline: number;
+    block: number;
+  };
+  crop: MillimeterEdges;
+  differs: boolean;
+}
+export type PagePlacementKind = 'fluid' | 'growing' | 'fixed';
+export interface PagePlacementLayout {
+  kind: PagePlacementKind;
+  piece: {
+    width: number;
+    height: number;
+  };
+  inset: boolean;
+  paper: PaperBox;
+}
+export declare function mirrorPlacement(front: Placement, paper: Imposed['paper'], flip: Imposition['flip'], page?: number): Placement;
+export declare function impose(imposition: Imposition, pageCount: number): Imposed;
+export declare function fitPage(page: {
+  size: Page['size'];
+  print?: Print;
+}, placement: Placement, fit: 'contain' | 'cover'): PageFit;
+export declare function pagePlacementLayout(size: Page['size'], placement: Placement, fit: PageFit): PagePlacementLayout;
+//#endregion

package/dist/imposition.js

@@ -0,0 +1,294 @@
+import { PX_PER_MM, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
+//#region src/imposition.ts
+const zeroCrop = () => ({
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0
+});
+function placementAt(imposition, paper, cell, page, paperSize) {
+	const mm = (value) => toMillimeters(value, imposition.unit);
+	const column = cell % imposition.columns;
+	const row = Math.floor(cell / imposition.columns);
+	const physicalColumn = imposition.dir === "rtl" ? imposition.columns - column - 1 : column;
+	const cellWidth = mm(imposition.cell.width);
+	const cellHeight = mm(imposition.cell.height);
+	const columnGap = mm(imposition.gap.column);
+	const rowGap = mm(imposition.gap.row);
+	const x = imposition.dir === "rtl" ? paperSize.width - mm(imposition.margin.right) - cellWidth - column * (cellWidth + columnGap) : mm(imposition.margin.left) + column * (cellWidth + columnGap);
+	const y = mm(imposition.margin.top) + row * (cellHeight + rowGap);
+	const requested = mm(imposition.bleed);
+	const bleed = {
+		top: Math.min(requested, row > 0 ? rowGap / 2 : y),
+		right: Math.min(requested, physicalColumn < imposition.columns - 1 ? columnGap / 2 : Math.max(0, paperSize.width - x - cellWidth)),
+		bottom: Math.min(requested, row < imposition.rows - 1 ? rowGap / 2 : Math.max(0, paperSize.height - y - cellHeight)),
+		left: Math.min(requested, physicalColumn > 0 ? columnGap / 2 : Math.max(0, x))
+	};
+	const clipped = [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	].filter((side) => bleed[side] < requested);
+	const trim = {
+		x: roundMillimeters(x),
+		y: roundMillimeters(y),
+		width: roundMillimeters(cellWidth),
+		height: roundMillimeters(cellHeight)
+	};
+	const roundedBleed = {
+		top: roundMillimeters(bleed.top),
+		right: roundMillimeters(bleed.right),
+		bottom: roundMillimeters(bleed.bottom),
+		left: roundMillimeters(bleed.left)
+	};
+	const safe = mm(imposition.safe);
+	return {
+		page,
+		paper,
+		side: "front",
+		column,
+		row,
+		trim,
+		bleed: roundedBleed,
+		bleedBox: {
+			x: roundMillimeters(x - bleed.left),
+			y: roundMillimeters(y - bleed.top),
+			width: roundMillimeters(cellWidth + bleed.left + bleed.right),
+			height: roundMillimeters(cellHeight + bleed.top + bleed.bottom)
+		},
+		safeBox: {
+			x: roundMillimeters(x + safe),
+			y: roundMillimeters(y + safe),
+			width: roundMillimeters(cellWidth - safe * 2),
+			height: roundMillimeters(cellHeight - safe * 2)
+		},
+		clipped
+	};
+}
+const mirrorBox = (box, paper, axis) => axis === "x" ? {
+	...box,
+	x: roundMillimeters(paper.width - box.x - box.width)
+} : {
+	...box,
+	y: roundMillimeters(paper.height - box.y - box.height)
+};
+const EDGE_ORDER = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+function mirrorEdge(edge, axis) {
+	if (axis === "x") return edge === "left" ? "right" : edge === "right" ? "left" : edge;
+	return edge === "top" ? "bottom" : edge === "bottom" ? "top" : edge;
+}
+function mirrorEdges(edges, axis) {
+	const mirrored = { ...edges };
+	for (const edge of EDGE_ORDER) mirrored[mirrorEdge(edge, axis)] = edges[edge];
+	return mirrored;
+}
+function mirrorPlacement(front, paper, flip, page = front.page) {
+	const portrait = paper.width <= paper.height;
+	const axis = flip === "long" === portrait ? "x" : "y";
+	const mirroredClipped = new Set(front.clipped.map((edge) => mirrorEdge(edge, axis)));
+	return {
+		...front,
+		page,
+		side: "back",
+		trim: mirrorBox(front.trim, paper, axis),
+		bleed: mirrorEdges(front.bleed, axis),
+		bleedBox: mirrorBox(front.bleedBox, paper, axis),
+		safeBox: mirrorBox(front.safeBox, paper, axis),
+		clipped: EDGE_ORDER.filter((edge) => mirroredClipped.has(edge))
+	};
+}
+function assignPieces(imposition, pieces, papers) {
+	const cells = imposition.columns * imposition.rows;
+	const assignments = [];
+	let piece = 0;
+	for (let paperIndex = 0; paperIndex < papers; paperIndex += 1) {
+		const firstCell = paperIndex === 0 ? imposition.skip : 0;
+		for (let cell = firstCell; cell < cells; cell += 1) {
+			const assignedPiece = imposition.fill === "repeat" ? paperIndex : piece;
+			if (assignedPiece >= pieces) break;
+			assignments.push({
+				paper: paperIndex,
+				cell,
+				piece: assignedPiece
+			});
+			if (imposition.fill === "sequence") piece += 1;
+		}
+	}
+	return assignments;
+}
+function expandAssignments(imposition, assignments, pageCount, paper) {
+	const placements = [];
+	let currentPaper = -1;
+	let fronts = [];
+	let backs = [];
+	const flush = () => {
+		placements.push(...fronts, ...backs);
+		fronts = [];
+		backs = [];
+	};
+	for (const assignment of assignments) {
+		if (assignment.paper !== currentPaper) {
+			flush();
+			currentPaper = assignment.paper;
+		}
+		const frontPage = imposition.sides === "two" ? assignment.piece * 2 : assignment.piece;
+		const front = placementAt(imposition, assignment.paper, assignment.cell, frontPage, paper);
+		fronts.push(front);
+		if (imposition.sides === "two" && frontPage + 1 < pageCount) backs.push(mirrorPlacement(front, paper, imposition.flip, frontPage + 1));
+	}
+	flush();
+	return placements;
+}
+function impose(imposition, pageCount) {
+	if (!Number.isInteger(pageCount) || pageCount < 0) throw new RangeError(`pageCount must be a nonnegative integer; received ${String(pageCount)}`);
+	const paper = sheetMm({
+		paper: imposition.paper,
+		orientation: imposition.orientation
+	});
+	const sides = imposition.sides === "two" ? 2 : 1;
+	if (pageCount === 0) return {
+		paper,
+		papers: 0,
+		sides,
+		placements: []
+	};
+	const cells = imposition.columns * imposition.rows;
+	const pieces = imposition.sides === "two" ? Math.ceil(pageCount / 2) : pageCount;
+	const papers = imposition.fill === "repeat" ? pieces : Math.ceil((pieces + imposition.skip) / cells);
+	return {
+		paper,
+		papers,
+		sides,
+		placements: expandAssignments(imposition, assignPieces(imposition, pieces, papers), pageCount, paper)
+	};
+}
+function trimDiffers(page, placement) {
+	if (!page.print) return false;
+	const trim = sheetMm(page.print);
+	return Math.abs(trim.width - placement.trim.width) > .01 || Math.abs(trim.height - placement.trim.height) > .01;
+}
+function fitPage(page, placement, fit) {
+	const differs = trimDiffers(page, placement);
+	if (page.size === "fluid") return {
+		flow: true,
+		width: placement.bleedBox.width * PX_PER_MM,
+		height: null,
+		scale: 1,
+		x: placement.bleedBox.x,
+		y: placement.bleedBox.y,
+		bands: {
+			inline: 0,
+			block: 0
+		},
+		crop: zeroCrop(),
+		differs
+	};
+	if (page.size.height === "auto") return {
+		flow: true,
+		width: page.size.width,
+		height: null,
+		scale: placement.trim.width * PX_PER_MM / page.size.width,
+		x: placement.trim.x,
+		y: placement.trim.y,
+		bands: {
+			inline: 0,
+			block: 0
+		},
+		crop: zeroCrop(),
+		differs
+	};
+	if (fit === "contain") {
+		const scale = Math.min(placement.trim.width * PX_PER_MM / page.size.width, placement.trim.height * PX_PER_MM / page.size.height);
+		const width = page.size.width * scale / PX_PER_MM;
+		const height = page.size.height * scale / PX_PER_MM;
+		const inline = (placement.trim.width - width) / 2;
+		const block = (placement.trim.height - height) / 2;
+		return {
+			flow: false,
+			width: page.size.width,
+			height: page.size.height,
+			scale,
+			x: roundMillimeters(placement.trim.x + inline),
+			y: roundMillimeters(placement.trim.y + block),
+			bands: {
+				inline: roundMillimeters(inline),
+				block: roundMillimeters(block)
+			},
+			crop: zeroCrop(),
+			differs
+		};
+	}
+	const horizontalBleed = Math.max(placement.bleed.left, placement.bleed.right);
+	const verticalBleed = Math.max(placement.bleed.top, placement.bleed.bottom);
+	const scale = Math.max((placement.trim.width + horizontalBleed * 2) * PX_PER_MM / page.size.width, (placement.trim.height + verticalBleed * 2) * PX_PER_MM / page.size.height);
+	const width = page.size.width * scale / PX_PER_MM;
+	const height = page.size.height * scale / PX_PER_MM;
+	const x = placement.trim.x + (placement.trim.width - width) / 2;
+	const y = placement.trim.y + (placement.trim.height - height) / 2;
+	return {
+		flow: false,
+		width: page.size.width,
+		height: page.size.height,
+		scale,
+		x: roundMillimeters(x),
+		y: roundMillimeters(y),
+		bands: {
+			inline: 0,
+			block: 0
+		},
+		crop: {
+			top: roundMillimeters(Math.max(0, placement.bleedBox.y - y)),
+			right: roundMillimeters(Math.max(0, x + width - placement.bleedBox.x - placement.bleedBox.width)),
+			bottom: roundMillimeters(Math.max(0, y + height - placement.bleedBox.y - placement.bleedBox.height)),
+			left: roundMillimeters(Math.max(0, placement.bleedBox.x - x))
+		},
+		differs
+	};
+}
+function pagePlacementLayout(size, placement, fit) {
+	if (size === "fluid") return {
+		kind: "fluid",
+		piece: {
+			width: placement.bleedBox.width * PX_PER_MM,
+			height: placement.bleedBox.height * PX_PER_MM
+		},
+		inset: true,
+		paper: placement.bleedBox
+	};
+	if (size.height === "auto") return {
+		kind: "growing",
+		piece: {
+			width: size.width,
+			height: placement.trim.height * PX_PER_MM / fit.scale
+		},
+		inset: false,
+		paper: {
+			x: fit.x,
+			y: fit.y,
+			width: placement.trim.width,
+			height: placement.trim.height
+		}
+	};
+	return {
+		kind: "fixed",
+		piece: {
+			width: size.width,
+			height: size.height
+		},
+		inset: false,
+		paper: {
+			x: fit.x,
+			y: fit.y,
+			width: size.width * fit.scale / PX_PER_MM,
+			height: size.height * fit.scale / PX_PER_MM
+		}
+	};
+}
+//#endregion
+export { fitPage, impose, mirrorPlacement, pagePlacementLayout };