@json-to-office/shared-pptx 0.3.0 → 0.8.0

package/dist/chunk-OJMLZFHW.js

@@ -0,0 +1,982 @@
+// src/schemas/component-defaults.ts
+import { Type as Type9 } from "@sinclair/typebox";
+
+// src/schemas/components/text.ts
+import { Type as Type3 } from "@sinclair/typebox";
+
+// src/schemas/components/common.ts
+import { Type as Type2 } from "@sinclair/typebox";
+
+// src/schemas/theme.ts
+import { Type } from "@sinclair/typebox";
+var GridMarginSchema = Type.Union(
+  [
+    Type.Number({ description: "Margin in inches (all sides)" }),
+    Type.Object(
+      {
+        top: Type.Number({ description: "Top margin in inches" }),
+        right: Type.Number({ description: "Right margin in inches" }),
+        bottom: Type.Number({ description: "Bottom margin in inches" }),
+        left: Type.Number({ description: "Left margin in inches" })
+      },
+      { additionalProperties: false }
+    )
+  ],
+  { description: "Slide margins in inches" }
+);
+var GridGutterSchema = Type.Union(
+  [
+    Type.Number({ description: "Gutter in inches (both axes)" }),
+    Type.Object(
+      {
+        column: Type.Number({ description: "Column gutter in inches" }),
+        row: Type.Number({ description: "Row gutter in inches" })
+      },
+      { additionalProperties: false }
+    )
+  ],
+  { description: "Gaps between grid tracks in inches" }
+);
+var GridConfigSchema = Type.Object(
+  {
+    columns: Type.Optional(Type.Number({ minimum: 1, description: "Number of columns (default: 12)" })),
+    rows: Type.Optional(Type.Number({ minimum: 1, description: "Number of rows (default: 6)" })),
+    margin: Type.Optional(GridMarginSchema),
+    gutter: Type.Optional(GridGutterSchema)
+  },
+  { additionalProperties: false, description: "Grid layout configuration" }
+);
+var HexColorSchema = Type.String({ pattern: "^#?[0-9A-Fa-f]{6}$", description: "Hex color (e.g. #FF0000)" });
+var SEMANTIC_COLOR_NAMES = [
+  "primary",
+  "secondary",
+  "accent",
+  "background",
+  "text",
+  "text2",
+  "background2",
+  "accent4",
+  "accent5",
+  "accent6"
+];
+var SEMANTIC_COLOR_ALIASES = [
+  "accent1",
+  "accent2",
+  "accent3",
+  "tx1",
+  "tx2",
+  "bg1",
+  "bg2"
+];
+var ColorValueSchema = Type.Union([
+  HexColorSchema,
+  ...SEMANTIC_COLOR_NAMES.map((n) => Type.Literal(n)),
+  ...SEMANTIC_COLOR_ALIASES.map((n) => Type.Literal(n))
+], { description: "Hex color or semantic theme color name" });
+var STYLE_NAMES = [
+  "title",
+  "subtitle",
+  "heading1",
+  "heading2",
+  "heading3",
+  "body",
+  "caption"
+];
+var StyleNameSchema = Type.Union(
+  STYLE_NAMES.map((n) => Type.Literal(n)),
+  { description: "Predefined style name" }
+);
+var TextStyleSchema = Type.Object({
+  fontSize: Type.Optional(Type.Number()),
+  fontFace: Type.Optional(Type.String()),
+  fontColor: Type.Optional(ColorValueSchema),
+  bold: Type.Optional(Type.Boolean()),
+  italic: Type.Optional(Type.Boolean()),
+  align: Type.Optional(Type.Union([
+    Type.Literal("left"),
+    Type.Literal("center"),
+    Type.Literal("right"),
+    Type.Literal("justify")
+  ])),
+  lineSpacing: Type.Optional(Type.Number()),
+  charSpacing: Type.Optional(Type.Number()),
+  paraSpaceAfter: Type.Optional(Type.Number())
+}, { additionalProperties: false, description: "Text style preset" });
+var ThemeConfigSchema = Type.Object(
+  {
+    name: Type.String({ description: "Theme name" }),
+    colors: Type.Object(
+      {
+        primary: HexColorSchema,
+        secondary: HexColorSchema,
+        accent: HexColorSchema,
+        background: HexColorSchema,
+        text: HexColorSchema,
+        text2: Type.Optional(HexColorSchema),
+        background2: Type.Optional(HexColorSchema),
+        accent4: Type.Optional(HexColorSchema),
+        accent5: Type.Optional(HexColorSchema),
+        accent6: Type.Optional(HexColorSchema)
+      },
+      { additionalProperties: false, description: "Theme color palette (10-slot scheme)" }
+    ),
+    fonts: Type.Object(
+      {
+        heading: Type.String({ description: "Heading font family" }),
+        body: Type.String({ description: "Body font family" })
+      },
+      { additionalProperties: false, description: "Font families" }
+    ),
+    defaults: Type.Object(
+      {
+        fontSize: Type.Number({ description: "Default font size in points" }),
+        fontColor: HexColorSchema
+      },
+      { additionalProperties: false, description: "Default text styling" }
+    ),
+    styles: Type.Optional(Type.Partial(
+      Type.Object(Object.fromEntries(
+        STYLE_NAMES.map((n) => [n, TextStyleSchema])
+      )),
+      { additionalProperties: false, description: "Named text style presets" }
+    )),
+    componentDefaults: Type.Optional(PptxComponentDefaultsSchema)
+  },
+  { additionalProperties: false, description: "Presentation theme configuration" }
+);
+function isValidThemeConfig(data) {
+  return typeof data === "object" && data !== null;
+}
+
+// src/schemas/components/common.ts
+var PositionSchema = Type2.Object(
+  {
+    x: Type2.Optional(
+      Type2.Union([
+        Type2.Number({ description: "X position in inches" }),
+        Type2.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'X position as percentage (e.g., "10%")'
+        })
+      ])
+    ),
+    y: Type2.Optional(
+      Type2.Union([
+        Type2.Number({ description: "Y position in inches" }),
+        Type2.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Y position as percentage (e.g., "10%")'
+        })
+      ])
+    ),
+    w: Type2.Optional(
+      Type2.Union([
+        Type2.Number({ description: "Width in inches" }),
+        Type2.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Width as percentage (e.g., "80%")'
+        })
+      ])
+    ),
+    h: Type2.Optional(
+      Type2.Union([
+        Type2.Number({ description: "Height in inches" }),
+        Type2.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Height as percentage (e.g., "20%")'
+        })
+      ])
+    )
+  },
+  {
+    description: "Position and size in inches or percentages",
+    additionalProperties: false
+  }
+);
+var SlideBackgroundSchema = Type2.Object(
+  {
+    color: Type2.Optional(ColorValueSchema),
+    image: Type2.Optional(
+      Type2.Object(
+        {
+          path: Type2.Optional(Type2.String({ description: "Image file path or URL" })),
+          base64: Type2.Optional(
+            Type2.String({ description: "Base64-encoded image data" })
+          )
+        },
+        { description: "Background image", additionalProperties: false }
+      )
+    )
+  },
+  {
+    description: "Slide background configuration",
+    additionalProperties: false
+  }
+);
+var TransitionSchema = Type2.Object(
+  {
+    type: Type2.Optional(
+      Type2.Union(
+        [
+          Type2.Literal("fade"),
+          Type2.Literal("push"),
+          Type2.Literal("wipe"),
+          Type2.Literal("zoom"),
+          Type2.Literal("none")
+        ],
+        { description: "Transition effect type" }
+      )
+    ),
+    speed: Type2.Optional(
+      Type2.Union(
+        [Type2.Literal("slow"), Type2.Literal("medium"), Type2.Literal("fast")],
+        { description: "Transition speed" }
+      )
+    )
+  },
+  {
+    description: "Slide transition configuration",
+    additionalProperties: false
+  }
+);
+var PptxAlignmentSchema = Type2.Union(
+  [Type2.Literal("left"), Type2.Literal("center"), Type2.Literal("right")],
+  { description: "Horizontal alignment options" }
+);
+var VerticalAlignmentSchema = Type2.Union(
+  [Type2.Literal("top"), Type2.Literal("middle"), Type2.Literal("bottom")],
+  { description: "Vertical alignment options" }
+);
+var ShadowSchema = Type2.Object(
+  {
+    type: Type2.Optional(
+      Type2.Union([Type2.Literal("outer"), Type2.Literal("inner")], {
+        description: "Shadow type"
+      })
+    ),
+    color: Type2.Optional(ColorValueSchema),
+    blur: Type2.Optional(Type2.Number({ description: "Shadow blur radius in points" })),
+    offset: Type2.Optional(Type2.Number({ description: "Shadow offset in points" })),
+    angle: Type2.Optional(Type2.Number({ description: "Shadow angle in degrees" })),
+    opacity: Type2.Optional(
+      Type2.Number({
+        minimum: 0,
+        maximum: 1,
+        description: "Shadow opacity (0-1)"
+      })
+    )
+  },
+  {
+    description: "Shadow configuration",
+    additionalProperties: false
+  }
+);
+var GridPositionSchema = Type2.Object(
+  {
+    column: Type2.Number({ minimum: 0, description: "Starting column (0-indexed)" }),
+    row: Type2.Number({ minimum: 0, description: "Starting row (0-indexed)" }),
+    columnSpan: Type2.Optional(Type2.Number({ minimum: 1, description: "Number of columns to span (default: 1)" })),
+    rowSpan: Type2.Optional(Type2.Number({ minimum: 1, description: "Number of rows to span (default: 1)" }))
+  },
+  { additionalProperties: false, description: "Grid-based positioning" }
+);
+
+// src/schemas/components/text.ts
+var TextPropsSchema = Type3.Object(
+  {
+    text: Type3.String({ description: "Text content to display" }),
+    x: Type3.Optional(
+      Type3.Union([
+        Type3.Number({ description: "X position in inches" }),
+        Type3.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
+      ])
+    ),
+    y: Type3.Optional(
+      Type3.Union([
+        Type3.Number({ description: "Y position in inches" }),
+        Type3.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
+      ])
+    ),
+    w: Type3.Optional(
+      Type3.Union([
+        Type3.Number({ description: "Width in inches" }),
+        Type3.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
+      ])
+    ),
+    h: Type3.Optional(
+      Type3.Union([
+        Type3.Number({ description: "Height in inches" }),
+        Type3.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
+      ])
+    ),
+    fontSize: Type3.Optional(
+      Type3.Number({ minimum: 1, description: "Font size in points" })
+    ),
+    fontFace: Type3.Optional(Type3.String({ description: "Font family name" })),
+    color: Type3.Optional(
+      Type3.String({ description: 'Text color (hex without #, e.g., "FF0000")' })
+    ),
+    bold: Type3.Optional(Type3.Boolean({ description: "Bold text" })),
+    italic: Type3.Optional(Type3.Boolean({ description: "Italic text" })),
+    underline: Type3.Optional(
+      Type3.Union([
+        Type3.Boolean({ description: "Simple underline toggle" }),
+        Type3.Object(
+          {
+            style: Type3.Optional(
+              Type3.Union([
+                Type3.Literal("sng"),
+                Type3.Literal("dbl"),
+                Type3.Literal("dash"),
+                Type3.Literal("dotted")
+              ])
+            ),
+            color: Type3.Optional(Type3.String({ description: "Underline color (hex)" }))
+          },
+          { additionalProperties: false }
+        )
+      ])
+    ),
+    strike: Type3.Optional(Type3.Boolean({ description: "Strikethrough text" })),
+    align: Type3.Optional(PptxAlignmentSchema),
+    valign: Type3.Optional(VerticalAlignmentSchema),
+    breakLine: Type3.Optional(
+      Type3.Boolean({ description: "Add line break after text" })
+    ),
+    bullet: Type3.Optional(
+      Type3.Union([
+        Type3.Boolean({ description: "Enable default bullet" }),
+        Type3.Object(
+          {
+            type: Type3.Optional(
+              Type3.Union([Type3.Literal("bullet"), Type3.Literal("number")])
+            ),
+            style: Type3.Optional(Type3.String({ description: "Bullet character or style" })),
+            startAt: Type3.Optional(Type3.Number({ description: "Starting number for numbered lists" }))
+          },
+          { additionalProperties: false }
+        )
+      ])
+    ),
+    margin: Type3.Optional(
+      Type3.Union([
+        Type3.Number({ description: "Margin in points (all sides)" }),
+        Type3.Array(Type3.Number(), {
+          description: "Margins as [top, right, bottom, left] in points",
+          minItems: 4,
+          maxItems: 4
+        })
+      ])
+    ),
+    rotate: Type3.Optional(Type3.Number({ description: "Rotation angle in degrees" })),
+    shadow: Type3.Optional(ShadowSchema),
+    fill: Type3.Optional(
+      Type3.Object(
+        {
+          color: Type3.String({ description: "Fill color (hex without #)" }),
+          transparency: Type3.Optional(
+            Type3.Number({ minimum: 0, maximum: 100, description: "Fill transparency (0-100)" })
+          )
+        },
+        { additionalProperties: false }
+      )
+    ),
+    hyperlink: Type3.Optional(
+      Type3.Object(
+        {
+          url: Type3.Optional(Type3.String({ description: "Hyperlink URL" })),
+          slide: Type3.Optional(Type3.Number({ description: "Slide number to link to" })),
+          tooltip: Type3.Optional(Type3.String({ description: "Hyperlink tooltip" }))
+        },
+        { additionalProperties: false }
+      )
+    ),
+    lineSpacing: Type3.Optional(Type3.Number({ description: "Line spacing in points" })),
+    charSpacing: Type3.Optional(Type3.Number({ description: "Character spacing in points (positive = wider, negative = tighter)" })),
+    paraSpaceBefore: Type3.Optional(Type3.Number({ description: "Space before paragraph in points" })),
+    paraSpaceAfter: Type3.Optional(Type3.Number({ description: "Space after paragraph in points" })),
+    grid: Type3.Optional(GridPositionSchema),
+    style: Type3.Optional(StyleNameSchema)
+  },
+  {
+    description: "Text component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/image.ts
+import { Type as Type4 } from "@sinclair/typebox";
+var PptxImagePropsSchema = Type4.Object(
+  {
+    path: Type4.Optional(
+      Type4.String({
+        description: "Image file path or URL (mutually exclusive with base64)"
+      })
+    ),
+    base64: Type4.Optional(
+      Type4.String({
+        description: "Base64-encoded image data in data URI format (mutually exclusive with path)"
+      })
+    ),
+    x: Type4.Optional(
+      Type4.Union([
+        Type4.Number({ description: "X position in inches" }),
+        Type4.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
+      ])
+    ),
+    y: Type4.Optional(
+      Type4.Union([
+        Type4.Number({ description: "Y position in inches" }),
+        Type4.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
+      ])
+    ),
+    w: Type4.Optional(
+      Type4.Union([
+        Type4.Number({ description: "Width in inches" }),
+        Type4.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
+      ])
+    ),
+    h: Type4.Optional(
+      Type4.Union([
+        Type4.Number({ description: "Height in inches" }),
+        Type4.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
+      ])
+    ),
+    sizing: Type4.Optional(
+      Type4.Object(
+        {
+          type: Type4.Union(
+            [
+              Type4.Literal("contain"),
+              Type4.Literal("cover"),
+              Type4.Literal("crop")
+            ],
+            { description: "Image sizing strategy" }
+          ),
+          w: Type4.Optional(Type4.Number({ description: "Target width in inches" })),
+          h: Type4.Optional(Type4.Number({ description: "Target height in inches" }))
+        },
+        { description: "Image sizing options", additionalProperties: false }
+      )
+    ),
+    rotate: Type4.Optional(
+      Type4.Number({ description: "Rotation angle in degrees" })
+    ),
+    rounding: Type4.Optional(
+      Type4.Boolean({ description: "Apply rounded corners to image" })
+    ),
+    shadow: Type4.Optional(ShadowSchema),
+    hyperlink: Type4.Optional(
+      Type4.Object(
+        {
+          url: Type4.Optional(Type4.String({ description: "Hyperlink URL" })),
+          slide: Type4.Optional(Type4.Number({ description: "Slide number to link to" })),
+          tooltip: Type4.Optional(Type4.String({ description: "Hyperlink tooltip" }))
+        },
+        { additionalProperties: false }
+      )
+    ),
+    alt: Type4.Optional(
+      Type4.String({ description: "Alternative text for accessibility" })
+    ),
+    grid: Type4.Optional(GridPositionSchema)
+  },
+  {
+    description: "PPTX image component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/shape.ts
+import { Type as Type5 } from "@sinclair/typebox";
+var ShapeTypeSchema = Type5.Union(
+  [
+    Type5.Literal("rect"),
+    Type5.Literal("roundRect"),
+    Type5.Literal("ellipse"),
+    Type5.Literal("triangle"),
+    Type5.Literal("diamond"),
+    Type5.Literal("pentagon"),
+    Type5.Literal("hexagon"),
+    Type5.Literal("star5"),
+    Type5.Literal("star6"),
+    Type5.Literal("line"),
+    Type5.Literal("arrow"),
+    Type5.Literal("chevron"),
+    Type5.Literal("cloud"),
+    Type5.Literal("heart"),
+    Type5.Literal("lightning")
+  ],
+  { description: "Shape type" }
+);
+var TextSegmentSchema = Type5.Object(
+  {
+    text: Type5.String(),
+    fontSize: Type5.Optional(Type5.Number({ minimum: 1 })),
+    fontFace: Type5.Optional(Type5.String()),
+    color: Type5.Optional(Type5.String({ description: "Segment color (hex without # or semantic name)" })),
+    bold: Type5.Optional(Type5.Boolean()),
+    italic: Type5.Optional(Type5.Boolean()),
+    breakLine: Type5.Optional(Type5.Boolean({ description: "Insert line break after this segment" })),
+    spaceBefore: Type5.Optional(Type5.Number({ minimum: 0, description: "Space before paragraph in points" })),
+    spaceAfter: Type5.Optional(Type5.Number({ minimum: 0, description: "Space after paragraph in points" })),
+    charSpacing: Type5.Optional(Type5.Number({ description: "Character spacing in points" }))
+  },
+  { additionalProperties: false }
+);
+var ShapePropsSchema = Type5.Object(
+  {
+    type: ShapeTypeSchema,
+    x: Type5.Optional(
+      Type5.Union([
+        Type5.Number({ description: "X position in inches" }),
+        Type5.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
+      ])
+    ),
+    y: Type5.Optional(
+      Type5.Union([
+        Type5.Number({ description: "Y position in inches" }),
+        Type5.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
+      ])
+    ),
+    w: Type5.Optional(
+      Type5.Union([
+        Type5.Number({ description: "Width in inches" }),
+        Type5.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
+      ])
+    ),
+    h: Type5.Optional(
+      Type5.Union([
+        Type5.Number({ description: "Height in inches" }),
+        Type5.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
+      ])
+    ),
+    fill: Type5.Optional(
+      Type5.Object(
+        {
+          color: Type5.String({ description: "Fill color (hex without #)" }),
+          transparency: Type5.Optional(
+            Type5.Number({ minimum: 0, maximum: 100, description: "Fill transparency (0-100)" })
+          )
+        },
+        { additionalProperties: false }
+      )
+    ),
+    line: Type5.Optional(
+      Type5.Object(
+        {
+          color: Type5.Optional(Type5.String({ description: "Line color (hex without #)" })),
+          width: Type5.Optional(Type5.Number({ minimum: 0, description: "Line width in points" })),
+          dashType: Type5.Optional(
+            Type5.Union([
+              Type5.Literal("solid"),
+              Type5.Literal("dash"),
+              Type5.Literal("dot"),
+              Type5.Literal("dashDot")
+            ])
+          )
+        },
+        { additionalProperties: false }
+      )
+    ),
+    text: Type5.Optional(Type5.Union([
+      Type5.String({ description: "Plain text" }),
+      Type5.Array(TextSegmentSchema, { description: "Rich text segments with per-segment formatting" })
+    ], { description: "Text content inside the shape" })),
+    fontSize: Type5.Optional(Type5.Number({ minimum: 1, description: "Font size for shape text" })),
+    fontFace: Type5.Optional(Type5.String({ description: "Font family for shape text" })),
+    fontColor: Type5.Optional(Type5.String({ description: "Font color for shape text (hex without #)" })),
+    charSpacing: Type5.Optional(Type5.Number({ description: "Character spacing in points for shape text" })),
+    bold: Type5.Optional(Type5.Boolean({ description: "Bold shape text" })),
+    italic: Type5.Optional(Type5.Boolean({ description: "Italic shape text" })),
+    align: Type5.Optional(PptxAlignmentSchema),
+    valign: Type5.Optional(VerticalAlignmentSchema),
+    rotate: Type5.Optional(Type5.Number({ description: "Rotation angle in degrees" })),
+    shadow: Type5.Optional(ShadowSchema),
+    rectRadius: Type5.Optional(
+      Type5.Number({
+        minimum: 0,
+        description: "Corner radius for roundRect shape in inches"
+      })
+    ),
+    grid: Type5.Optional(GridPositionSchema),
+    style: Type5.Optional(StyleNameSchema)
+  },
+  {
+    description: "Shape component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/table.ts
+import { Type as Type6 } from "@sinclair/typebox";
+var PptxTableCellSchema = Type6.Union([
+  Type6.String({ description: "Simple text cell" }),
+  Type6.Object(
+    {
+      text: Type6.String({ description: "Cell text content" }),
+      color: Type6.Optional(Type6.String({ description: "Text color (hex without #)" })),
+      fill: Type6.Optional(Type6.String({ description: "Cell background color (hex without #)" })),
+      fontSize: Type6.Optional(Type6.Number({ description: "Font size in points" })),
+      fontFace: Type6.Optional(Type6.String({ description: "Font family" })),
+      bold: Type6.Optional(Type6.Boolean({ description: "Bold text" })),
+      italic: Type6.Optional(Type6.Boolean({ description: "Italic text" })),
+      align: Type6.Optional(PptxAlignmentSchema),
+      valign: Type6.Optional(VerticalAlignmentSchema),
+      colspan: Type6.Optional(Type6.Number({ minimum: 1, description: "Column span" })),
+      rowspan: Type6.Optional(Type6.Number({ minimum: 1, description: "Row span" })),
+      margin: Type6.Optional(
+        Type6.Union([
+          Type6.Number({ description: "Margin in points (all sides)" }),
+          Type6.Array(Type6.Number(), { minItems: 4, maxItems: 4 })
+        ])
+      )
+    },
+    { additionalProperties: false }
+  )
+]);
+var PptxTablePropsSchema = Type6.Object(
+  {
+    rows: Type6.Array(
+      Type6.Array(PptxTableCellSchema, { description: "Row of cells" }),
+      { description: "Table rows (array of arrays)", minItems: 1 }
+    ),
+    x: Type6.Optional(
+      Type6.Union([
+        Type6.Number({ description: "X position in inches" }),
+        Type6.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
+      ])
+    ),
+    y: Type6.Optional(
+      Type6.Union([
+        Type6.Number({ description: "Y position in inches" }),
+        Type6.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
+      ])
+    ),
+    w: Type6.Optional(
+      Type6.Union([
+        Type6.Number({ description: "Width in inches" }),
+        Type6.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
+      ])
+    ),
+    h: Type6.Optional(
+      Type6.Union([
+        Type6.Number({ description: "Height in inches" }),
+        Type6.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
+      ])
+    ),
+    colW: Type6.Optional(
+      Type6.Union([
+        Type6.Number({ description: "Uniform column width in inches" }),
+        Type6.Array(Type6.Number(), { description: "Individual column widths in inches" })
+      ])
+    ),
+    rowH: Type6.Optional(
+      Type6.Union([
+        Type6.Number({ description: "Uniform row height in inches" }),
+        Type6.Array(Type6.Number(), { description: "Individual row heights in inches" })
+      ])
+    ),
+    border: Type6.Optional(
+      Type6.Object(
+        {
+          type: Type6.Optional(
+            Type6.Union([
+              Type6.Literal("solid"),
+              Type6.Literal("dash"),
+              Type6.Literal("dot"),
+              Type6.Literal("none")
+            ])
+          ),
+          pt: Type6.Optional(Type6.Number({ minimum: 0, description: "Border width in points" })),
+          color: Type6.Optional(Type6.String({ description: "Border color (hex without #)" }))
+        },
+        { additionalProperties: false }
+      )
+    ),
+    fill: Type6.Optional(Type6.String({ description: "Table background color (hex without #)" })),
+    fontSize: Type6.Optional(Type6.Number({ minimum: 1, description: "Default font size for all cells" })),
+    fontFace: Type6.Optional(Type6.String({ description: "Default font family for all cells" })),
+    color: Type6.Optional(Type6.String({ description: "Default text color for all cells (hex without #)" })),
+    align: Type6.Optional(PptxAlignmentSchema),
+    valign: Type6.Optional(VerticalAlignmentSchema),
+    autoPage: Type6.Optional(
+      Type6.Boolean({ description: "Auto-paginate table across multiple slides when content overflows" })
+    ),
+    autoPageRepeatHeader: Type6.Optional(
+      Type6.Boolean({ description: "Repeat first row as header on each auto-paged slide" })
+    ),
+    margin: Type6.Optional(
+      Type6.Union([
+        Type6.Number({ description: "Cell margin in points (all sides)" }),
+        Type6.Array(Type6.Number(), { minItems: 4, maxItems: 4 })
+      ])
+    ),
+    borderRadius: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Rounded corner radius in inches. Renders a roundRect shape behind the table." })
+    ),
+    grid: Type6.Optional(GridPositionSchema)
+  },
+  {
+    description: "PPTX table component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/highcharts.ts
+import { Type as Type7 } from "@sinclair/typebox";
+var PptxHighchartsPropsSchema = Type7.Object(
+  {
+    options: Type7.Intersect([
+      Type7.Record(Type7.String(), Type7.Unknown()),
+      Type7.Object({
+        chart: Type7.Object({
+          width: Type7.Number(),
+          height: Type7.Number()
+        })
+      })
+    ]),
+    scale: Type7.Optional(Type7.Number()),
+    serverUrl: Type7.Optional(Type7.String({ description: "Highcharts Export Server URL (default: http://localhost:7801)" })),
+    x: Type7.Optional(
+      Type7.Union([
+        Type7.Number({ description: "X position in inches" }),
+        Type7.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
+      ])
+    ),
+    y: Type7.Optional(
+      Type7.Union([
+        Type7.Number({ description: "Y position in inches" }),
+        Type7.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
+      ])
+    ),
+    w: Type7.Optional(
+      Type7.Union([
+        Type7.Number({ description: "Width in inches" }),
+        Type7.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
+      ])
+    ),
+    h: Type7.Optional(
+      Type7.Union([
+        Type7.Number({ description: "Height in inches" }),
+        Type7.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
+      ])
+    ),
+    grid: Type7.Optional(GridPositionSchema)
+  },
+  {
+    description: "PPTX Highcharts component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/chart.ts
+import { Type as Type8 } from "@sinclair/typebox";
+var PositionValue = Type8.Union([
+  Type8.Number(),
+  Type8.String({ pattern: "^\\d+(\\.\\d+)?%$" })
+]);
+var ChartTypeSchema = Type8.Union(
+  [
+    Type8.Literal("area"),
+    Type8.Literal("bar"),
+    Type8.Literal("bar3D"),
+    Type8.Literal("bubble"),
+    Type8.Literal("doughnut"),
+    Type8.Literal("line"),
+    Type8.Literal("pie"),
+    Type8.Literal("radar"),
+    Type8.Literal("scatter")
+  ],
+  { description: "Chart type" }
+);
+var ChartDataSeriesSchema = Type8.Object(
+  {
+    name: Type8.Optional(Type8.String({ description: "Series name" })),
+    labels: Type8.Optional(Type8.Array(Type8.String(), { description: "Category labels" })),
+    values: Type8.Optional(Type8.Array(Type8.Number(), { description: "Data values" })),
+    sizes: Type8.Optional(Type8.Array(Type8.Number(), { description: "Bubble sizes (bubble charts only)" }))
+  },
+  { additionalProperties: false }
+);
+var PptxChartPropsSchema = Type8.Object(
+  {
+    type: ChartTypeSchema,
+    data: Type8.Array(ChartDataSeriesSchema, {
+      description: "Chart data series",
+      minItems: 1
+    }),
+    // Display toggles
+    showLegend: Type8.Optional(Type8.Boolean({ description: "Show chart legend" })),
+    showTitle: Type8.Optional(Type8.Boolean({ description: "Show chart title" })),
+    showValue: Type8.Optional(Type8.Boolean({ description: "Show data values" })),
+    showPercent: Type8.Optional(Type8.Boolean({ description: "Show percentages (pie/doughnut)" })),
+    showLabel: Type8.Optional(Type8.Boolean({ description: "Show category labels on data points" })),
+    showSerName: Type8.Optional(Type8.Boolean({ description: "Show series name on data points" })),
+    // Title
+    title: Type8.Optional(Type8.String({ description: "Chart title text" })),
+    titleFontSize: Type8.Optional(Type8.Number({ description: "Title font size (points)" })),
+    titleColor: Type8.Optional(Type8.String({ description: "Title color (hex or semantic)" })),
+    titleFontFace: Type8.Optional(Type8.String({ description: "Title font face" })),
+    // Chart colors
+    chartColors: Type8.Optional(
+      Type8.Array(Type8.String(), {
+        description: "Series colors (hex or semantic theme names). Defaults to theme palette."
+      })
+    ),
+    // Legend
+    legendPos: Type8.Optional(
+      Type8.Union(
+        [Type8.Literal("b"), Type8.Literal("l"), Type8.Literal("r"), Type8.Literal("t"), Type8.Literal("tr")],
+        { description: "Legend position" }
+      )
+    ),
+    legendFontSize: Type8.Optional(Type8.Number({ description: "Legend font size" })),
+    legendFontFace: Type8.Optional(Type8.String({ description: "Legend font face" })),
+    legendColor: Type8.Optional(Type8.String({ description: "Legend text color" })),
+    // Category axis
+    catAxisTitle: Type8.Optional(Type8.String({ description: "Category axis title" })),
+    catAxisHidden: Type8.Optional(Type8.Boolean({ description: "Hide category axis" })),
+    catAxisLabelRotate: Type8.Optional(Type8.Number({ description: "Category axis label rotation (degrees)" })),
+    catAxisLabelFontSize: Type8.Optional(Type8.Number({ description: "Category axis label font size" })),
+    catAxisLabelColor: Type8.Optional(Type8.String({ description: "Category axis label color (hex or semantic)" })),
+    // Value axis
+    valAxisTitle: Type8.Optional(Type8.String({ description: "Value axis title" })),
+    valAxisHidden: Type8.Optional(Type8.Boolean({ description: "Hide value axis" })),
+    valAxisMinVal: Type8.Optional(Type8.Number({ description: "Value axis minimum" })),
+    valAxisMaxVal: Type8.Optional(Type8.Number({ description: "Value axis maximum" })),
+    valAxisLabelFormatCode: Type8.Optional(Type8.String({ description: 'Value axis label format (e.g. "$0.00", "#%")' })),
+    valAxisMajorUnit: Type8.Optional(Type8.Number({ description: "Value axis major unit / tick interval" })),
+    valAxisLabelColor: Type8.Optional(Type8.String({ description: "Value axis label color (hex or semantic)" })),
+    // Bar-specific
+    barDir: Type8.Optional(
+      Type8.Union([Type8.Literal("bar"), Type8.Literal("col")], {
+        description: 'Bar direction: "bar" (horizontal) or "col" (vertical, default)'
+      })
+    ),
+    barGrouping: Type8.Optional(
+      Type8.Union(
+        [Type8.Literal("clustered"), Type8.Literal("stacked"), Type8.Literal("percentStacked")],
+        { description: "Bar grouping style" }
+      )
+    ),
+    barGapWidthPct: Type8.Optional(
+      Type8.Number({ minimum: 0, maximum: 500, description: "Bar gap width (0-500%)" })
+    ),
+    // Line-specific
+    lineSmooth: Type8.Optional(Type8.Boolean({ description: "Smooth lines" })),
+    lineDataSymbol: Type8.Optional(
+      Type8.Union(
+        [
+          Type8.Literal("circle"),
+          Type8.Literal("dash"),
+          Type8.Literal("diamond"),
+          Type8.Literal("dot"),
+          Type8.Literal("none"),
+          Type8.Literal("square"),
+          Type8.Literal("triangle")
+        ],
+        { description: "Line data point marker symbol" }
+      )
+    ),
+    lineSize: Type8.Optional(Type8.Number({ description: "Line width (points)" })),
+    // Pie/doughnut-specific
+    firstSliceAng: Type8.Optional(Type8.Number({ minimum: 0, maximum: 359, description: "Angle of first slice (degrees)" })),
+    holeSize: Type8.Optional(Type8.Number({ minimum: 10, maximum: 90, description: "Doughnut hole size (%)" })),
+    // Radar-specific
+    radarStyle: Type8.Optional(
+      Type8.Union(
+        [Type8.Literal("standard"), Type8.Literal("marker"), Type8.Literal("filled")],
+        { description: "Radar chart style" }
+      )
+    ),
+    // Data labels
+    dataLabelColor: Type8.Optional(Type8.String({ description: "Data label text color" })),
+    dataLabelFontSize: Type8.Optional(Type8.Number({ description: "Data label font size" })),
+    dataLabelFontFace: Type8.Optional(Type8.String({ description: "Data label font face" })),
+    dataLabelFontBold: Type8.Optional(Type8.Boolean({ description: "Bold data labels" })),
+    dataLabelPosition: Type8.Optional(
+      Type8.Union(
+        [
+          Type8.Literal("b"),
+          Type8.Literal("bestFit"),
+          Type8.Literal("ctr"),
+          Type8.Literal("l"),
+          Type8.Literal("r"),
+          Type8.Literal("t"),
+          Type8.Literal("inEnd"),
+          Type8.Literal("outEnd")
+        ],
+        { description: "Data label position" }
+      )
+    ),
+    // Positioning
+    x: Type8.Optional(PositionValue),
+    y: Type8.Optional(PositionValue),
+    w: Type8.Optional(PositionValue),
+    h: Type8.Optional(PositionValue),
+    grid: Type8.Optional(GridPositionSchema)
+  },
+  {
+    description: "Native PowerPoint chart component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/component-defaults.ts
+var TextComponentDefaultsSchema = Type9.Partial(TextPropsSchema);
+var ImageComponentDefaultsSchema = Type9.Partial(PptxImagePropsSchema);
+var ShapeComponentDefaultsSchema = Type9.Partial(ShapePropsSchema);
+var TableComponentDefaultsSchema = Type9.Partial(PptxTablePropsSchema);
+var HighchartsComponentDefaultsSchema = Type9.Partial(
+  PptxHighchartsPropsSchema
+);
+var ChartComponentDefaultsSchema = Type9.Partial(PptxChartPropsSchema);
+var PptxComponentDefaultsSchema = Type9.Object(
+  {
+    text: Type9.Optional(TextComponentDefaultsSchema),
+    image: Type9.Optional(ImageComponentDefaultsSchema),
+    shape: Type9.Optional(ShapeComponentDefaultsSchema),
+    table: Type9.Optional(TableComponentDefaultsSchema),
+    highcharts: Type9.Optional(HighchartsComponentDefaultsSchema),
+    chart: Type9.Optional(ChartComponentDefaultsSchema)
+  },
+  { additionalProperties: true }
+);
+
+export {
+  TextPropsSchema,
+  PptxImagePropsSchema,
+  ShapeTypeSchema,
+  TextSegmentSchema,
+  ShapePropsSchema,
+  PptxTablePropsSchema,
+  PptxHighchartsPropsSchema,
+  PptxChartPropsSchema,
+  TextComponentDefaultsSchema,
+  ImageComponentDefaultsSchema,
+  ShapeComponentDefaultsSchema,
+  TableComponentDefaultsSchema,
+  HighchartsComponentDefaultsSchema,
+  ChartComponentDefaultsSchema,
+  PptxComponentDefaultsSchema,
+  GridMarginSchema,
+  GridGutterSchema,
+  GridConfigSchema,
+  SEMANTIC_COLOR_NAMES,
+  SEMANTIC_COLOR_ALIASES,
+  ColorValueSchema,
+  STYLE_NAMES,
+  StyleNameSchema,
+  TextStyleSchema,
+  ThemeConfigSchema,
+  isValidThemeConfig,
+  PositionSchema,
+  SlideBackgroundSchema,
+  TransitionSchema,
+  PptxAlignmentSchema,
+  VerticalAlignmentSchema,
+  ShadowSchema,
+  GridPositionSchema
+};
+//# sourceMappingURL=chunk-OJMLZFHW.js.map