@segnavia/format 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,38 +1,17 @@
-import { MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, PAPER_MM, PX_PER_MM, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
-import { MAX_SLIDE_TIMING_MS, SlideTiming, slideTimingIssues } from "./timing.js";
+import { Direction, firstStrongDirection, languageDirection, resolveDirection } from "./direction.js";
+import { NoteMarker, NumberSystem, formatNumber, noteMarker } from "./numbering.js";
+import { MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, NAMED_PAPERS, PAPER_MM, PX_PER_MM, Paper, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
+import { Scripts } from "./scripts.js";
+import { Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookShape, Chapter, isBookContents, noteMarkerIssues } from "./book.js";
+import { MAX_SLIDE_TIMING_MS } from "./timing.js";
 import { DEFAULT_TRANSITION_DURATION_MS, MAX_TRANSITION_DURATION_MS, MIN_TRANSITION_DURATION_MS, Transition } from "./transition.js";
-import { firstStrongDirection, languageDirection, resolveDirection } from "./direction.js";
+import { Annotation, Box, Cue, DECK_SIZE, Deck, DeckShape, Manifest, Narration, Point, PublishedShot, SHOT_KEY, Shot, Size, Slide, SlideContent, Word, annotationCueIssues, exceedsLimits } from "./deck.js";
+import { Lexicon, PronunciationEntry, lexiconVersion } from "./lexicon.js";
+import { deckFromSlides } from "./deck-from-slides.js";
 import { fitPage, impose, mirrorPlacement, pagePlacementLayout } from "./imposition.js";
 import { shotsUsed } from "./shots-used.js";
 import { z } from "zod";
 //#region src/index.ts
-const Size = z.object({
-	width: z.number().int().positive(),
-	height: z.number().int().positive()
-});
-const Scripts = z.enum(["refuse", "sandboxed"]);
-const Direction = z.enum([
-	"ltr",
-	"rtl",
-	"auto"
-]);
-const NAMED_PAPERS = [
-	"letter",
-	"legal",
-	"tabloid",
-	"a3",
-	"a4",
-	"a5"
-];
-const Paper = z.union([z.enum(NAMED_PAPERS), z.object({
-	width: z.number().positive(),
-	height: z.number().positive(),
-	unit: z.enum([
-		"mm",
-		"in",
-		"pt"
-	])
-})]);
 const Margin = z.object({
 	top: z.number().nonnegative().default(0),
 	right: z.number().nonnegative().default(0),
@@ -159,193 +138,11 @@ const Page = z.object({
 	lang: z.string().optional(),
 	print: Print.optional()
 });
-const Box = z.object({
-	x: z.number(),
-	y: z.number(),
-	width: z.number(),
-	height: z.number()
-});
-const Point = z.object({
-	x: z.number(),
-	y: z.number()
-});
-const Annotation = z.object({
-	ring: Box.nullable(),
-	badge: z.object({
-		center: Point,
-		number: z.number().int()
-	}).nullable(),
-	arrow: z.object({
-		head: Point,
-		tail: Point,
-		label: z.string().nullable()
-	}).nullable()
-});
-const SHOT_KEY = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
-const Shot = z.object({
-	key: z.string().regex(SHOT_KEY),
-	title: z.string(),
-	description: z.string().nullable().default(null),
-	tags: z.array(z.string()).default([]),
-	file: z.string(),
-	annotatedFile: z.string().nullable().default(null),
-	size: Size,
-	scale: z.number().positive(),
-	dir: z.enum(["ltr", "rtl"]).default("ltr"),
-	annotations: z.array(Annotation),
-	capturedAt: z.string(),
-	meta: z.record(z.string(), z.unknown()).default({})
-});
-const PublishedShot = z.object({
-	src: z.string(),
-	shot: Shot
-});
-const Word = z.object({
-	text: z.string(),
-	startMs: z.number().nonnegative(),
-	endMs: z.number().nonnegative()
-});
-const Cue = z.object({
-	word: z.number().int().nonnegative(),
-	annotation: z.number().int().nonnegative(),
-	untilWord: z.number().int().nonnegative().optional()
-});
-const Narration = z.object({
-	text: z.string(),
-	lang: z.string().optional(),
-	dir: Direction.optional(),
-	voice: z.string().optional(),
-	words: z.array(Word),
-	durationMs: z.number().nonnegative(),
-	audio: z.string().nullable(),
-	live: z.boolean().default(false),
-	cues: z.array(Cue).default([])
-});
-const SlideContent = z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("html"),
-		html: z.string()
-	}),
-	z.object({
-		kind: z.literal("url"),
-		src: z.string()
-	}),
-	z.object({
-		kind: z.literal("shot"),
-		src: z.string(),
-		shot: Shot
-	}),
-	z.object({
-		kind: z.literal("shot-ref"),
-		href: z.string()
-	}),
-	z.object({
-		kind: z.literal("image"),
-		src: z.string(),
-		alt: z.string()
-	})
-]);
-const Slide = z.object({
-	id: z.string(),
-	content: SlideContent,
-	notes: z.string().optional(),
-	narration: Narration.optional(),
-	beforeMs: SlideTiming.optional(),
-	afterMs: SlideTiming.optional(),
-	holdMs: SlideTiming.optional()
-});
-const DECK_SIZE = {
-	width: 1280,
-	height: 720
-};
-const DeckShape = z.object({
-	title: z.string(),
-	size: Size.default(DECK_SIZE),
-	scripts: Scripts.default("refuse"),
-	dir: Direction.optional(),
-	lang: z.string().optional(),
-	transition: Transition.optional(),
-	playback: z.enum(["step", "continuous"]).optional(),
-	captions: z.enum([
-		"on",
-		"off",
-		"viewer"
-	]).optional(),
-	slides: z.array(Slide).min(1)
-});
-function annotationCueIssues(narration, annotations) {
-	if (!narration) return [];
-	return narration.cues.filter((cue) => cue.annotation >= annotations).map((cue) => `a cue names annotation ${cue.annotation}, but the slide has ${annotations}`);
-}
-function cueIssues(slide) {
-	const narration = slide.narration;
-	if (!narration) return [];
-	const annotations = slide.content.kind === "shot" ? slide.content.shot.annotations.length : null;
-	const words = narration.live ? null : narration.words.length;
-	const issues = [];
-	for (const cue of narration.cues) {
-		for (const word of [cue.word, cue.untilWord]) if (word !== void 0 && words !== null && word >= words) issues.push(`a cue names word ${word}, but the narration has ${words} words`);
-		if (slide.content.kind !== "shot" && slide.content.kind !== "shot-ref") issues.push("a cue names an annotation, but only a shot carries annotations");
-	}
-	if (annotations !== null) issues.push(...annotationCueIssues(narration, annotations));
-	return issues;
-}
-const Deck = DeckShape.superRefine((deck, ctx) => {
-	deck.slides.forEach((slide, index) => {
-		for (const message of cueIssues(slide)) ctx.addIssue({
-			code: "custom",
-			path: [
-				"slides",
-				index,
-				"narration",
-				"cues"
-			],
-			message
-		});
-		for (const field of slideTimingIssues(slide)) {
-			const kind = field === "holdMs" ? "without" : "with";
-			ctx.addIssue({
-				code: "custom",
-				path: [
-					"slides",
-					index,
-					field
-				],
-				message: `${field} is allowed only ${kind} narration`
-			});
-		}
-	});
-	const ids = /* @__PURE__ */ new Set();
-	deck.slides.forEach((slide, index) => {
-		if (ids.has(slide.id)) ctx.addIssue({
-			code: "custom",
-			path: [
-				"slides",
-				index,
-				"id"
-			],
-			message: `slide id "${slide.id}" is used twice`
-		});
-		ids.add(slide.id);
-	});
-});
-const Manifest = z.object({
-	shots: z.record(z.string(), Shot),
-	updatedAt: z.string()
-});
-function exceedsLimits(deck, limits) {
-	const reasons = [];
-	const bytes = (text) => new TextEncoder().encode(text).length;
-	if (limits.maxSlides !== void 0 && deck.slides.length > limits.maxSlides) reasons.push(`the deck has ${deck.slides.length} slides; the limit is ${limits.maxSlides}`);
-	deck.slides.forEach((slide, index) => {
-		if (limits.maxSlideBytes !== void 0 && slide.content.kind === "html" && bytes(slide.content.html) > limits.maxSlideBytes) reasons.push(`slide ${index + 1} is ${bytes(slide.content.html)} bytes; the limit is ${limits.maxSlideBytes}`);
-		if (limits.maxNotesBytes !== void 0 && slide.notes && bytes(slide.notes) > limits.maxNotesBytes) reasons.push(`slide ${index + 1} has ${bytes(slide.notes)} bytes of notes; the limit is ${limits.maxNotesBytes}`);
-	});
-	return reasons;
-}
 function jsonSchemas() {
 	return {
+		book: z.toJSONSchema(BookShape, { 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" }),
@@ -353,4 +150,4 @@ function jsonSchemas() {
 	};
 }
 //#endregion
-export { Annotation, Box, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, Direction, Imposition, MARK_GAP_MM, MARK_LENGTH_MM, MAX_IMPOSITION_CELLS, MAX_SLIDE_TIMING_MS, MAX_TRANSITION_DURATION_MS, MIN_TRANSITION_DURATION_MS, MM_PER_PT, Manifest, Margin, NAMED_PAPERS, Narration, PAPER_MM, PX_PER_MM, Page, PageSize, Paper, Point, Print, PublishedShot, SHOT_KEY, Scripts, Shot, Size, Slide, SlideContent, Transition, Word, annotationCueIssues, exceedsLimits, firstStrongDirection, fitPage, impose, jsonSchemas, languageDirection, mirrorPlacement, pagePlacementLayout, printBoxes, printPadding, printProperties, resolveDirection, roundMillimeters, sheetMm, shotsUsed, toMillimeters };
+export { Annotation, Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, Box, Chapter, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, Direction, Imposition, Lexicon, MARK_GAP_MM, MARK_LENGTH_MM, MAX_IMPOSITION_CELLS, MAX_SLIDE_TIMING_MS, MAX_TRANSITION_DURATION_MS, MIN_TRANSITION_DURATION_MS, MM_PER_PT, Manifest, Margin, NAMED_PAPERS, Narration, NoteMarker, NumberSystem, PAPER_MM, PX_PER_MM, Page, PageSize, Paper, Point, Print, PronunciationEntry, PublishedShot, SHOT_KEY, Scripts, Shot, Size, Slide, SlideContent, Transition, Word, annotationCueIssues, deckFromSlides, exceedsLimits, firstStrongDirection, fitPage, formatNumber, impose, isBookContents, jsonSchemas, languageDirection, lexiconVersion, mirrorPlacement, noteMarker, noteMarkerIssues, pagePlacementLayout, printBoxes, printPadding, printProperties, resolveDirection, roundMillimeters, sheetMm, shotsUsed, toMillimeters };

package/dist/lexicon.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+//#region src/lexicon.d.ts
+export declare const PronunciationEntry: z.ZodObject<{
+  term: z.ZodString;
+  say: z.ZodString;
+  ipa: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PronunciationEntry = z.infer<typeof PronunciationEntry>;
+export declare const Lexicon: z.ZodObject<{
+  entries: z.ZodArray<z.ZodObject<{
+    term: z.ZodString;
+    say: z.ZodString;
+    ipa: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Lexicon = z.infer<typeof Lexicon>;
+export declare function lexiconVersion(lexicon: Lexicon): string;
+//#endregion

package/dist/lexicon.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+//#region src/lexicon.ts
+const SingleWord = z.string().min(1).regex(/^\S+$/u);
+const PronunciationEntry = z.object({
+	term: SingleWord,
+	say: SingleWord,
+	ipa: z.string().optional()
+});
+const Lexicon = z.object({ entries: z.array(PronunciationEntry) }).superRefine((lexicon, ctx) => {
+	const terms = /* @__PURE__ */ new Set();
+	lexicon.entries.forEach((entry, index) => {
+		if (terms.has(entry.term)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"entries",
+				index,
+				"term"
+			],
+			message: `the term ${JSON.stringify(entry.term)} appears more than once`
+		});
+		terms.add(entry.term);
+	});
+});
+function lexiconVersion(lexicon) {
+	const canonical = [...lexicon.entries].sort((left, right) => left.term < right.term ? -1 : left.term > right.term ? 1 : 0).map(({ term, say, ipa }) => [
+		term,
+		say,
+		ipa ?? null
+	]);
+	let hash = 14695981039346656037n;
+	for (const byte of new TextEncoder().encode(JSON.stringify(canonical))) {
+		hash ^= BigInt(byte);
+		hash = BigInt.asUintN(64, hash * 1099511628211n);
+	}
+	return hash.toString(16).padStart(16, "0").slice(0, 12);
+}
+//#endregion
+export { Lexicon, PronunciationEntry, lexiconVersion };

package/dist/numbering.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+//#region src/numbering.d.ts
+export declare const NumberSystem: z.ZodEnum<{
+  arabic: "arabic";
+  "roman-lower": "roman-lower";
+  "roman-upper": "roman-upper";
+  hebrew: "hebrew";
+}>;
+export type NumberSystem = z.infer<typeof NumberSystem>;
+export declare const NoteMarker: z.ZodUnion<readonly [z.ZodEnum<{
+  arabic: "arabic";
+  "roman-lower": "roman-lower";
+  "roman-upper": "roman-upper";
+  hebrew: "hebrew";
+}>, z.ZodLiteral<"symbols">]>;
+export type NoteMarker = z.infer<typeof NoteMarker>;
+export declare function formatNumber(value: number, system: NumberSystem): string;
+export declare function noteMarker(index: number, marker: NoteMarker): string;
+//#endregion

package/dist/numbering.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+//#region src/numbering.ts
+const NumberSystem = z.enum([
+	"arabic",
+	"roman-lower",
+	"roman-upper",
+	"hebrew"
+]);
+const NoteMarker = z.union([NumberSystem, z.literal("symbols")]);
+const ROMAN_DIGITS = [
+	[1e3, "M"],
+	[900, "CM"],
+	[500, "D"],
+	[400, "CD"],
+	[100, "C"],
+	[90, "XC"],
+	[50, "L"],
+	[40, "XL"],
+	[10, "X"],
+	[9, "IX"],
+	[5, "V"],
+	[4, "IV"],
+	[1, "I"]
+];
+const HEBREW_ONES = [
+	"",
+	"א",
+	"ב",
+	"ג",
+	"ד",
+	"ה",
+	"ו",
+	"ז",
+	"ח",
+	"ט"
+];
+const HEBREW_TENS = [
+	"",
+	"י",
+	"כ",
+	"ל",
+	"מ",
+	"נ",
+	"ס",
+	"ע",
+	"פ",
+	"צ"
+];
+const NOTE_SYMBOLS = [
+	"*",
+	"†",
+	"‡",
+	"§"
+];
+function positiveInteger(value) {
+	if (!Number.isInteger(value) || value < 1) throw new RangeError(`value ${value} must be a positive integer`);
+}
+function inRange(value, maximum, system) {
+	if (value > maximum) throw new RangeError(`${system} value ${value} is outside the range 1 to ${maximum}`);
+}
+function roman(value) {
+	let remaining = value;
+	let result = "";
+	for (const [amount, digit] of ROMAN_DIGITS) while (remaining >= amount) {
+		result += digit;
+		remaining -= amount;
+	}
+	return result;
+}
+function hebrewBelowThousand(value) {
+	const hundreds = "ת".repeat(Math.floor(value / 400));
+	const underFourHundred = value % 400;
+	const hundredsLetter = [
+		"",
+		"ק",
+		"ר",
+		"ש"
+	][Math.floor(underFourHundred / 100)];
+	const remainder = underFourHundred % 100;
+	if (remainder === 15) return `${hundreds}${hundredsLetter}טו`;
+	if (remainder === 16) return `${hundreds}${hundredsLetter}טז`;
+	return `${hundreds}${hundredsLetter}${HEBREW_TENS[Math.floor(remainder / 10)]}${HEBREW_ONES[remainder % 10]}`;
+}
+function hebrew(value) {
+	const thousands = Math.floor(value / 1e3);
+	const rest = value % 1e3;
+	return `${thousands === 0 ? "" : `${HEBREW_ONES[thousands]}׳`}${hebrewBelowThousand(rest)}`;
+}
+function formatNumber(value, system) {
+	positiveInteger(value);
+	if (system === "arabic") return String(value);
+	if (system === "hebrew") {
+		inRange(value, 9999, system);
+		return hebrew(value);
+	}
+	inRange(value, 3999, system);
+	const result = roman(value);
+	return system === "roman-lower" ? result.toLowerCase() : result;
+}
+function noteMarker(index, marker) {
+	positiveInteger(index);
+	if (marker !== "symbols") return formatNumber(index, marker);
+	return NOTE_SYMBOLS[(index - 1) % NOTE_SYMBOLS.length].repeat(Math.ceil(index / NOTE_SYMBOLS.length));
+}
+//#endregion
+export { NoteMarker, NumberSystem, formatNumber, noteMarker };

package/dist/paper.d.ts

@@ -1,5 +1,24 @@
-import { Paper, Print } from "./index.js";
+import { Print } from "./index.js";
+import { z } from "zod";
 //#region src/paper.d.ts
+export declare const NAMED_PAPERS: readonly ["letter", "legal", "tabloid", "a3", "a4", "a5"];
+export declare const Paper: z.ZodUnion<readonly [z.ZodEnum<{
+  letter: "letter";
+  legal: "legal";
+  tabloid: "tabloid";
+  a3: "a3";
+  a4: "a4";
+  a5: "a5";
+}>, z.ZodObject<{
+  width: z.ZodNumber;
+  height: z.ZodNumber;
+  unit: z.ZodEnum<{
+    mm: "mm";
+    in: "in";
+    pt: "pt";
+  }>;
+}, z.core.$strip>]>;
+export type Paper = z.infer<typeof Paper>;
 export declare const MM_PER_PT: number;
 export declare const MARK_LENGTH_MM = 5;
 export declare const MARK_GAP_MM = 1;

package/dist/paper.js

@@ -1,4 +1,22 @@
+import { z } from "zod";
 //#region src/paper.ts
+const NAMED_PAPERS = [
+	"letter",
+	"legal",
+	"tabloid",
+	"a3",
+	"a4",
+	"a5"
+];
+const Paper = z.union([z.enum(NAMED_PAPERS), z.object({
+	width: z.number().positive(),
+	height: z.number().positive(),
+	unit: z.enum([
+		"mm",
+		"in",
+		"pt"
+	])
+})]);
 const MM_PER_PT = 25.4 / 72;
 const MARK_LENGTH_MM = 5;
 const MARK_GAP_MM = 1;
@@ -156,4 +174,4 @@ function printBoxes(print) {
 	};
 }
 //#endregion
-export { MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, PAPER_MM, PX_PER_MM, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters };
+export { MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, NAMED_PAPERS, PAPER_MM, PX_PER_MM, Paper, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters };

package/dist/scripts.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+//#region src/scripts.d.ts
+export declare const Scripts: z.ZodEnum<{
+  refuse: "refuse";
+  sandboxed: "sandboxed";
+}>;
+export type Scripts = z.infer<typeof Scripts>;
+//#endregion

package/dist/scripts.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/scripts.ts
+const Scripts = z.enum(["refuse", "sandboxed"]);
+//#endregion
+export { Scripts };

package/dist/shots-used.d.ts

@@ -1,4 +1,5 @@
-import { Deck } from "./index.js";
+import { Deck } from "./deck.js";
+import "./index.js";
 //#region src/shots-used.d.ts
 export interface ShotUse {
   slide: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/format",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "module",
   "license": "MIT",
   "repository": {