@segnavia/format 0.9.0 → 0.10.0

package/dist/board-geometry.d.ts

@@ -0,0 +1,34 @@
+import { Board, BoardItem } from "./board.js";
+import { Box, Point, Size } from "./deck.js";
+//#region src/board-geometry.d.ts
+export interface BoardShapes {
+  items: Record<string, Size>;
+  labels: Record<string, Size>;
+}
+export interface BoardView {
+  zoom: number;
+  pan: Point;
+  viewport: Size;
+}
+export interface ZoomBounds {
+  minZoom?: number;
+  maxZoom?: number;
+}
+export interface ArrangeOptions {
+  layout: 'grid' | 'row';
+  gap: number;
+  columns?: number;
+  sectionPadding?: number;
+}
+export declare const MIN_BOARD_ZOOM = 0.05;
+export declare const MAX_BOARD_ZOOM = 8;
+export declare function itemHeight(item: BoardItem, shape: Size): number;
+export declare function boardBounds(board: Board, shapes: BoardShapes): Box;
+export declare function boardToScreen(view: BoardView, point: Point): Point;
+export declare function screenToBoard(view: BoardView, point: Point): Point;
+export declare function zoomToFit(bounds: Box, viewport: Size, padding: number): BoardView;
+export declare function zoomAt(view: BoardView, point: Point, factor: number, options?: ZoomBounds): BoardView;
+export declare function visibleItems(board: Board, shapes: BoardShapes, view: BoardView, margin: number): BoardItem[];
+export declare function itemAt(board: Board, shapes: BoardShapes, point: Point): BoardItem | undefined;
+export declare function arrange(board: Board, shapes: BoardShapes, options: ArrangeOptions): Board;
+//#endregion

package/dist/board-geometry.js

