@segnavia/format 0.26.0 → 0.28.0

package/dist/motif.d.ts

@@ -0,0 +1,157 @@
+import { z } from "zod";
+//#region src/motif.d.ts
+export declare const MOTIF_ATTRIBUTE = "data-motif";
+export declare const PRINTED_PAGE_CONTEXT = "printedPage";
+export declare const PRINTED_PAGE_NUMBER_PATH = "printedPage.number";
+export declare const PRINTED_PAGE_TOTAL_PATH = "printedPage.total";
+export declare const PRINTED_PAGE_FOLIO_PATH = "printedPage.folio";
+export declare const PRINTED_PAGE_RUNNING_HEAD_PATH = "printedPage.runningHead";
+export declare const LIBRARY_MOTIF_PREFIX = "segnavia:";
+export declare const BOOK_FURNITURE: readonly [{
+  readonly key: "segnavia:folio";
+  readonly path: "printedPage.folio";
+  readonly value: "folio";
+  readonly className: "segnavia-folio";
+  readonly region: "foot";
+  readonly fields: readonly [];
+}, {
+  readonly key: "segnavia:running-head";
+  readonly path: "printedPage.runningHead";
+  readonly value: "runningHead";
+  readonly className: "segnavia-running-head";
+  readonly region: "head";
+  readonly fields: readonly [];
+}, {
+  readonly key: "segnavia:mark";
+  readonly className: "segnavia-mark";
+  readonly region: "head";
+  readonly fields: readonly [{
+    readonly key: "name";
+    readonly required: true;
+  }, {
+    readonly key: "which";
+    readonly choices: readonly ["first", "last"];
+    readonly default: "first";
+  }];
+}];
+export type BookFurniture = (typeof BOOK_FURNITURE)[number];
+export declare const motifFieldAttribute: (key: string) => string;
+export declare const MotifField: z.ZodObject<{
+  key: z.ZodString;
+  label: z.ZodString;
+  choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  default: z.ZodOptional<z.ZodString>;
+  required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type MotifField = z.infer<typeof MotifField>;
+export declare const MotifFieldInput: z.ZodObject<{
+  key: z.ZodString;
+  label: z.ZodString;
+  choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  default: z.ZodOptional<z.ZodString>;
+  required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type MotifFieldInput = z.input<typeof MotifFieldInput>;
+export declare const MotifVersion: z.ZodObject<{
+  lang: z.ZodString;
+  dir: z.ZodOptional<z.ZodEnum<{
+    ltr: "ltr";
+    rtl: "rtl";
+  }>>;
+  when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  html: z.ZodString;
+}, z.core.$strip>;
+export type MotifVersion = z.infer<typeof MotifVersion>;
+export declare const MotifVersionInput: z.ZodObject<{
+  lang: z.ZodString;
+  dir: z.ZodOptional<z.ZodEnum<{
+    ltr: "ltr";
+    rtl: "rtl";
+  }>>;
+  when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  html: z.ZodString;
+}, z.core.$strict>;
+export type MotifVersionInput = z.input<typeof MotifVersionInput>;
+export declare const Motif: z.ZodObject<{
+  key: z.ZodString;
+  revision: z.ZodString;
+  label: z.ZodString;
+  fields: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    default: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  versions: z.ZodArray<z.ZodObject<{
+    lang: z.ZodString;
+    dir: z.ZodOptional<z.ZodEnum<{
+      ltr: "ltr";
+      rtl: "rtl";
+    }>>;
+    when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    html: z.ZodString;
+  }, z.core.$strip>>;
+  fonts: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    app: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    local: z.ZodString;
+    fallback: z.ZodString;
+  }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export type Motif = z.infer<typeof Motif>;
+export declare const MotifInput: z.ZodObject<{
+  fields: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    default: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strict>>;
+  versions: z.ZodArray<z.ZodObject<{
+    lang: z.ZodString;
+    dir: z.ZodOptional<z.ZodEnum<{
+      ltr: "ltr";
+      rtl: "rtl";
+    }>>;
+    when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    html: z.ZodString;
+  }, z.core.$strict>>;
+  fonts: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    app: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    local: z.ZodString;
+    fallback: z.ZodString;
+  }, z.core.$strict>]>>>;
+  key: z.ZodString;
+  revision: z.ZodString;
+  label: z.ZodString;
+}, z.core.$strict>;
+export type MotifInput = z.input<typeof MotifInput>;
+export interface MotifPlacement {
+  key: string;
+  revision: string;
+  lang: string;
+  fields: Record<string, string>;
+}
+export interface MotifSource {
+  motif(key: string, options: {
+    revision?: string;
+    signal: AbortSignal;
+  }): Promise<Motif | undefined>;
+  data?(placement: MotifPlacement, options: {
+    signal: AbortSignal;
+  }): Promise<Record<string, unknown>>;
+}
+export type MotifVersionChoice = {
+  ok: true;
+  version: MotifVersion;
+  index: number;
+} | {
+  ok: false;
+  reason: string;
+};
+export declare function chooseMotifVersion(motif: Motif, values: {
+  lang?: string;
+} & Record<string, string | undefined>): MotifVersionChoice;
+//#endregion

