@segnavia/format 0.25.0 → 0.27.0

package/dist/printed-pages.d.ts

@@ -0,0 +1,118 @@
+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 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

package/dist/printed-pages.js

@@ -0,0 +1,188 @@
+import { NumberSystem } from "./numbering.js";
+import { BOOK_FURNITURE } from "./motif.js";
+import { z } from "zod";
+//#region src/printed-pages.ts
+const PRINTED_PAGE_LIMIT = 500;
+const PRINTED_PAGE_ROLES = [
+	"every",
+	"first",
+	"recto",
+	"verso",
+	"last"
+];
+const ParentPageMargin = z.object({
+	top: z.number().nonnegative(),
+	bottom: z.number().nonnegative(),
+	inner: z.number().nonnegative(),
+	outer: z.number().nonnegative()
+});
+const ParentPage = z.object({
+	name: z.string().min(1),
+	basedOn: z.string().min(1).optional(),
+	margin: ParentPageMargin.optional(),
+	head: z.string().optional(),
+	foot: z.string().optional()
+});
+const ParentName = z.string().min(1);
+const PrintedPageRules = z.object({
+	every: z.string({ error: "every is required; name the default parent page to clear this refusal" }).min(1),
+	first: ParentName.optional(),
+	recto: ParentName.optional(),
+	verso: ParentName.optional(),
+	last: ParentName.optional()
+}).passthrough().superRefine((rules, ctx) => {
+	const unknown = Object.keys(rules).filter((key) => !PRINTED_PAGE_ROLES.includes(key));
+	if (unknown.length) ctx.addIssue({
+		code: "custom",
+		message: `unknown printed-page role ${unknown.map((key) => JSON.stringify(key)).join(", ")}; use only every, first, recto, verso or last to clear this refusal`
+	});
+}).transform(({ every, first, recto, verso, last }) => ({
+	every,
+	...first === void 0 ? {} : { first },
+	...recto === void 0 ? {} : { recto },
+	...verso === void 0 ? {} : { verso },
+	...last === void 0 ? {} : { last }
+}));
+const PrintedPages = z.object({
+	parents: z.array(ParentPage).min(1),
+	rules: PrintedPageRules,
+	numbering: NumberSystem.optional()
+});
+const BOOK_PARENT_NAMES = {
+	recto: "segnavia:recto",
+	verso: "segnavia:verso",
+	opener: "segnavia:opener",
+	blank: "segnavia:blank"
+};
+function furniture(region) {
+	return BOOK_FURNITURE.filter((item) => item.region === region).map((item) => `<div class="${item.className}" data-motif="${item.key}"></div>`).join("");
+}
+function bookParentPages(margin) {
+	const held = () => ({ ...margin });
+	const head = furniture("head");
+	const foot = furniture("foot");
+	return [
+		{
+			name: BOOK_PARENT_NAMES.recto,
+			margin: held(),
+			head,
+			foot
+		},
+		{
+			name: BOOK_PARENT_NAMES.verso,
+			margin: held(),
+			head,
+			foot
+		},
+		{
+			name: BOOK_PARENT_NAMES.opener,
+			margin: held(),
+			foot
+		},
+		{
+			name: BOOK_PARENT_NAMES.blank,
+			margin: held()
+		}
+	];
+}
+const ZERO_PARENT_MARGIN = {
+	top: 0,
+	bottom: 0,
+	inner: 0,
+	outer: 0
+};
+function resolveParentPages(parents) {
+	const source = new Map(parents.map((parent) => [parent.name, parent]));
+	const resolved = /* @__PURE__ */ new Map();
+	const resolve = (parent) => {
+		const held = resolved.get(parent.name);
+		if (held) return held;
+		const baseParent = parent.basedOn ? source.get(parent.basedOn) : void 0;
+		const base = baseParent ? resolve(baseParent) : void 0;
+		const result = {
+			name: parent.name,
+			margin: parent.margin ?? base?.margin ?? ZERO_PARENT_MARGIN,
+			head: parent.head ?? base?.head ?? "",
+			foot: parent.foot ?? base?.foot ?? ""
+		};
+		resolved.set(parent.name, result);
+		return result;
+	};
+	return parents.map(resolve);
+}
+function printedPagesIssues(value) {
+	const issues = [];
+	const parents = /* @__PURE__ */ new Map();
+	value.parents.forEach((parent, index) => {
+		if (parents.has(parent.name)) issues.push({
+			path: [
+				"parents",
+				index,
+				"name"
+			],
+			message: `parent page "${parent.name}" is duplicated; give every parent page a unique name to clear this refusal`
+		});
+		parents.set(parent.name, parent);
+	});
+	for (const [role, name] of Object.entries(value.rules)) {
+		if (name === void 0) continue;
+		if (!parents.has(name)) issues.push({
+			path: ["rules", role],
+			message: `${role} names unknown parent page "${name}"; add that parent page or name an existing one to clear this refusal`
+		});
+	}
+	value.parents.forEach((parent, index) => {
+		if (parent.basedOn && !parents.has(parent.basedOn)) issues.push({
+			path: [
+				"parents",
+				index,
+				"basedOn"
+			],
+			message: `parent page "${parent.name}" is based on unknown parent page "${parent.basedOn}"; add that parent page or remove basedOn to clear this refusal`
+		});
+		const path = [];
+		let cursor = parent;
+		while (cursor) {
+			if (path.includes(cursor.name)) {
+				issues.push({
+					path: [
+						"parents",
+						index,
+						"basedOn"
+					],
+					message: `parent page inheritance has a cycle ${[...path, cursor.name].join(" -> ")}; remove a basedOn link to clear this refusal`
+				});
+				break;
+			}
+			path.push(cursor.name);
+			cursor = cursor.basedOn ? parents.get(cursor.basedOn) : void 0;
+		}
+	});
+	return issues;
+}
+function pagePrintedPagesIssues(page) {
+	if (!page.printedPages) return [];
+	const issues = printedPagesIssues(page.printedPages).map((issue) => ({
+		...issue,
+		path: ["printedPages", ...issue.path]
+	}));
+	if (!page.print) issues.push({
+		path: ["print"],
+		message: "printedPages could not establish a paper; add print.paper to clear this refusal"
+	});
+	if (page.scripts !== "refuse") issues.push({
+		path: ["scripts"],
+		message: "printedPages could not establish deterministic cloned content; set scripts to \"refuse\" to clear this refusal"
+	});
+	if (page.print?.margin) issues.push({
+		path: ["print", "margin"],
+		message: "printedPages and print.margin both own the margins; remove print.margin to clear this refusal"
+	});
+	if (page.print && (page.print.bleed > 0 || page.print.marks)) issues.push({
+		path: ["print"],
+		message: "printedPages could not establish one composed paper with bleed or marks; remove bleed and marks to clear this refusal"
+	});
+	return issues;
+}
+//#endregion
+export { BOOK_PARENT_NAMES, PRINTED_PAGE_LIMIT, PRINTED_PAGE_ROLES, ParentPage, ParentPageMargin, PrintedPageRules, PrintedPages, bookParentPages, pagePrintedPagesIssues, printedPagesIssues, resolveParentPages };

package/package.json

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