@segnavia/format 0.26.0 → 0.28.0

package/dist/book.js

@@ -1,28 +1,14 @@
-import { Direction } from "./direction.js";
+import { Direction, resolveDirection } from "./direction.js";
 import { Scripts } from "./scripts.js";
-import { NoteMarker, NumberSystem } from "./numbering.js";
+import { Slots } from "./slots.js";
+import { FontReference } from "./fonts.js";
+import { NoteMarker, NumberSystem, isHebrew } from "./numbering.js";
+import { ParentPage, bookParentPages } from "./printed-pages.js";
+import { BookChapterEntry, BookContents, BookFrontMatterEntry, BookOpens, BookSection, BookSectionParents, BookTemplate, Chapter, DesignedPage, DesignedSection, REGION_NAME, TemplatedPage, TemplatedSection, bookParentIssues, isBookContents, isChapter, isDesignedSection, isTemplatedSection } from "./book-section.js";
 import { Orientation, Paper, sheetMm } from "./paper.js";
 import { z } from "zod";
 //#region src/book.ts
 const BookMode = z.enum(["continuous", "paginated"]);
-const BookSection = z.object({
-	title: z.string().optional(),
-	html: z.string(),
-	contents: z.boolean().default(true)
-});
-const BookContents = z.object({
-	kind: z.literal("contents"),
-	title: z.string().optional()
-});
-const BookFrontMatterEntry = z.union([BookSection, BookContents]);
-function isBookContents(entry) {
-	return "kind" in entry && entry.kind === "contents";
-}
-const Chapter = z.object({
-	title: z.string(),
-	html: z.string(),
-	runningHead: z.string().optional()
-});
 const BookPage = z.object({
 	paper: Paper,
 	orientation: Orientation.default("portrait"),
@@ -31,7 +17,16 @@ const BookPage = z.object({
 		bottom: z.number().nonnegative(),
 		inner: z.number().nonnegative(),
 		outer: z.number().nonnegative()
-	})
+	}),
+	columnGap: z.number().nonnegative().default(4)
+});
+const BookRunningHeadSource = z.union([z.literal("title"), z.object({
+	mark: z.string().min(1),
+	which: z.enum(["first", "last"])
+})]);
+const BookRunningHead = z.object({
+	recto: BookRunningHeadSource.default("title"),
+	verso: BookRunningHeadSource.default("title")
 });
 const BookShape = z.object({
 	title: z.string(),
@@ -41,7 +36,12 @@ const BookShape = z.object({
 	dir: Direction.optional(),
 	lang: z.string().optional(),
 	frontMatter: z.array(BookFrontMatterEntry).default([]),
-	chapters: z.array(Chapter).min(1),
+	chapters: z.array(BookChapterEntry).min(1),
+	parentPages: z.array(ParentPage).default([]),
+	templates: z.array(BookTemplate).default([]),
+	slots: Slots.optional(),
+	fonts: z.array(FontReference).optional(),
+	css: z.string().optional(),
 	numbering: z.object({
 		frontMatter: NumberSystem.optional(),
 		body: NumberSystem.optional()
@@ -56,6 +56,12 @@ const BookShape = z.object({
 		title: z.string().optional()
 	}).default({ placement: "book" }),
 	rectoOpenings: z.boolean().default(false),
+	orphans: z.number().int().min(1).default(2),
+	widows: z.number().int().min(1).default(2),
+	runningHead: BookRunningHead.default({
+		recto: "title",
+		verso: "title"
+	}),
 	contents: z.object({
 		pageNumbers: z.boolean().default(true),
 		depth: z.number().int().min(1).max(6).default(2)
@@ -64,19 +70,41 @@ const BookShape = z.object({
 		depth: 2
 	})
 });
+const BookViewPagination = z.object({
+	paper: z.object({
+		width: z.number().positive(),
+		height: z.number().positive()
+	}),
+	margin: BookPage.shape.margin,
+	columnGap: z.number().nonnegative(),
+	direction: z.enum(["ltr", "rtl"]),
+	numbering: z.object({
+		frontMatter: NumberSystem,
+		body: NumberSystem
+	}),
+	rectoOpenings: z.boolean(),
+	orphans: z.number().int().min(1),
+	widows: z.number().int().min(1),
+	parents: z.array(ParentPage),
+	endnotePlacement: z.enum(["book", "chapter"]),
+	contents: z.object({
+		pageNumbers: z.boolean(),
+		depth: z.number().int().min(1).max(6)
+	}),
+	runningHead: BookRunningHead
+});
 const BookView = BookShape.pick({
 	title: true,
 	dir: true,
 	lang: true,
-	scripts: true
+	scripts: true,
+	fonts: true,
+	css: true
 }).extend({
 	title: BookShape.shape.title.optional(),
-	html: z.string()
+	html: z.string(),
+	pagination: BookViewPagination.optional()
 });
-function isHebrew(lang) {
-	const primary = lang?.split("-")[0]?.toLowerCase();
-	return primary === "he" || primary === "iw";
-}
 const Book = BookShape.transform((book) => {
 	const hebrew = isHebrew(book.lang);
 	return {
@@ -117,6 +145,10 @@ const Book = BookShape.transform((book) => {
 		path: ["endnotes", "placement"],
 		message: "endnotes are placed at the end of each chapter only in paginated mode; use book placement or paginated mode"
 	});
+	for (const issue of bookParentIssues(book)) ctx.addIssue({
+		code: "custom",
+		...issue
+	});
 	if (!book.page) return;
 	const trim = sheetMm(book.page);
 	const vertical = book.page.margin.top + book.page.margin.bottom;
@@ -132,9 +164,26 @@ const Book = BookShape.transform((book) => {
 		message: `the inner and outer margins total ${horizontal}mm and the page is ${trim.width}mm wide; reduce the horizontal margins to leave a text area`
 	});
 });
+function resolveBookPagination(book) {
+	if (book.mode !== "paginated" || !book.page) return void 0;
+	return {
+		paper: sheetMm(book.page),
+		margin: book.page.margin,
+		columnGap: book.page.columnGap,
+		direction: resolveDirection(book.dir, book.lang, book.title),
+		numbering: book.numbering,
+		rectoOpenings: book.rectoOpenings,
+		orphans: book.orphans,
+		widows: book.widows,
+		parents: [...bookParentPages(book.page.margin), ...book.parentPages],
+		endnotePlacement: book.endnotes.placement,
+		contents: book.contents,
+		runningHead: book.runningHead
+	};
+}
 function noteMarkerIssues(book, used) {
 	if (!used.footnotes || !used.endnotes || book.footnotes.marker !== book.endnotes.marker) return [];
 	return [`footnote and endnote markers are both ${book.footnotes.marker}; the two must differ when both kinds are used`];
 }
 //#endregion
-export { Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookShape, BookView, Chapter, isBookContents, isHebrew, noteMarkerIssues };
+export { Book, BookChapterEntry, BookContents, BookFrontMatterEntry, BookMode, BookOpens, BookPage, BookRunningHead, BookRunningHeadSource, BookSection, BookSectionParents, BookShape, BookTemplate, BookView, BookViewPagination, Chapter, DesignedPage, DesignedSection, REGION_NAME, TemplatedPage, TemplatedSection, isBookContents, isChapter, isDesignedSection, isTemplatedSection, noteMarkerIssues, resolveBookPagination };

package/dist/direction.d.ts

@@ -10,6 +10,7 @@ export declare const TextDirection: z.ZodEnum<{
   rtl: "rtl";
 }>;
 export type TextDirection = z.infer<typeof TextDirection>;
+export declare function textDirection(dir: string | undefined, lang: string | undefined, sample: string): TextDirection | null;
 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;

package/dist/direction.js

@@ -6,41 +6,44 @@ const Direction = z.enum([
 	"auto"
 ]);
 const TextDirection = z.enum(["ltr", "rtl"]);
-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";
+function textDirection(dir, lang, sample) {
+	const rtlLetter = /[\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 rtlLanguages = /* @__PURE__ */ new Set([
+		"ar",
+		"arc",
+		"ckb",
+		"dv",
+		"fa",
+		"he",
+		"iw",
+		"ji",
+		"ks",
+		"ku",
+		"nqo",
+		"ps",
+		"sd",
+		"syr",
+		"ug",
+		"ur",
+		"yi"
+	]);
+	if (dir === "ltr" || dir === "rtl") return dir;
+	if (lang) return rtlLanguages.has(lang.toLowerCase().split("-")[0] ?? "") ? "rtl" : "ltr";
+	for (const char of sample) {
+		if (rtlLetter.test(char)) return "rtl";
+		if (letter.test(char)) return "ltr";
 	}
 	return null;
 }
+function firstStrongDirection(text) {
+	return textDirection(void 0, void 0, text);
+}
 function languageDirection(lang) {
-	if (!lang) return null;
-	return RTL_LANGUAGES.has(lang.toLowerCase().split("-")[0] ?? "") ? "rtl" : "ltr";
+	return lang ? textDirection(void 0, lang, "") : null;
 }
 function resolveDirection(dir, lang, sample) {
-	if (dir === "ltr" || dir === "rtl") return dir;
-	return languageDirection(lang) ?? firstStrongDirection(sample) ?? "ltr";
+	return textDirection(dir, lang, sample) ?? "ltr";
 }
 //#endregion
-export { Direction, TextDirection, firstStrongDirection, languageDirection, resolveDirection };
+export { Direction, TextDirection, firstStrongDirection, languageDirection, resolveDirection, textDirection };

package/dist/fonts.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+//#region src/fonts.d.ts
+export declare const APP_FONT_NAME: RegExp;
+export declare const APP_FONT_NAME_MESSAGE = "app font names are lowercase letters, digits and hyphens";
+export declare const FontReference: z.ZodUnion<readonly [z.ZodObject<{
+  app: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  local: z.ZodString;
+  fallback: z.ZodString;
+}, z.core.$strip>]>;
+export type FontReference = z.infer<typeof FontReference>;
+export declare const FontReferenceInput: z.ZodUnion<readonly [z.ZodObject<{
+  app: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  local: z.ZodString;
+  fallback: z.ZodString;
+}, z.core.$strict>]>;
+export type FontReferenceInput = z.input<typeof FontReferenceInput>;
+export declare function localFontReferences(references: readonly FontReference[]): Array<{
+  local: string;
+  fallback: string;
+}>;
+export declare const FONT_FORMATS: readonly ["woff2", "woff", "truetype", "opentype"];
+export type FontFormat = (typeof FONT_FORMATS)[number];
+export declare const LocalFaceTransport: z.ZodObject<{
+  family: z.ZodString;
+  format: z.ZodEnum<{
+    woff2: "woff2";
+    woff: "woff";
+    truetype: "truetype";
+    opentype: "opentype";
+  }>;
+  weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  style: z.ZodOptional<z.ZodEnum<{
+    normal: "normal";
+    italic: "italic";
+  }>>;
+  data: z.ZodString;
+}, z.core.$strict>;
+export type LocalFaceTransport = z.infer<typeof LocalFaceTransport>;
+export declare const LocalFacesTransport: z.ZodArray<z.ZodObject<{
+  family: z.ZodString;
+  format: z.ZodEnum<{
+    woff2: "woff2";
+    woff: "woff";
+    truetype: "truetype";
+    opentype: "opentype";
+  }>;
+  weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  style: z.ZodOptional<z.ZodEnum<{
+    normal: "normal";
+    italic: "italic";
+  }>>;
+  data: z.ZodString;
+}, z.core.$strict>>;
+export type LocalFacesInput = LocalFaceTransport[];
+export declare const FONT_GENERICS: readonly ["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui"];
+export type FontGeneric = (typeof FONT_GENERICS)[number];
+export interface FontFace {
+  family: string;
+  data: Uint8Array;
+  format: FontFormat;
+  weight?: number | string;
+  style?: 'normal' | 'italic';
+  unicodeRange?: string;
+}
+export interface AppFont {
+  family: string;
+  faces: FontFace[];
+  generic?: FontGeneric;
+}
+export interface FontSource {
+  font(name: string, options: {
+    signal: AbortSignal;
+  }): Promise<AppFont | undefined>;
+}
+//#endregion

package/dist/fonts.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+//#region src/fonts.ts
+const APP_FONT_NAME = /^[a-z0-9-]+$/;
+const APP_FONT_NAME_MESSAGE = "app font names are lowercase letters, digits and hyphens";
+const AppFontName = z.string().min(1).regex(APP_FONT_NAME, APP_FONT_NAME_MESSAGE);
+const AppFontShape = { app: AppFontName };
+const LocalFontShape = {
+	local: z.string().min(1),
+	fallback: AppFontName
+};
+const FontReference = z.union([z.object(AppFontShape), z.object(LocalFontShape)]);
+const FontReferenceInput = z.union([z.strictObject(AppFontShape), z.strictObject(LocalFontShape)]);
+function localFontReferences(references) {
+	const seen = /* @__PURE__ */ new Set();
+	const locals = [];
+	for (const reference of references) {
+		if (!("local" in reference)) continue;
+		const key = JSON.stringify(reference);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		locals.push(reference);
+	}
+	return locals;
+}
+const FONT_FORMATS = [
+	"woff2",
+	"woff",
+	"truetype",
+	"opentype"
+];
+const LocalFaceTransportShape = {
+	family: z.string().min(1),
+	format: z.enum(FONT_FORMATS),
+	weight: z.union([z.number(), z.string()]).optional(),
+	style: z.enum(["normal", "italic"]).optional(),
+	data: z.string()
+};
+const LocalFaceTransport = z.strictObject(LocalFaceTransportShape);
+const LocalFacesTransport = z.array(LocalFaceTransport);
+const FONT_GENERICS = [
+	"serif",
+	"sans-serif",
+	"monospace",
+	"cursive",
+	"fantasy",
+	"system-ui"
+];
+//#endregion
+export { APP_FONT_NAME, APP_FONT_NAME_MESSAGE, FONT_FORMATS, FONT_GENERICS, FontReference, FontReferenceInput, LocalFaceTransport, LocalFacesTransport, localFontReferences };