@json-to-office/shared-docx 0.38.1 → 1.1.0

package/dist/chunk-5KOKA5GY.js

@@ -0,0 +1,687 @@
+import {
+  AlignmentSchema,
+  FloatingPropertiesSchema,
+  SpacingSchema
+} from "./chunk-VX2J2KWA.js";
+
+// src/schemas/components/visual.ts
+import { Type as Type2 } from "@sinclair/typebox";
+import {
+  MIN_VISUAL_DPI,
+  MAX_VISUAL_DPI,
+  DEFAULT_VISUAL_DPI
+} from "@json-to-office/shared";
+import { PptxSlideContentSchema } from "@json-to-office/shared/schemas/slide-content";
+
+// src/schemas/components/visual-native.ts
+import { Type } from "@sinclair/typebox";
+import { ShapeTypeSchema } from "@json-to-office/shared/schemas/slide-content";
+var NativeVisualColorSchema = Type.String({
+  pattern: "^(#?[0-9A-Fa-f]{6}|[a-zA-Z][a-zA-Z0-9]*)$",
+  description: 'Hex colour ("#0F172A" or "0F172A") or a docx theme colour name (e.g. "primary")'
+});
+var SIGNED_PERCENT_PATTERN = "^-?\\d+(\\.\\d+)?%$";
+var PERCENT_PATTERN = "^\\d+(\\.\\d+)?%$";
+var NativeVisualOffsetSchema = Type.Union(
+  [
+    Type.Number({ description: "Inches from the canvas origin" }),
+    Type.String({
+      pattern: SIGNED_PERCENT_PATTERN,
+      description: 'Percentage of the canvas extent on this axis, e.g. "25%"'
+    })
+  ],
+  { description: "Position in inches (number) or as a canvas percentage" }
+);
+var NativeVisualExtentSchema = Type.Union(
+  [
+    Type.Number({ minimum: 0, description: "Size in inches" }),
+    Type.String({
+      pattern: PERCENT_PATTERN,
+      description: 'Percentage of the canvas extent on this axis, e.g. "50%"'
+    })
+  ],
+  { description: "Size in inches (number) or as a canvas percentage" }
+);
+var FrameProps = {
+  x: Type.Optional(NativeVisualOffsetSchema),
+  y: Type.Optional(NativeVisualOffsetSchema),
+  w: Type.Optional(NativeVisualExtentSchema),
+  h: Type.Optional(NativeVisualExtentSchema),
+  rotate: Type.Optional(
+    Type.Number({ description: "Clockwise rotation in degrees" })
+  )
+};
+var NativeVisualUnderlineSchema = Type.Union(
+  [
+    Type.Boolean({ description: "Single underline in the text colour" }),
+    Type.Object(
+      {
+        style: Type.Optional(
+          Type.Union(
+            [
+              Type.Literal("sng"),
+              Type.Literal("dbl"),
+              Type.Literal("dash"),
+              Type.Literal("dotted")
+            ],
+            { description: 'Underline style (default "sng")' }
+          )
+        ),
+        color: Type.Optional(NativeVisualColorSchema)
+      },
+      { additionalProperties: false }
+    )
+  ],
+  { description: "Underline: true for a single line, or a style/colour object" }
+);
+var InlineTextProps = {
+  fontFace: Type.Optional(Type.String({ description: "Font family name" })),
+  fontSize: Type.Optional(
+    Type.Number({ minimum: 1, description: "Font size in points" })
+  ),
+  bold: Type.Optional(Type.Boolean()),
+  italic: Type.Optional(Type.Boolean())
+};
+var NativeVisualTextRunSchema = Type.Object(
+  {
+    text: Type.String({ description: "Run text" }),
+    color: Type.Optional(NativeVisualColorSchema),
+    ...InlineTextProps,
+    underline: Type.Optional(NativeVisualUnderlineSchema),
+    strike: Type.Optional(Type.Boolean({ description: "Strikethrough" })),
+    breakLine: Type.Optional(
+      Type.Boolean({ description: "Start a new line after this run" })
+    )
+  },
+  {
+    additionalProperties: false,
+    description: "A formatted run inside a native visual text element"
+  }
+);
+var NativeVisualTextSegmentSchema = Type.Object(
+  {
+    text: Type.String({ description: "Segment text" }),
+    color: Type.Optional(NativeVisualColorSchema),
+    ...InlineTextProps,
+    breakLine: Type.Optional(
+      Type.Boolean({ description: "Start a new line after this segment" })
+    )
+  },
+  {
+    additionalProperties: false,
+    description: "A formatted segment of a native visual shape\u2019s text"
+  }
+);
+var NativeVisualFillSchema = Type.Object(
+  {
+    color: Type.Optional(NativeVisualColorSchema),
+    transparency: Type.Optional(
+      Type.Number({
+        minimum: 0,
+        maximum: 100,
+        description: "Fill transparency, 0 (opaque) to 100 (invisible)"
+      })
+    )
+  },
+  {
+    additionalProperties: false,
+    description: "Solid fill. Omit the whole property for no fill; gradients and patterns are raster-only."
+  }
+);
+var NativeVisualLineSchema = Type.Object(
+  {
+    color: Type.Optional(NativeVisualColorSchema),
+    width: Type.Optional(
+      Type.Number({ minimum: 0, description: "Outline width in points" })
+    ),
+    dashType: Type.Optional(
+      Type.Union(
+        [
+          Type.Literal("solid"),
+          Type.Literal("dash"),
+          Type.Literal("dot"),
+          Type.Literal("dashDot")
+        ],
+        { description: 'Outline dash pattern (default "solid")' }
+      )
+    )
+  },
+  { additionalProperties: false, description: "Shape outline" }
+);
+var NativeVisualAlignmentSchema = Type.Union(
+  [
+    Type.Literal("left"),
+    Type.Literal("center"),
+    Type.Literal("right"),
+    Type.Literal("justify")
+  ],
+  { description: "Horizontal text alignment" }
+);
+var NativeVisualVerticalAlignmentSchema = Type.Union(
+  [Type.Literal("top"), Type.Literal("middle"), Type.Literal("bottom")],
+  { description: "Vertical text anchoring inside the box" }
+);
+var NativeVisualMarginSchema = Type.Union(
+  [
+    Type.Number({ minimum: 0, description: "Inset on every side, in points" }),
+    Type.Array(Type.Number({ minimum: 0 }), {
+      minItems: 4,
+      maxItems: 4,
+      description: "Insets as [top, right, bottom, left], in points"
+    })
+  ],
+  { description: "Text insets in points" }
+);
+var NativeVisualTextPropsSchema = Type.Object(
+  {
+    text: Type.Optional(Type.String({ description: "Plain text content" })),
+    runs: Type.Optional(
+      Type.Array(NativeVisualTextRunSchema, {
+        minItems: 1,
+        description: 'Formatted runs, as an alternative to "text"'
+      })
+    ),
+    ...FrameProps,
+    color: Type.Optional(NativeVisualColorSchema),
+    ...InlineTextProps,
+    underline: Type.Optional(NativeVisualUnderlineSchema),
+    strike: Type.Optional(Type.Boolean({ description: "Strikethrough" })),
+    align: Type.Optional(NativeVisualAlignmentSchema),
+    valign: Type.Optional(NativeVisualVerticalAlignmentSchema),
+    margin: Type.Optional(NativeVisualMarginSchema),
+    fill: Type.Optional(NativeVisualFillSchema)
+  },
+  {
+    additionalProperties: false,
+    description: "Native visual text element \u2014 becomes a Word text box (wps:wsp) inside the drawing group"
+  }
+);
+var NativeVisualShapePropsSchema = Type.Object(
+  {
+    type: ShapeTypeSchema,
+    ...FrameProps,
+    fill: Type.Optional(NativeVisualFillSchema),
+    line: Type.Optional(NativeVisualLineSchema),
+    text: Type.Optional(
+      Type.Union(
+        [
+          Type.String(),
+          Type.Array(NativeVisualTextSegmentSchema, { minItems: 1 })
+        ],
+        { description: "Text drawn inside the shape" }
+      )
+    ),
+    ...InlineTextProps,
+    fontColor: Type.Optional(NativeVisualColorSchema),
+    align: Type.Optional(NativeVisualAlignmentSchema),
+    valign: Type.Optional(NativeVisualVerticalAlignmentSchema),
+    margin: Type.Optional(NativeVisualMarginSchema),
+    flipH: Type.Optional(Type.Boolean({ description: "Mirror horizontally" })),
+    flipV: Type.Optional(Type.Boolean({ description: "Mirror vertically" }))
+  },
+  {
+    additionalProperties: false,
+    description: "Native visual shape element \u2014 becomes a preset-geometry shape (wps:wsp) inside the drawing group"
+  }
+);
+var NativeVisualImagePropsSchema = Type.Object(
+  {
+    path: Type.Optional(
+      Type.String({ description: "File path or http(s) URL" })
+    ),
+    base64: Type.Optional(Type.String({ description: "Base64 data URI" })),
+    svg: Type.Optional(Type.String({ description: "Raw SVG markup" })),
+    ...FrameProps,
+    sizing: Type.Optional(
+      Type.Object(
+        {
+          type: Type.Union(
+            [
+              Type.Literal("contain"),
+              Type.Literal("cover"),
+              Type.Literal("crop")
+            ],
+            { description: "How the image fills its box" }
+          ),
+          w: Type.Optional(
+            Type.Number({
+              minimum: 0,
+              description: 'Box width in inches; overrides the element\u2019s own "w"'
+            })
+          ),
+          h: Type.Optional(
+            Type.Number({
+              minimum: 0,
+              description: 'Box height in inches; overrides the element\u2019s own "h"'
+            })
+          )
+        },
+        {
+          additionalProperties: false,
+          description: 'How the image fills its box. "w"/"h" state the box itself, taking precedence over the element\u2019s "w"/"h", as they do in raster mode.'
+        }
+      )
+    ),
+    alt: Type.Optional(
+      Type.String({ description: "Alternative text for accessibility" })
+    )
+  },
+  {
+    additionalProperties: false,
+    description: "Native visual image element \u2014 becomes a native picture inside the drawing group"
+  }
+);
+var NATIVE_VISUAL_ELEMENT_NAMES = ["text", "shape", "image"];
+function nativeElement(name, propsSchema, description) {
+  return Type.Object(
+    {
+      name: Type.Literal(name),
+      id: Type.Optional(Type.String()),
+      enabled: Type.Optional(
+        Type.Boolean({
+          default: true,
+          description: "When false, this element is filtered out and not drawn. Defaults to true."
+        })
+      ),
+      props: propsSchema
+    },
+    { additionalProperties: false, description }
+  );
+}
+var NativeVisualElementSchema = Type.Union(
+  [
+    nativeElement(
+      "text",
+      NativeVisualTextPropsSchema,
+      "Text element - a native Word text box drawn on the visual canvas."
+    ),
+    nativeElement(
+      "shape",
+      NativeVisualShapePropsSchema,
+      "Shape element - a native preset-geometry shape, optionally holding text."
+    ),
+    nativeElement(
+      "image",
+      NativeVisualImagePropsSchema,
+      "Image element - a native picture; an SVG stays vector."
+    )
+  ],
+  {
+    $id: "DocxNativeVisualContent",
+    discriminator: { propertyName: "name" },
+    description: "A single native visual element (text, shape, or image)."
+  }
+);
+var NativeVisualCanvasSchema = Type.Object(
+  {
+    width: Type.Number({
+      minimum: 0.1,
+      description: "Canvas width in inches"
+    }),
+    height: Type.Number({
+      minimum: 0.1,
+      description: "Canvas height in inches"
+    }),
+    background: Type.Optional(
+      Type.Object(
+        {
+          color: Type.Optional(NativeVisualColorSchema),
+          image: Type.Optional(
+            Type.Object(
+              {
+                path: Type.Optional(Type.String()),
+                base64: Type.Optional(Type.String())
+              },
+              { additionalProperties: false }
+            )
+          )
+        },
+        {
+          additionalProperties: false,
+          description: "Canvas background. A colour becomes the bottom-most rectangle; an image becomes the bottom-most picture."
+        }
+      )
+    )
+  },
+  {
+    additionalProperties: false,
+    description: "Drawing canvas for a native visual"
+  }
+);
+
+// src/schemas/components/visual.ts
+var VisualCanvasBackgroundSchema = Type2.Object(
+  {
+    color: Type2.Optional(
+      Type2.String({
+        description: 'Background color (hex like "#FFFFFF" or a theme color name)'
+      })
+    ),
+    image: Type2.Optional(
+      Type2.Object(
+        {
+          path: Type2.Optional(Type2.String()),
+          base64: Type2.Optional(Type2.String())
+        },
+        { additionalProperties: false }
+      )
+    )
+  },
+  { additionalProperties: false }
+);
+var VisualCanvasSchema = Type2.Object(
+  {
+    width: Type2.Number({
+      minimum: 0.1,
+      description: "Canvas width in inches (pptx slideWidth)"
+    }),
+    height: Type2.Number({
+      minimum: 0.1,
+      description: "Canvas height in inches (pptx slideHeight)"
+    }),
+    theme: Type2.Optional(
+      Type2.String({ description: "pptx theme name applied to the slide" })
+    ),
+    background: Type2.Optional(VisualCanvasBackgroundSchema)
+  },
+  {
+    description: "pptx canvas definition for the visual",
+    additionalProperties: false
+  }
+);
+var PlacementProps = {
+  width: Type2.Optional(
+    Type2.Union(
+      [
+        Type2.Number({ minimum: 1, description: "Rendered width in pixels" }),
+        Type2.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Rendered width as percentage (e.g. "90%")'
+        })
+      ],
+      {
+        description: "Rendered width in the document, in pixels (number) or percentage string. Defaults to the canvas physical size."
+      }
+    )
+  ),
+  height: Type2.Optional(
+    Type2.Union([
+      Type2.Number({ minimum: 1, description: "Rendered height in pixels" }),
+      Type2.String({
+        pattern: "^\\d+(\\.\\d+)?%$",
+        description: 'Rendered height as percentage (e.g. "90%")'
+      })
+    ])
+  ),
+  alignment: Type2.Optional(AlignmentSchema),
+  caption: Type2.Optional(
+    Type2.String({
+      description: "Caption (supports rich text with **bold**, *italic*, ***both***)"
+    })
+  ),
+  alt: Type2.Optional(
+    Type2.String({ description: "Alternative text for accessibility" })
+  ),
+  spacing: Type2.Optional(SpacingSchema),
+  floating: Type2.Optional(FloatingPropertiesSchema),
+  keepNext: Type2.Optional(
+    Type2.Boolean({
+      description: "Keep paragraph with next paragraph on same page"
+    })
+  ),
+  keepLines: Type2.Optional(
+    Type2.Boolean({
+      description: "Keep all lines of paragraph together on same page"
+    })
+  )
+};
+var VisualRasterPropsSchema = Type2.Object(
+  {
+    renderMode: Type2.Optional(
+      Type2.Literal("raster", {
+        description: "Render as a rasterized pptx slide (the default when omitted)."
+      })
+    ),
+    // ── canvas (drives aspect ratio + physical size) ──
+    canvas: VisualCanvasSchema,
+    // pptx slide content elements, absolutely positioned on the canvas
+    elements: Type2.Optional(
+      Type2.Array(PptxSlideContentSchema, {
+        description: "pptx slide content elements (text, image, shape, table, highcharts, chart), positioned with x/y/w/h in inches"
+      })
+    ),
+    // ── rasterization ──
+    dpi: Type2.Optional(
+      Type2.Number({
+        minimum: MIN_VISUAL_DPI,
+        maximum: MAX_VISUAL_DPI,
+        default: DEFAULT_VISUAL_DPI,
+        description: `Raster resolution in DPI (default ${DEFAULT_VISUAL_DPI}, range ${MIN_VISUAL_DPI}-${MAX_VISUAL_DPI}). Higher = sharper + larger.`
+      })
+    ),
+    serverUrl: Type2.Optional(
+      Type2.String({
+        description: "Rasterization service URL override (default from services.pptx)"
+      })
+    ),
+    // ── placement in the document (mirrors `image`) ──
+    ...PlacementProps
+  },
+  {
+    // Hoisted into its own JSON-Schema definition rather than inlined at every
+    // position a component can appear. `visual.props` is by far the largest
+    // props schema in the registry, and inlining two of them pushed the
+    // exported `ComponentDefinition` past the depth Ajv can compile.
+    $id: "DocxVisualRasterProps",
+    description: "Visual component props (pptx-rendered graphic)",
+    additionalProperties: false
+  }
+);
+var VisualNativePropsSchema = Type2.Object(
+  {
+    renderMode: Type2.Literal("native", {
+      description: 'Draw natively as a Word DrawingML group. Requires the "office-open" renderer.'
+    }),
+    canvas: NativeVisualCanvasSchema,
+    elements: Type2.Optional(
+      Type2.Array(NativeVisualElementSchema, {
+        description: "Native drawing elements (text, shape, image), positioned with x/y/w/h in inches or canvas percentages"
+      })
+    ),
+    ...PlacementProps
+  },
+  {
+    // Hoisted for the same reason as the raster branch above.
+    $id: "DocxVisualNativeProps",
+    description: 'Visual component props (native Word drawing group; requires renderer "office-open")',
+    additionalProperties: false
+  }
+);
+var VisualPropsSchema = Type2.Union(
+  [VisualRasterPropsSchema, VisualNativePropsSchema],
+  {
+    description: "Visual component props \u2014 rasterized pptx slide (default) or a native Word drawing group"
+  }
+);
+var NATIVE_RENDER_MODE = "native";
+function isNativeVisualProps(props) {
+  return !!props && props.renderMode === NATIVE_RENDER_MODE;
+}
+
+// src/schemas/renderer.ts
+var DOCX_RENDERER_IDS = ["docxjs", "office-open"];
+var DEFAULT_DOCX_RENDERER_ID = "docxjs";
+var NATIVE_VISUAL_ELEMENTS = /* @__PURE__ */ new Set([
+  "text",
+  "shape",
+  "image"
+]);
+function docxComponentDefinitionName(renderer) {
+  return `ComponentDefinition_${renderer}`;
+}
+function docxPropsSchemaForRenderer(componentName, schema, renderer) {
+  const copy = cloneSchema(schema);
+  nameComponentPlaceholders(copy, docxComponentDefinitionName(renderer));
+  if (componentName === "visual" && renderer !== "office-open") {
+    return firstUnionBranch(copy) ?? copy;
+  }
+  if (renderer === "office-open") pruneThreadFields(copy);
+  return copy;
+}
+function collectDocxRendererErrors(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+  const root = data;
+  const renderer = root.renderer ?? DEFAULT_DOCX_RENDERER_ID;
+  if (!DOCX_RENDERER_IDS.includes(renderer)) {
+    return [
+      {
+        path: "/renderer",
+        message: `Invalid renderer "${String(renderer)}". Expected "docxjs" or "office-open".`,
+        code: "invalid_value"
+      }
+    ];
+  }
+  const errors = [];
+  const isOfficeOpen = renderer === "office-open";
+  const visit = (node, path) => {
+    if (Array.isArray(node)) {
+      node.forEach((entry, index) => visit(entry, `${path}/${index}`));
+      return;
+    }
+    if (!node || typeof node !== "object") return;
+    const object = node;
+    if (isOfficeOpen) {
+      const comment = object.comment;
+      if (comment && typeof comment === "object" && !Array.isArray(comment)) {
+        const value = comment;
+        for (const field of ["replies", "resolved"]) {
+          if (value[field] !== void 0) {
+            errors.push({
+              path: `${path}/comment/${field}`,
+              message: `The "office-open" renderer does not support comment threads.`,
+              code: "unsupported_renderer_feature"
+            });
+          }
+        }
+      }
+    }
+    if (object.name === "visual") {
+      collectVisualErrors(object, `${path}`, isOfficeOpen, errors);
+    }
+    for (const [key, value] of Object.entries(object)) {
+      if (key !== "renderer") visit(value, `${path}/${key}`);
+    }
+  };
+  visit(root, "");
+  return errors;
+}
+function collectVisualErrors(node, path, isOfficeOpen, errors) {
+  const props = node.props;
+  if (!props || typeof props !== "object" || Array.isArray(props)) return;
+  const value = props;
+  if (value.renderMode !== NATIVE_RENDER_MODE) return;
+  if (!isOfficeOpen) {
+    errors.push({
+      path: `${path}/props/renderMode`,
+      message: `Only the "office-open" renderer draws a native visual. Set the document's "renderer" to "office-open", or drop "renderMode" to rasterize.`,
+      code: "unsupported_renderer_feature"
+    });
+    return;
+  }
+  const elements = value.elements;
+  if (!Array.isArray(elements)) return;
+  elements.forEach((element, index) => {
+    if (!element || typeof element !== "object" || Array.isArray(element)) {
+      return;
+    }
+    const name = element.name;
+    if (typeof name !== "string" || NATIVE_VISUAL_ELEMENTS.has(name)) return;
+    errors.push({
+      path: `${path}/props/elements/${index}/name`,
+      message: `A native visual cannot draw "${name}". Native mode holds "text", "shape" and "image"; use renderMode "raster" for anything else.`,
+      code: "unsupported_renderer_feature"
+    });
+  });
+}
+function firstUnionBranch(schema) {
+  const branches = schema.anyOf;
+  return Array.isArray(branches) && branches.length > 0 ? branches[0] : void 0;
+}
+function pruneThreadFields(node) {
+  if (Array.isArray(node)) {
+    node.forEach(pruneThreadFields);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  const schema = node;
+  const properties = schema.properties;
+  if (properties?.text && properties?.author && (properties.replies || properties.resolved) && typeof schema.description === "string" && schema.description.includes("Word review comment")) {
+    delete properties.replies;
+    delete properties.resolved;
+    const required = schema.required;
+    if (required) {
+      schema.required = required.filter(
+        (key) => key !== "replies" && key !== "resolved"
+      );
+    }
+  }
+  for (const key of Reflect.ownKeys(schema)) {
+    pruneThreadFields(schema[key]);
+  }
+}
+function nameComponentPlaceholders(node, definitionName) {
+  if (Array.isArray(node)) {
+    node.forEach((entry) => nameComponentPlaceholders(entry, definitionName));
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  const schema = node;
+  if (schema.type === "array" && schema.items && typeof schema.items === "object" && Object.keys(schema.items).length === 0) {
+    schema.items = { $ref: definitionName };
+  }
+  for (const key of Reflect.ownKeys(schema)) {
+    nameComponentPlaceholders(schema[key], definitionName);
+  }
+}
+function cloneSchema(value) {
+  if (Array.isArray(value)) return value.map(cloneSchema);
+  if (!value || typeof value !== "object") return value;
+  const copy = Object.create(Object.getPrototypeOf(value));
+  for (const key of Reflect.ownKeys(value)) {
+    copy[key] = cloneSchema(value[key]);
+  }
+  return copy;
+}
+
+export {
+  NativeVisualColorSchema,
+  NativeVisualOffsetSchema,
+  NativeVisualExtentSchema,
+  NativeVisualUnderlineSchema,
+  NativeVisualTextRunSchema,
+  NativeVisualTextSegmentSchema,
+  NativeVisualFillSchema,
+  NativeVisualLineSchema,
+  NativeVisualAlignmentSchema,
+  NativeVisualVerticalAlignmentSchema,
+  NativeVisualMarginSchema,
+  NativeVisualTextPropsSchema,
+  NativeVisualShapePropsSchema,
+  NativeVisualImagePropsSchema,
+  NATIVE_VISUAL_ELEMENT_NAMES,
+  NativeVisualElementSchema,
+  NativeVisualCanvasSchema,
+  VisualCanvasBackgroundSchema,
+  VisualCanvasSchema,
+  VisualRasterPropsSchema,
+  VisualNativePropsSchema,
+  VisualPropsSchema,
+  NATIVE_RENDER_MODE,
+  isNativeVisualProps,
+  DOCX_RENDERER_IDS,
+  DEFAULT_DOCX_RENDERER_ID,
+  docxComponentDefinitionName,
+  docxPropsSchemaForRenderer,
+  collectDocxRendererErrors
+};
+//# sourceMappingURL=chunk-5KOKA5GY.js.map