@hirokisakabe/pom 2.0.0 → 3.0.0

package/dist/{inputSchema.d.ts → parseXml/inputSchema.d.ts}

@@ -5,7 +5,7 @@
  * Used by `parseXml` to validate parsed XML input.
  */
 import { z } from "zod";
-import { type TreeDataItem } from "./types.ts";
+import { type TreeDataItem } from "../types.ts";
 export declare const inputBaseNodeSchema: z.ZodObject<{
     w: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"max">, z.ZodString]>>;
     h: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"max">, z.ZodString]>>;
@@ -116,32 +116,259 @@ export declare const inputTextNodeSchema: z.ZodObject<{
     highlight: z.ZodOptional<z.ZodString>;
     fontFamily: z.ZodOptional<z.ZodString>;
     lineSpacingMultiple: z.ZodOptional<z.ZodNumber>;
-    bullet: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-        type: z.ZodOptional<z.ZodEnum<{
-            number: "number";
-            bullet: "bullet";
+}, z.core.$strip>;
+export declare const inputLiNodeSchema: z.ZodObject<{
+    text: z.ZodString;
+    bold: z.ZodOptional<z.ZodBoolean>;
+    italic: z.ZodOptional<z.ZodBoolean>;
+    underline: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        style: z.ZodOptional<z.ZodEnum<{
+            dash: "dash";
+            dashHeavy: "dashHeavy";
+            dashLong: "dashLong";
+            dashLongHeavy: "dashLongHeavy";
+            dbl: "dbl";
+            dotDash: "dotDash";
+            dotDotDash: "dotDotDash";
+            dotted: "dotted";
+            dottedHeavy: "dottedHeavy";
+            heavy: "heavy";
+            none: "none";
+            sng: "sng";
+            wavy: "wavy";
+            wavyDbl: "wavyDbl";
+            wavyHeavy: "wavyHeavy";
+        }>>;
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    strike: z.ZodOptional<z.ZodBoolean>;
+    highlight: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    fontPx: z.ZodOptional<z.ZodNumber>;
+    fontFamily: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const inputUlNodeSchema: z.ZodObject<{
+    w: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"max">, z.ZodString]>>;
+    h: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"max">, z.ZodString]>>;
+    minW: z.ZodOptional<z.ZodNumber>;
+    maxW: z.ZodOptional<z.ZodNumber>;
+    minH: z.ZodOptional<z.ZodNumber>;
+    maxH: z.ZodOptional<z.ZodNumber>;
+    padding: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+        top: z.ZodOptional<z.ZodNumber>;
+        right: z.ZodOptional<z.ZodNumber>;
+        bottom: z.ZodOptional<z.ZodNumber>;
+        left: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    backgroundColor: z.ZodOptional<z.ZodString>;
+    backgroundImage: z.ZodOptional<z.ZodObject<{
+        src: z.ZodString;
+        sizing: z.ZodOptional<z.ZodEnum<{
+            cover: "cover";
+            contain: "contain";
+        }>>;
+    }, z.core.$strip>>;
+    border: z.ZodOptional<z.ZodObject<{
+        color: z.ZodOptional<z.ZodString>;
+        width: z.ZodOptional<z.ZodNumber>;
+        dashType: z.ZodOptional<z.ZodEnum<{
+            solid: "solid";
+            dash: "dash";
+            dashDot: "dashDot";
+            lgDash: "lgDash";
+            lgDashDot: "lgDashDot";
+            lgDashDotDot: "lgDashDotDot";
+            sysDash: "sysDash";
+            sysDot: "sysDot";
+        }>>;
+    }, z.core.$strip>>;
+    borderRadius: z.ZodOptional<z.ZodNumber>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"ul">;
+    items: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        bold: z.ZodOptional<z.ZodBoolean>;
+        italic: z.ZodOptional<z.ZodBoolean>;
+        underline: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            style: z.ZodOptional<z.ZodEnum<{
+                dash: "dash";
+                dashHeavy: "dashHeavy";
+                dashLong: "dashLong";
+                dashLongHeavy: "dashLongHeavy";
+                dbl: "dbl";
+                dotDash: "dotDash";
+                dotDotDash: "dotDotDash";
+                dotted: "dotted";
+                dottedHeavy: "dottedHeavy";
+                heavy: "heavy";
+                none: "none";
+                sng: "sng";
+                wavy: "wavy";
+                wavyDbl: "wavyDbl";
+                wavyHeavy: "wavyHeavy";
+            }>>;
+            color: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        strike: z.ZodOptional<z.ZodBoolean>;
+        highlight: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        fontPx: z.ZodOptional<z.ZodNumber>;
+        fontFamily: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    fontPx: z.ZodOptional<z.ZodNumber>;
+    color: z.ZodOptional<z.ZodString>;
+    alignText: z.ZodOptional<z.ZodEnum<{
+        right: "right";
+        left: "left";
+        center: "center";
+    }>>;
+    bold: z.ZodOptional<z.ZodBoolean>;
+    italic: z.ZodOptional<z.ZodBoolean>;
+    underline: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        style: z.ZodOptional<z.ZodEnum<{
+            dash: "dash";
+            dashHeavy: "dashHeavy";
+            dashLong: "dashLong";
+            dashLongHeavy: "dashLongHeavy";
+            dbl: "dbl";
+            dotDash: "dotDash";
+            dotDotDash: "dotDotDash";
+            dotted: "dotted";
+            dottedHeavy: "dottedHeavy";
+            heavy: "heavy";
+            none: "none";
+            sng: "sng";
+            wavy: "wavy";
+            wavyDbl: "wavyDbl";
+            wavyHeavy: "wavyHeavy";
         }>>;
-        indent: z.ZodOptional<z.ZodNumber>;
-        numberType: z.ZodOptional<z.ZodEnum<{
-            alphaLcParenBoth: "alphaLcParenBoth";
-            alphaLcParenR: "alphaLcParenR";
-            alphaLcPeriod: "alphaLcPeriod";
-            alphaUcParenBoth: "alphaUcParenBoth";
-            alphaUcParenR: "alphaUcParenR";
-            alphaUcPeriod: "alphaUcPeriod";
-            arabicParenBoth: "arabicParenBoth";
-            arabicParenR: "arabicParenR";
-            arabicPeriod: "arabicPeriod";
-            arabicPlain: "arabicPlain";
-            romanLcParenBoth: "romanLcParenBoth";
-            romanLcParenR: "romanLcParenR";
-            romanLcPeriod: "romanLcPeriod";
-            romanUcParenBoth: "romanUcParenBoth";
-            romanUcParenR: "romanUcParenR";
-            romanUcPeriod: "romanUcPeriod";
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    strike: z.ZodOptional<z.ZodBoolean>;
+    highlight: z.ZodOptional<z.ZodString>;
+    fontFamily: z.ZodOptional<z.ZodString>;
+    lineSpacingMultiple: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const inputOlNodeSchema: z.ZodObject<{
+    w: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"max">, z.ZodString]>>;
+    h: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"max">, z.ZodString]>>;
+    minW: z.ZodOptional<z.ZodNumber>;
+    maxW: z.ZodOptional<z.ZodNumber>;
+    minH: z.ZodOptional<z.ZodNumber>;
+    maxH: z.ZodOptional<z.ZodNumber>;
+    padding: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+        top: z.ZodOptional<z.ZodNumber>;
+        right: z.ZodOptional<z.ZodNumber>;
+        bottom: z.ZodOptional<z.ZodNumber>;
+        left: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
+    backgroundColor: z.ZodOptional<z.ZodString>;
+    backgroundImage: z.ZodOptional<z.ZodObject<{
+        src: z.ZodString;
+        sizing: z.ZodOptional<z.ZodEnum<{
+            cover: "cover";
+            contain: "contain";
         }>>;
-        numberStartAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    border: z.ZodOptional<z.ZodObject<{
+        color: z.ZodOptional<z.ZodString>;
+        width: z.ZodOptional<z.ZodNumber>;
+        dashType: z.ZodOptional<z.ZodEnum<{
+            solid: "solid";
+            dash: "dash";
+            dashDot: "dashDot";
+            lgDash: "lgDash";
+            lgDashDot: "lgDashDot";
+            lgDashDotDot: "lgDashDotDot";
+            sysDash: "sysDash";
+            sysDot: "sysDot";
+        }>>;
+    }, z.core.$strip>>;
+    borderRadius: z.ZodOptional<z.ZodNumber>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"ol">;
+    items: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        bold: z.ZodOptional<z.ZodBoolean>;
+        italic: z.ZodOptional<z.ZodBoolean>;
+        underline: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            style: z.ZodOptional<z.ZodEnum<{
+                dash: "dash";
+                dashHeavy: "dashHeavy";
+                dashLong: "dashLong";
+                dashLongHeavy: "dashLongHeavy";
+                dbl: "dbl";
+                dotDash: "dotDash";
+                dotDotDash: "dotDotDash";
+                dotted: "dotted";
+                dottedHeavy: "dottedHeavy";
+                heavy: "heavy";
+                none: "none";
+                sng: "sng";
+                wavy: "wavy";
+                wavyDbl: "wavyDbl";
+                wavyHeavy: "wavyHeavy";
+            }>>;
+            color: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        strike: z.ZodOptional<z.ZodBoolean>;
+        highlight: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        fontPx: z.ZodOptional<z.ZodNumber>;
+        fontFamily: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    fontPx: z.ZodOptional<z.ZodNumber>;
+    color: z.ZodOptional<z.ZodString>;
+    alignText: z.ZodOptional<z.ZodEnum<{
+        right: "right";
+        left: "left";
+        center: "center";
+    }>>;
+    bold: z.ZodOptional<z.ZodBoolean>;
+    italic: z.ZodOptional<z.ZodBoolean>;
+    underline: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        style: z.ZodOptional<z.ZodEnum<{
+            dash: "dash";
+            dashHeavy: "dashHeavy";
+            dashLong: "dashLong";
+            dashLongHeavy: "dashLongHeavy";
+            dbl: "dbl";
+            dotDash: "dotDash";
+            dotDotDash: "dotDotDash";
+            dotted: "dotted";
+            dottedHeavy: "dottedHeavy";
+            heavy: "heavy";
+            none: "none";
+            sng: "sng";
+            wavy: "wavy";
+            wavyDbl: "wavyDbl";
+            wavyHeavy: "wavyHeavy";
+        }>>;
+        color: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>;
+    strike: z.ZodOptional<z.ZodBoolean>;
+    highlight: z.ZodOptional<z.ZodString>;
+    fontFamily: z.ZodOptional<z.ZodString>;
+    lineSpacingMultiple: z.ZodOptional<z.ZodNumber>;
+    numberType: z.ZodOptional<z.ZodEnum<{
+        alphaLcParenBoth: "alphaLcParenBoth";
+        alphaLcParenR: "alphaLcParenR";
+        alphaLcPeriod: "alphaLcPeriod";
+        alphaUcParenBoth: "alphaUcParenBoth";
+        alphaUcParenR: "alphaUcParenR";
+        alphaUcPeriod: "alphaUcPeriod";
+        arabicParenBoth: "arabicParenBoth";
+        arabicParenR: "arabicParenR";
+        arabicPeriod: "arabicPeriod";
+        arabicPlain: "arabicPlain";
+        romanLcParenBoth: "romanLcParenBoth";
+        romanLcParenR: "romanLcParenR";
+        romanLcPeriod: "romanLcPeriod";
+        romanUcParenBoth: "romanUcParenBoth";
+        romanUcParenR: "romanUcParenR";
+        romanUcPeriod: "romanUcPeriod";
+    }>>;
+    numberStartAt: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const inputImageNodeSchema: z.ZodObject<{
     w: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"max">, z.ZodString]>>;
@@ -565,6 +792,8 @@ export declare const inputShapeNodeSchema: z.ZodObject<{
     }, z.core.$strip>]>>;
     strike: z.ZodOptional<z.ZodBoolean>;
     highlight: z.ZodOptional<z.ZodString>;
+    fontFamily: z.ZodOptional<z.ZodString>;
+    lineSpacingMultiple: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const inputChartNodeSchema: z.ZodObject<{
     w: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"max">, z.ZodString]>>;

package/dist/parseXml/inputSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputSchema.d.ts","sourceRoot":"","sources":["../../src/parseXml/inputSchema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAoCL,KAAK,YAAY,EAElB,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa9B,CAAC;AAKH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAe,CAAC;AAE9C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa5B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAe5B,CAAC;AAUH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiB/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU/B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKhC,CAAC;AAUH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU9B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS9B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAatC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW9B,CAAC"}

package/dist/{inputSchema.js → parseXml/inputSchema.js}

@@ -5,7 +5,7 @@
  * Used by `parseXml` to validate parsed XML input.
  */
 import { z } from "zod";
-import { lengthSchema, paddingSchema, borderStyleSchema, borderDashSchema, fillStyleSchema, shadowStyleSchema, alignItemsSchema, justifyContentSchema, shapeTypeSchema, tableColumnSchema, tableRowSchema, chartTypeSchema, chartDataSchema, bulletOptionsSchema, radarStyleSchema, timelineDirectionSchema, timelineItemSchema, matrixAxisSchema, matrixQuadrantsSchema, matrixItemSchema, treeLayoutSchema, treeNodeShapeSchema, treeConnectorStyleSchema, flowDirectionSchema, flowNodeItemSchema, flowConnectionSchema, flowConnectorStyleSchema, processArrowDirectionSchema, processArrowStepSchema, lineArrowSchema, underlineSchema, backgroundImageSchema, } from "./types.js";
+import { lengthSchema, paddingSchema, borderStyleSchema, borderDashSchema, fillStyleSchema, shadowStyleSchema, alignItemsSchema, justifyContentSchema, shapeTypeSchema, tableColumnSchema, tableRowSchema, chartTypeSchema, chartDataSchema, liNodeSchema, radarStyleSchema, bulletNumberTypeSchema, timelineDirectionSchema, timelineItemSchema, matrixAxisSchema, matrixQuadrantsSchema, matrixItemSchema, treeLayoutSchema, treeNodeShapeSchema, treeConnectorStyleSchema, flowDirectionSchema, flowNodeItemSchema, flowConnectionSchema, flowConnectorStyleSchema, processArrowDirectionSchema, processArrowStepSchema, lineArrowSchema, underlineSchema, backgroundImageSchema, } from "../types.js";
 // ===== Base Node Schema =====
 export const inputBaseNodeSchema = z.object({
     w: lengthSchema.optional(),
@@ -35,7 +35,37 @@ export const inputTextNodeSchema = inputBaseNodeSchema.extend({
     highlight: z.string().optional(),
     fontFamily: z.string().optional(),
     lineSpacingMultiple: z.number().optional(),
-    bullet: z.union([z.boolean(), bulletOptionsSchema]).optional(),
+});
+export const inputLiNodeSchema = liNodeSchema;
+export const inputUlNodeSchema = inputBaseNodeSchema.extend({
+    type: z.literal("ul"),
+    items: z.array(inputLiNodeSchema),
+    fontPx: z.number().optional(),
+    color: z.string().optional(),
+    alignText: z.enum(["left", "center", "right"]).optional(),
+    bold: z.boolean().optional(),
+    italic: z.boolean().optional(),
+    underline: underlineSchema.optional(),
+    strike: z.boolean().optional(),
+    highlight: z.string().optional(),
+    fontFamily: z.string().optional(),
+    lineSpacingMultiple: z.number().optional(),
+});
+export const inputOlNodeSchema = inputBaseNodeSchema.extend({
+    type: z.literal("ol"),
+    items: z.array(inputLiNodeSchema),
+    fontPx: z.number().optional(),
+    color: z.string().optional(),
+    alignText: z.enum(["left", "center", "right"]).optional(),
+    bold: z.boolean().optional(),
+    italic: z.boolean().optional(),
+    underline: underlineSchema.optional(),
+    strike: z.boolean().optional(),
+    highlight: z.string().optional(),
+    fontFamily: z.string().optional(),
+    lineSpacingMultiple: z.number().optional(),
+    numberType: bulletNumberTypeSchema.optional(),
+    numberStartAt: z.number().optional(),
 });
 const inputImageSizingSchema = z.object({
     type: z.enum(["contain", "cover", "crop"]),
@@ -71,6 +101,8 @@ export const inputShapeNodeSchema = inputBaseNodeSchema.extend({
     underline: underlineSchema.optional(),
     strike: z.boolean().optional(),
     highlight: z.string().optional(),
+    fontFamily: z.string().optional(),
+    lineSpacingMultiple: z.number().optional(),
 });
 export const inputChartNodeSchema = inputBaseNodeSchema.extend({
     type: z.literal("chart"),
@@ -177,6 +209,8 @@ const inputLayerNodeSchemaBase = inputBaseNodeSchema.extend({
 /** Input schema for POM nodes (used internally by parseXml) */
 const inputPomNodeSchema = z.lazy(() => z.discriminatedUnion("type", [
     inputTextNodeSchema,
+    inputUlNodeSchema,
+    inputOlNodeSchema,
     inputImageNodeSchema,
     inputTableNodeSchema,
     inputBoxNodeSchemaBase,

package/dist/{parseXml.d.ts → parseXml/parseXml.d.ts}

@@ -1,4 +1,4 @@
-import type { POMNode } from "./types.ts";
+import type { POMNode } from "../types.ts";
 export declare class ParseXmlError extends Error {
     readonly errors: string[];
     constructor(errors: string[]);

package/dist/parseXml/parseXml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseXml.d.ts","sourceRoot":"","sources":["../../src/parseXml/parseXml.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAmC3C,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAgB,MAAM,EAAE,MAAM,EAAE,CAAC;gBACrB,MAAM,EAAE,MAAM,EAAE;CAM7B;AAk9BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,EAAE,CAiCrD"}

package/dist/{parseXml.js → parseXml/parseXml.js}

@@ -1,7 +1,7 @@
 import { XMLParser } from "fast-xml-parser";
 import { z } from "zod";
-import { inputTextNodeSchema, inputImageNodeSchema, inputTableNodeSchema, inputShapeNodeSchema, inputChartNodeSchema, inputTimelineNodeSchema, inputMatrixNodeSchema, inputTreeNodeSchema, inputFlowNodeSchema, inputProcessArrowNodeSchema, inputLineNodeSchema, inputBaseNodeSchema, } from "./inputSchema.js";
-import { alignItemsSchema, justifyContentSchema, shadowStyleSchema, processArrowStepSchema, timelineItemSchema, matrixAxisSchema, matrixQuadrantsSchema, matrixItemSchema, flowNodeItemSchema, flowConnectionSchema, chartDataSchema, tableColumnSchema, tableCellSchema, } from "./types.js";
+import { inputTextNodeSchema, inputUlNodeSchema, inputOlNodeSchema, inputLiNodeSchema, inputImageNodeSchema, inputTableNodeSchema, inputShapeNodeSchema, inputChartNodeSchema, inputTimelineNodeSchema, inputMatrixNodeSchema, inputTreeNodeSchema, inputFlowNodeSchema, inputProcessArrowNodeSchema, inputLineNodeSchema, inputBaseNodeSchema, } from "./inputSchema.js";
+import { alignItemsSchema, justifyContentSchema, shadowStyleSchema, processArrowStepSchema, timelineItemSchema, matrixAxisSchema, matrixQuadrantsSchema, matrixItemSchema, flowNodeItemSchema, flowConnectionSchema, chartDataSchema, tableColumnSchema, tableCellSchema, } from "../types.js";
 // ===== ParseXmlError =====
 export class ParseXmlError extends Error {
     errors;
@@ -24,6 +24,8 @@ const TAG_TO_TYPE = {
     Tree: "tree",
     Flow: "flow",
     ProcessArrow: "processArrow",
+    Ul: "ul",
+    Ol: "ol",
     Line: "line",
     Box: "box",
     VStack: "vstack",
@@ -47,6 +49,8 @@ const leafNodeShapes = {
     flow: extractShape(inputFlowNodeSchema),
     processArrow: extractShape(inputProcessArrowNodeSchema),
     line: extractShape(inputLineNodeSchema),
+    ul: extractShape(inputUlNodeSchema),
+    ol: extractShape(inputOlNodeSchema),
 };
 const containerShapes = {
     box: extractShape(inputBaseNodeSchema.extend({ shadow: shadowStyleSchema.optional() })),
@@ -123,6 +127,8 @@ const leafNodeValidationSchemas = {
     flow: inputFlowNodeSchema,
     processArrow: inputProcessArrowNodeSchema,
     line: inputLineNodeSchema,
+    ul: inputUlNodeSchema,
+    ol: inputOlNodeSchema,
 };
 function formatZodIssue(issue, tagName) {
     const path = issue.path;
@@ -180,6 +186,8 @@ const CHILD_ELEMENT_PROPS = {
     matrix: new Set(["axes", "items", "quadrants"]),
     processArrow: new Set(["steps"]),
     tree: new Set(["data"]),
+    ul: new Set(["items"]),
+    ol: new Set(["items"]),
 };
 function validateLeafNode(nodeType, result, errors) {
     const schema = leafNodeValidationSchemas[nodeType];
@@ -409,6 +417,7 @@ const childElementShapes = {
     Connection: extractShape(flowConnectionSchema),
     Column: extractShape(tableColumnSchema),
     Cell: extractShape(tableCellSchema),
+    Li: extractShape(inputLiNodeSchema),
 };
 function coerceChildAttrs(parentTagName, tagName, attrs, errors) {
     const shape = childElementShapes[tagName];
@@ -650,7 +659,26 @@ function convertTreeChildren(childElements, result, errors) {
     }
     result.data = convertTreeItem(child, errors);
 }
+function convertListChildren(parentTag, childElements, result, errors) {
+    const items = [];
+    for (const child of childElements) {
+        const tag = getTagName(child);
+        if (tag !== "Li") {
+            errors.push(`Unknown child element <${tag}> inside <${parentTag}>. Expected: <Li>`);
+            continue;
+        }
+        const attrs = coerceChildAttrs(parentTag, tag, getAttributes(child), errors);
+        const textContent = getTextContent(child);
+        if (textContent !== undefined && !("text" in attrs)) {
+            attrs.text = textContent;
+        }
+        items.push(attrs);
+    }
+    result.items = items;
+}
 const CHILD_ELEMENT_CONVERTERS = {
+    ul: (childElements, result, errors) => convertListChildren("Ul", childElements, result, errors),
+    ol: (childElements, result, errors) => convertListChildren("Ol", childElements, result, errors),
     processArrow: convertProcessArrowChildren,
     timeline: convertTimelineChildren,
     matrix: convertMatrixChildren,

package/dist/renderPptx/nodes/flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../../../src/renderPptx/nodes/flow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,KAAK,kBAAkB,GAAG,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAWpE,wBAAgB,cAAc,CAC5B,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,aAAa,GACjB,IAAI,CA0GN"}
+{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../../../src/renderPptx/nodes/flow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,KAAK,kBAAkB,GAAG,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAWpE,wBAAgB,cAAc,CAC5B,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,aAAa,GACjB,IAAI,CA6HN"}

package/dist/renderPptx/nodes/flow.js

@@ -1,4 +1,6 @@
 import { pxToIn, pxToPt } from "../units.js";
+import { measureFlow } from "../../calcYogaLayout/measureCompositeNodes.js";
+import { calcScaleFactor } from "../utils/scaleToFit.js";
 export function renderFlowNode(node, ctx) {
     const direction = node.direction ?? "horizontal";
     const nodeWidth = node.nodeWidth ?? 120;
@@ -6,14 +8,20 @@ export function renderFlowNode(node, ctx) {
     const nodeGap = node.nodeGap ?? 80;
     const connectorStyle = node.connectorStyle ?? {};
     const defaultColor = "1D4ED8";
+    // スケール係数を計算
+    const intrinsic = measureFlow(node);
+    const scaleFactor = calcScaleFactor(node.w, node.h, intrinsic.width, intrinsic.height, "flow");
+    const scaledNodeWidth = nodeWidth * scaleFactor;
+    const scaledNodeHeight = nodeHeight * scaleFactor;
+    const scaledNodeGap = nodeGap * scaleFactor;
     const layouts = new Map();
     const nodeCount = node.nodes.length;
     // ノードのレイアウトを計算
     if (direction === "horizontal") {
-        calculateHorizontalLayout(node, layouts, nodeCount, nodeWidth, nodeHeight, nodeGap);
+        calculateHorizontalLayout(node, layouts, nodeCount, scaledNodeWidth, scaledNodeHeight, scaledNodeGap, scaleFactor);
     }
     else {
-        calculateVerticalLayout(node, layouts, nodeCount, nodeWidth, nodeHeight, nodeGap);
+        calculateVerticalLayout(node, layouts, nodeCount, scaledNodeWidth, scaledNodeHeight, scaledNodeGap, scaleFactor);
     }
     // 接続線を描画（ノードより先に描画して背面に配置）
     for (const conn of node.connections) {
@@ -22,7 +30,7 @@ export function renderFlowNode(node, ctx) {
         if (!fromLayout || !toLayout)
             continue;
         const lineColor = conn.color ?? connectorStyle.color ?? "333333";
-        const lineWidth = connectorStyle.width ?? 2;
+        const lineWidth = (connectorStyle.width ?? 2) * scaleFactor;
         const arrowType = connectorStyle.arrowType ?? "triangle";
         drawConnection(ctx, direction, fromLayout, toLayout, lineColor, lineWidth, arrowType);
         // ラベルを描画
@@ -37,12 +45,14 @@ export function renderFlowNode(node, ctx) {
                 toLayout.y +
                 toLayout.height / 2) /
                 2;
+            const labelW = 60 * scaleFactor;
+            const labelH = 20 * scaleFactor;
             ctx.slide.addText(conn.label, {
-                x: pxToIn(labelX - 30),
-                y: pxToIn(labelY - 10),
-                w: pxToIn(60),
-                h: pxToIn(20),
-                fontSize: pxToPt(10),
+                x: pxToIn(labelX - labelW / 2),
+                y: pxToIn(labelY - labelH / 2),
+                w: pxToIn(labelW),
+                h: pxToIn(labelH),
+                fontSize: pxToPt(10 * scaleFactor),
                 fontFace: "Noto Sans JP",
                 color: "64748B",
                 align: "center",
@@ -65,8 +75,8 @@ export function renderFlowNode(node, ctx) {
             h: pxToIn(layout.height),
             shape: item.shape,
             fill: { color: fillColor },
-            line: { color: "333333", width: pxToPt(1) },
-            fontSize: pxToPt(14),
+            line: { color: "333333", width: pxToPt(1 * scaleFactor) },
+            fontSize: pxToPt(14 * scaleFactor),
             fontFace: "Noto Sans JP",
             color: textColor,
             align: "center",
@@ -74,13 +84,13 @@ export function renderFlowNode(node, ctx) {
         });
     }
 }
-function calculateHorizontalLayout(node, layouts, nodeCount, nodeWidth, nodeHeight, nodeGap) {
+function calculateHorizontalLayout(node, layouts, nodeCount, nodeWidth, nodeHeight, nodeGap, scaleFactor) {
     const totalWidth = nodeCount * nodeWidth + (nodeCount - 1) * nodeGap;
     const startX = node.x + (node.w - totalWidth) / 2;
     const centerY = node.y + node.h / 2;
     node.nodes.forEach((item, index) => {
-        const w = item.width ?? nodeWidth;
-        const h = item.height ?? nodeHeight;
+        const w = (item.width ?? nodeWidth / scaleFactor) * scaleFactor;
+        const h = (item.height ?? nodeHeight / scaleFactor) * scaleFactor;
         layouts.set(item.id, {
             id: item.id,
             x: startX + index * (nodeWidth + nodeGap) + (nodeWidth - w) / 2,
@@ -91,13 +101,13 @@ function calculateHorizontalLayout(node, layouts, nodeCount, nodeWidth, nodeHeig
         });
     });
 }
-function calculateVerticalLayout(node, layouts, nodeCount, nodeWidth, nodeHeight, nodeGap) {
+function calculateVerticalLayout(node, layouts, nodeCount, nodeWidth, nodeHeight, nodeGap, scaleFactor) {
     const totalHeight = nodeCount * nodeHeight + (nodeCount - 1) * nodeGap;
     const startY = node.y + (node.h - totalHeight) / 2;
     const centerX = node.x + node.w / 2;
     node.nodes.forEach((item, index) => {
-        const w = item.width ?? nodeWidth;
-        const h = item.height ?? nodeHeight;
+        const w = (item.width ?? nodeWidth / scaleFactor) * scaleFactor;
+        const h = (item.height ?? nodeHeight / scaleFactor) * scaleFactor;
         layouts.set(item.id, {
             id: item.id,
             x: centerX - w / 2,

package/dist/renderPptx/nodes/index.d.ts

@@ -9,4 +9,5 @@ export { renderTreeNode } from "./tree.ts";
 export { renderFlowNode } from "./flow.ts";
 export { renderProcessArrowNode } from "./processArrow.ts";
 export { renderLineNode } from "./line.ts";
+export { renderUlNode, renderOlNode } from "./list.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/renderPptx/nodes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/renderPptx/nodes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/renderPptx/nodes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC"}

package/dist/renderPptx/nodes/index.js

@@ -9,3 +9,4 @@ export { renderTreeNode } from "./tree.js";
 export { renderFlowNode } from "./flow.js";
 export { renderProcessArrowNode } from "./processArrow.js";
 export { renderLineNode } from "./line.js";
+export { renderUlNode, renderOlNode } from "./list.js";

package/dist/renderPptx/nodes/list.d.ts

@@ -0,0 +1,12 @@
+import type { PositionedNode } from "../../types.ts";
+import type { RenderContext } from "../types.ts";
+type UlPositionedNode = Extract<PositionedNode, {
+    type: "ul";
+}>;
+type OlPositionedNode = Extract<PositionedNode, {
+    type: "ol";
+}>;
+export declare function renderUlNode(node: UlPositionedNode, ctx: RenderContext): void;
+export declare function renderOlNode(node: OlPositionedNode, ctx: RenderContext): void;
+export {};
+//# sourceMappingURL=list.d.ts.map

package/dist/renderPptx/nodes/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/renderPptx/nodes/list.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAU,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,KAAK,gBAAgB,GAAG,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC;AAChE,KAAK,gBAAgB,GAAG,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC;AA6BhE,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CA2D7E;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CAiE7E"}