@@ -0,0 +1,184 @@
+//#region src/board-geometry.ts
+const MIN_BOARD_ZOOM = .05;
+const MAX_BOARD_ZOOM = 8;
+function requireShape(shapes, kind, id) {
+	if (!Object.hasOwn(shapes[kind], id)) throw new Error(`${kind === "items" ? "item" : "label"} "${id}" has no supplied shape; supply shapes.${kind}["${id}"]`);
+	const shape = shapes[kind][id];
+	if (!shape) throw new Error(`${kind === "items" ? "item" : "label"} "${id}" has no supplied shape; supply shapes.${kind}["${id}"]`);
+	return shape;
+}
+function requireView(view) {
+	if (!(view.zoom > 0)) throw new Error(`board view zoom is ${view.zoom}; provide a zoom greater than zero`);
+}
+function itemHeight(item, shape) {
+	return item.width * shape.height / shape.width;
+}
+function itemRectangle(item, shapes) {
+	const shape = requireShape(shapes, "items", item.id);
+	return {
+		x: item.x,
+		y: item.y,
+		width: item.width,
+		height: itemHeight(item, shape)
+	};
+}
+function union(rectangles) {
+	if (rectangles.length === 0) return {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+	const left = Math.min(...rectangles.map((rectangle) => rectangle.x));
+	const top = Math.min(...rectangles.map((rectangle) => rectangle.y));
+	const right = Math.max(...rectangles.map((rectangle) => rectangle.x + rectangle.width));
+	const bottom = Math.max(...rectangles.map((rectangle) => rectangle.y + rectangle.height));
+	return {
+		x: left,
+		y: top,
+		width: right - left,
+		height: bottom - top
+	};
+}
+function boardBounds(board, shapes) {
+	return union([
+		...board.items.map((item) => itemRectangle(item, shapes)),
+		...board.labels.map((label) => {
+			const shape = requireShape(shapes, "labels", label.id);
+			return {
+				x: label.x,
+				y: label.y,
+				width: shape.width,
+				height: shape.height
+			};
+		}),
+		...board.sections.map((section) => section.rectangle)
+	]);
+}
+function boardToScreen(view, point) {
+	requireView(view);
+	return {
+		x: point.x * view.zoom + view.pan.x,
+		y: point.y * view.zoom + view.pan.y
+	};
+}
+function screenToBoard(view, point) {
+	requireView(view);
+	return {
+		x: (point.x - view.pan.x) / view.zoom,
+		y: (point.y - view.pan.y) / view.zoom
+	};
+}
+function zoomToFit(bounds, viewport, padding) {
+	const availableWidth = viewport.width - padding * 2;
+	const availableHeight = viewport.height - padding * 2;
+	if (!(availableWidth > 0 && availableHeight > 0 && bounds.width > 0 && bounds.height > 0)) throw new Error("zoom to fit needs positive bounds and a viewport larger than twice its padding; provide non-empty bounds and usable space");
+	const zoom = Math.min(availableWidth / bounds.width, availableHeight / bounds.height);
+	return {
+		zoom,
+		pan: {
+			x: (viewport.width - bounds.width * zoom) / 2 - bounds.x * zoom,
+			y: (viewport.height - bounds.height * zoom) / 2 - bounds.y * zoom
+		},
+		viewport
+	};
+}
+function zoomAt(view, point, factor, options = {}) {
+	requireView(view);
+	if (!(factor > 0)) throw new Error(`zoom factor is ${factor}; provide a factor greater than zero`);
+	const minZoom = options.minZoom ?? .05;
+	const maxZoom = options.maxZoom ?? 8;
+	if (!(minZoom > 0 && maxZoom >= minZoom)) throw new Error("zoom bounds are invalid; provide a positive minZoom no greater than maxZoom");
+	const zoom = Math.min(maxZoom, Math.max(minZoom, view.zoom * factor));
+	const boardPoint = screenToBoard(view, point);
+	return {
+		...view,
+		zoom,
+		pan: {
+			x: point.x - boardPoint.x * zoom,
+			y: point.y - boardPoint.y * zoom
+		}
+	};
+}
+function intersects(a, b) {
+	return a.x <= b.x + b.width && a.x + a.width >= b.x && a.y <= b.y + b.height && a.y + a.height >= b.y;
+}
+function visibleItems(board, shapes, view, margin) {
+	requireView(view);
+	const viewport = {
+		x: -margin,
+		y: -margin,
+		width: view.viewport.width + margin * 2,
+		height: view.viewport.height + margin * 2
+	};
+	return board.items.filter((item) => {
+		const rectangle = itemRectangle(item, shapes);
+		const screen = boardToScreen(view, {
+			x: rectangle.x,
+			y: rectangle.y
+		});
+		return intersects({
+			x: screen.x,
+			y: screen.y,
+			width: rectangle.width * view.zoom,
+			height: rectangle.height * view.zoom
+		}, viewport);
+	});
+}
+function itemAt(board, shapes, point) {
+	for (let index = board.items.length - 1; index >= 0; index -= 1) {
+		const item = board.items[index];
+		if (!item) continue;
+		const rectangle = itemRectangle(item, shapes);
+		if (point.x >= rectangle.x && point.x <= rectangle.x + rectangle.width && point.y >= rectangle.y && point.y <= rectangle.y + rectangle.height) return item;
+	}
+}
+function arrangedItems(board, shapes, options) {
+	if (options.layout === "grid" && options.columns !== void 0 && (!Number.isFinite(options.columns) || !Number.isInteger(options.columns) || options.columns <= 0)) throw new Error(`grid columns is ${options.columns}; provide a positive integer`);
+	const columns = options.layout === "row" ? Math.max(1, board.items.length) : Math.max(1, options.columns ?? Math.ceil(Math.sqrt(board.items.length)));
+	const columnWidths = Array.from({ length: columns }, () => 0);
+	const rowHeights = Array.from({ length: Math.ceil(board.items.length / columns) }, () => 0);
+	board.items.forEach((item, index) => {
+		const column = index % columns;
+		const row = Math.floor(index / columns);
+		columnWidths[column] = Math.max(columnWidths[column] ?? 0, item.width);
+		rowHeights[row] = Math.max(rowHeights[row] ?? 0, itemHeight(item, requireShape(shapes, "items", item.id)));
+	});
+	const offsets = (sizes) => sizes.map((_, index) => sizes.slice(0, index).reduce((total, size) => total + size, 0) + index * options.gap);
+	const xOffsets = offsets(columnWidths);
+	const yOffsets = offsets(rowHeights);
+	return board.items.map((item, index) => {
+		const column = index % columns;
+		const x = xOffsets[column] ?? 0;
+		return {
+			...item,
+			x: board.direction === "rtl" ? -x - item.width : x,
+			y: yOffsets[Math.floor(index / columns)] ?? 0
+		};
+	});
+}
+function arrange(board, shapes, options) {
+	const items = arrangedItems(board, shapes, options);
+	const byId = new Map(items.map((item) => [item.id, item]));
+	const padding = options.sectionPadding ?? options.gap;
+	const sections = board.sections.map((section) => {
+		if (section.items.length === 0) return section;
+		const rectangle = union(section.items.map((id) => itemRectangle(byId.get(id), shapes)));
+		return {
+			...section,
+			rectangle: {
+				x: rectangle.x - padding,
+				y: rectangle.y - padding,
+				width: rectangle.width + padding * 2,
+				height: rectangle.height + padding * 2
+			}
+		};
+	});
+	return {
+		...board,
+		items,
+		sections
+	};
+}
+//#endregion
+export { MAX_BOARD_ZOOM, MIN_BOARD_ZOOM, arrange, boardBounds, boardToScreen, itemAt, itemHeight, screenToBoard, visibleItems, zoomAt, zoomToFit };

package/dist/board.d.ts

@@ -0,0 +1,79 @@
+import { z } from "zod";
+//#region src/board.d.ts
+export declare const BoardItem: z.ZodObject<{
+  id: z.ZodString;
+  kind: z.ZodEnum<{
+    paper: "paper";
+    page: "page";
+    book: "book";
+    shot: "shot";
+    image: "image";
+    deck: "deck";
+  }>;
+  address: z.ZodString;
+  x: z.ZodNumber;
+  y: z.ZodNumber;
+  width: z.ZodNumber;
+}, z.core.$strip>;
+export type BoardItem = z.infer<typeof BoardItem>;
+export declare const BoardLabel: z.ZodObject<{
+  id: z.ZodString;
+  text: z.ZodString;
+  x: z.ZodNumber;
+  y: z.ZodNumber;
+}, z.core.$strip>;
+export type BoardLabel = z.infer<typeof BoardLabel>;
+export declare const BoardSection: z.ZodObject<{
+  id: z.ZodString;
+  title: z.ZodString;
+  rectangle: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+  }, z.core.$strip>;
+  items: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type BoardSection = z.infer<typeof BoardSection>;
+export declare const Board: z.ZodObject<{
+  title: z.ZodString;
+  direction: z.ZodEnum<{
+    ltr: "ltr";
+    rtl: "rtl";
+  }>;
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+      paper: "paper";
+      page: "page";
+      book: "book";
+      shot: "shot";
+      image: "image";
+      deck: "deck";
+    }>;
+    address: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+  }, z.core.$strip>>;
+  labels: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>>;
+  sections: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    rectangle: z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+    }, z.core.$strip>;
+    items: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Board = z.infer<typeof Board>;
+export type BoardInput = z.input<typeof Board>;
+//#endregion