package/dist/motif.js

@@ -0,0 +1,193 @@
+import { SlotKey } from "./slots.js";
+import { FontReference, FontReferenceInput } from "./fonts.js";
+import { z } from "zod";
+//#region src/motif.ts
+const MOTIF_ATTRIBUTE = "data-motif";
+const PRINTED_PAGE_CONTEXT = "printedPage";
+const PRINTED_PAGE_NUMBER_PATH = `${PRINTED_PAGE_CONTEXT}.number`;
+const PRINTED_PAGE_TOTAL_PATH = `${PRINTED_PAGE_CONTEXT}.total`;
+const PRINTED_PAGE_FOLIO_PATH = `${PRINTED_PAGE_CONTEXT}.folio`;
+const PRINTED_PAGE_RUNNING_HEAD_PATH = `${PRINTED_PAGE_CONTEXT}.runningHead`;
+const LIBRARY_MOTIF_PREFIX = "segnavia:";
+const BOOK_FURNITURE = [
+	{
+		key: "segnavia:folio",
+		path: PRINTED_PAGE_FOLIO_PATH,
+		value: "folio",
+		className: "segnavia-folio",
+		region: "foot",
+		fields: []
+	},
+	{
+		key: "segnavia:running-head",
+		path: PRINTED_PAGE_RUNNING_HEAD_PATH,
+		value: "runningHead",
+		className: "segnavia-running-head",
+		region: "head",
+		fields: []
+	},
+	{
+		key: "segnavia:mark",
+		className: "segnavia-mark",
+		region: "head",
+		fields: [{
+			key: "name",
+			required: true
+		}, {
+			key: "which",
+			choices: ["first", "last"],
+			default: "first"
+		}]
+	}
+];
+const motifFieldAttribute = (key) => `${MOTIF_ATTRIBUTE}-${key}`;
+const uniqueChoices = (field, ctx) => {
+	if (field.choices && new Set(field.choices).size !== field.choices.length) ctx.addIssue({
+		code: "custom",
+		path: ["choices"],
+		message: "choices must be unique"
+	});
+	if (field.choices && field.default !== void 0 && !field.choices.includes(field.default)) ctx.addIssue({
+		code: "custom",
+		path: ["default"],
+		message: "default must be one of the field choices"
+	});
+};
+const MotifFieldShape = {
+	key: SlotKey,
+	label: z.string().min(1),
+	choices: z.array(z.string()).min(1).optional(),
+	default: z.string().optional(),
+	required: z.boolean().default(false)
+};
+const MotifField = z.object(MotifFieldShape).superRefine(uniqueChoices);
+const MotifFieldInput = z.strictObject(MotifFieldShape).superRefine(uniqueChoices);
+const MotifVersionShape = {
+	lang: z.string().min(1),
+	dir: z.enum(["ltr", "rtl"]).optional(),
+	when: z.record(SlotKey, z.string()).optional(),
+	html: z.string()
+};
+const MotifVersion = z.object(MotifVersionShape);
+const MotifVersionInput = z.strictObject(MotifVersionShape);
+const validateMotif = (motif, ctx) => {
+	const fields = new Map(motif.fields.map((field) => [field.key, field]));
+	const fieldCases = /* @__PURE__ */ new Map();
+	motif.fields.forEach((field, index) => {
+		const normalized = field.key.toLowerCase();
+		if (field.key.toLowerCase() === "lang") ctx.addIssue({
+			code: "custom",
+			path: [
+				"fields",
+				index,
+				"key"
+			],
+			message: "lang is always present and must not be declared"
+		});
+		const previous = fieldCases.get(normalized);
+		if (previous !== void 0) ctx.addIssue({
+			code: "custom",
+			path: [
+				"fields",
+				index,
+				"key"
+			],
+			message: `field key differs only by case from field ${previous + 1}`
+		});
+		else fieldCases.set(normalized, index);
+	});
+	const seen = /* @__PURE__ */ new Map();
+	motif.versions.forEach((version, index) => {
+		for (const [key, value] of Object.entries(version.when ?? {})) {
+			const field = fields.get(key);
+			if (!field?.choices) ctx.addIssue({
+				code: "custom",
+				path: [
+					"versions",
+					index,
+					"when",
+					key
+				],
+				message: `when key "${key}" must name a choice field`
+			});
+			else if (!field.choices.includes(value)) ctx.addIssue({
+				code: "custom",
+				path: [
+					"versions",
+					index,
+					"when",
+					key
+				],
+				message: `when value "${value}" must be one of the choices for "${key}"`
+			});
+		}
+		const conditions = Object.entries(version.when ?? {}).sort(([left], [right]) => left.localeCompare(right));
+		const signature = JSON.stringify([version.lang.toLowerCase(), conditions]);
+		const previous = seen.get(signature);
+		if (previous !== void 0) ctx.addIssue({
+			code: "custom",
+			path: ["versions", index],
+			message: `version duplicates version ${previous + 1} for the same lang and when values`
+		});
+		else seen.set(signature, index);
+	});
+};
+const MotifShape = {
+	key: SlotKey,
+	revision: z.string().min(1),
+	label: z.string().min(1),
+	fields: z.array(MotifField),
+	versions: z.array(MotifVersion).min(1),
+	fonts: z.array(FontReference).default([])
+};
+const MotifInputShape = {
+	...MotifShape,
+	fields: z.array(MotifFieldInput),
+	versions: z.array(MotifVersionInput).min(1),
+	fonts: z.array(FontReferenceInput).default([])
+};
+const Motif = z.object(MotifShape).superRefine(validateMotif);
+const MotifInput = z.strictObject(MotifInputShape).superRefine(validateMotif);
+function chooseMotifVersion(motif, values) {
+	const suppliedLang = values.lang;
+	const langs = new Map(motif.versions.map((version) => [version.lang.toLowerCase(), version.lang]));
+	const lang = suppliedLang ?? (langs.size === 1 ? langs.values().next().value : void 0);
+	if (!lang) return {
+		ok: false,
+		reason: "no language was supplied and the motif has more than one language"
+	};
+	const resolved = Object.fromEntries(motif.fields.map((field) => [field.key, values[field.key] ?? field.default]));
+	const normalized = lang.toLowerCase();
+	const primary = normalized.split("-")[0];
+	const matches = motif.versions.map((version, index) => ({
+		version,
+		index
+	})).filter(({ version }) => {
+		const versionLang = version.lang.toLowerCase();
+		const versionPrimary = versionLang.split("-")[0];
+		if (versionLang !== normalized && versionPrimary !== primary) return false;
+		return Object.entries(version.when ?? {}).every(([key, value]) => resolved[key] === value);
+	}).map((match) => ({
+		...match,
+		exact: match.version.lang.toLowerCase() === normalized,
+		specificity: Object.keys(match.version.when ?? {}).length
+	}));
+	if (matches.length === 0) return {
+		ok: false,
+		reason: `no version matches language "${lang}" and the supplied field values`
+	};
+	matches.sort((left, right) => Number(right.exact) - Number(left.exact) || right.specificity - left.specificity);
+	const best = matches[0];
+	const tied = matches.filter((match) => match.exact === best.exact && match.specificity === best.specificity);
+	if (tied.length > 1) return {
+		ok: false,
+		reason: `versions ${tied.map((match) => match.index + 1).join(", ")} match equally specifically`
+	};
+	return {
+		ok: true,
+		version: best.version,
+		index: best.index
+	};
+}
+//#endregion
+export { BOOK_FURNITURE, LIBRARY_MOTIF_PREFIX, MOTIF_ATTRIBUTE, Motif, MotifField, MotifFieldInput, MotifInput, MotifVersion, MotifVersionInput, PRINTED_PAGE_CONTEXT, PRINTED_PAGE_FOLIO_PATH, PRINTED_PAGE_NUMBER_PATH, PRINTED_PAGE_RUNNING_HEAD_PATH, PRINTED_PAGE_TOTAL_PATH, chooseMotifVersion, motifFieldAttribute };

