@json-to-office/shared-docx 0.1.0

package/dist/chunk-LOE6BZQG.js

@@ -0,0 +1,750 @@
+import {
+  ComponentDefinitionSchema,
+  StandardComponentDefinitionSchema
+} from "./chunk-ET6YMNMF.js";
+import {
+  ColumnsPropsSchema,
+  FooterPropsSchema,
+  HeaderPropsSchema,
+  HeadingPropsSchema,
+  ImagePropsSchema,
+  ListPropsSchema,
+  ParagraphPropsSchema,
+  ReportPropsSchema,
+  SectionPropsSchema,
+  StatisticPropsSchema,
+  TablePropsSchema
+} from "./chunk-5533WPL6.js";
+import {
+  CustomComponentDefinitionSchema
+} from "./chunk-VP3X6DBP.js";
+
+// src/validation/unified/error-transformer.ts
+import {
+  isObjectSchema,
+  getObjectSchemaPropertyNames,
+  getLiteralValue,
+  createErrorConfig,
+  formatErrorMessage,
+  ERROR_EMOJIS
+} from "@json-to-office/shared";
+function generateEnhancedMessage(error, _config) {
+  const typeStr = String(error.type || "");
+  const path = error.path || "root";
+  if (typeStr === "62" || typeStr === "union") {
+    return generateUnionErrorMessage(error);
+  }
+  if (error.message?.includes("additionalProperties")) {
+    return generateAdditionalPropertiesMessage(error);
+  }
+  if (error.message?.includes("Required property")) {
+    return generateRequiredPropertyMessage(error);
+  }
+  if (typeStr === "string" || typeStr === "number" || typeStr === "boolean" || typeStr === "array" || typeStr === "object") {
+    return generateTypeMismatchMessage(error);
+  }
+  if (typeStr === "literal") {
+    return generateLiteralErrorMessage(error);
+  }
+  if (typeStr === "pattern" || typeStr === "RegExp") {
+    return generatePatternErrorMessage(error);
+  }
+  return `At ${path}: ${error.message}`;
+}
+function generateUnionErrorMessage(error) {
+  const path = error.path || "root";
+  const value = error.value;
+  if (path === "root" || path === "/" || path === "/jsonDefinition") {
+    if (value && typeof value === "object") {
+      if ("name" in value) {
+        const name = value.name;
+        if (name === "docx") {
+          return "Document structure appears valid but contains invalid component configurations. Check each component for errors.";
+        }
+        return `Unknown document name '${name}'. Expected 'docx'.`;
+      }
+      const valueAny = value;
+      if ("children" in value && Array.isArray(valueAny.children)) {
+        return `Document is missing required 'name' field. Add "name": "docx" at the root level.`;
+      }
+      if ("name" in value || "styles" in value) {
+        return "This appears to be a theme configuration. Use --type theme or ensure proper document structure.";
+      }
+    }
+    return 'Invalid document structure. Expected a document with name="docx" or a theme configuration.';
+  }
+  if (path.includes("/children/")) {
+    if (value && typeof value === "object" && "name" in value) {
+      const componentType = value.name;
+      return `Invalid component configuration for type '${componentType}'. Check that all required fields are present and correctly formatted.`;
+    }
+    return 'Invalid component structure. Each component must have a "name" field and valid configuration.';
+  }
+  return `Value at ${path} doesn't match any of the expected formats. Check the structure and required fields.`;
+}
+function generateAdditionalPropertiesMessage(error) {
+  const path = error.path || "root";
+  const value = error.value;
+  if (typeof value === "object" && value !== null) {
+    const schema = error.schema;
+    if (schema && isObjectSchema(schema)) {
+      const knownProps = getObjectSchemaPropertyNames(schema);
+      const actualProps = Object.keys(value);
+      const unknownProps = actualProps.filter((p) => !knownProps.includes(p));
+      if (unknownProps.length > 0) {
+        return `Unknown properties at ${path}: ${unknownProps.join(", ")}. Allowed properties are: ${knownProps.join(", ")}`;
+      }
+    }
+  }
+  return `Additional properties not allowed at ${path}. Check for typos or unsupported fields.`;
+}
+function generateRequiredPropertyMessage(error) {
+  const path = error.path || "root";
+  const match = error.message?.match(/Required property '([^']+)'/);
+  if (match) {
+    const propName = match[1];
+    return `Missing required field '${propName}' at ${path}. This field is mandatory for this configuration.`;
+  }
+  return `Missing required property at ${path}. Check that all mandatory fields are present.`;
+}
+function generateTypeMismatchMessage(error) {
+  const path = error.path || "root";
+  const expectedType = String(error.type);
+  const actualType = Array.isArray(error.value) ? "array" : typeof error.value;
+  if (path.includes("alignment")) {
+    return `Invalid alignment value at ${path}. Expected one of: left, center, right, justify`;
+  }
+  if (path.includes("color")) {
+    return `Invalid color value at ${path}. Use hex format (#RRGGBB), rgb(r,g,b), or a named color`;
+  }
+  if (path.includes("fontSize") || path.includes("size")) {
+    return `Invalid size value at ${path}. Expected a number (in points)`;
+  }
+  if (path.includes("margin") || path.includes("padding") || path.includes("spacing")) {
+    return `Invalid spacing value at ${path}. Expected a number or spacing object with top/bottom/left/right`;
+  }
+  return `Type mismatch at ${path}: Expected ${expectedType} but got ${actualType}`;
+}
+function generateLiteralErrorMessage(error) {
+  const path = error.path || "root";
+  const expected = error.schema ? JSON.stringify(getLiteralValue(error.schema)) : "specific value";
+  const actual = JSON.stringify(error.value);
+  return `Invalid value at ${path}: Expected exactly ${expected} but got ${actual}`;
+}
+function generatePatternErrorMessage(error) {
+  const path = error.path || "root";
+  if (path.includes("email")) {
+    return `Invalid email format at ${path}. Use format: user@example.com`;
+  }
+  if (path.includes("url") || path.includes("link")) {
+    return `Invalid URL format at ${path}. Use format: https://example.com`;
+  }
+  if (path.includes("date")) {
+    return `Invalid date format at ${path}. Use ISO format: YYYY-MM-DD`;
+  }
+  if (path.includes("phone")) {
+    return `Invalid phone number format at ${path}`;
+  }
+  return `Value at ${path} doesn't match the required pattern`;
+}
+function transformValueError(error, jsonString, config) {
+  const formatterConfig = createErrorConfig(config);
+  const enhancedMessage = generateEnhancedMessage(error, formatterConfig);
+  const baseError = {
+    path: error.path || "root",
+    message: formatErrorMessage(
+      enhancedMessage || error.message,
+      formatterConfig
+    ),
+    code: String(error.type || "validation_error"),
+    value: error.value
+  };
+  if (formatterConfig.includeSuggestions) {
+    const suggestion = getSuggestion(error, formatterConfig);
+    if (suggestion) {
+      baseError.suggestion = formatErrorMessage(suggestion, formatterConfig);
+    }
+  }
+  if (jsonString && error.path) {
+    const position = calculatePosition(jsonString, error.path);
+    if (position) {
+      baseError.line = position.line;
+      baseError.column = position.column;
+    }
+  }
+  return baseError;
+}
+function transformValueErrors(errors, options) {
+  const maxErrors = options?.maxErrors ?? Number.MAX_SAFE_INTEGER;
+  const result = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const error of errors) {
+    if (result.length >= maxErrors) break;
+    const errorKey = `${error.path}:${error.type}`;
+    if (!seenPaths.has(errorKey)) {
+      seenPaths.add(errorKey);
+      result.push(transformValueError(error, options?.jsonString, void 0));
+    }
+  }
+  return result;
+}
+function calculatePosition(jsonString, path) {
+  try {
+    const pathParts = path.split("/").filter(Boolean);
+    if (pathParts.length === 0) {
+      return { line: 1, column: 1 };
+    }
+    const lastPart = pathParts[pathParts.length - 1];
+    const searchPattern = `"${lastPart}"`;
+    const index = jsonString.indexOf(searchPattern);
+    if (index === -1) {
+      return { line: 1, column: 1 };
+    }
+    const beforeError = jsonString.substring(0, index);
+    const lines = beforeError.split("\n");
+    const line = lines.length;
+    const column = lines[lines.length - 1].length + 1;
+    return { line, column };
+  } catch {
+    return null;
+  }
+}
+function getSuggestion(error, config) {
+  const { type, path, value } = error;
+  const typeStr = String(type);
+  if (typeStr === "62" || typeStr === "union") {
+    if (path === "root" || path === "/") {
+      if (value && typeof value === "object") {
+        if (!("name" in value)) {
+          const msg = 'Add a "name" field with value "docx" for documents';
+          return config.includeEmojis ? `${ERROR_EMOJIS.FIX} ${msg}` : msg;
+        }
+        if ("props" in value && typeof value.props === "object") {
+          const knownFields = getObjectSchemaPropertyNames(ReportPropsSchema);
+          return `Review the props section for unsupported fields. Allowed fields: ${knownFields.join(", ")}`;
+        }
+      }
+      return 'Ensure the document has proper structure: { "name": "docx", "props": {...}, "children": [...] }';
+    }
+    if (path?.includes("/children/")) {
+      return 'Check that the component has a valid "name" and all required fields for that component type';
+    }
+    return "Review the structure and ensure all required fields are present with correct types";
+  }
+  if (error.message?.includes("additionalProperties")) {
+    return "Remove any unknown or unsupported fields. Check documentation for allowed properties.";
+  }
+  if (error.message?.includes("Required property")) {
+    return "Add the missing required field to fix this error";
+  }
+  if (typeStr === "string") {
+    if (path?.includes("alignment")) {
+      return "Use one of: left, center, right, justify";
+    }
+    if (path?.includes("color")) {
+      return "Use a valid color format (hex: #RRGGBB, rgb: rgb(r,g,b), or named color)";
+    }
+    return "Provide a text string value";
+  }
+  if (typeStr === "number") {
+    if (path?.includes("fontSize") || path?.includes("size")) {
+      return "Use a number in points (e.g., 12, 14, 16)";
+    }
+    if (path?.includes("margin") || path?.includes("padding")) {
+      return "Use a number for spacing in points";
+    }
+    return "Provide a numeric value";
+  }
+  if (typeStr === "boolean") {
+    return "Use true or false (without quotes)";
+  }
+  if (typeStr === "array") {
+    if (path?.includes("children") || path?.includes("modules")) {
+      return 'Provide an array of component objects, each with a "name" field';
+    }
+    return "Provide an array/list of values using square brackets []";
+  }
+  if (typeStr === "object") {
+    return "Provide an object with key-value pairs using curly braces {}";
+  }
+  if (typeStr === "literal") {
+    const expected = error.schema ? JSON.stringify(getLiteralValue(error.schema)) : "specific value";
+    return `Use exactly this value: ${expected}`;
+  }
+  if (typeStr === "pattern" || typeStr === "RegExp") {
+    if (path?.includes("email")) {
+      return "Use valid email format: user@example.com";
+    }
+    if (path?.includes("url")) {
+      return "Use valid URL format: https://example.com";
+    }
+    if (path?.includes("date")) {
+      return "Use ISO date format: YYYY-MM-DD";
+    }
+    return "Ensure the value matches the required format";
+  }
+  if (path?.includes("name") || path?.includes("type")) {
+    return "Use a valid component name: docx, section, columns, heading, paragraph, image, statistic, table, header, footer, list, toc, text-box, or highcharts";
+  }
+  return void 0;
+}
+
+// src/validation/unified/deep-validator.ts
+import { Value } from "@sinclair/typebox/value";
+var COMPONENT_SCHEMAS = {
+  report: ReportPropsSchema,
+  section: SectionPropsSchema,
+  heading: HeadingPropsSchema,
+  paragraph: ParagraphPropsSchema,
+  table: TablePropsSchema,
+  image: ImagePropsSchema,
+  list: ListPropsSchema,
+  statistic: StatisticPropsSchema,
+  columns: ColumnsPropsSchema,
+  header: HeaderPropsSchema,
+  footer: FooterPropsSchema,
+  custom: CustomComponentDefinitionSchema
+};
+function deepValidateDocument(data) {
+  const allErrors = [];
+  if (!data || typeof data !== "object") {
+    allErrors.push({
+      path: "root",
+      message: "Document must be an object",
+      code: "invalid_type"
+    });
+    return allErrors;
+  }
+  if (!data.name) {
+    allErrors.push({
+      path: "/name",
+      message: 'Missing required field "name"',
+      code: "required_property"
+    });
+  } else if (data.name !== "docx") {
+    allErrors.push({
+      path: "/name",
+      message: `Invalid name "${data.name}". Expected "docx"`,
+      code: "invalid_value"
+    });
+  }
+  if (data.name === "docx" && data.props) {
+    const propsErrors = validateComponentProps("docx", data.props, "/props");
+    allErrors.push(...propsErrors);
+  }
+  if (!data.children) {
+    allErrors.push({
+      path: "/children",
+      message: 'Missing required field "children"',
+      code: "required_property"
+    });
+  } else if (!Array.isArray(data.children)) {
+    allErrors.push({
+      path: "/children",
+      message: 'Field "children" must be an array',
+      code: "invalid_type"
+    });
+  } else {
+    data.children.forEach((child, index) => {
+      const childPath = `/children/${index}`;
+      if (!child || typeof child !== "object") {
+        allErrors.push({
+          path: childPath,
+          message: "Component must be an object",
+          code: "invalid_type"
+        });
+        return;
+      }
+      if (!child.name) {
+        allErrors.push({
+          path: `${childPath}/name`,
+          message: 'Component missing required field "name"',
+          code: "required_property"
+        });
+        return;
+      }
+      if (child.props) {
+        const componentErrors = validateComponentProps(
+          child.name,
+          child.props,
+          `${childPath}/props`
+        );
+        allErrors.push(...componentErrors);
+      } else if (child.name !== "custom") {
+        allErrors.push({
+          path: `${childPath}/props`,
+          message: 'Component missing required field "props"',
+          code: "required_property"
+        });
+      }
+      if (child.name === "section" && child.children) {
+        if (!Array.isArray(child.children)) {
+          allErrors.push({
+            path: `${childPath}/children`,
+            message: "Section children must be an array",
+            code: "invalid_type"
+          });
+        } else {
+          child.children.forEach((nestedChild, nestedIndex) => {
+            const nestedChildPath = `${childPath}/children/${nestedIndex}`;
+            if (!nestedChild || typeof nestedChild !== "object") {
+              allErrors.push({
+                path: nestedChildPath,
+                message: "Nested component must be an object",
+                code: "invalid_type"
+              });
+              return;
+            }
+            if (!nestedChild.name) {
+              allErrors.push({
+                path: `${nestedChildPath}/name`,
+                message: 'Nested component missing required field "name"',
+                code: "required_property"
+              });
+            } else {
+              if (nestedChild.props) {
+                const nestedErrors = validateComponentProps(
+                  nestedChild.name,
+                  nestedChild.props,
+                  `${nestedChildPath}/props`
+                );
+                allErrors.push(...nestedErrors);
+              } else if (nestedChild.name !== "custom") {
+                allErrors.push({
+                  path: `${nestedChildPath}/props`,
+                  message: 'Component missing required field "props"',
+                  code: "required_property"
+                });
+              }
+            }
+          });
+        }
+      }
+    });
+  }
+  return allErrors;
+}
+function validateComponentProps(componentName, props, basePath) {
+  const errors = [];
+  const schema = COMPONENT_SCHEMAS[componentName];
+  if (!schema) {
+    errors.push({
+      path: basePath.replace("/props", "/name"),
+      message: `Unknown component "${componentName}"`,
+      code: "unknown_component"
+    });
+    return errors;
+  }
+  if (!Value.Check(schema, props)) {
+    const valueErrors = [...Value.Errors(schema, props)];
+    const transformedErrors = transformValueErrors(valueErrors, {
+      maxErrors: 100
+    });
+    transformedErrors.forEach((error) => {
+      const fullPath = error.path === "root" ? basePath : `${basePath}${error.path.startsWith("/") ? error.path : "/" + error.path}`;
+      errors.push({
+        ...error,
+        path: fullPath
+      });
+    });
+  }
+  return errors;
+}
+function comprehensiveValidateDocument(data, existingErrors = []) {
+  const deepErrors = deepValidateDocument(data);
+  if (deepErrors.length > 0) {
+    const filteredExisting = existingErrors.filter(
+      (e) => !e.message.includes("invalid module configurations") && !e.message.includes("invalid component configurations")
+    );
+    const allErrors = [...filteredExisting, ...deepErrors];
+    const uniqueErrors = deduplicateErrors(allErrors);
+    return uniqueErrors;
+  }
+  return existingErrors;
+}
+function deduplicateErrors(errors) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const error of errors) {
+    const key = `${error.path}:${error.message}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(error);
+    }
+  }
+  return unique;
+}
+
+// src/validation/unified/base-validator.ts
+import { Value as Value2 } from "@sinclair/typebox/value";
+import {
+  transformValueErrors as transformValueErrors2,
+  createJsonParseError,
+  formatErrorSummary
+} from "@json-to-office/shared";
+function validateAgainstSchema(schema, data, options) {
+  try {
+    if (!Value2.Check(schema, data)) {
+      const errors = [...Value2.Errors(schema, data)];
+      const transformedErrors = transformValueErrors2(errors, {
+        jsonString: options?.jsonString,
+        maxErrors: options?.maxErrors || 100
+        // Default to 100 if not specified
+      });
+      return {
+        valid: false,
+        errors: transformedErrors
+      };
+    }
+    let processedData = data;
+    if (options?.clean) {
+      processedData = Value2.Clean(schema, Value2.Clone(processedData));
+    }
+    if (options?.applyDefaults) {
+      processedData = Value2.Default(schema, processedData);
+    }
+    return {
+      valid: true,
+      data: processedData
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "root",
+          message: error instanceof Error ? error.message : "Unknown validation error",
+          code: "validation_exception"
+        }
+      ]
+    };
+  }
+}
+function validateJson(schema, jsonInput, options) {
+  if (typeof jsonInput === "string") {
+    if (!jsonInput.trim()) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "root",
+            message: "Input must be a non-empty string",
+            code: "empty_input"
+          }
+        ],
+        isJsonError: true
+      };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(jsonInput);
+    } catch (error) {
+      if (error instanceof Error) {
+        return {
+          valid: false,
+          errors: [createJsonParseError(error, jsonInput)],
+          isJsonError: true
+        };
+      }
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "root",
+            message: "Failed to parse JSON",
+            code: "json_parse_error"
+          }
+        ],
+        isJsonError: true
+      };
+    }
+    const result2 = validateAgainstSchema(schema, parsed, {
+      ...options,
+      jsonString: jsonInput,
+      calculatePosition: true
+    });
+    return {
+      ...result2,
+      parsed,
+      isJsonError: false
+    };
+  }
+  const result = validateAgainstSchema(schema, jsonInput, options);
+  return {
+    ...result,
+    parsed: jsonInput,
+    isJsonError: false
+  };
+}
+function validateBatch(schema, items, options) {
+  const results = [];
+  const allErrors = [];
+  let hasErrors = false;
+  for (let i = 0; i < items.length; i++) {
+    const result = validateAgainstSchema(schema, items[i], options);
+    if (result.valid && result.data) {
+      results.push(result.data);
+    } else {
+      hasErrors = true;
+      if (result.errors) {
+        const prefixedErrors = result.errors.map((e) => ({
+          ...e,
+          path: `[${i}]${e.path ? "/" + e.path : ""}`
+        }));
+        allErrors.push(...prefixedErrors);
+      }
+    }
+    if (options?.maxErrors && allErrors.length >= options.maxErrors) {
+      break;
+    }
+  }
+  if (hasErrors) {
+    return {
+      valid: false,
+      errors: allErrors.slice(0, options?.maxErrors)
+    };
+  }
+  return {
+    valid: true,
+    data: results
+  };
+}
+function validateWithEnhancement(schema, data, enhancer, options) {
+  const result = validateAgainstSchema(schema, data, options);
+  if (!result.valid && result.errors) {
+    result.errors = enhancer(result.errors);
+  }
+  return result;
+}
+function createValidator(schema, defaultOptions) {
+  return (data, options) => {
+    return validateAgainstSchema(schema, data, {
+      ...defaultOptions,
+      ...options
+    });
+  };
+}
+function createJsonValidator(schema, defaultOptions) {
+  return (jsonInput, options) => {
+    return validateJson(schema, jsonInput, {
+      ...defaultOptions,
+      ...options
+    });
+  };
+}
+function isValidationSuccess(result) {
+  return result.valid === true && result.data !== void 0;
+}
+function getValidationSummary(result) {
+  if (result.valid) {
+    return "Validation successful";
+  }
+  if (!result.errors || result.errors.length === 0) {
+    return "Validation failed with unknown error";
+  }
+  return formatErrorSummary(result.errors);
+}
+
+// src/validation/unified/document-validator.ts
+import { extractStandardComponentNames } from "@json-to-office/shared";
+var JsonComponentDefinitionSchema = ComponentDefinitionSchema;
+function validateDocument(data, options) {
+  const result = validateAgainstSchema(ComponentDefinitionSchema, data, options);
+  let finalErrors = result.errors || [];
+  if (!result.valid && data) {
+    finalErrors = comprehensiveValidateDocument(data, result.errors);
+  }
+  const documentResult = {
+    ...result,
+    documentType: "docx",
+    errors: finalErrors
+    // Use the comprehensive errors
+  };
+  if (result.valid && result.data) {
+    const doc = result.data;
+    if (doc.children && Array.isArray(doc.children)) {
+      const hasCustom = doc.children.some(
+        (c) => !isStandardComponentName(c.name)
+      );
+      documentResult.hasCustomComponents = hasCustom;
+    }
+  }
+  return documentResult;
+}
+function validateJsonDocument(jsonInput, options) {
+  const result = validateJson(JsonComponentDefinitionSchema, jsonInput, options);
+  let finalErrors = result.errors || [];
+  if (!result.valid && result.parsed) {
+    finalErrors = comprehensiveValidateDocument(result.parsed, result.errors);
+  }
+  const documentResult = {
+    ...result,
+    documentType: "docx",
+    errors: finalErrors
+    // Use the comprehensive errors
+  };
+  if (result.valid && result.data) {
+    const doc = result.data;
+    if (doc.children && Array.isArray(doc.children)) {
+      const hasCustom = doc.children.some(
+        (c) => !isStandardComponentName(c.name)
+      );
+      documentResult.hasCustomComponents = hasCustom;
+    }
+  }
+  return documentResult;
+}
+function isValidDocument(result) {
+  return result.valid === true && result.data !== void 0;
+}
+function getStandardComponentNames() {
+  return extractStandardComponentNames(StandardComponentDefinitionSchema);
+}
+function isStandardComponentName(name) {
+  const standardNames = getStandardComponentNames();
+  return standardNames.includes(name);
+}
+function createDocumentValidator(defaultOptions) {
+  return {
+    validate: (data, options) => validateDocument(data, { ...defaultOptions, ...options }),
+    validateJson: (jsonInput, options) => validateJsonDocument(jsonInput, { ...defaultOptions, ...options })
+  };
+}
+var documentValidator = createDocumentValidator({
+  clean: true,
+  applyDefaults: true,
+  maxErrors: 100
+  // Collect up to 100 errors to show all validation issues
+});
+var strictDocumentValidator = createDocumentValidator({
+  clean: false,
+  applyDefaults: false,
+  maxErrors: 100
+  // Increased from 10 to show more errors
+});
+var validateJsonComponent = validateJsonDocument;
+var validateDocumentWithSchema = validateDocument;
+
+export {
+  transformValueError,
+  transformValueErrors,
+  deepValidateDocument,
+  comprehensiveValidateDocument,
+  validateAgainstSchema,
+  validateJson,
+  validateBatch,
+  validateWithEnhancement,
+  createValidator,
+  createJsonValidator,
+  isValidationSuccess,
+  getValidationSummary,
+  validateDocument,
+  validateJsonDocument,
+  isValidDocument,
+  createDocumentValidator,
+  documentValidator,
+  strictDocumentValidator,
+  validateJsonComponent,
+  validateDocumentWithSchema
+};
+//# sourceMappingURL=chunk-LOE6BZQG.js.map