document-content-model 1.9.1 → 1.10.1

package/README.md

@@ -12,16 +12,19 @@ graph TD
     ooxml("ooxml.js")
     odf("odf.js")
     pdfcodec("pdf-codec")
+    mdcodec("markdown-codec")
     documents("documents.js")
     cli("document-cli")
 
     schema --> ooxml
     schema --> odf
     schema --> pdfcodec
+    schema --> mdcodec
     schema --> documents
     ooxml --> documents
     odf --> documents
     pdfcodec --> documents
+    mdcodec --> documents
     documents --> cli
     odf --> cli
 
@@ -29,6 +32,7 @@ graph TD
     click ooxml "https://github.com/ExaDev/ooxml.js" "ooxml.js"
     click odf "https://github.com/ExaDev/odf.js" "odf.js"
     click pdfcodec "https://github.com/ExaDev/pdf-codec" "pdf-codec"
+    click mdcodec "https://github.com/ExaDev/markdown-codec" "markdown-codec"
     click documents "https://github.com/ExaDev/documents.js" "documents.js"
     click cli "https://github.com/ExaDev/document-cli" "document-cli"
 
@@ -51,6 +55,13 @@ const layout = LayoutDocumentSchema.parse(somePageLayoutValue);
 const pkg = DocumentPackageSchema.parse({ formatVersion: 1, content, layout });
 ```
 
+Every module is also importable directly, without going through the barrel above -- `tsdown` builds one file per source module rather than a single bundle, and `package.json`'s `"./*"` export makes each one individually resolvable by name:
+
+```ts
+import { schemaUriFor } from 'document-schema.js/schema-io';
+import { ColorSchema } from 'document-schema.js/color';
+```
+
 ## JSON Schema
 
 Alongside the Zod schemas/types above, the package publishes three plain [JSON Schema](https://json-schema.org) files -- generated from the same Zod definitions via [`z.toJSONSchema()`](https://zod.dev/json-schema) at build time (`scripts/generate-json-schemas.mjs`) -- for non-TypeScript consumers that want to validate against or generate types from these shapes without depending on Zod at all:

package/dist/color-AELCDH_b.d.cts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+//#region src/color.d.ts
+declare const ColorSchema: z.ZodObject<{
+  r: z.ZodNumber;
+  g: z.ZodNumber;
+  b: z.ZodNumber;
+}, z.core.$strip>;
+type Color = z.infer<typeof ColorSchema>;
+declare const COLOR_BLACK: Color;
+declare function rgbHexToColor(hex: string): Color;
+declare function colorToRgbHex(color: Color): string;
+//#endregion
+export { rgbHexToColor as a, colorToRgbHex as i, Color as n, ColorSchema as r, COLOR_BLACK as t };

package/dist/color-AELCDH_b.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+//#region src/color.d.ts
+declare const ColorSchema: z.ZodObject<{
+  r: z.ZodNumber;
+  g: z.ZodNumber;
+  b: z.ZodNumber;
+}, z.core.$strip>;
+type Color = z.infer<typeof ColorSchema>;
+declare const COLOR_BLACK: Color;
+declare function rgbHexToColor(hex: string): Color;
+declare function colorToRgbHex(color: Color): string;
+//#endregion
+export { rgbHexToColor as a, colorToRgbHex as i, Color as n, ColorSchema as r, COLOR_BLACK as t };

package/dist/color.cjs

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#region src/color.ts
+const ColorSchema = zod.z.object({
+	r: zod.z.number().min(0).max(1),
+	g: zod.z.number().min(0).max(1),
+	b: zod.z.number().min(0).max(1)
+});
+const COLOR_BLACK = {
+	r: 0,
+	g: 0,
+	b: 0
+};
+const HEX_COLOR_PATTERN = /^#?([0-9a-fA-F]{6})$/;
+const HEX_BYTE_MAX = 255;
+function rgbHexToColor(hex) {
+	const match = HEX_COLOR_PATTERN.exec(hex);
+	if (match === null) throw new Error(`not a 6-digit hex colour: ${hex}`);
+	const digits = match[1];
+	if (digits === void 0) throw new Error(`not a 6-digit hex colour: ${hex}`);
+	const r = Number.parseInt(digits.slice(0, 2), 16);
+	const g = Number.parseInt(digits.slice(2, 4), 16);
+	const b = Number.parseInt(digits.slice(4, 6), 16);
+	return {
+		r: r / HEX_BYTE_MAX,
+		g: g / HEX_BYTE_MAX,
+		b: b / HEX_BYTE_MAX
+	};
+}
+function toHexByte(component) {
+	return Math.round(component * HEX_BYTE_MAX).toString(16).padStart(2, "0");
+}
+function colorToRgbHex(color) {
+	return `${toHexByte(color.r)}${toHexByte(color.g)}${toHexByte(color.b)}`;
+}
+//#endregion
+exports.COLOR_BLACK = COLOR_BLACK;
+exports.ColorSchema = ColorSchema;
+exports.colorToRgbHex = colorToRgbHex;
+exports.rgbHexToColor = rgbHexToColor;

package/dist/color.d.cts

@@ -0,0 +1,2 @@
+import { a as rgbHexToColor, i as colorToRgbHex, n as Color, r as ColorSchema, t as COLOR_BLACK } from "./color-AELCDH_b.cjs";
+export { COLOR_BLACK, Color, ColorSchema, colorToRgbHex, rgbHexToColor };

package/dist/color.d.ts

@@ -0,0 +1,2 @@
+import { a as rgbHexToColor, i as colorToRgbHex, n as Color, r as ColorSchema, t as COLOR_BLACK } from "./color-AELCDH_b.js";
+export { COLOR_BLACK, Color, ColorSchema, colorToRgbHex, rgbHexToColor };

package/dist/color.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+//#region src/color.ts
+const ColorSchema = z.object({
+	r: z.number().min(0).max(1),
+	g: z.number().min(0).max(1),
+	b: z.number().min(0).max(1)
+});
+const COLOR_BLACK = {
+	r: 0,
+	g: 0,
+	b: 0
+};
+const HEX_COLOR_PATTERN = /^#?([0-9a-fA-F]{6})$/;
+const HEX_BYTE_MAX = 255;
+function rgbHexToColor(hex) {
+	const match = HEX_COLOR_PATTERN.exec(hex);
+	if (match === null) throw new Error(`not a 6-digit hex colour: ${hex}`);
+	const digits = match[1];
+	if (digits === void 0) throw new Error(`not a 6-digit hex colour: ${hex}`);
+	const r = Number.parseInt(digits.slice(0, 2), 16);
+	const g = Number.parseInt(digits.slice(2, 4), 16);
+	const b = Number.parseInt(digits.slice(4, 6), 16);
+	return {
+		r: r / HEX_BYTE_MAX,
+		g: g / HEX_BYTE_MAX,
+		b: b / HEX_BYTE_MAX
+	};
+}
+function toHexByte(component) {
+	return Math.round(component * HEX_BYTE_MAX).toString(16).padStart(2, "0");
+}
+function colorToRgbHex(color) {
+	return `${toHexByte(color.r)}${toHexByte(color.g)}${toHexByte(color.b)}`;
+}
+//#endregion
+export { COLOR_BLACK, ColorSchema, colorToRgbHex, rgbHexToColor };

package/dist/content.cjs

@@ -0,0 +1,341 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_color = require("./color.cjs");
+const require_geometry = require("./geometry.cjs");
+const require_metadata = require("./metadata.cjs");
+const require_style = require("./style.cjs");
+let zod = require("zod");
+//#region src/content.ts
+const ContentRunSchema = zod.z.object({
+	text: zod.z.string(),
+	bold: zod.z.boolean().optional(),
+	italic: zod.z.boolean().optional(),
+	underline: zod.z.boolean().optional(),
+	strike: zod.z.boolean().optional(),
+	fontFamily: zod.z.string().optional(),
+	sizePt: zod.z.number().positive().optional(),
+	color: require_color.ColorSchema.optional(),
+	hyperlink: zod.z.string().optional(),
+	sourcePath: zod.z.string().optional()
+});
+const ContentListMembershipSchema = zod.z.object({
+	numId: zod.z.string(),
+	level: zod.z.number().int().nonnegative()
+});
+const ContentParagraphSchema = zod.z.object({
+	kind: zod.z.literal("paragraph"),
+	runs: zod.z.array(ContentRunSchema),
+	styleId: zod.z.string().optional(),
+	alignment: require_style.AlignmentSchema.optional(),
+	list: ContentListMembershipSchema.optional(),
+	spacingBeforePt: zod.z.number().optional(),
+	spacingAfterPt: zod.z.number().optional(),
+	lineSpacing: zod.z.number().positive().optional(),
+	indentLeftPt: zod.z.number().optional(),
+	indentFirstLinePt: zod.z.number().optional(),
+	sourcePath: zod.z.string().optional()
+});
+const ContentImageBlockSchema = zod.z.object({
+	kind: zod.z.literal("image"),
+	format: zod.z.enum(["png", "jpeg"]),
+	base64: zod.z.string(),
+	widthPt: zod.z.number().positive(),
+	heightPt: zod.z.number().positive(),
+	altText: zod.z.string().optional(),
+	sourcePath: zod.z.string().optional()
+});
+const ContentPageBreakSchema = zod.z.object({
+	kind: zod.z.literal("pageBreak"),
+	sourcePath: zod.z.string().optional()
+});
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isContentRun(value) {
+	return isRecord(value) && typeof value.text === "string";
+}
+function isContentTableCell(value) {
+	return isRecord(value) && Array.isArray(value.blocks) && value.blocks.every(isContentBlock);
+}
+function isContentTableRow(value) {
+	return isRecord(value) && Array.isArray(value.cells) && value.cells.every(isContentTableCell) && (value.heightPt === void 0 || typeof value.heightPt === "number");
+}
+function isContentEmbeddedObjectKind(value) {
+	return value === "formula" || value === "wordprocessing" || value === "presentation" || value === "spreadsheet" || value === "drawing";
+}
+function isContentEmbeddedObject(value) {
+	return isRecord(value) && isContentEmbeddedObjectKind(value.objectKind) && require_geometry.BoxSchema.safeParse(value.frame).success && ContentDocumentSchema.safeParse(value.document).success;
+}
+function isContentEmbeddedObjectBlock(value) {
+	return isRecord(value) && value.kind === "embeddedObject" && isContentEmbeddedObject(value);
+}
+function isContentBlock(value) {
+	if (!isRecord(value)) return false;
+	const kind = value.kind;
+	if (kind === "paragraph") return Array.isArray(value.runs) && value.runs.every(isContentRun);
+	if (kind === "image") return (value.format === "png" || value.format === "jpeg") && typeof value.base64 === "string" && typeof value.widthPt === "number" && typeof value.heightPt === "number";
+	if (kind === "pageBreak") return true;
+	if (kind === "table") return Array.isArray(value.rows) && value.rows.every(isContentTableRow) && Array.isArray(value.columnWidthsPt) && value.columnWidthsPt.every((w) => typeof w === "number");
+	if (kind === "embeddedObject") return isContentEmbeddedObject(value);
+	return false;
+}
+const ContentBlockSchema = zod.z.custom(isContentBlock);
+const ContentEmbeddedObjectSchema = zod.z.custom(isContentEmbeddedObject);
+const ContentEmbeddedObjectBlockSchema = zod.z.custom(isContentEmbeddedObjectBlock);
+const ContentTableCellSchema = zod.z.object({
+	blocks: zod.z.array(ContentBlockSchema),
+	colSpan: zod.z.number().int().positive().optional(),
+	rowSpan: zod.z.number().int().positive().optional(),
+	background: require_color.ColorSchema.optional()
+});
+const ContentTableRowSchema = zod.z.object({
+	cells: zod.z.array(ContentTableCellSchema),
+	heightPt: zod.z.number().positive().optional()
+});
+const ContentTableSchema = zod.z.object({
+	kind: zod.z.literal("table"),
+	rows: zod.z.array(ContentTableRowSchema),
+	columnWidthsPt: zod.z.array(zod.z.number().positive()),
+	sourcePath: zod.z.string().optional()
+});
+const ContentSectionSchema = zod.z.object({
+	pageSize: require_geometry.PageSizeSchema,
+	margins: require_geometry.MarginsSchema,
+	blocks: zod.z.array(ContentBlockSchema)
+});
+const ContentShapeSchema = zod.z.object({
+	name: zod.z.string().optional(),
+	frame: require_geometry.BoxSchema,
+	rotationDeg: zod.z.number().optional(),
+	insetLeftPt: zod.z.number().nonnegative(),
+	insetTopPt: zod.z.number().nonnegative(),
+	insetRightPt: zod.z.number().nonnegative(),
+	insetBottomPt: zod.z.number().nonnegative(),
+	fontScale: zod.z.number().positive().optional(),
+	lineSpacingReduction: zod.z.number().nonnegative().optional(),
+	sourcePath: zod.z.string().optional(),
+	blocks: zod.z.array(ContentBlockSchema)
+});
+const ContentSlideSchema = zod.z.object({
+	size: require_geometry.PageSizeSchema,
+	shapes: zod.z.array(ContentShapeSchema),
+	notes: zod.z.string()
+});
+const ContentCellValueSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("number"),
+		value: zod.z.number()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("percentage"),
+		value: zod.z.number()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("currency"),
+		value: zod.z.number(),
+		currency: zod.z.string().optional()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("boolean"),
+		value: zod.z.boolean()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("date"),
+		value: zod.z.string()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("time"),
+		value: zod.z.string()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("string"),
+		value: zod.z.string()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("error"),
+		value: zod.z.string()
+	}),
+	zod.z.object({ kind: zod.z.literal("empty") })
+]);
+const ContentSheetCellSchema = zod.z.object({
+	row: zod.z.number().int().nonnegative(),
+	column: zod.z.number().int().nonnegative(),
+	value: ContentCellValueSchema,
+	formula: zod.z.string().optional(),
+	displayText: zod.z.string(),
+	runs: zod.z.array(ContentRunSchema).optional(),
+	colSpan: zod.z.number().int().positive().optional(),
+	rowSpan: zod.z.number().int().positive().optional()
+});
+const ContentSheetColumnSchema = zod.z.object({
+	index: zod.z.number().int().nonnegative(),
+	widthPt: zod.z.number().nonnegative(),
+	hidden: zod.z.boolean().optional()
+});
+const ContentSheetRowSchema = zod.z.object({
+	index: zod.z.number().int().nonnegative(),
+	heightPt: zod.z.number().nonnegative(),
+	hidden: zod.z.boolean().optional()
+});
+const ContentSheetPrintRangeSchema = zod.z.object({
+	startRow: zod.z.number().int().nonnegative(),
+	startColumn: zod.z.number().int().nonnegative(),
+	endRow: zod.z.number().int().nonnegative(),
+	endColumn: zod.z.number().int().nonnegative()
+});
+const ContentSheetRepeatRangeSchema = zod.z.object({
+	start: zod.z.number().int().nonnegative(),
+	end: zod.z.number().int().nonnegative()
+});
+const ContentSheetPrintSettingsSchema = zod.z.object({
+	pageSize: require_geometry.PageSizeSchema,
+	margins: require_geometry.MarginsSchema,
+	printRange: ContentSheetPrintRangeSchema.optional(),
+	scale: zod.z.number().positive().optional(),
+	fitToPages: zod.z.object({
+		width: zod.z.number().int().positive(),
+		height: zod.z.number().int().positive()
+	}).optional(),
+	repeatRows: ContentSheetRepeatRangeSchema.optional(),
+	repeatColumns: ContentSheetRepeatRangeSchema.optional(),
+	gridlines: zod.z.boolean(),
+	headers: zod.z.boolean(),
+	pageOrder: zod.z.enum(["downThenOver", "overThenDown"]),
+	manualBreaks: zod.z.object({
+		rows: zod.z.array(zod.z.number().int().nonnegative()),
+		columns: zod.z.array(zod.z.number().int().nonnegative())
+	}).optional()
+});
+const ContentSheetImageSchema = ContentImageBlockSchema.extend({
+	anchorRow: zod.z.number().int().nonnegative(),
+	anchorColumn: zod.z.number().int().nonnegative(),
+	offsetXPt: zod.z.number(),
+	offsetYPt: zod.z.number()
+});
+const ContentSheetSchema = zod.z.object({
+	name: zod.z.string(),
+	cells: zod.z.array(ContentSheetCellSchema),
+	columns: zod.z.array(ContentSheetColumnSchema),
+	rows: zod.z.array(ContentSheetRowSchema),
+	images: zod.z.array(ContentSheetImageSchema),
+	printSettings: ContentSheetPrintSettingsSchema,
+	embeddedObjects: zod.z.array(ContentEmbeddedObjectSchema).optional()
+});
+const ContentStrokeSchema = zod.z.object({
+	color: require_color.ColorSchema,
+	widthPt: zod.z.number().positive()
+});
+const ContentPathPointSchema = zod.z.object({
+	xPt: zod.z.number(),
+	yPt: zod.z.number()
+});
+const ContentPathSegmentSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("line"),
+	to: ContentPathPointSchema
+}), zod.z.object({
+	kind: zod.z.literal("cubic"),
+	control1: ContentPathPointSchema,
+	control2: ContentPathPointSchema,
+	to: ContentPathPointSchema
+})]);
+const ContentSubpathSchema = zod.z.object({
+	start: ContentPathPointSchema,
+	segments: zod.z.array(ContentPathSegmentSchema),
+	closed: zod.z.boolean()
+});
+const ContentVectorSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("rect"),
+		frame: require_geometry.BoxSchema,
+		fill: require_color.ColorSchema.optional(),
+		stroke: ContentStrokeSchema.optional(),
+		sourcePath: zod.z.string().optional()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("ellipse"),
+		frame: require_geometry.BoxSchema,
+		fill: require_color.ColorSchema.optional(),
+		stroke: ContentStrokeSchema.optional(),
+		sourcePath: zod.z.string().optional()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("line"),
+		from: ContentPathPointSchema,
+		to: ContentPathPointSchema,
+		stroke: ContentStrokeSchema,
+		sourcePath: zod.z.string().optional()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("path"),
+		frame: require_geometry.BoxSchema,
+		subpaths: zod.z.array(ContentSubpathSchema),
+		fill: require_color.ColorSchema.optional(),
+		fillRule: zod.z.enum(["nonzero", "evenodd"]).optional(),
+		stroke: ContentStrokeSchema.optional(),
+		sourcePath: zod.z.string().optional()
+	})
+]);
+const ContentDrawPageSchema = zod.z.object({
+	size: require_geometry.PageSizeSchema,
+	shapes: zod.z.array(ContentShapeSchema),
+	vectors: zod.z.array(ContentVectorSchema)
+});
+const CONTENT_FORMAT_VERSION = 1;
+const ContentDocumentSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("wordprocessing"),
+		formatVersion: zod.z.literal(1),
+		metadata: require_metadata.LayoutMetadataSchema,
+		sections: zod.z.array(ContentSectionSchema)
+	}),
+	zod.z.object({
+		kind: zod.z.literal("presentation"),
+		formatVersion: zod.z.literal(1),
+		metadata: require_metadata.LayoutMetadataSchema,
+		slides: zod.z.array(ContentSlideSchema)
+	}),
+	zod.z.object({
+		kind: zod.z.literal("spreadsheet"),
+		formatVersion: zod.z.literal(1),
+		metadata: require_metadata.LayoutMetadataSchema,
+		sheets: zod.z.array(ContentSheetSchema)
+	}),
+	zod.z.object({
+		kind: zod.z.literal("drawing"),
+		formatVersion: zod.z.literal(1),
+		metadata: require_metadata.LayoutMetadataSchema,
+		pages: zod.z.array(ContentDrawPageSchema)
+	})
+]);
+//#endregion
+exports.CONTENT_FORMAT_VERSION = CONTENT_FORMAT_VERSION;
+exports.ContentBlockSchema = ContentBlockSchema;
+exports.ContentCellValueSchema = ContentCellValueSchema;
+exports.ContentDocumentSchema = ContentDocumentSchema;
+exports.ContentDrawPageSchema = ContentDrawPageSchema;
+exports.ContentEmbeddedObjectBlockSchema = ContentEmbeddedObjectBlockSchema;
+exports.ContentEmbeddedObjectSchema = ContentEmbeddedObjectSchema;
+exports.ContentImageBlockSchema = ContentImageBlockSchema;
+exports.ContentListMembershipSchema = ContentListMembershipSchema;
+exports.ContentPageBreakSchema = ContentPageBreakSchema;
+exports.ContentParagraphSchema = ContentParagraphSchema;
+exports.ContentPathPointSchema = ContentPathPointSchema;
+exports.ContentPathSegmentSchema = ContentPathSegmentSchema;
+exports.ContentRunSchema = ContentRunSchema;
+exports.ContentSectionSchema = ContentSectionSchema;
+exports.ContentShapeSchema = ContentShapeSchema;
+exports.ContentSheetCellSchema = ContentSheetCellSchema;
+exports.ContentSheetColumnSchema = ContentSheetColumnSchema;
+exports.ContentSheetImageSchema = ContentSheetImageSchema;
+exports.ContentSheetPrintRangeSchema = ContentSheetPrintRangeSchema;
+exports.ContentSheetPrintSettingsSchema = ContentSheetPrintSettingsSchema;
+exports.ContentSheetRepeatRangeSchema = ContentSheetRepeatRangeSchema;
+exports.ContentSheetRowSchema = ContentSheetRowSchema;
+exports.ContentSheetSchema = ContentSheetSchema;
+exports.ContentSlideSchema = ContentSlideSchema;
+exports.ContentStrokeSchema = ContentStrokeSchema;
+exports.ContentSubpathSchema = ContentSubpathSchema;
+exports.ContentTableCellSchema = ContentTableCellSchema;
+exports.ContentTableRowSchema = ContentTableRowSchema;
+exports.ContentTableSchema = ContentTableSchema;
+exports.ContentVectorSchema = ContentVectorSchema;
+exports.isContentBlock = isContentBlock;