@segnavia/format 0.37.0 → 0.39.0

package/dist/json-schemas.js

@@ -0,0 +1,43 @@
+import { Media } from "./media.js";
+import { PlacementShape } from "./placement.js";
+import { SlotDeclaration, SlotDeclarationInput } from "./slots.js";
+import { DeckShape, Manifest, PublishedShot } from "./deck.js";
+import { Board } from "./board.js";
+import { FontReference, FontReferenceInput, LocalFaceTransport, LocalFacesTransport } from "./fonts.js";
+import { Motif, MotifInput } from "./motif.js";
+import { PrintSetting, PrintSettingInput } from "./paper.js";
+import { BookShape, BookView } from "./book.js";
+import { Page } from "./page.js";
+import { Cover } from "./cover.js";
+import { Imposition } from "./imposition-schema.js";
+import { Lexicon } from "./lexicon.js";
+import { z } from "zod";
+//#region src/json-schemas.ts
+function jsonSchemas() {
+	return {
+		book: z.toJSONSchema(BookShape, { io: "input" }),
+		bookView: z.toJSONSchema(BookView, { io: "input" }),
+		page: z.toJSONSchema(Page, { io: "input" }),
+		lexicon: z.toJSONSchema(Lexicon, { io: "input" }),
+		imposition: z.toJSONSchema(Imposition, { io: "input" }),
+		deck: z.toJSONSchema(DeckShape, { io: "input" }),
+		manifest: z.toJSONSchema(Manifest, { io: "input" }),
+		publishedShot: z.toJSONSchema(PublishedShot, { io: "input" }),
+		board: z.toJSONSchema(Board, { io: "input" }),
+		printSetting: z.toJSONSchema(PrintSetting, { io: "input" }),
+		printSettingInput: z.toJSONSchema(PrintSettingInput, { io: "input" }),
+		slotDeclaration: z.toJSONSchema(SlotDeclaration, { io: "input" }),
+		slotDeclarationInput: z.toJSONSchema(SlotDeclarationInput, { io: "input" }),
+		fontReference: z.toJSONSchema(FontReference, { io: "input" }),
+		fontReferenceInput: z.toJSONSchema(FontReferenceInput, { io: "input" }),
+		localFaceTransport: z.toJSONSchema(LocalFaceTransport, { io: "input" }),
+		localFacesTransport: z.toJSONSchema(LocalFacesTransport, { io: "input" }),
+		motif: z.toJSONSchema(Motif, { io: "input" }),
+		motifInput: z.toJSONSchema(MotifInput, { io: "input" }),
+		media: z.toJSONSchema(Media, { io: "input" }),
+		placement: z.toJSONSchema(PlacementShape, { io: "input" }),
+		cover: z.toJSONSchema(Cover, { io: "input" })
+	};
+}
+//#endregion
+export { jsonSchemas };

package/dist/local-font-limits.d.ts

@@ -0,0 +1,15 @@
+//#region src/local-font-limits.d.ts
+export interface LocalFontLimits {
+  count?: number;
+  bytes?: number;
+}
+export interface LocalFontLimitFace {
+  family: string;
+  bytes: number;
+}
+export declare const LOCAL_FONT_LIMITS: {
+  readonly count: 64;
+  readonly bytes: number;
+};
+export declare function localFontLimitRefusal(faces: readonly LocalFontLimitFace[], limits?: LocalFontLimits): string | undefined;
+//#endregion

package/dist/local-font-limits.js