package/dist/board.js

@@ -0,0 +1,75 @@
+import { TextDirection } from "./direction.js";
+import { Box } from "./deck.js";
+import { z } from "zod";
+//#region src/board.ts
+const BoardKind = z.enum([
+	"deck",
+	"page",
+	"paper",
+	"book",
+	"image",
+	"shot"
+], { error: "item kind is unknown; use deck, page, paper, book, image or shot" });
+const BoardItem = z.object({
+	id: z.string(),
+	kind: BoardKind,
+	address: z.string().min(1, "item address is empty; provide a non-empty address"),
+	x: z.number(),
+	y: z.number(),
+	width: z.number().positive("item width is not positive; provide a width greater than zero")
+});
+const BoardLabel = z.object({
+	id: z.string(),
+	text: z.string(),
+	x: z.number(),
+	y: z.number()
+});
+const BoardSection = z.object({
+	id: z.string(),
+	title: z.string(),
+	rectangle: Box,
+	items: z.array(z.string())
+});
+const Board = z.object({
+	title: z.string(),
+	direction: TextDirection,
+	items: z.array(BoardItem),
+	labels: z.array(BoardLabel),
+	sections: z.array(BoardSection)
+}).superRefine((board, ctx) => {
+	const ids = /* @__PURE__ */ new Set();
+	const checkIds = (entries, listName) => {
+		entries.forEach((entry, index) => {
+			if (ids.has(entry.id)) ctx.addIssue({
+				code: "custom",
+				path: [
+					listName,
+					index,
+					"id"
+				],
+				message: `id "${entry.id}" is duplicated across board items, labels and sections; use a unique id`
+			});
+			ids.add(entry.id);
+		});
+	};
+	checkIds(board.items, "items");
+	checkIds(board.labels, "labels");
+	checkIds(board.sections, "sections");
+	const itemIds = new Set(board.items.map((item) => item.id));
+	board.sections.forEach((section, sectionIndex) => {
+		section.items.forEach((id, itemIndex) => {
+			if (!itemIds.has(id)) ctx.addIssue({
+				code: "custom",
+				path: [
+					"sections",
+					sectionIndex,
+					"items",
+					itemIndex
+				],
+				message: `section member "${id}" is not a board item id; use the id of an existing item`
+			});
+		});
+	});
+});
+//#endregion
+export { Board, BoardItem, BoardLabel, BoardSection };

