@json-to-office/shared-docx 0.1.0

package/dist/index.js

@@ -0,0 +1,1129 @@
+import {
+  generateUnifiedDocumentSchema
+} from "./chunk-LWR4TFZ5.js";
+import {
+  DOC_LINKS,
+  ERROR_TEMPLATES,
+  componentValidator,
+  createComponentValidator,
+  createThemeValidator,
+  getThemeName,
+  isColumnsProps,
+  isCustomComponentProps,
+  isFooterProps,
+  isHeaderProps,
+  isHeadingProps,
+  isImageProps,
+  isListProps,
+  isParagraphProps,
+  isReportProps,
+  isSectionProps,
+  isStandardComponentName,
+  isStatisticProps,
+  isTableProps,
+  isThemeConfig,
+  isValidTheme,
+  strictComponentValidator,
+  strictThemeValidator,
+  themeValidator,
+  validate,
+  validateComponent,
+  validateComponentDefinition,
+  validateCustomComponentProps,
+  validateStrict,
+  validateTheme,
+  validateThemeJson,
+  validateThemeWithEnhancement
+} from "./chunk-BEPLK76M.js";
+import {
+  ThemeConfigSchema,
+  isValidThemeConfig
+} from "./chunk-BOUURUYX.js";
+import {
+  GenerateDocumentRequestSchema,
+  GenerateDocumentResponseSchema,
+  ValidateDocumentRequestSchema,
+  ValidateDocumentResponseSchema
+} from "./chunk-EKWM2CWA.js";
+import {
+  JSON_SCHEMA_URLS,
+  JsonComponentDefinitionSchema
+} from "./chunk-AA4HIXRG.js";
+import {
+  comprehensiveValidateDocument,
+  createDocumentValidator,
+  createJsonValidator,
+  createValidator,
+  deepValidateDocument,
+  documentValidator,
+  getValidationSummary,
+  isValidDocument,
+  isValidationSuccess,
+  strictDocumentValidator,
+  transformValueError,
+  transformValueErrors,
+  validateAgainstSchema,
+  validateBatch,
+  validateDocument,
+  validateDocumentWithSchema,
+  validateJson,
+  validateJsonComponent,
+  validateJsonDocument,
+  validateWithEnhancement
+} from "./chunk-LOE6BZQG.js";
+import {
+  ComponentDefinitionSchema,
+  StandardComponentDefinitionSchema
+} from "./chunk-ET6YMNMF.js";
+import {
+  AlignmentSchema,
+  BaseComponentPropsSchema,
+  BorderSchema,
+  ColumnsPropsSchema,
+  FooterPropsSchema,
+  HeaderPropsSchema,
+  HeadingLevelSchema,
+  HeadingPropsSchema,
+  HighchartsPropsSchema,
+  ImagePropsSchema,
+  IndentSchema,
+  JustifiedAlignmentSchema,
+  LineSpacingSchema,
+  ListPropsSchema,
+  MarginsSchema,
+  NumberingSchema,
+  ParagraphPropsSchema,
+  ReportPropsSchema,
+  SectionPropsSchema,
+  SpacingSchema,
+  StatisticPropsSchema,
+  TablePropsSchema,
+  TextBoxPropsSchema,
+  TocPropsSchema
+} from "./chunk-5533WPL6.js";
+import {
+  CustomComponentDefinitionSchema,
+  TextSpaceAfterComponentSchema,
+  TextSpaceAfterPropsSchema
+} from "./chunk-VP3X6DBP.js";
+import {
+  BASE_SCHEMA_METADATA,
+  COMPONENT_METADATA,
+  THEME_SCHEMA_METADATA,
+  convertToJsonSchema,
+  createComponentSchema,
+  exportSchemaToFile,
+  fixSchemaReferences
+} from "./chunk-HHMK2RWF.js";
+import "./chunk-F5LVWDTY.js";
+
+// src/index.ts
+import {
+  fixSchemaReferences as fixSchemaReferences2,
+  convertToJsonSchema as convertToJsonSchema2,
+  createComponentSchema as createComponentSchema2,
+  createComponentSchemaObject,
+  exportSchemaToFile as exportSchemaToFile2
+} from "@json-to-office/shared";
+import {
+  transformValueError as transformValueError2,
+  transformValueErrors as transformValueErrors2,
+  formatErrorSummary,
+  groupErrorsByPath,
+  createJsonParseError,
+  calculatePosition
+} from "@json-to-office/shared";
+import {
+  DEFAULT_ERROR_CONFIG,
+  createErrorConfig,
+  ERROR_EMOJIS,
+  formatErrorMessage
+} from "@json-to-office/shared";
+import {
+  isUnionSchema,
+  isObjectSchema,
+  isLiteralSchema,
+  getObjectSchemaPropertyNames,
+  getLiteralValue,
+  extractStandardComponentNames,
+  clearComponentNamesCache,
+  getSchemaMetadata
+} from "@json-to-office/shared";
+import {
+  isValidSemver,
+  parseSemver,
+  compareSemver,
+  latestVersion
+} from "@json-to-office/shared";
+
+// src/validation/parsers/json.ts
+import { Value } from "@sinclair/typebox/value";
+import { FormatRegistry } from "@sinclair/typebox";
+FormatRegistry.Set("uri", (value) => {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    if (value.includes(".json") || value.includes("/") || value.includes("\\")) {
+      return true;
+    }
+    return /^https?:\/\/.+/.test(value);
+  }
+});
+FormatRegistry.Set("date-time", (value) => {
+  const dateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+  return dateTimeRegex.test(value) && !isNaN(Date.parse(value));
+});
+var JsonDocumentParser = class {
+  schema = ComponentDefinitionSchema;
+  constructor() {
+  }
+  /**
+   * Parse JSON input (string or object) and validate against schema
+   * Only supports unified ComponentDefinition structure where document IS a report component
+   */
+  parse(jsonInput) {
+    let parsedObject;
+    if (typeof jsonInput === "string") {
+      try {
+        parsedObject = JSON.parse(jsonInput);
+      } catch (error) {
+        throw new JsonParsingError(
+          "Invalid JSON syntax",
+          this.extractJSONSyntaxError(error, jsonInput)
+        );
+      }
+    } else {
+      parsedObject = jsonInput;
+    }
+    if (typeof parsedObject !== "object" || parsedObject === null || !("name" in parsedObject) || parsedObject.name !== "docx") {
+      throw new JsonValidationError(
+        'Invalid document structure: Document must be a docx component with name="docx"',
+        [
+          {
+            path: "name",
+            message: 'Document must be a docx component with name="docx"',
+            code: "INVALID_STRUCTURE"
+          }
+        ]
+      );
+    }
+    if (!Value.Check(this.schema, parsedObject)) {
+      const errors = [...Value.Errors(this.schema, parsedObject)];
+      throw new JsonValidationError(
+        "JSON validation failed",
+        this.formatTypeBoxErrors(
+          errors,
+          typeof jsonInput === "string" ? jsonInput : JSON.stringify(jsonInput, null, 2)
+        )
+      );
+    }
+    return parsedObject;
+  }
+  /**
+   * Validate JSON without throwing errors - returns ValidationResult
+   */
+  validate(jsonInput) {
+    try {
+      this.parse(jsonInput);
+      return {
+        valid: true,
+        errors: [],
+        warnings: []
+      };
+    } catch (error) {
+      if (error instanceof JsonParsingError || error instanceof JsonValidationError) {
+        return {
+          valid: false,
+          errors: error.validationErrors,
+          warnings: []
+        };
+      }
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: error instanceof Error ? error.message : "Unknown validation error",
+            code: "UNEXPECTED_ERROR"
+          }
+        ],
+        warnings: []
+      };
+    }
+  }
+  /**
+   * Parse JSON file content with line number tracking
+   */
+  parseWithLineNumbers(jsonString) {
+    const lines = jsonString.split("\n");
+    try {
+      return this.parse(jsonString);
+    } catch (error) {
+      if (error instanceof JsonParsingError || error instanceof JsonValidationError) {
+        const enhancedErrors = error.validationErrors.map((err) => ({
+          ...err,
+          ...this.findLineNumber(err.path, jsonString, lines)
+        }));
+        if (error instanceof JsonParsingError) {
+          throw new JsonParsingError(error.message, enhancedErrors);
+        } else {
+          throw new JsonValidationError(error.message, enhancedErrors);
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Extract JSON syntax error information
+   */
+  extractJSONSyntaxError(error, jsonString) {
+    const message = error.message;
+    const positionMatch = message.match(/position\s+(\d+)/i) || message.match(/at\s+(\d+)/i) || message.match(/character\s+(\d+)/i);
+    let line = 0;
+    let column = 0;
+    if (positionMatch) {
+      const position = parseInt(positionMatch[1], 10);
+      const lines = jsonString.substring(0, position).split("\n");
+      line = lines.length;
+      column = lines[lines.length - 1].length + 1;
+    }
+    return [
+      {
+        path: "",
+        message: `JSON syntax error: ${message}`,
+        code: "JSON_SYNTAX_ERROR",
+        line: line || void 0,
+        column: column || void 0,
+        suggestions: [
+          "Check for missing commas, brackets, or quotes",
+          "Validate JSON syntax using a JSON validator",
+          "Ensure all strings are properly quoted"
+        ]
+      }
+    ];
+  }
+  /**
+   * Format TypeBox validation errors into ValidationError format
+   */
+  formatTypeBoxErrors(errors, originalJson) {
+    return errors.map((error) => {
+      const path = error.path || "";
+      const lineInfo = this.findLineNumber(path, originalJson);
+      return {
+        path,
+        message: this.formatTypeBoxErrorMessage(error),
+        code: this.getErrorCode(error),
+        line: lineInfo.line,
+        column: lineInfo.column,
+        suggestions: this.generateSuggestions(error)
+      };
+    });
+  }
+  /**
+   * Format individual TypeBox error message
+   */
+  formatTypeBoxErrorMessage(error) {
+    const path = error.path ? `at "${error.path}"` : "";
+    const message = error.message;
+    if (message.includes("Expected")) {
+      return `${message} ${path}`;
+    } else if (message.includes("Required property")) {
+      return `${message} ${path}`;
+    } else if (message.includes("Unexpected property")) {
+      return `${message} ${path}`;
+    } else if (message.includes("minimum")) {
+      return `Value is too small ${path}. ${message}`;
+    } else if (message.includes("maximum")) {
+      return `Value is too big ${path}. ${message}`;
+    } else {
+      return `${message} ${path}`;
+    }
+  }
+  /**
+   * Get error code from TypeBox error
+   */
+  getErrorCode(error) {
+    const baseCode = String(error.type || "VALIDATION_ERROR").toUpperCase();
+    const path = error.path ? error.path.replace(/\//g, "_").toUpperCase() : "";
+    return path ? `${baseCode}_${path}` : baseCode;
+  }
+  /**
+   * Generate helpful suggestions based on error type
+   */
+  generateSuggestions(error) {
+    const suggestions = [];
+    const message = error.message;
+    if (message.includes("Expected string")) {
+      suggestions.push("Ensure the value is wrapped in quotes");
+    } else if (message.includes("Expected number")) {
+      suggestions.push("Remove quotes around numeric values");
+    } else if (message.includes("Expected array")) {
+      suggestions.push("Use square brackets [] for arrays");
+    } else if (message.includes("Expected object")) {
+      suggestions.push("Use curly braces {} for objects");
+    } else if (message.includes("Expected literal")) {
+      const match = message.match(/Expected literal (.+)/);
+      if (match) {
+        suggestions.push(`Use the exact value: ${match[1]}`);
+      }
+    } else if (message.includes("Unexpected property")) {
+      suggestions.push("Remove unknown properties or check spelling");
+      suggestions.push(
+        "Refer to the JSON schema documentation for valid properties"
+      );
+    } else if (message.includes("Expected union")) {
+      suggestions.push(
+        "Check that the value matches one of the allowed formats"
+      );
+      suggestions.push("Verify the module type is spelled correctly");
+    } else if (message.includes("minimum")) {
+      const match = message.match(/minimum.*?(\d+)/);
+      if (match) {
+        if (message.includes("Array")) {
+          suggestions.push(`Array must have at least ${match[1]} items`);
+        } else {
+          suggestions.push(`Value must be at least ${match[1]}`);
+        }
+      }
+    } else if (message.includes("format") && message.includes("uri")) {
+      suggestions.push(
+        "Ensure the URL is valid and starts with http:// or https://"
+      );
+    }
+    if (suggestions.length === 0) {
+      suggestions.push("Check the JSON schema documentation for valid values");
+      suggestions.push("Verify the property name and value format");
+    }
+    return suggestions;
+  }
+  /**
+   * Find line and column number for a given JSON path
+   */
+  findLineNumber(path, jsonString, lines) {
+    if (!path) {
+      return {};
+    }
+    const jsonLines = lines || jsonString.split("\n");
+    const pathParts = path.split(".");
+    for (let i = 0; i < jsonLines.length; i++) {
+      const line = jsonLines[i];
+      const lastPathPart = pathParts[pathParts.length - 1];
+      if (line.includes(`"${lastPathPart}"`)) {
+        const column = line.indexOf(`"${lastPathPart}"`) + 1;
+        return {
+          line: i + 1,
+          column
+        };
+      }
+    }
+    return {};
+  }
+};
+var JsonParsingError = class extends Error {
+  validationErrors;
+  constructor(message, errors) {
+    super(message);
+    this.name = "JsonParsingError";
+    this.validationErrors = errors;
+  }
+};
+var JsonValidationError = class extends Error {
+  validationErrors;
+  constructor(message, errors) {
+    super(message);
+    this.name = "JsonValidationError";
+    this.validationErrors = errors;
+  }
+};
+function parseJsonComponent(jsonInput) {
+  const parser = new JsonDocumentParser();
+  return parser.parse(jsonInput);
+}
+function parseJsonWithLineNumbers(jsonString) {
+  const parser = new JsonDocumentParser();
+  return parser.parseWithLineNumbers(jsonString);
+}
+
+// src/validation/validators/theme.ts
+function formatValidationErrors(errors) {
+  if (!Array.isArray(errors)) return [];
+  return errors.map((error) => {
+    if (typeof error === "string") return error;
+    const path = error.path ? `${error.path}: ` : "";
+    const message = error.message || "Validation error";
+    return `${path}${message}`;
+  });
+}
+
+// src/validation/validators/component.ts
+function safeValidateComponentProps(name, props) {
+  const componentName = isStandardComponentName(name) ? name : "custom";
+  const result = validateComponent(componentName, props);
+  if (result.valid) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.errors || [] };
+}
+function safeValidateComponentDefinition(component) {
+  const result = validateComponentDefinition(component);
+  if (result.valid) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.errors || [] };
+}
+function getValidationErrors(props, name) {
+  const componentName = name && isStandardComponentName(name) ? name : "custom";
+  const result = validateComponent(componentName, props);
+  if (result.valid) return [];
+  return (result.errors || []).map(
+    (e) => e.path ? `${e.path}: ${e.message}` : e.message
+  );
+}
+
+// src/validation/core/validator.ts
+import { Value as Value2 } from "@sinclair/typebox/value";
+
+// src/validation/core/errors.ts
+function formatSingleIssue(issue) {
+  const path = issue.path || "root";
+  let message = issue.message;
+  let suggestion;
+  let expected;
+  let received;
+  let options;
+  if (message.includes("Expected")) {
+    const match = message.match(/Expected (.+) but received (.+)/);
+    if (match) {
+      expected = match[1];
+      received = match[2];
+      suggestion = getSuggestionForType(expected, received);
+    }
+  }
+  if (message.includes("Required property")) {
+    const match = message.match(/Required property '(.+)'/);
+    if (match) {
+      message = `Missing required field: ${match[1]}`;
+      suggestion = `Add the required field: ${match[1]}`;
+    }
+  }
+  if (message.includes("Unexpected property")) {
+    const match = message.match(/Unexpected property '(.+)'/);
+    if (match) {
+      message = `Unknown property: ${match[1]}`;
+      suggestion = `Remove the unknown property: ${match[1]}`;
+    }
+  }
+  if (message.includes("Expected union")) {
+    message = "Value does not match any of the expected types";
+    suggestion = "Check the documentation for valid format options";
+  }
+  if (message.includes("Expected literal")) {
+    const match = message.match(/Expected literal (.+)/);
+    if (match) {
+      expected = match[1];
+      message = `Expected value: ${expected}`;
+      suggestion = `Use the exact value: ${expected}`;
+    }
+  }
+  if (message.includes("String length")) {
+    const minMatch = message.match(/minimum length of (\d+)/);
+    const maxMatch = message.match(/maximum length of (\d+)/);
+    if (minMatch) {
+      message = `String must be at least ${minMatch[1]} characters long`;
+      suggestion = `Add more characters to meet the minimum length of ${minMatch[1]}`;
+    } else if (maxMatch) {
+      message = `String must be at most ${maxMatch[1]} characters long`;
+      suggestion = `Reduce to ${maxMatch[1]} characters or less`;
+    }
+  }
+  if (message.includes("Expected number")) {
+    const minMatch = message.match(/minimum value of ([\d.]+)/);
+    const maxMatch = message.match(/maximum value of ([\d.]+)/);
+    if (minMatch) {
+      message = `Number must be greater than or equal to ${minMatch[1]}`;
+      suggestion = `Use a value of ${minMatch[1]} or higher`;
+    } else if (maxMatch) {
+      message = `Number must be less than or equal to ${maxMatch[1]}`;
+      suggestion = `Use a value of ${maxMatch[1]} or lower`;
+    }
+  }
+  if (message.includes("Array length")) {
+    const minMatch = message.match(/minimum length of (\d+)/);
+    const maxMatch = message.match(/maximum length of (\d+)/);
+    if (minMatch) {
+      message = `Array must have at least ${minMatch[1]} items`;
+      suggestion = `Add more items to meet the minimum of ${minMatch[1]}`;
+    } else if (maxMatch) {
+      message = `Array must have at most ${maxMatch[1]} items`;
+      suggestion = `Remove items to meet the maximum of ${maxMatch[1]}`;
+    }
+  }
+  if (message.includes("format")) {
+    if (message.includes("email")) {
+      message = "Invalid email address format";
+      suggestion = "Use a valid email format like user@example.com";
+    } else if (message.includes("uri") || message.includes("url")) {
+      message = "Invalid URL format";
+      suggestion = "Use a valid URL format like https://example.com";
+    } else if (message.includes("date-time")) {
+      message = "Invalid date-time format";
+      suggestion = "Use ISO 8601 format like 2024-01-01T00:00:00Z";
+    }
+  }
+  if (message.includes("pattern")) {
+    message = "String does not match the required pattern";
+    suggestion = "Check the format requirements for this field";
+  }
+  return {
+    path,
+    message,
+    code: String(issue.type || "validation_error"),
+    suggestion,
+    expected,
+    received,
+    options
+  };
+}
+function getSuggestionForType(expected, received) {
+  if (expected === "number" && received === "string") {
+    return "Remove quotes or convert the string to a number";
+  }
+  if (expected === "string" && received === "number") {
+    return "Add quotes or convert the number to a string";
+  }
+  if (expected === "boolean") {
+    return "Use true or false (without quotes)";
+  }
+  if (expected === "array" && received === "object") {
+    return "Use square brackets [] for arrays instead of curly braces {}";
+  }
+  if (expected === "object" && received === "array") {
+    return "Use curly braces {} for objects instead of square brackets []";
+  }
+  if (received === "null" || received === "undefined") {
+    return `Provide a valid ${expected} value or mark the field as optional`;
+  }
+  return void 0;
+}
+function formatTypeBoxError(errors) {
+  return errors.map(formatSingleIssue);
+}
+function formatTypeBoxErrorStrings(errors) {
+  return formatTypeBoxError(errors).map((err) => {
+    let msg = `${err.path}: ${err.message}`;
+    if (err.suggestion) {
+      msg += ` (Suggestion: ${err.suggestion})`;
+    }
+    return msg;
+  });
+}
+function getErrorSummary(errors) {
+  const summary = /* @__PURE__ */ new Map();
+  for (const formattedError of formatTypeBoxError(errors)) {
+    const existing = summary.get(formattedError.path) || [];
+    existing.push(formattedError);
+    summary.set(formattedError.path, existing);
+  }
+  return summary;
+}
+function formatErrorReport(errors) {
+  const formattedErrors = formatTypeBoxError(errors);
+  const summary = getErrorSummary(errors);
+  let report = `Validation failed with ${formattedErrors.length} error${formattedErrors.length > 1 ? "s" : ""}:
+
+`;
+  for (const [path, pathErrors] of summary) {
+    report += `\u{1F4CD} ${path}:
+`;
+    for (const err of pathErrors) {
+      report += `   \u274C ${err.message}
+`;
+      if (err.suggestion) {
+        report += `   \u{1F4A1} ${err.suggestion}
+`;
+      }
+      if (err.expected && err.received) {
+        report += `   \u{1F4CB} Expected: ${err.expected}, Received: ${err.received}
+`;
+      }
+      if (err.options) {
+        report += `   \u{1F4CB} Valid options: ${err.options.join(", ")}
+`;
+      }
+    }
+    report += "\n";
+  }
+  return report;
+}
+function hasCriticalErrors(errors) {
+  return errors.some((issue) => {
+    if (issue.message.includes("Required property")) {
+      return true;
+    }
+    if (issue.path.includes("name") && issue.message.includes("Expected literal")) {
+      return true;
+    }
+    if (issue.message.includes("Expected union") || issue.message.includes("Never")) {
+      return true;
+    }
+    return false;
+  });
+}
+function getValidationContext(path) {
+  if (!path || path === "root") return "document root";
+  const pathParts = path.split(".");
+  if (pathParts.includes("children")) {
+    const childIndex = pathParts.indexOf("children");
+    if (pathParts.length > childIndex + 1) {
+      const index = pathParts[childIndex + 1];
+      return `component at index ${index}`;
+    }
+  }
+  if (pathParts.includes("props")) {
+    return "props section";
+  }
+  if (pathParts.includes("theme")) {
+    return "theme configuration";
+  }
+  return pathParts.join(" > ");
+}
+var formatValidationError = formatTypeBoxError;
+var formatValidationErrorStrings = formatTypeBoxErrorStrings;
+
+// src/validation/core/validator.ts
+var COMPONENT_SCHEMA_MAP = {
+  report: ReportPropsSchema,
+  section: SectionPropsSchema,
+  heading: HeadingPropsSchema,
+  paragraph: ParagraphPropsSchema,
+  columns: ColumnsPropsSchema,
+  image: ImagePropsSchema,
+  statistic: StatisticPropsSchema,
+  table: TablePropsSchema,
+  header: HeaderPropsSchema,
+  footer: FooterPropsSchema,
+  list: ListPropsSchema
+};
+function validateComponent2(name, props, options) {
+  const schema = COMPONENT_SCHEMA_MAP[name];
+  if (!schema) {
+    if (Value2.Check(CustomComponentDefinitionSchema, props)) {
+      return {
+        success: true,
+        data: props
+      };
+    }
+    const errors2 = [...Value2.Errors(CustomComponentDefinitionSchema, props)];
+    const formattedErrors2 = formatTypeBoxError(errors2);
+    return {
+      success: false,
+      errors: formattedErrors2,
+      errorStrings: formatTypeBoxErrorStrings(errors2),
+      report: options?.includeReport ? formatErrorReport(errors2) : void 0,
+      hasCriticalErrors: options?.checkCritical ? hasCriticalErrors(errors2) : void 0
+    };
+  }
+  if (Value2.Check(schema, props)) {
+    return {
+      success: true,
+      data: props
+    };
+  }
+  const errors = [...Value2.Errors(schema, props)];
+  const formattedErrors = formatTypeBoxError(errors);
+  return {
+    success: false,
+    errors: formattedErrors,
+    errorStrings: formatTypeBoxErrorStrings(errors),
+    report: options?.includeReport ? formatErrorReport(errors) : void 0,
+    hasCriticalErrors: options?.checkCritical ? hasCriticalErrors(errors) : void 0
+  };
+}
+function validateComponentDefinition2(component, options) {
+  const maxDepth = options?.maxDepth ?? 10;
+  const currentDepth = options?.currentDepth ?? 0;
+  if (currentDepth > maxDepth) {
+    return {
+      success: false,
+      errors: [
+        {
+          path: "children",
+          message: `Maximum nesting depth (${maxDepth}) exceeded`,
+          code: "custom",
+          suggestion: "Reduce the nesting level of components"
+        }
+      ],
+      errorStrings: [`Maximum nesting depth (${maxDepth}) exceeded`],
+      hasCriticalErrors: true
+    };
+  }
+  if (Value2.Check(ComponentDefinitionSchema, component)) {
+    const data = component;
+    const warnings = [];
+    if (data.children && Array.isArray(data.children)) {
+      for (let i = 0; i < data.children.length; i++) {
+        const nestedResult = validateComponentDefinition2(data.children[i], {
+          ...options,
+          currentDepth: currentDepth + 1
+        });
+        if (!nestedResult.success) {
+          const nestedErrors = nestedResult.errors?.map((err) => ({
+            ...err,
+            path: `children[${i}].${err.path}`
+          }));
+          return {
+            success: false,
+            errors: nestedErrors,
+            errorStrings: nestedErrors?.map(
+              (err) => `${err.path}: ${err.message}`
+            ),
+            report: options?.includeReport ? `Validation failed in nested component at index ${i}:
+${nestedResult.report}` : void 0,
+            hasCriticalErrors: nestedResult.hasCriticalErrors
+          };
+        }
+        if (nestedResult.warnings) {
+          warnings.push(
+            ...nestedResult.warnings.map((w) => `children[${i}]: ${w}`)
+          );
+        }
+      }
+    }
+    return {
+      success: true,
+      data: component,
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  }
+  const errors = [...Value2.Errors(ComponentDefinitionSchema, component)];
+  const formattedErrors = formatTypeBoxError(errors);
+  return {
+    success: false,
+    errors: formattedErrors,
+    errorStrings: formatTypeBoxErrorStrings(errors),
+    report: options?.includeReport ? formatErrorReport(errors) : void 0,
+    hasCriticalErrors: options?.checkCritical ? hasCriticalErrors(errors) : void 0
+  };
+}
+function validateComponents2(components, options) {
+  const results = [];
+  let criticalCount = 0;
+  for (const { name, props } of components) {
+    const result = name in COMPONENT_SCHEMA_MAP ? validateComponent2(name, props, options) : validateComponentDefinition2(props, options);
+    results.push(result);
+    if (result.hasCriticalErrors) {
+      criticalCount++;
+    }
+    if (!result.success && options?.stopOnFirst) {
+      break;
+    }
+  }
+  const valid = results.filter((r) => r.success).length;
+  const invalid = results.length - valid;
+  return {
+    success: invalid === 0,
+    results,
+    summary: {
+      total: results.length,
+      valid,
+      invalid,
+      criticalErrors: criticalCount
+    }
+  };
+}
+function transformAndValidate(name, data, transformer) {
+  try {
+    const transformed = transformer ? transformer(data) : data;
+    return validateComponent2(name, transformed, {
+      includeReport: true,
+      checkCritical: true
+    });
+  } catch (error) {
+    return {
+      success: false,
+      errors: [
+        {
+          path: "root",
+          message: `Transformation failed: ${error instanceof Error ? error.message : String(error)}`,
+          code: "custom"
+        }
+      ],
+      errorStrings: [
+        `Transformation failed: ${error instanceof Error ? error.message : String(error)}`
+      ],
+      hasCriticalErrors: true
+    };
+  }
+}
+function createValidatedComponent(name, partialConfig) {
+  const schema = COMPONENT_SCHEMA_MAP[name];
+  if (!schema) {
+    return {
+      success: false,
+      errors: [
+        {
+          path: "name",
+          message: `Unknown component name: ${name}`,
+          code: "custom",
+          suggestion: `Use one of: ${Object.keys(COMPONENT_SCHEMA_MAP).join(", ")}`
+        }
+      ],
+      errorStrings: [`Unknown component name: ${name}`],
+      hasCriticalErrors: true
+    };
+  }
+  if (Value2.Check(schema, partialConfig)) {
+    return {
+      success: true,
+      data: partialConfig
+    };
+  }
+  const errors = [...Value2.Errors(schema, partialConfig)];
+  const formattedErrors = formatTypeBoxError(errors);
+  return {
+    success: false,
+    errors: formattedErrors,
+    errorStrings: formatTypeBoxErrorStrings(errors),
+    report: formatErrorReport(errors),
+    hasCriticalErrors: hasCriticalErrors(errors)
+  };
+}
+function isValidComponent(name, props) {
+  const result = validateComponent2(name, props);
+  return result.success;
+}
+
+// src/types/components.ts
+var STANDARD_COMPONENTS = [
+  "columns",
+  "footer",
+  "header",
+  "heading",
+  "highcharts",
+  "image",
+  "list",
+  "paragraph",
+  "docx",
+  "section",
+  "statistic",
+  "table",
+  "text-box",
+  "toc"
+];
+var STANDARD_COMPONENTS_SET = new Set(STANDARD_COMPONENTS);
+function isReportComponent(component) {
+  return component.name === "docx";
+}
+function isSectionComponent(component) {
+  return component.name === "section";
+}
+function isColumnsComponent(component) {
+  return component.name === "columns";
+}
+function isHeadingComponent(component) {
+  return component.name === "heading";
+}
+function isParagraphComponent(component) {
+  return component.name === "paragraph";
+}
+function isImageComponent(component) {
+  return component.name === "image";
+}
+function isTextBoxComponent(component) {
+  return component.name === "text-box";
+}
+function isStatisticComponent(component) {
+  return component.name === "statistic";
+}
+function isTableComponent(component) {
+  return component.name === "table";
+}
+function isHeaderComponent(component) {
+  return component.name === "header";
+}
+function isFooterComponent(component) {
+  return component.name === "footer";
+}
+function isListComponent(component) {
+  return component.name === "list";
+}
+function isTocComponent(component) {
+  return component.name === "toc";
+}
+function isHighchartsComponent(component) {
+  return component.name === "highcharts";
+}
+function isTextSpaceAfterComponent(component) {
+  return component.name === "text-space-after";
+}
+
+// src/index.ts
+var SHARED_DOCX_VERSION = "1.0.0";
+export {
+  AlignmentSchema,
+  BASE_SCHEMA_METADATA,
+  BaseComponentPropsSchema,
+  BorderSchema,
+  COMPONENT_METADATA,
+  ColumnsPropsSchema,
+  ComponentDefinitionSchema,
+  CustomComponentDefinitionSchema,
+  DEFAULT_ERROR_CONFIG,
+  DOC_LINKS,
+  ERROR_EMOJIS,
+  ERROR_TEMPLATES,
+  FooterPropsSchema,
+  GenerateDocumentRequestSchema,
+  GenerateDocumentResponseSchema,
+  HeaderPropsSchema,
+  HeadingLevelSchema,
+  HeadingPropsSchema,
+  HighchartsPropsSchema,
+  ImagePropsSchema,
+  IndentSchema,
+  JSON_SCHEMA_URLS,
+  JsonComponentDefinitionSchema,
+  JsonDocumentParser,
+  JsonParsingError,
+  JsonValidationError,
+  JustifiedAlignmentSchema,
+  LineSpacingSchema,
+  ListPropsSchema,
+  MarginsSchema,
+  NumberingSchema,
+  ParagraphPropsSchema,
+  ReportPropsSchema,
+  SHARED_DOCX_VERSION,
+  STANDARD_COMPONENTS,
+  STANDARD_COMPONENTS_SET,
+  SectionPropsSchema,
+  SpacingSchema,
+  StandardComponentDefinitionSchema,
+  StatisticPropsSchema,
+  THEME_SCHEMA_METADATA,
+  TablePropsSchema,
+  TextBoxPropsSchema,
+  TextSpaceAfterComponentSchema,
+  TextSpaceAfterPropsSchema,
+  ThemeConfigSchema,
+  TocPropsSchema,
+  ValidateDocumentRequestSchema,
+  ValidateDocumentResponseSchema,
+  calculatePosition,
+  clearComponentNamesCache,
+  compareSemver,
+  componentValidator,
+  comprehensiveValidateDocument,
+  convertToJsonSchema as convertDocxToJsonSchema,
+  convertToJsonSchema2 as convertToJsonSchema,
+  createComponentSchema2 as createComponentSchema,
+  createComponentValidator,
+  createDocumentValidator,
+  createComponentSchema as createDocxComponentSchema,
+  createErrorConfig,
+  createJsonParseError,
+  createJsonValidator,
+  createThemeValidator,
+  createValidatedComponent,
+  createValidator,
+  deepValidateDocument,
+  documentValidator,
+  exportSchemaToFile as exportDocxSchemaToFile,
+  exportSchemaToFile2 as exportSchemaToFile,
+  extractStandardComponentNames,
+  fixSchemaReferences as fixDocxSchemaReferences,
+  fixSchemaReferences2 as fixSchemaReferences,
+  formatErrorMessage,
+  formatErrorReport,
+  formatErrorSummary,
+  formatValidationError,
+  formatValidationErrorStrings,
+  formatValidationErrors,
+  generateUnifiedDocumentSchema,
+  getErrorSummary,
+  getLiteralValue,
+  getObjectSchemaPropertyNames,
+  getSchemaMetadata,
+  getThemeName,
+  getValidationContext,
+  getValidationErrors,
+  getValidationSummary,
+  groupErrorsByPath,
+  hasCriticalErrors,
+  isColumnsComponent,
+  isColumnsProps,
+  isCustomComponentProps,
+  isFooterComponent,
+  isFooterProps,
+  isHeaderComponent,
+  isHeaderProps,
+  isHeadingComponent,
+  isHeadingProps,
+  isHighchartsComponent,
+  isImageComponent,
+  isImageProps,
+  isListComponent,
+  isListProps,
+  isLiteralSchema,
+  isObjectSchema,
+  isParagraphComponent,
+  isParagraphProps,
+  isReportComponent,
+  isReportProps,
+  isSectionComponent,
+  isSectionProps,
+  isStandardComponentName,
+  isStatisticComponent,
+  isStatisticProps,
+  isTableComponent,
+  isTableProps,
+  isTextBoxComponent,
+  isTextSpaceAfterComponent,
+  isThemeConfig,
+  isTocComponent,
+  isUnionSchema,
+  isValidComponent,
+  isValidDocument,
+  isValidSemver,
+  isValidTheme,
+  isValidThemeConfig,
+  isValidTheme as isValidThemeJson,
+  isValidationSuccess,
+  latestVersion,
+  parseJsonComponent,
+  parseJsonWithLineNumbers,
+  parseSemver,
+  safeValidateComponentDefinition,
+  safeValidateComponentProps,
+  createComponentSchemaObject as sharedCreateComponentSchemaObject,
+  strictComponentValidator,
+  strictDocumentValidator,
+  strictThemeValidator,
+  themeValidator,
+  transformAndValidate,
+  transformValueError as transformDocxValueError,
+  transformValueErrors as transformDocxValueErrors,
+  transformValueError2 as transformValueError,
+  transformValueErrors2 as transformValueErrors,
+  validate,
+  validateAgainstSchema,
+  validateBatch,
+  validateComponent2 as validateComponent,
+  validateComponentDefinition2 as validateComponentDefinition,
+  validateComponent as validateComponentProps,
+  validateComponents2 as validateComponents,
+  validateCustomComponentProps,
+  validateDocument,
+  validateDocumentWithSchema,
+  validateJson,
+  validateJsonDocument as validateJsonComponent,
+  validateJsonComponent as validateJsonComponentDoc,
+  validateJsonDocument,
+  validateStrict,
+  validateTheme,
+  validateThemeJson,
+  validateThemeWithEnhancement,
+  validateWithEnhancement
+};
+//# sourceMappingURL=index.js.map