@@ -0,0 +1,24 @@
+//#region src/local-font-limits.ts
+const LOCAL_FONT_LIMITS = {
+	count: 64,
+	bytes: 33554432
+};
+function limit(value, fallback, label) {
+	const resolved = value ?? fallback;
+	if (!Number.isSafeInteger(resolved) || resolved < 0) return `The local font ${label} limit must be a non-negative safe integer; pass valid limits to clear this refusal.`;
+	return resolved;
+}
+function localFontLimitRefusal(faces, limits = {}) {
+	const countLimit = limit(limits.count, LOCAL_FONT_LIMITS.count, "count");
+	if (typeof countLimit === "string") return countLimit;
+	const byteLimit = limit(limits.bytes, LOCAL_FONT_LIMITS.bytes, "byte");
+	if (typeof byteLimit === "string") return byteLimit;
+	if (faces.length > countLimit) return `The local face ${JSON.stringify(faces[countLimit]?.family ?? "unknown family")} exceeds the count limit of ${countLimit}; pass higher limits or declare fewer local font families to clear this refusal.`;
+	let bytes = 0;
+	for (const face of faces) {
+		bytes += face.bytes;
+		if (bytes > byteLimit) return `The local face ${JSON.stringify(face.family)} exceeds the byte limit of ${byteLimit}; pass higher limits or declare fewer local font families to clear this refusal.`;
+	}
+}
+//#endregion
+export { LOCAL_FONT_LIMITS, localFontLimitRefusal };

package/dist/media.d.ts

