@arslankhan/doc-forge 0.0.0-stage → 0.1.1

package/dist/validate.js

@@ -0,0 +1,977 @@
+import { parseBindingPath } from "./binding-path.js";
+import { DOCUMENT_TYPES, isSupportedSchemaVersion, SUPPORTED_SCHEMA_VERSIONS } from "./schema.js";
+import { cssColor, cssFontFamily } from "./render/css.js";
+import { AGGREGATES, ELEMENT_TYPES, FONT_STYLES, FONT_WEIGHT_NAMES, LAYOUT_MODES, LENGTH_UNITS, PAGE_ORIENTATIONS, PAPER_SIZES, REPORT_BAND_TYPES, SORT_DIRECTIONS, TEXT_ALIGNS, TEXT_DECORATIONS, VERTICAL_ALIGNS, } from "./types.js";
+export class TemplateValidationError extends Error {
+    errors;
+    constructor(errors) {
+        super(formatIssues(errors));
+        this.name = "TemplateValidationError";
+        this.errors = errors;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+const TEMPLATE_KEYS = ["schemaVersion", "id", "name", "documentType", "page", "elements", "invoice", "report"];
+const INVOICE_OPTION_KEYS = ["fractionDigits"];
+const REPORT_OPTION_KEYS = [
+    "title",
+    "description",
+    "emptyText",
+    "showPageNumber",
+    "pageHeader",
+    "pageFooter",
+    "reportHeader",
+    "reportFooter",
+];
+const REPORT_TEXT_BAND_KEYS = ["id", "type", "text", "binding"];
+const REPORT_IMAGE_BAND_KEYS = ["id", "type", "src", "alt", "binding"];
+const PAGE_KEYS = ["paperSize", "orientation", "dimensions", "margins", "layoutMode"];
+const PAGE_DIMENSION_KEYS = ["width", "height", "unit"];
+const MARGIN_KEYS = ["top", "right", "bottom", "left"];
+const POSITION_KEYS = ["x", "y"];
+const ELEMENT_DIMENSION_KEYS = ["width", "height"];
+const BINDING_KEYS = ["path", "fallback", "prefix", "suffix", "format"];
+const FORMAT_KEYS = ["style", "locale", "currency", "minimumFractionDigits", "maximumFractionDigits", "dateStyle"];
+const FORMAT_STYLES = ["decimal", "currency", "percent", "date"];
+const DATE_STYLES = ["iso", "short", "medium", "long"];
+const ITEMS_KEYS = [
+    "id",
+    "type",
+    "position",
+    "dimensions",
+    "style",
+    "itemsPath",
+    "columns",
+    "showHeader",
+    "emptyText",
+    "headerStyle",
+    "padding",
+];
+const COLUMN_KEYS = ["id", "header", "binding", "width", "align", "visible"];
+const REPORT_TABLE_KEYS = [
+    "id",
+    "type",
+    "position",
+    "dimensions",
+    "style",
+    "collectionPath",
+    "columns",
+    "showHeader",
+    "emptyText",
+    "headerStyle",
+    "padding",
+    "alternateRowColor",
+    "oddRowColor",
+    "evenRowColor",
+    "stripeRows",
+    "bodyStyle",
+    "groupStyle",
+    "subtotalStyle",
+    "grandTotalStyle",
+    "tableAlign",
+    "headerHeight",
+    "rowRules",
+    "groupBy",
+    "sort",
+    "showGrandTotal",
+    "grandTotalLabel",
+    "pageBreakBefore",
+];
+const REPORT_COLUMN_KEYS = ["id", "header", "binding", "width", "align", "visible", "aggregate", "headerStyle", "style"];
+const ROW_RULE_KEYS = ["path", "operator", "value", "style"];
+const ROW_RULE_OPERATORS = ["eq", "neq", "gt", "gte", "lt", "lte", "blank"];
+const BOX_EDGE_KEYS = ["top", "right", "bottom", "left"];
+const BORDER_EDGE_KEYS = ["width", "color", "style"];
+const BORDER_LINE_STYLES = ["solid", "dashed", "dotted", "double", "none"];
+const REPORT_GROUP_KEYS = ["path", "label"];
+const REPORT_SORT_KEYS = ["path", "direction"];
+const TOTALS_KEYS = ["id", "type", "position", "dimensions", "style", "rows"];
+const TOTAL_ROW_KEYS = ["id", "label", "binding", "visible", "hideWhenZero"];
+const TEXT_KEYS = ["id", "type", "position", "dimensions", "style", "text", "binding"];
+const IMAGE_KEYS = ["id", "type", "position", "dimensions", "style", "src", "alt", "binding"];
+const SHAPE_KEYS = ["id", "type", "position", "dimensions", "style"];
+const STYLE_STRING_KEYS = ["color", "backgroundColor", "fontFamily", "borderColor", "strokeColor"];
+const STYLE_COLOR_KEYS = ["color", "backgroundColor", "borderColor", "strokeColor"];
+const STYLE_KEYS = [
+    ...STYLE_STRING_KEYS,
+    "fontSize",
+    "fontWeight",
+    "fontStyle",
+    "textAlign",
+    "verticalAlign",
+    "textDecoration",
+    "lineHeight",
+    "borderWidth",
+    "borderStyle",
+    "borderRadius",
+    "borderTop",
+    "borderRight",
+    "borderBottom",
+    "borderLeft",
+    "padding",
+    "opacity",
+    "strokeWidth",
+];
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+function formatIssues(errors) {
+    if (errors.length === 0) {
+        return "Template is invalid.";
+    }
+    const lines = errors.map((error) => {
+        const location = error.path.length > 0 ? error.path : "(template)";
+        return `${location}: ${error.message}`;
+    });
+    return `Template is invalid.\n${lines.join("\n")}`;
+}
+function issue(path, code, message) {
+    return { path, code, message };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isOneOf(values, value) {
+    return typeof value === "string" && values.includes(value);
+}
+function rejectUnknown(value, allowed, path, errors) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key)) {
+            const child = path.length > 0 ? `${path}.${key}` : key;
+            errors.push(issue(child, "unknown_property", `Unknown property "${key}".`));
+        }
+    }
+}
+export function validateTemplate(input) {
+    const errors = [];
+    if (!isRecord(input)) {
+        return {
+            valid: false,
+            errors: [issue("", "invalid_type", "Template must be an object.")],
+        };
+    }
+    rejectUnknown(input, TEMPLATE_KEYS, "", errors);
+    validateSchemaVersion(input.schemaVersion, errors);
+    validateIdentifier(input.id, "id", errors, "Template id");
+    validateName(input.name, errors);
+    validateDocumentType(input.documentType, errors);
+    validatePage(input.page, errors);
+    validateInvoiceOptions(input.invoice, errors);
+    validateReportOptions(input.report, errors);
+    validateElements(input.elements, errors);
+    return { valid: errors.length === 0, errors };
+}
+function validateSchemaVersion(value, errors) {
+    if (value === undefined) {
+        errors.push(issue("schemaVersion", "required", "Schema version is required."));
+        return;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || !isSupportedSchemaVersion(value)) {
+        const supported = SUPPORTED_SCHEMA_VERSIONS.join(", ");
+        errors.push(issue("schemaVersion", "unsupported_schema_version", `Schema version ${String(value)} is not supported. Supported version: ${supported}.`));
+    }
+}
+function validateIdentifier(value, path, errors, label) {
+    if (value === undefined) {
+        errors.push(issue(path, "required", `${label} is required.`));
+        return;
+    }
+    if (typeof value !== "string" || !IDENTIFIER.test(value)) {
+        errors.push(issue(path, "invalid_id", `${label} must be a non-empty identifier without spaces.`));
+    }
+}
+function validateName(value, errors) {
+    if (value === undefined) {
+        errors.push(issue("name", "required", "Template name is required."));
+        return;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        errors.push(issue("name", "invalid_name", "Template name must be a non-empty string."));
+    }
+}
+function validateDocumentType(value, errors) {
+    if (value === undefined) {
+        errors.push(issue("documentType", "required", "Document type is required."));
+        return;
+    }
+    if (!isOneOf(DOCUMENT_TYPES, value)) {
+        errors.push(issue("documentType", "invalid_document_type", 'Document type must be "generic", "invoice", or "report".'));
+    }
+}
+function validatePage(value, errors) {
+    if (value === undefined) {
+        errors.push(issue("page", "required", "Page configuration is required."));
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(issue("page", "invalid_type", "Page configuration must be an object."));
+        return;
+    }
+    rejectUnknown(value, PAGE_KEYS, "page", errors);
+    if (value.paperSize === undefined) {
+        errors.push(issue("page.paperSize", "required", "Paper size is required."));
+    }
+    else if (!isOneOf(PAPER_SIZES, value.paperSize)) {
+        errors.push(issue("page.paperSize", "invalid_paper_size", 'Paper size must be "A4", "Letter", "Legal", or "custom".'));
+    }
+    if (value.orientation === undefined) {
+        errors.push(issue("page.orientation", "required", "Page orientation is required."));
+    }
+    else if (!isOneOf(PAGE_ORIENTATIONS, value.orientation)) {
+        errors.push(issue("page.orientation", "invalid_orientation", 'Orientation must be "portrait" or "landscape".'));
+    }
+    if (value.layoutMode === undefined) {
+        errors.push(issue("page.layoutMode", "required", "Layout mode is required."));
+    }
+    else if (!isOneOf(LAYOUT_MODES, value.layoutMode)) {
+        errors.push(issue("page.layoutMode", "invalid_layout_mode", 'Layout mode must be "fixed" or "flow".'));
+    }
+    if (value.dimensions === undefined) {
+        if (value.paperSize === "custom") {
+            errors.push(issue("page.dimensions", "required", "Custom paper sizes require dimensions."));
+        }
+    }
+    else {
+        validatePageDimensions(value.dimensions, errors);
+    }
+    if (value.margins === undefined) {
+        errors.push(issue("page.margins", "required", "Page margins are required."));
+    }
+    else {
+        validateMargins(value.margins, errors);
+    }
+}
+function validatePageDimensions(value, errors) {
+    const path = "page.dimensions";
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_type", "Page dimensions must be an object."));
+        return;
+    }
+    rejectUnknown(value, PAGE_DIMENSION_KEYS, path, errors);
+    validatePositiveNumber(value.width, `${path}.width`, errors, "Width");
+    validatePositiveNumber(value.height, `${path}.height`, errors, "Height");
+    if (value.unit === undefined) {
+        errors.push(issue(`${path}.unit`, "required", "Dimension unit is required."));
+    }
+    else if (!isOneOf(LENGTH_UNITS, value.unit)) {
+        errors.push(issue(`${path}.unit`, "invalid_unit", 'Unit must be "mm", "pt", "in", or "px".'));
+    }
+}
+function validateMargins(value, errors) {
+    const path = "page.margins";
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_type", "Page margins must be an object."));
+        return;
+    }
+    rejectUnknown(value, MARGIN_KEYS, path, errors);
+    for (const edge of MARGIN_KEYS) {
+        validateNonNegativeNumber(value[edge], `${path}.${edge}`, errors, edge);
+    }
+}
+function validatePositiveNumber(value, path, errors, label) {
+    if (value === undefined) {
+        errors.push(issue(path, "required", `${label} is required.`));
+        return;
+    }
+    if (!isFiniteNumber(value) || value <= 0) {
+        errors.push(issue(path, "invalid_number", `${label} must be a finite number greater than 0.`));
+    }
+}
+function validateNonNegativeNumber(value, path, errors, label) {
+    if (value === undefined) {
+        errors.push(issue(path, "required", `${label} is required.`));
+        return;
+    }
+    if (!isFiniteNumber(value) || value < 0) {
+        errors.push(issue(path, "invalid_number", `${label} must be a finite number greater than or equal to 0.`));
+    }
+}
+function validateElements(value, errors) {
+    if (value === undefined) {
+        errors.push(issue("elements", "required", "Elements are required."));
+        return;
+    }
+    if (!Array.isArray(value)) {
+        errors.push(issue("elements", "invalid_type", "Elements must be an array."));
+        return;
+    }
+    const seen = new Map();
+    value.forEach((element, index) => {
+        validateElement(element, index, seen, errors);
+    });
+}
+function validateElement(value, index, seen, errors) {
+    const path = `elements[${index}]`;
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_type", "Element must be an object."));
+        return;
+    }
+    const type = value.type;
+    const knownType = isElementType(type);
+    if (!knownType) {
+        if (type === undefined) {
+            errors.push(issue(`${path}.type`, "required", "Element type is required."));
+        }
+        else {
+            errors.push(issue(`${path}.type`, "invalid_element_type", 'Element type must be "text", "image", "line", or "rectangle".'));
+        }
+    }
+    else {
+        rejectUnknown(value, keysForElement(type), path, errors);
+    }
+    if (typeof value.id === "string" && IDENTIFIER.test(value.id)) {
+        const previous = seen.get(value.id);
+        if (previous === undefined) {
+            seen.set(value.id, index);
+        }
+        else {
+            errors.push(issue(`${path}.id`, "duplicate_element_id", `Element id "${value.id}" is duplicated (also used at elements[${previous}]).`));
+        }
+    }
+    else {
+        validateIdentifier(value.id, `${path}.id`, errors, "Element id");
+    }
+    validatePosition(value.position, `${path}.position`, errors);
+    if (!knownType) {
+        return;
+    }
+    validateElementDimensions(value.dimensions, `${path}.dimensions`, errors, type === "line");
+    validateStyle(value.style, `${path}.style`, errors);
+    if (type === "text") {
+        validateTextFields(value, path, errors);
+    }
+    else if (type === "image") {
+        validateImageFields(value, path, errors);
+    }
+    else if (type === "items") {
+        validateItemsFields(value, path, errors);
+    }
+    else if (type === "totals") {
+        validateTotalsFields(value, path, errors);
+    }
+    else if (type === "reportTable") {
+        validateReportTableFields(value, path, errors);
+    }
+}
+function isElementType(value) {
+    return isOneOf(ELEMENT_TYPES, value);
+}
+function keysForElement(type) {
+    if (type === "text") {
+        return TEXT_KEYS;
+    }
+    if (type === "image") {
+        return IMAGE_KEYS;
+    }
+    if (type === "items") {
+        return ITEMS_KEYS;
+    }
+    if (type === "totals") {
+        return TOTALS_KEYS;
+    }
+    if (type === "reportTable") {
+        return REPORT_TABLE_KEYS;
+    }
+    return SHAPE_KEYS;
+}
+function validatePosition(value, path, errors) {
+    if (value === undefined) {
+        errors.push(issue(path, "required", "Position is required."));
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_type", "Position must be an object."));
+        return;
+    }
+    rejectUnknown(value, POSITION_KEYS, path, errors);
+    validateCoordinate(value.x, `${path}.x`, errors, "x");
+    validateCoordinate(value.y, `${path}.y`, errors, "y");
+}
+function validateCoordinate(value, path, errors, axis) {
+    if (value === undefined) {
+        errors.push(issue(path, "required", `Position ${axis} is required.`));
+        return;
+    }
+    if (!isFiniteNumber(value) || value < 0) {
+        errors.push(issue(path, "invalid_position", `Position ${axis} must be a finite number greater than or equal to 0.`));
+    }
+}
+function validateElementDimensions(value, path, errors, allowZeroSpan) {
+    if (value === undefined) {
+        errors.push(issue(path, "required", "Dimensions are required."));
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_type", "Dimensions must be an object."));
+        return;
+    }
+    rejectUnknown(value, ELEMENT_DIMENSION_KEYS, path, errors);
+    const widthOk = validateSpan(value.width, `${path}.width`, errors, "Width", allowZeroSpan);
+    const heightOk = validateSpan(value.height, `${path}.height`, errors, "Height", allowZeroSpan);
+    if (allowZeroSpan && widthOk && heightOk && value.width === 0 && value.height === 0) {
+        errors.push(issue(path, "invalid_dimensions", "A line must have a non-zero width or height."));
+    }
+}
+function validateSpan(value, path, errors, label, allowZero) {
+    if (value === undefined) {
+        errors.push(issue(path, "required", `${label} is required.`));
+        return false;
+    }
+    const valid = allowZero ? isFiniteNumber(value) && value >= 0 : isFiniteNumber(value) && value > 0;
+    if (!valid) {
+        const comparison = allowZero ? "greater than or equal to 0" : "greater than 0";
+        errors.push(issue(path, "invalid_dimensions", `${label} must be a finite number ${comparison}.`));
+        return false;
+    }
+    return true;
+}
+function validateStyle(value, path, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_type", "Style must be an object."));
+        return;
+    }
+    rejectUnknown(value, STYLE_KEYS, path, errors);
+    for (const key of STYLE_STRING_KEYS) {
+        const property = value[key];
+        if (property !== undefined && typeof property !== "string") {
+            errors.push(issue(`${path}.${key}`, "invalid_style", `${key} must be a string.`));
+        }
+    }
+    for (const key of STYLE_COLOR_KEYS) {
+        const property = value[key];
+        if (typeof property === "string" && cssColor(property) === null) {
+            errors.push(issue(`${path}.${key}`, "invalid_color", `${key} must be a CSS color.`));
+        }
+    }
+    if (typeof value.fontFamily === "string" && value.fontFamily.trim().length > 0 && cssFontFamily(value.fontFamily) === null) {
+        errors.push(issue(`${path}.fontFamily`, "invalid_style", "fontFamily must be a plain font family list."));
+    }
+    validateOptionalPositive(value.fontSize, `${path}.fontSize`, errors, "fontSize");
+    validateOptionalPositive(value.lineHeight, `${path}.lineHeight`, errors, "lineHeight");
+    validateOptionalNonNegative(value.borderWidth, `${path}.borderWidth`, errors, "borderWidth");
+    validateOptionalNonNegative(value.borderRadius, `${path}.borderRadius`, errors, "borderRadius");
+    validateOptionalNonNegative(value.strokeWidth, `${path}.strokeWidth`, errors, "strokeWidth");
+    validateBoxEdges(value.padding, `${path}.padding`, errors);
+    for (const edge of ["borderTop", "borderRight", "borderBottom", "borderLeft"]) {
+        validateBorderEdge(value[edge], `${path}.${edge}`, errors);
+    }
+    if (value.opacity !== undefined && (!isFiniteNumber(value.opacity) || value.opacity < 0 || value.opacity > 1)) {
+        errors.push(issue(`${path}.opacity`, "invalid_style", "opacity must be a finite number from 0 to 1."));
+    }
+    if (value.fontWeight !== undefined && !isFontWeight(value.fontWeight)) {
+        errors.push(issue(`${path}.fontWeight`, "invalid_style", 'fontWeight must be "normal", "medium", "bold", "lighter", "bolder", or a finite number greater than 0.'));
+    }
+    if (value.fontStyle !== undefined && !isOneOf(FONT_STYLES, value.fontStyle)) {
+        errors.push(issue(`${path}.fontStyle`, "invalid_style", 'fontStyle must be "normal" or "italic".'));
+    }
+    if (value.textAlign !== undefined && !isOneOf(TEXT_ALIGNS, value.textAlign)) {
+        errors.push(issue(`${path}.textAlign`, "invalid_style", 'textAlign must be "left", "center", "right", or "justify".'));
+    }
+    if (value.verticalAlign !== undefined && !isOneOf(VERTICAL_ALIGNS, value.verticalAlign)) {
+        errors.push(issue(`${path}.verticalAlign`, "invalid_style", 'verticalAlign must be "top", "middle", or "bottom".'));
+    }
+    if (value.textDecoration !== undefined && !isOneOf(TEXT_DECORATIONS, value.textDecoration)) {
+        errors.push(issue(`${path}.textDecoration`, "invalid_style", 'textDecoration must be "none", "underline", or "line-through".'));
+    }
+    if (value.borderStyle !== undefined && !isOneOf(BORDER_LINE_STYLES, value.borderStyle)) {
+        errors.push(issue(`${path}.borderStyle`, "invalid_style", 'borderStyle must be "solid", "dashed", "dotted", "double", or "none".'));
+    }
+}
+function validateBoxEdges(value, path, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_style", "padding must be an object."));
+        return;
+    }
+    rejectUnknown(value, BOX_EDGE_KEYS, path, errors);
+    for (const edge of BOX_EDGE_KEYS) {
+        validateOptionalNonNegative(value[edge], `${path}.${edge}`, errors, edge);
+    }
+}
+function validateBorderEdge(value, path, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_style", "A border side must be an object."));
+        return;
+    }
+    rejectUnknown(value, BORDER_EDGE_KEYS, path, errors);
+    validateOptionalNonNegative(value.width, `${path}.width`, errors, "width");
+    if (value.color !== undefined && (typeof value.color !== "string" || cssColor(value.color) === null)) {
+        errors.push(issue(`${path}.color`, "invalid_color", "Border color must be a CSS color."));
+    }
+    if (value.style !== undefined && !isOneOf(BORDER_LINE_STYLES, value.style)) {
+        errors.push(issue(`${path}.style`, "invalid_style", 'Border style must be "solid", "dashed", "dotted", "double", or "none".'));
+    }
+}
+function isFontWeight(value) {
+    if (typeof value === "string") {
+        return isOneOf(FONT_WEIGHT_NAMES, value);
+    }
+    return isFiniteNumber(value) && value > 0;
+}
+function validateOptionalPositive(value, path, errors, label) {
+    if (value === undefined) {
+        return;
+    }
+    if (!isFiniteNumber(value) || value <= 0) {
+        errors.push(issue(path, "invalid_style", `${label} must be a finite number greater than 0.`));
+    }
+}
+function validateOptionalNonNegative(value, path, errors, label) {
+    if (value === undefined) {
+        return;
+    }
+    if (!isFiniteNumber(value) || value < 0) {
+        errors.push(issue(path, "invalid_style", `${label} must be a finite number greater than or equal to 0.`));
+    }
+}
+function validateTextFields(value, path, errors) {
+    if (value.text !== undefined && typeof value.text !== "string") {
+        errors.push(issue(`${path}.text`, "invalid_type", "Text content must be a string."));
+    }
+    if (value.binding !== undefined) {
+        validateBinding(value.binding, `${path}.binding`, errors);
+    }
+}
+function validateImageFields(value, path, errors) {
+    if (value.src !== undefined) {
+        if (typeof value.src !== "string" || value.src.trim().length === 0) {
+            errors.push(issue(`${path}.src`, "invalid_type", "Image src must be a non-empty string."));
+        }
+        else if (/^\s*javascript:/i.test(value.src)) {
+            errors.push(issue(`${path}.src`, "invalid_src", "Image src must not be a javascript: URL."));
+        }
+    }
+    if (value.alt !== undefined && typeof value.alt !== "string") {
+        errors.push(issue(`${path}.alt`, "invalid_type", "Image alt text must be a string."));
+    }
+    if (value.binding !== undefined) {
+        validateBinding(value.binding, `${path}.binding`, errors);
+        if (isRecord(value.binding) &&
+            typeof value.binding.fallback === "string" &&
+            /^\s*javascript:/i.test(value.binding.fallback)) {
+            errors.push(issue(`${path}.binding.fallback`, "invalid_src", "Image fallback must not be a javascript: URL."));
+        }
+    }
+}
+function validateBinding(value, path, errors) {
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_binding", "Binding must be an object with a path."));
+        return;
+    }
+    rejectUnknown(value, BINDING_KEYS, path, errors);
+    if (typeof value.path !== "string") {
+        errors.push(issue(`${path}.path`, "invalid_binding", 'Binding path must be a dot-separated identifier, such as "company.name" or "items.0.name".'));
+    }
+    else {
+        const parsed = parseBindingPath(value.path);
+        if (!parsed.valid) {
+            errors.push(issue(`${path}.path`, parsed.reason === "unsafe" ? "unsafe_binding" : "invalid_binding", parsed.reason === "unsafe"
+                ? "Binding path must not use __proto__, prototype, or constructor."
+                : 'Binding path must be a dot-separated identifier, such as "company.name" or "items.0.name".'));
+        }
+    }
+    for (const key of ["fallback", "prefix", "suffix"]) {
+        if (value[key] !== undefined && typeof value[key] !== "string") {
+            errors.push(issue(`${path}.${key}`, "invalid_binding", `Binding ${key} must be a string.`));
+        }
+    }
+    if (value.format !== undefined) {
+        validateFormat(value.format, `${path}.format`, errors);
+    }
+}
+function validateReportOptions(value, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(issue("report", "invalid_type", "Report options must be an object."));
+        return;
+    }
+    rejectUnknown(value, REPORT_OPTION_KEYS, "report", errors);
+    for (const key of ["title", "description", "emptyText"]) {
+        if (value[key] !== undefined && typeof value[key] !== "string") {
+            errors.push(issue(`report.${key}`, "invalid_type", `Report ${key} must be a string.`));
+        }
+    }
+    if (value.showPageNumber !== undefined && typeof value.showPageNumber !== "boolean") {
+        errors.push(issue("report.showPageNumber", "invalid_type", "showPageNumber must be a boolean."));
+    }
+    for (const key of ["pageHeader", "pageFooter", "reportHeader", "reportFooter"]) {
+        validateBandList(value[key], `report.${key}`, errors);
+    }
+}
+function validateBandList(value, path, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value) || value.length > 8) {
+        errors.push(issue(path, "invalid_band", "A report band needs at most 8 entries."));
+        return;
+    }
+    const seen = new Set();
+    value.forEach((entry, index) => {
+        const entryPath = `${path}[${index}]`;
+        if (!isRecord(entry) || !isOneOf(REPORT_BAND_TYPES, entry.type)) {
+            errors.push(issue(entryPath, "invalid_band", 'A report band entry must be type "text" or "image".'));
+            return;
+        }
+        rejectUnknown(entry, entry.type === "text" ? REPORT_TEXT_BAND_KEYS : REPORT_IMAGE_BAND_KEYS, entryPath, errors);
+        validateIdentifier(entry.id, `${entryPath}.id`, errors, "Band id");
+        if (typeof entry.id === "string" && seen.has(entry.id)) {
+            errors.push(issue(`${entryPath}.id`, "duplicate_band_id", `Band id "${entry.id}" is duplicated.`));
+        }
+        if (typeof entry.id === "string") {
+            seen.add(entry.id);
+        }
+        if (entry.type === "text") {
+            if (entry.text !== undefined && typeof entry.text !== "string") {
+                errors.push(issue(`${entryPath}.text`, "invalid_type", "Band text must be a string."));
+            }
+            if (entry.binding !== undefined) {
+                validateBinding(entry.binding, `${entryPath}.binding`, errors);
+            }
+            return;
+        }
+        if (entry.src !== undefined && typeof entry.src !== "string") {
+            errors.push(issue(`${entryPath}.src`, "invalid_type", "Band image src must be a string."));
+        }
+        else if (typeof entry.src === "string" && /^\s*javascript:/i.test(entry.src)) {
+            errors.push(issue(`${entryPath}.src`, "invalid_src", "Band image src must not be a javascript: URL."));
+        }
+        if (entry.alt !== undefined && typeof entry.alt !== "string") {
+            errors.push(issue(`${entryPath}.alt`, "invalid_type", "Band image alt text must be a string."));
+        }
+        if (entry.binding !== undefined) {
+            validateBinding(entry.binding, `${entryPath}.binding`, errors);
+            if (isRecord(entry.binding) && typeof entry.binding.fallback === "string" && /^\s*javascript:/i.test(entry.binding.fallback)) {
+                errors.push(issue(`${entryPath}.binding.fallback`, "invalid_src", "Band image fallback must not be a javascript: URL."));
+            }
+        }
+    });
+}
+function validateReportTableFields(value, path, errors) {
+    validateBindingPathValue(value.collectionPath, `${path}.collectionPath`, errors, "Collection path");
+    if (value.showHeader !== undefined && typeof value.showHeader !== "boolean") {
+        errors.push(issue(`${path}.showHeader`, "invalid_type", "showHeader must be a boolean."));
+    }
+    if (value.emptyText !== undefined && typeof value.emptyText !== "string") {
+        errors.push(issue(`${path}.emptyText`, "invalid_type", "Empty report text must be a string."));
+    }
+    if (value.padding !== undefined && (!isFiniteNumber(value.padding) || value.padding < 0)) {
+        errors.push(issue(`${path}.padding`, "invalid_number", "Report padding must be a finite number greater than or equal to 0."));
+    }
+    if (value.headerStyle !== undefined) {
+        validateStyle(value.headerStyle, `${path}.headerStyle`, errors);
+    }
+    for (const key of ["alternateRowColor", "oddRowColor", "evenRowColor"]) {
+        if (value[key] !== undefined) {
+            if (typeof value[key] !== "string" || cssColor(value[key]) === null) {
+                errors.push(issue(`${path}.${key}`, "invalid_color", "Row color must be a CSS color."));
+            }
+        }
+    }
+    if (value.stripeRows !== undefined && typeof value.stripeRows !== "boolean") {
+        errors.push(issue(`${path}.stripeRows`, "invalid_type", "stripeRows must be a boolean."));
+    }
+    for (const key of ["bodyStyle", "groupStyle", "subtotalStyle", "grandTotalStyle"]) {
+        if (value[key] !== undefined) {
+            validateStyle(value[key], `${path}.${key}`, errors);
+        }
+    }
+    if (value.tableAlign !== undefined && value.tableAlign !== "left" && value.tableAlign !== "center" && value.tableAlign !== "right") {
+        errors.push(issue(`${path}.tableAlign`, "invalid_style", 'tableAlign must be "left", "center", or "right".'));
+    }
+    if (value.headerHeight !== undefined && (!isFiniteNumber(value.headerHeight) || value.headerHeight <= 0 || value.headerHeight > 200)) {
+        errors.push(issue(`${path}.headerHeight`, "invalid_number", "headerHeight must be a finite number greater than 0 and at most 200."));
+    }
+    validateRowRules(value.rowRules, `${path}.rowRules`, errors);
+    if (value.showGrandTotal !== undefined && typeof value.showGrandTotal !== "boolean") {
+        errors.push(issue(`${path}.showGrandTotal`, "invalid_type", "showGrandTotal must be a boolean."));
+    }
+    if (value.grandTotalLabel !== undefined && typeof value.grandTotalLabel !== "string") {
+        errors.push(issue(`${path}.grandTotalLabel`, "invalid_type", "Grand total label must be a string."));
+    }
+    if (value.pageBreakBefore !== undefined && typeof value.pageBreakBefore !== "boolean") {
+        errors.push(issue(`${path}.pageBreakBefore`, "invalid_type", "pageBreakBefore must be a boolean."));
+    }
+    validateReportColumns(value.columns, `${path}.columns`, errors);
+    validateGroupLevels(value.groupBy, `${path}.groupBy`, errors);
+    validateSorts(value.sort, `${path}.sort`, errors);
+}
+function validateBindingPathValue(value, path, errors, label) {
+    if (typeof value !== "string") {
+        errors.push(issue(path, "invalid_binding", `${label} must be a binding path.`));
+        return;
+    }
+    const parsed = parseBindingPath(value);
+    if (!parsed.valid) {
+        errors.push(issue(path, parsed.reason === "unsafe" ? "unsafe_binding" : "invalid_binding", `${label} must be a safe binding path.`));
+    }
+}
+function validateReportColumns(value, path, errors) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 12) {
+        errors.push(issue(path, "invalid_columns", "A report table needs from 1 to 12 columns."));
+        return;
+    }
+    const seen = new Set();
+    value.forEach((column, index) => {
+        const columnPath = `${path}[${index}]`;
+        if (!isRecord(column)) {
+            errors.push(issue(columnPath, "invalid_type", "A column must be an object."));
+            return;
+        }
+        rejectUnknown(column, REPORT_COLUMN_KEYS, columnPath, errors);
+        validateIdentifier(column.id, `${columnPath}.id`, errors, "Column id");
+        if (typeof column.id === "string" && seen.has(column.id)) {
+            errors.push(issue(`${columnPath}.id`, "duplicate_column_id", `Column id "${column.id}" is duplicated.`));
+        }
+        if (typeof column.id === "string") {
+            seen.add(column.id);
+        }
+        if (typeof column.header !== "string") {
+            errors.push(issue(`${columnPath}.header`, "invalid_type", "Column header must be a string."));
+        }
+        validateBinding(column.binding, `${columnPath}.binding`, errors);
+        if (column.width !== undefined && (!isFiniteNumber(column.width) || column.width <= 0)) {
+            errors.push(issue(`${columnPath}.width`, "invalid_number", "Column width must be a finite number greater than 0."));
+        }
+        if (column.align !== undefined && !isOneOf(TEXT_ALIGNS, column.align)) {
+            errors.push(issue(`${columnPath}.align`, "invalid_align", 'Column alignment must be "left", "center", "right", or "justify".'));
+        }
+        if (column.visible !== undefined && typeof column.visible !== "boolean") {
+            errors.push(issue(`${columnPath}.visible`, "invalid_type", "Column visible must be a boolean."));
+        }
+        if (column.aggregate !== undefined && !isOneOf(AGGREGATES, column.aggregate)) {
+            errors.push(issue(`${columnPath}.aggregate`, "invalid_aggregate", 'Aggregate must be "sum", "count", "min", or "max".'));
+        }
+        if (column.headerStyle !== undefined) {
+            validateStyle(column.headerStyle, `${columnPath}.headerStyle`, errors);
+        }
+        if (column.style !== undefined) {
+            validateStyle(column.style, `${columnPath}.style`, errors);
+        }
+    });
+}
+function validateRowRules(value, path, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value) || value.length > 20) {
+        errors.push(issue(path, "invalid_style", "A report table supports at most 20 row rules."));
+        return;
+    }
+    value.forEach((rule, index) => {
+        const rulePath = `${path}[${index}]`;
+        if (!isRecord(rule)) {
+            errors.push(issue(rulePath, "invalid_type", "A row rule must be an object."));
+            return;
+        }
+        rejectUnknown(rule, ROW_RULE_KEYS, rulePath, errors);
+        validateBindingPathValue(rule.path, `${rulePath}.path`, errors, "Row rule path");
+        if (!isOneOf(ROW_RULE_OPERATORS, rule.operator)) {
+            errors.push(issue(`${rulePath}.operator`, "invalid_style", 'Row rule operator must be "eq", "neq", "gt", "gte", "lt", "lte", or "blank".'));
+        }
+        if (rule.value !== undefined && typeof rule.value !== "string" && typeof rule.value !== "number" && typeof rule.value !== "boolean") {
+            errors.push(issue(`${rulePath}.value`, "invalid_type", "Row rule value must be text, a number, or a boolean."));
+        }
+        if (typeof rule.value === "number" && !Number.isFinite(rule.value)) {
+            errors.push(issue(`${rulePath}.value`, "invalid_number", "Row rule value must be a finite number."));
+        }
+        if (!isRecord(rule.style)) {
+            errors.push(issue(`${rulePath}.style`, "invalid_style", "A row rule needs a style object."));
+        }
+        else {
+            validateStyle(rule.style, `${rulePath}.style`, errors);
+        }
+    });
+}
+function validateGroupLevels(value, path, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value) || value.length > 3) {
+        errors.push(issue(path, "invalid_group", "A report table supports at most 3 group levels."));
+        return;
+    }
+    value.forEach((level, index) => {
+        const levelPath = `${path}[${index}]`;
+        if (!isRecord(level)) {
+            errors.push(issue(levelPath, "invalid_type", "A group level must be an object."));
+            return;
+        }
+        rejectUnknown(level, REPORT_GROUP_KEYS, levelPath, errors);
+        validateBindingPathValue(level.path, `${levelPath}.path`, errors, "Group path");
+        if (level.label !== undefined && typeof level.label !== "string") {
+            errors.push(issue(`${levelPath}.label`, "invalid_type", "Group label must be a string."));
+        }
+    });
+}
+function validateSorts(value, path, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value) || value.length > 4) {
+        errors.push(issue(path, "invalid_sort", "A report table supports at most 4 sort fields."));
+        return;
+    }
+    value.forEach((sort, index) => {
+        const sortPath = `${path}[${index}]`;
+        if (!isRecord(sort)) {
+            errors.push(issue(sortPath, "invalid_type", "A sort must be an object."));
+            return;
+        }
+        rejectUnknown(sort, REPORT_SORT_KEYS, sortPath, errors);
+        validateBindingPathValue(sort.path, `${sortPath}.path`, errors, "Sort path");
+        if (!isOneOf(SORT_DIRECTIONS, sort.direction)) {
+            errors.push(issue(`${sortPath}.direction`, "invalid_sort", 'Sort direction must be "asc" or "desc".'));
+        }
+    });
+}
+function validateInvoiceOptions(value, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(issue("invoice", "invalid_type", "Invoice options must be an object."));
+        return;
+    }
+    rejectUnknown(value, INVOICE_OPTION_KEYS, "invoice", errors);
+    if (value.fractionDigits !== undefined && (!Number.isInteger(value.fractionDigits) || value.fractionDigits < 0 || value.fractionDigits > 6)) {
+        errors.push(issue("invoice.fractionDigits", "invalid_number", "Invoice fraction digits must be an integer from 0 to 6."));
+    }
+}
+function validateFormat(value, path, errors) {
+    if (!isRecord(value)) {
+        errors.push(issue(path, "invalid_format", "Format must be an object."));
+        return;
+    }
+    rejectUnknown(value, FORMAT_KEYS, path, errors);
+    if (!isOneOf(FORMAT_STYLES, value.style)) {
+        errors.push(issue(`${path}.style`, "invalid_format", 'Format style must be "decimal", "currency", "percent", or "date".'));
+    }
+    if (value.locale !== undefined && (typeof value.locale !== "string" || value.locale.trim().length === 0)) {
+        errors.push(issue(`${path}.locale`, "invalid_format", "Format locale must be a non-empty string."));
+    }
+    if (value.currency !== undefined && (typeof value.currency !== "string" || !/^[A-Za-z]{3}$/.test(value.currency))) {
+        errors.push(issue(`${path}.currency`, "invalid_format", "Format currency must be a 3-letter code."));
+    }
+    validateFractionDigits(value.minimumFractionDigits, `${path}.minimumFractionDigits`, errors);
+    validateFractionDigits(value.maximumFractionDigits, `${path}.maximumFractionDigits`, errors);
+    if (typeof value.minimumFractionDigits === "number" &&
+        typeof value.maximumFractionDigits === "number" &&
+        value.minimumFractionDigits > value.maximumFractionDigits) {
+        errors.push(issue(path, "invalid_format", "Minimum fraction digits cannot exceed maximum fraction digits."));
+    }
+    if (value.dateStyle !== undefined && !isOneOf(DATE_STYLES, value.dateStyle)) {
+        errors.push(issue(`${path}.dateStyle`, "invalid_format", 'Date style must be "iso", "short", "medium", or "long".'));
+    }
+}
+function validateFractionDigits(value, path, errors) {
+    if (value === undefined) {
+        return;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 20) {
+        errors.push(issue(path, "invalid_format", "Fraction digits must be an integer from 0 to 20."));
+    }
+}
+function validateItemsFields(value, path, errors) {
+    if (typeof value.itemsPath !== "string") {
+        errors.push(issue(`${path}.itemsPath`, "invalid_binding", 'Items path must be a binding path such as "invoice.items".'));
+    }
+    else {
+        const parsed = parseBindingPath(value.itemsPath);
+        if (!parsed.valid) {
+            errors.push(issue(`${path}.itemsPath`, parsed.reason === "unsafe" ? "unsafe_binding" : "invalid_binding", 'Items path must be a binding path such as "invoice.items".'));
+        }
+    }
+    if (value.showHeader !== undefined && typeof value.showHeader !== "boolean") {
+        errors.push(issue(`${path}.showHeader`, "invalid_type", "showHeader must be a boolean."));
+    }
+    if (value.emptyText !== undefined && typeof value.emptyText !== "string") {
+        errors.push(issue(`${path}.emptyText`, "invalid_type", "Empty items text must be a string."));
+    }
+    if (value.padding !== undefined && (!isFiniteNumber(value.padding) || value.padding < 0)) {
+        errors.push(issue(`${path}.padding`, "invalid_number", "Items padding must be a finite number greater than or equal to 0."));
+    }
+    if (value.headerStyle !== undefined) {
+        validateStyle(value.headerStyle, `${path}.headerStyle`, errors);
+    }
+    validateColumns(value.columns, `${path}.columns`, errors);
+}
+function validateColumns(value, path, errors) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 12) {
+        errors.push(issue(path, "invalid_columns", "An items table needs from 1 to 12 columns."));
+        return;
+    }
+    const seen = new Set();
+    value.forEach((column, index) => {
+        const columnPath = `${path}[${index}]`;
+        if (!isRecord(column)) {
+            errors.push(issue(columnPath, "invalid_type", "A column must be an object."));
+            return;
+        }
+        rejectUnknown(column, COLUMN_KEYS, columnPath, errors);
+        validateIdentifier(column.id, `${columnPath}.id`, errors, "Column id");
+        if (typeof column.id === "string" && seen.has(column.id)) {
+            errors.push(issue(`${columnPath}.id`, "duplicate_column_id", `Column id "${column.id}" is duplicated.`));
+        }
+        if (typeof column.id === "string") {
+            seen.add(column.id);
+        }
+        if (typeof column.header !== "string") {
+            errors.push(issue(`${columnPath}.header`, "invalid_type", "Column header must be a string."));
+        }
+        validateBinding(column.binding, `${columnPath}.binding`, errors);
+        if (column.width !== undefined && (!isFiniteNumber(column.width) || column.width <= 0)) {
+            errors.push(issue(`${columnPath}.width`, "invalid_number", "Column width must be a finite number greater than 0."));
+        }
+        if (column.align !== undefined && !isOneOf(TEXT_ALIGNS, column.align)) {
+            errors.push(issue(`${columnPath}.align`, "invalid_align", 'Column alignment must be "left", "center", "right", or "justify".'));
+        }
+        if (column.visible !== undefined && typeof column.visible !== "boolean") {
+            errors.push(issue(`${columnPath}.visible`, "invalid_type", "Column visible must be a boolean."));
+        }
+    });
+}
+function validateTotalsFields(value, path, errors) {
+    if (!Array.isArray(value.rows) || value.rows.length === 0 || value.rows.length > 12) {
+        errors.push(issue(`${path}.rows`, "invalid_rows", "A totals block needs from 1 to 12 rows."));
+        return;
+    }
+    const seen = new Set();
+    value.rows.forEach((row, index) => {
+        const rowPath = `${path}.rows[${index}]`;
+        if (!isRecord(row)) {
+            errors.push(issue(rowPath, "invalid_type", "A totals row must be an object."));
+            return;
+        }
+        rejectUnknown(row, TOTAL_ROW_KEYS, rowPath, errors);
+        validateIdentifier(row.id, `${rowPath}.id`, errors, "Totals row id");
+        if (typeof row.id === "string" && seen.has(row.id)) {
+            errors.push(issue(`${rowPath}.id`, "duplicate_row_id", `Totals row id "${row.id}" is duplicated.`));
+        }
+        if (typeof row.id === "string") {
+            seen.add(row.id);
+        }
+        if (typeof row.label !== "string") {
+            errors.push(issue(`${rowPath}.label`, "invalid_type", "Totals label must be a string."));
+        }
+        validateBinding(row.binding, `${rowPath}.binding`, errors);
+        if (row.visible !== undefined && typeof row.visible !== "boolean") {
+            errors.push(issue(`${rowPath}.visible`, "invalid_type", "Totals visible must be a boolean."));
+        }
+        if (row.hideWhenZero !== undefined && typeof row.hideWhenZero !== "boolean") {
+            errors.push(issue(`${rowPath}.hideWhenZero`, "invalid_type", "hideWhenZero must be a boolean."));
+        }
+    });
+}
+//# sourceMappingURL=validate.js.map