package/dist/book.js

@@ -1,7 +1,7 @@
 import { Direction } from "./direction.js";
+import { Scripts } from "./scripts.js";
 import { NoteMarker, NumberSystem } from "./numbering.js";
 import { Paper, sheetMm } from "./paper.js";
-import { Scripts } from "./scripts.js";
 import { z } from "zod";
 //#region src/book.ts
 const BookMode = z.enum(["continuous", "paginated"]);

package/dist/deck.d.ts

@@ -16,6 +16,7 @@ export declare const Point: z.ZodObject<{
   x: z.ZodNumber;
   y: z.ZodNumber;
 }, z.core.$strip>;
+export type Point = z.infer<typeof Point>;
 export declare const ImageFit: z.ZodEnum<{
   width: "width";
   contain: "contain";

package/dist/direction.d.ts

@@ -5,7 +5,11 @@ export declare const Direction: z.ZodEnum<{
   rtl: "rtl";
   auto: "auto";
 }>;
-export type TextDirection = 'ltr' | 'rtl';
+export declare const TextDirection: z.ZodEnum<{
+  ltr: "ltr";
+  rtl: "rtl";
+}>;
+export type TextDirection = z.infer<typeof TextDirection>;
 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

@@ -5,6 +5,7 @@ const Direction = z.enum([
 	"rtl",
 	"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([
@@ -42,4 +43,4 @@ function resolveDirection(dir, lang, sample) {
 	return languageDirection(lang) ?? firstStrongDirection(sample) ?? "ltr";
 }
 //#endregion
-export { Direction, firstStrongDirection, languageDirection, resolveDirection };
+export { Direction, TextDirection, firstStrongDirection, languageDirection, resolveDirection };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { Book, BookContents, BookFrontMatterEntry, BookInput, BookMode, BookPage, BookSection, BookView, BookViewInput, Chapter, isBookContents, isHebrew, noteMarkerIssues } from "./book.js";
+import { Board, BoardInput, BoardItem, BoardLabel, BoardSection } from "./board.js";
 import { Annotation, Box, Cue, DECK_SIZE, Deck, DeckInput, DeckLimits, ImageFit, Manifest, Narration, Point, PublishedShot, SHOT_KEY, Shot, Size, Slide, SlideContent, Word, annotationCueIssues, exceedsLimits } from "./deck.js";
+import { ArrangeOptions, BoardShapes, BoardView, MAX_BOARD_ZOOM, MIN_BOARD_ZOOM, ZoomBounds, arrange, boardBounds, boardToScreen, itemAt, itemHeight, screenToBoard, visibleItems, zoomAt, zoomToFit } from "./board-geometry.js";
+import { Book, BookContents, BookFrontMatterEntry, BookInput, BookMode, BookPage, BookSection, BookView, BookViewInput, Chapter, isBookContents, isHebrew, noteMarkerIssues } from "./book.js";
 import { DeckFromSlidesOptions, SlideRow, deckFromSlides } from "./deck-from-slides.js";
 import { Direction, TextDirection, firstStrongDirection, languageDirection, resolveDirection } from "./direction.js";
 import { MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, NAMED_PAPERS, PAPER_MM, PX_PER_MM, Paper, PaperBox, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
@@ -676,6 +678,45 @@ export declare function jsonSchemas(): {
       meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>;
   }, z.core.$strip>>;
+  board: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    title: z.ZodString;
+    direction: z.ZodEnum<{
+      ltr: "ltr";
+      rtl: "rtl";
+    }>;
+    items: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      kind: z.ZodEnum<{
+        paper: "paper";
+        page: "page";
+        book: "book";
+        shot: "shot";
+        image: "image";
+        deck: "deck";
+      }>;
+      address: z.ZodString;
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodNumber;
+    }, z.core.$strip>>;
+    labels: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      text: z.ZodString;
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>>;
+    sections: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      title: z.ZodString;
+      rectangle: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>;
+      items: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
 };
 //#endregion
-export { Annotation, Book, BookContents, BookFrontMatterEntry, type BookInput, BookMode, BookPage, BookSection, BookView, type BookViewInput, Box, Chapter, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, type DeckFromSlidesOptions, type DeckInput, type DeckLimits, Direction, ImageFit, type Imposed, Lexicon, MARK_GAP_MM, MARK_LENGTH_MM, MAX_SLIDE_TIMING_MS, MAX_TRANSITION_DURATION_MS, MIN_TRANSITION_DURATION_MS, MM_PER_PT, Manifest, type MillimeterEdges, NAMED_PAPERS, Narration, NoteMarker, NumberSystem, PAPER_MM, PX_PER_MM, type PageFit, type PagePlacementKind, type PagePlacementLayout, Paper, type PaperBox, type Placement, Point, PronunciationEntry, PublishedShot, SHOT_KEY, Scripts, Shot, type ShotUse, Size, Slide, SlideContent, type SlideRow, type TextDirection, Transition, TransitionInput, Word, annotationCueIssues, deckFromSlides, exceedsLimits, firstStrongDirection, fitPage, formatNumber, impose, isBookContents, isHebrew, languageDirection, lexiconVersion, mirrorPlacement, noteMarker, noteMarkerIssues, pagePlacementLayout, printBoxes, printPadding, printProperties, resolveDirection, roundMillimeters, sheetMm, shotsUsed, toMillimeters };
+export { Annotation, type ArrangeOptions, Board, type BoardInput, BoardItem, BoardLabel, BoardSection, type BoardShapes, type BoardView, Book, BookContents, BookFrontMatterEntry, type BookInput, BookMode, BookPage, BookSection, BookView, type BookViewInput, Box, Chapter, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, type DeckFromSlidesOptions, type DeckInput, type DeckLimits, Direction, ImageFit, type Imposed, Lexicon, MARK_GAP_MM, MARK_LENGTH_MM, MAX_BOARD_ZOOM, MAX_SLIDE_TIMING_MS, MAX_TRANSITION_DURATION_MS, MIN_BOARD_ZOOM, MIN_TRANSITION_DURATION_MS, MM_PER_PT, Manifest, type MillimeterEdges, NAMED_PAPERS, Narration, NoteMarker, NumberSystem, PAPER_MM, PX_PER_MM, type PageFit, type PagePlacementKind, type PagePlacementLayout, Paper, type PaperBox, type Placement, Point, PronunciationEntry, PublishedShot, SHOT_KEY, Scripts, Shot, type ShotUse, Size, Slide, SlideContent, type SlideRow, TextDirection, Transition, TransitionInput, Word, type ZoomBounds, annotationCueIssues, arrange, boardBounds, boardToScreen, deckFromSlides, exceedsLimits, firstStrongDirection, fitPage, formatNumber, impose, isBookContents, isHebrew, itemAt, itemHeight, languageDirection, lexiconVersion, mirrorPlacement, noteMarker, noteMarkerIssues, pagePlacementLayout, printBoxes, printPadding, printProperties, resolveDirection, roundMillimeters, screenToBoard, sheetMm, shotsUsed, toMillimeters, visibleItems, zoomAt, zoomToFit };

package/dist/index.js

@@ -1,12 +1,14 @@
-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 { Direction, TextDirection, firstStrongDirection, languageDirection, resolveDirection } from "./direction.js";
 import { Scripts } from "./scripts.js";
-import { Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookShape, BookView, Chapter, isBookContents, isHebrew, 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 { Annotation, Box, Cue, DECK_SIZE, Deck, DeckShape, ImageFit, Manifest, Narration, Point, PublishedShot, SHOT_KEY, Shot, Size, Slide, SlideContent, Word, annotationCueIssues, exceedsLimits } from "./deck.js";
+import { Board, BoardItem, BoardLabel, BoardSection } from "./board.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 { Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookShape, BookView, Chapter, isBookContents, isHebrew, noteMarkerIssues } from "./book.js";
 import { Lexicon, PronunciationEntry, lexiconVersion } from "./lexicon.js";
+import { MAX_BOARD_ZOOM, MIN_BOARD_ZOOM, arrange, boardBounds, boardToScreen, itemAt, itemHeight, screenToBoard, visibleItems, zoomAt, zoomToFit } from "./board-geometry.js";
 import { deckFromSlides } from "./deck-from-slides.js";
 import { fitPage, impose, mirrorPlacement, pagePlacementLayout } from "./imposition.js";
 import { shotsUsed } from "./shots-used.js";
@@ -147,8 +149,9 @@ function jsonSchemas() {
 		imposition: z.toJSONSchema(Imposition, { io: "input" }),
 		deck: z.toJSONSchema(DeckShape, { io: "input" }),
 		manifest: z.toJSONSchema(Manifest, { io: "input" }),
-		publishedShot: z.toJSONSchema(PublishedShot, { io: "input" })
+		publishedShot: z.toJSONSchema(PublishedShot, { io: "input" }),
+		board: z.toJSONSchema(Board, { io: "input" })
 	};
 }
 //#endregion
-export { Annotation, Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookView, Box, Chapter, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, Direction, ImageFit, 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, isHebrew, jsonSchemas, languageDirection, lexiconVersion, mirrorPlacement, noteMarker, noteMarkerIssues, pagePlacementLayout, printBoxes, printPadding, printProperties, resolveDirection, roundMillimeters, sheetMm, shotsUsed, toMillimeters };
+export { Annotation, Board, BoardItem, BoardLabel, BoardSection, Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookView, Box, Chapter, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, Direction, ImageFit, Imposition, Lexicon, MARK_GAP_MM, MARK_LENGTH_MM, MAX_BOARD_ZOOM, MAX_IMPOSITION_CELLS, MAX_SLIDE_TIMING_MS, MAX_TRANSITION_DURATION_MS, MIN_BOARD_ZOOM, 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, TextDirection, Transition, Word, annotationCueIssues, arrange, boardBounds, boardToScreen, deckFromSlides, exceedsLimits, firstStrongDirection, fitPage, formatNumber, impose, isBookContents, isHebrew, itemAt, itemHeight, jsonSchemas, languageDirection, lexiconVersion, mirrorPlacement, noteMarker, noteMarkerIssues, pagePlacementLayout, printBoxes, printPadding, printProperties, resolveDirection, roundMillimeters, screenToBoard, sheetMm, shotsUsed, toMillimeters, visibleItems, zoomAt, zoomToFit };

package/package.json

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