package/dist/numbering.d.ts

@@ -7,6 +7,8 @@ export declare const NumberSystem: z.ZodEnum<{
   hebrew: "hebrew";
 }>;
 export type NumberSystem = z.infer<typeof NumberSystem>;
+export declare function isHebrew(lang: string | undefined): boolean;
+export declare function defaultPageNumbering(lang: string | undefined): NumberSystem;
 export declare const NoteMarker: z.ZodUnion<readonly [z.ZodEnum<{
   arabic: "arabic";
   "roman-lower": "roman-lower";

package/dist/numbering.js

@@ -6,6 +6,13 @@ const NumberSystem = z.enum([
 	"roman-upper",
 	"hebrew"
 ]);
+function isHebrew(lang) {
+	const primary = lang?.split("-")[0]?.toLowerCase();
+	return primary === "he" || primary === "iw";
+}
+function defaultPageNumbering(lang) {
+	return isHebrew(lang) ? "hebrew" : "arabic";
+}
 const NoteMarker = z.union([NumberSystem, z.literal("symbols")]);
 const ROMAN_DIGITS = [
 	[1e3, "M"],
@@ -103,4 +110,4 @@ function noteMarker(index, marker) {
 	return NOTE_SYMBOLS[(index - 1) % NOTE_SYMBOLS.length].repeat(Math.ceil(index / NOTE_SYMBOLS.length));
 }
 //#endregion
-export { NoteMarker, NumberSystem, formatNumber, noteMarker };
+export { NoteMarker, NumberSystem, defaultPageNumbering, formatNumber, isHebrew, noteMarker };

package/dist/printed-page-imposition.d.ts

@@ -0,0 +1,5 @@
+import { Imposition, Print } from "./index.js";
+//#region src/printed-page-imposition.d.ts
+/** True when an imposition leaves one printed page unchanged on one paper. */
+export declare function isPrintedPageIdentityImposition(print: Print, imposition: Imposition): boolean;
+//#endregion

package/dist/printed-page-imposition.js

@@ -0,0 +1,12 @@
+import { sheetMm, toMillimeters } from "./paper.js";
+//#region src/printed-page-imposition.ts
+const close = (left, right) => Math.abs(left - right) <= .01;
+/** True when an imposition leaves one printed page unchanged on one paper. */
+function isPrintedPageIdentityImposition(print, imposition) {
+	const pagePaper = sheetMm(print);
+	const imposedPaper = sheetMm(imposition);
+	const mm = (value) => toMillimeters(value, imposition.unit);
+	return print.orientation === imposition.orientation && close(pagePaper.width, imposedPaper.width) && close(pagePaper.height, imposedPaper.height) && imposition.columns === 1 && imposition.rows === 1 && close(mm(imposition.cell.width ?? 0), pagePaper.width) && close(mm(imposition.cell.height), pagePaper.height) && Object.values(imposition.margin).every((value) => value === 0) && imposition.gap.column === 0 && imposition.gap.row === 0 && imposition.bleed === 0 && imposition.marks === false && imposition.cornerMarks === false && imposition.fill === "sequence" && imposition.sides !== "two" && imposition.skip === 0 && imposition.fold === void 0;
+}
+//#endregion
+export { isPrintedPageIdentityImposition };

package/dist/printed-pages.d.ts

@@ -0,0 +1,125 @@
+import { z } from "zod";
+//#region src/printed-pages.d.ts
+export declare const PRINTED_PAGE_LIMIT = 500;
+export declare const PRINTED_PAGE_ROLES: readonly ["every", "first", "recto", "verso", "last"];
+export type PrintedPageRole = (typeof PRINTED_PAGE_ROLES)[number];
+export declare const ParentPageMargin: z.ZodObject<{
+  top: z.ZodNumber;
+  bottom: z.ZodNumber;
+  inner: z.ZodNumber;
+  outer: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ParentPage: z.ZodObject<{
+  name: z.ZodString;
+  basedOn: z.ZodOptional<z.ZodString>;
+  margin: z.ZodOptional<z.ZodObject<{
+    top: z.ZodNumber;
+    bottom: z.ZodNumber;
+    inner: z.ZodNumber;
+    outer: z.ZodNumber;
+  }, z.core.$strip>>;
+  head: z.ZodOptional<z.ZodString>;
+  foot: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PrintedPageRules: z.ZodPipe<z.ZodObject<{
+  every: z.ZodString;
+  first: z.ZodOptional<z.ZodString>;
+  recto: z.ZodOptional<z.ZodString>;
+  verso: z.ZodOptional<z.ZodString>;
+  last: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodTransform<{
+  last?: string | undefined;
+  verso?: string | undefined;
+  recto?: string | undefined;
+  first?: string | undefined;
+  every: string;
+}, {
+  [x: string]: unknown;
+  every: string;
+  first?: string | undefined;
+  recto?: string | undefined;
+  verso?: string | undefined;
+  last?: string | undefined;
+}>>;
+export declare const PrintedPages: z.ZodObject<{
+  parents: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    basedOn: z.ZodOptional<z.ZodString>;
+    margin: z.ZodOptional<z.ZodObject<{
+      top: z.ZodNumber;
+      bottom: z.ZodNumber;
+      inner: z.ZodNumber;
+      outer: z.ZodNumber;
+    }, z.core.$strip>>;
+    head: z.ZodOptional<z.ZodString>;
+    foot: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  rules: z.ZodPipe<z.ZodObject<{
+    every: z.ZodString;
+    first: z.ZodOptional<z.ZodString>;
+    recto: z.ZodOptional<z.ZodString>;
+    verso: z.ZodOptional<z.ZodString>;
+    last: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>, z.ZodTransform<{
+    last?: string | undefined;
+    verso?: string | undefined;
+    recto?: string | undefined;
+    first?: string | undefined;
+    every: string;
+  }, {
+    [x: string]: unknown;
+    every: string;
+    first?: string | undefined;
+    recto?: string | undefined;
+    verso?: string | undefined;
+    last?: string | undefined;
+  }>>;
+  numbering: z.ZodOptional<z.ZodEnum<{
+    arabic: "arabic";
+    "roman-lower": "roman-lower";
+    "roman-upper": "roman-upper";
+    hebrew: "hebrew";
+  }>>;
+}, z.core.$strip>;
+export type ParentPageMargin = z.infer<typeof ParentPageMargin>;
+export type ParentPage = z.infer<typeof ParentPage>;
+export type PrintedPageRules = z.infer<typeof PrintedPageRules>;
+export type PrintedPages = z.infer<typeof PrintedPages>;
+export declare const BOOK_PARENT_NAMES: {
+  readonly recto: "segnavia:recto";
+  readonly verso: "segnavia:verso";
+  readonly opener: "segnavia:opener";
+  readonly blank: "segnavia:blank";
+};
+export declare function bookParentPages(margin: ParentPageMargin): ParentPage[];
+export interface ResolvedParentPage {
+  name: string;
+  margin: ParentPageMargin;
+  head: string;
+  foot: string;
+}
+export declare function resolveParentPages(parents: ParentPage[]): ResolvedParentPage[];
+export declare function parentListIssues(parents: ParentPage[], options?: {
+  path?: (string | number)[];
+  known?: Iterable<string>;
+}): Array<{
+  path: (string | number)[];
+  message: string;
+}>;
+export declare function printedPagesIssues(value: PrintedPages): Array<{
+  path: (string | number)[];
+  message: string;
+}>;
+export declare function pagePrintedPagesIssues(page: {
+  scripts: 'refuse' | 'sandboxed';
+  print?: {
+    margin?: unknown;
+    bleed: number;
+    marks: boolean;
+  };
+  printedPages?: PrintedPages;
+}): Array<{
+  path: (string | number)[];
+  message: string;
+}>;
+//#endregion