@@ -0,0 +1,152 @@
+import { TextDirection } from "./direction.js";
+import { z } from "zod";
+//#region src/media.d.ts
+export declare const MediaFormat: z.ZodEnum<{
+  png: "png";
+  jpeg: "jpeg";
+  gif: "gif";
+  webp: "webp";
+  svg: "svg";
+  pdf: "pdf";
+  ai: "ai";
+}>;
+export type MediaFormat = z.infer<typeof MediaFormat>;
+export declare const MEDIA_FORMATS: Record<MediaFormat, {
+  pages: boolean;
+  raster: boolean;
+}>;
+export declare const MediaText: z.ZodObject<{
+  text: z.ZodString;
+  lang: z.ZodOptional<z.ZodString>;
+  dir: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
+    ltr: "ltr";
+    rtl: "rtl";
+  }>>;
+}, z.core.$strip>;
+export type MediaText = z.infer<typeof MediaText>;
+export declare function mediaTextDirection(text: MediaText): TextDirection;
+export declare const PageSelector: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+export type PageSelector = z.infer<typeof PageSelector>;
+export declare const MediaPage: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  boxes: z.ZodObject<{
+    media: z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>;
+    crop: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>>;
+    trim: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>>;
+    bleed: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>>;
+    art: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+export type MediaPage = z.infer<typeof MediaPage>;
+export declare const Media: z.ZodObject<{
+  format: z.ZodEnum<{
+    png: "png";
+    jpeg: "jpeg";
+    gif: "gif";
+    webp: "webp";
+    svg: "svg";
+    pdf: "pdf";
+    ai: "ai";
+  }>;
+  size: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+  }, z.core.$strip>;
+  pages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    boxes: z.ZodObject<{
+      media: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>;
+      crop: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>>;
+      trim: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>>;
+      bleed: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>>;
+      art: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+  resolution: z.ZodOptional<z.ZodNumber>;
+  alt: z.ZodOptional<z.ZodObject<{
+    text: z.ZodString;
+    lang: z.ZodOptional<z.ZodString>;
+    dir: z.ZodOptional<z.ZodEnum<{
+      auto: "auto";
+      ltr: "ltr";
+      rtl: "rtl";
+    }>>;
+  }, z.core.$strip>>;
+  caption: z.ZodOptional<z.ZodObject<{
+    text: z.ZodString;
+    lang: z.ZodOptional<z.ZodString>;
+    dir: z.ZodOptional<z.ZodEnum<{
+      auto: "auto";
+      ltr: "ltr";
+      rtl: "rtl";
+    }>>;
+  }, z.core.$strip>>;
+  credit: z.ZodOptional<z.ZodObject<{
+    text: z.ZodString;
+    lang: z.ZodOptional<z.ZodString>;
+    dir: z.ZodOptional<z.ZodEnum<{
+      auto: "auto";
+      ltr: "ltr";
+      rtl: "rtl";
+    }>>;
+  }, z.core.$strip>>;
+  derivedFrom: z.ZodOptional<z.ZodObject<{
+    address: z.ZodString;
+    page: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Media = z.infer<typeof Media>;
+export type MediaInput = z.input<typeof Media>;
+//#endregion

package/dist/media.js

@@ -0,0 +1,119 @@
+import { Direction, resolveDirection } from "./direction.js";
+import { Box } from "./geometry.js";
+import { z } from "zod";
+//#region src/media.ts
+const MediaFormat = z.enum([
+	"png",
+	"jpeg",
+	"gif",
+	"webp",
+	"svg",
+	"pdf",
+	"ai"
+]);
+const MEDIA_FORMATS = {
+	png: {
+		pages: false,
+		raster: true
+	},
+	jpeg: {
+		pages: false,
+		raster: true
+	},
+	gif: {
+		pages: false,
+		raster: true
+	},
+	webp: {
+		pages: false,
+		raster: true
+	},
+	svg: {
+		pages: false,
+		raster: false
+	},
+	pdf: {
+		pages: true,
+		raster: false
+	},
+	ai: {
+		pages: true,
+		raster: false
+	}
+};
+const MediaText = z.object({
+	text: z.string().min(1),
+	lang: z.string().optional(),
+	dir: Direction.optional()
+});
+function mediaTextDirection(text) {
+	return resolveDirection(text.dir, text.lang, text.text);
+}
+const PageSelector = z.union([z.string().trim().min(1), z.number().int().positive()]);
+const PageBox = Box.superRefine((box, ctx) => {
+	if (box.width <= 0) ctx.addIssue({
+		code: "custom",
+		path: ["width"],
+		message: "box width must be positive; pass a positive width to clear this refusal"
+	});
+	if (box.height <= 0) ctx.addIssue({
+		code: "custom",
+		path: ["height"],
+		message: "box height must be positive; pass a positive height to clear this refusal"
+	});
+});
+const PAGE_BOXES = [
+	"media",
+	"crop",
+	"trim",
+	"bleed",
+	"art"
+];
+const PageBoxName = z.enum(PAGE_BOXES);
+const MediaPageBoxesShape = {
+	media: PageBox,
+	crop: PageBox.optional(),
+	trim: PageBox.optional(),
+	bleed: PageBox.optional(),
+	art: PageBox.optional()
+};
+const MediaPage = z.object({
+	name: z.string().min(1).optional(),
+	boxes: z.object(MediaPageBoxesShape)
+});
+const Media = z.object({
+	format: MediaFormat,
+	size: z.object({
+		width: z.number().positive("size.width could not be accepted; pass a positive width to clear this refusal"),
+		height: z.number().positive("size.height could not be accepted; pass a positive height to clear this refusal")
+	}),
+	pages: z.array(MediaPage).optional(),
+	resolution: z.number().positive("resolution could not be accepted; pass a positive resolution to clear this refusal").optional(),
+	alt: MediaText.optional(),
+	caption: MediaText.optional(),
+	credit: MediaText.optional(),
+	derivedFrom: z.object({
+		address: z.string().min(1),
+		page: PageSelector,
+		name: z.string().min(1).optional()
+	}).optional()
+}).superRefine((media, ctx) => {
+	const capabilities = MEDIA_FORMATS[media.format];
+	if (media.pages !== void 0 && !capabilities.pages) ctx.addIssue({
+		code: "custom",
+		path: ["pages"],
+		message: `pages could not be accepted for ${media.format}; remove pages or use a format with pages to clear this refusal`
+	});
+	if (media.resolution !== void 0 && !capabilities.raster) ctx.addIssue({
+		code: "custom",
+		path: ["resolution"],
+		message: `resolution could not be accepted for ${media.format}; remove resolution or use a raster format to clear this refusal`
+	});
+	if (media.derivedFrom !== void 0 && capabilities.pages) ctx.addIssue({
+		code: "custom",
+		path: ["derivedFrom"],
+		message: `derivedFrom could not be accepted for ${media.format}; remove derivedFrom or use a format without pages to clear this refusal`
+	});
+});
+//#endregion
+export { MEDIA_FORMATS, Media, MediaFormat, MediaPage, MediaText, PAGE_BOXES, PageBoxName, PageSelector, mediaTextDirection };

package/dist/note-series.d.ts

@@ -0,0 +1,70 @@
+import { NoteMarker } from "./numbering.js";
+import { z } from "zod";
+//#region src/note-series.d.ts
+export declare const NotePlacement: z.ZodEnum<{
+  page: "page";
+  book: "book";
+  chapter: "chapter";
+  part: "part";
+}>;
+export type NotePlacement = z.infer<typeof NotePlacement>;
+export declare const NoteNumbering: z.ZodEnum<{
+  book: "book";
+  chapter: "chapter";
+  part: "part";
+}>;
+export type NoteNumbering = z.infer<typeof NoteNumbering>;
+export declare const NoteSeries: z.ZodObject<{
+  name: z.ZodString;
+  placement: z.ZodOptional<z.ZodEnum<{
+    page: "page";
+    book: "book";
+    chapter: "chapter";
+    part: "part";
+  }>>;
+  numbering: z.ZodOptional<z.ZodEnum<{
+    book: "book";
+    chapter: "chapter";
+    part: "part";
+  }>>;
+  marker: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+    arabic: "arabic";
+    "roman-lower": "roman-lower";
+    "roman-upper": "roman-upper";
+    hebrew: "hebrew";
+  }>, z.ZodLiteral<"symbols">]>>;
+  title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type NoteSeriesInput = z.input<typeof NoteSeries>;
+export interface ResolvedNoteSeries {
+  name: string;
+  placement: NotePlacement;
+  numbering: NoteNumbering;
+  marker: NoteMarker;
+  title: string;
+  idStem: string;
+  idScope: 'chapter' | 'numbering';
+  blockClass: string;
+  bodyClass: string;
+  titleClass: string;
+  sectionIdPrefix: string;
+  markerLabel: string;
+  markerConflictSuffixes: Readonly<Record<string, string>>;
+  markBlockSeries: boolean;
+}
+interface NoteSeriesSettings {
+  lang?: string;
+  footnotes: {
+    marker?: NoteMarker;
+    restart: 'chapter' | 'book';
+  };
+  endnotes: {
+    marker?: NoteMarker;
+    placement: 'book' | 'chapter';
+    title?: string;
+  };
+  notes: NoteSeriesInput[];
+}
+export declare function resolveNoteSeries(settings: NoteSeriesSettings): ResolvedNoteSeries[];
+export declare function noteMarkerIssues(series: ResolvedNoteSeries[], used: ReadonlySet<string>): string[];
+//#endregion

package/dist/note-series.js

@@ -0,0 +1,153 @@
+import { NoteMarker, isHebrew } from "./numbering.js";
+import { REGION_NAME } from "./book-section.js";
+import { z } from "zod";
+//#region src/note-series.ts
+const NotePlacement = z.enum([
+	"page",
+	"chapter",
+	"part",
+	"book"
+]);
+const NoteNumbering = z.enum([
+	"chapter",
+	"part",
+	"book"
+]);
+const NoteSeries = z.object({
+	name: z.string().regex(REGION_NAME, "a note series name must be an HTML name token"),
+	placement: NotePlacement.optional(),
+	numbering: NoteNumbering.optional(),
+	marker: NoteMarker.optional(),
+	title: z.string().optional()
+});
+function markerOrder(lang) {
+	return isHebrew(lang) ? [
+		"hebrew",
+		"arabic",
+		"symbols",
+		"roman-lower"
+	] : [
+		"symbols",
+		"arabic",
+		"roman-lower",
+		"hebrew"
+	];
+}
+function unusedMarker(lang, used) {
+	return markerOrder(lang).find((marker) => !used.has(marker)) ?? "symbols";
+}
+function resolveCustomSeries(series) {
+	if (series.placement === void 0 || series.numbering === void 0) throw new Error(`note series ${series.name} needs placement and numbering`);
+	return {
+		...series,
+		placement: series.placement,
+		numbering: series.numbering,
+		title: series.title ?? series.name,
+		idStem: `note-${series.name}`,
+		idScope: "numbering",
+		blockClass: `segnavia-notes-${series.name}`,
+		bodyClass: `segnavia-note-${series.name}`,
+		titleClass: "segnavia-notes-title",
+		sectionIdPrefix: `segnavia-notes-${series.name}`,
+		markerLabel: `note series ${series.name}`,
+		markerConflictSuffixes: {},
+		markBlockSeries: true
+	};
+}
+function resolveNoteSeries(settings) {
+	const hebrew = isHebrew(settings.lang);
+	const declared = new Map(settings.notes.map((series) => [series.name, series]));
+	const footnotePresentation = {
+		idStem: "fn",
+		idScope: "chapter",
+		blockClass: "segnavia-footnotes",
+		bodyClass: "segnavia-footnote",
+		titleClass: "segnavia-notes-title",
+		sectionIdPrefix: "segnavia-notes-footnote",
+		markerLabel: "footnote",
+		markerConflictSuffixes: { endnote: "the two must differ when both kinds are used" },
+		markBlockSeries: false
+	};
+	const endnotePresentation = {
+		idStem: "en",
+		idScope: "numbering",
+		blockClass: "segnavia-notes-endnote",
+		bodyClass: "segnavia-endnote",
+		titleClass: "segnavia-endnotes-title",
+		sectionIdPrefix: "segnavia-endnotes",
+		markerLabel: "endnote",
+		markerConflictSuffixes: {},
+		markBlockSeries: true
+	};
+	const inputs = [
+		{
+			name: "footnote",
+			placement: "page",
+			numbering: settings.footnotes.restart,
+			marker: settings.footnotes.marker ?? (hebrew ? "hebrew" : "symbols"),
+			title: hebrew ? "מקורות" : "Footnotes",
+			...footnotePresentation,
+			...declared.get("footnote")
+		},
+		{
+			name: "endnote",
+			placement: settings.endnotes.placement,
+			numbering: "book",
+			marker: settings.endnotes.marker ?? "arabic",
+			title: settings.endnotes.title ?? (hebrew ? "הערות" : "Notes"),
+			...endnotePresentation,
+			...declared.get("endnote")
+		},
+		...settings.notes.filter(({ name }) => name !== "footnote" && name !== "endnote").map(resolveCustomSeries)
+	];
+	const used = /* @__PURE__ */ new Set();
+	return inputs.map((series) => {
+		const marker = series.marker ?? unusedMarker(settings.lang, used);
+		used.add(marker);
+		return {
+			name: series.name,
+			placement: series.placement,
+			numbering: series.numbering,
+			marker,
+			title: series.title,
+			idStem: series.idStem,
+			idScope: series.idScope,
+			blockClass: series.blockClass,
+			bodyClass: series.bodyClass,
+			titleClass: series.titleClass,
+			sectionIdPrefix: series.sectionIdPrefix,
+			markerLabel: series.markerLabel,
+			markerConflictSuffixes: series.markerConflictSuffixes,
+			markBlockSeries: series.markBlockSeries
+		};
+	});
+}
+function noteSeriesIssues(series, mode) {
+	const issues = [];
+	series.forEach((item, index) => {
+		if (mode === "continuous" && (item.placement === "chapter" || item.placement === "part")) issues.push({
+			path: [
+				"notes",
+				index,
+				"placement"
+			],
+			message: `note series ${item.name} uses ${item.placement} placement only available in paginated mode; use page or book placement, or paginated mode`
+		});
+	});
+	return issues;
+}
+function noteMarkerIssues(series, used) {
+	const active = series.filter(({ name }) => used.has(name));
+	const issues = [];
+	for (let left = 0; left < active.length; left += 1) for (let right = left + 1; right < active.length; right += 1) {
+		const a = active[left];
+		const b = active[right];
+		if (!a || !b) continue;
+		if (a.marker !== b.marker) continue;
+		const suffix = a.markerConflictSuffixes[b.name] ?? b.markerConflictSuffixes[a.name] ?? "used series must have different markers";
+		issues.push(`${a.markerLabel} and ${b.markerLabel} markers are both ${a.marker}; ${suffix}`);
+	}
+	return issues;
+}
+//#endregion
+export { NoteNumbering, NotePlacement, NoteSeries, noteMarkerIssues, noteSeriesIssues, resolveNoteSeries };