@hirokisakabe/pom 1.3.0 → 1.4.0

package/README.md

@@ -192,6 +192,33 @@ const slides = expandComponentSlides(llmOutput, registry);
 const pptx = await buildPptx(slides, { w: 1280, h: 720 });
 ```
 
+## XML Input
+
+`parseXml` allows you to describe slides in XML instead of JSON. XML tags (PascalCase) are mapped to POM node types, and attribute values are automatically type-coerced using Zod schemas.
+
+```typescript
+import { parseXml, buildPptx } from "@hirokisakabe/pom";
+
+const xml = `
+<VStack gap="16" padding="32">
+  <Text fontPx="32" bold="true">売上レポート</Text>
+  <HStack gap="16">
+    <Chart chartType="bar" w="400" h="300"
+      data='[{ "name": "Q1", "labels": ["1月","2月","3月"], "values": [100,120,90] }]'
+    />
+    <Text fontPx="18" color="00AA00">前年比 +15%</Text>
+  </HStack>
+</VStack>
+`;
+
+const nodes = parseXml(xml);
+const pptx = await buildPptx(nodes, { w: 1280, h: 720 });
+```
+
+Unknown tags are treated as component nodes (`{ type: "component", name: tagName, props: {...} }`), which can be resolved with `expandComponents()`.
+
+For more details, see [LLM Integration - XML Format](./docs/llm-integration.md#xml-format).
+
 ## Documentation
 
 | Document                                        | Description                             |

package/dist/index.d.ts

@@ -4,4 +4,5 @@ export { buildPptx } from "./buildPptx.ts";
 export type { TextMeasurementMode } from "./buildPptx.ts";
 export { defineComponent, defaultTheme, mergeTheme, expandComponents, expandComponentSlides, } from "./component.ts";
 export type { Theme, ComponentRegistry } from "./component.ts";
+export { parseXml } from "./parseXml.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EACL,eAAe,EACf,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EACL,eAAe,EACf,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -2,3 +2,4 @@ export * from "./types.js";
 export * from "./inputSchema.js";
 export { buildPptx } from "./buildPptx.js";
 export { defineComponent, defaultTheme, mergeTheme, expandComponents, expandComponentSlides, } from "./component.js";
+export { parseXml } from "./parseXml.js";

package/dist/parseXml.d.ts

@@ -0,0 +1,24 @@
+import type { POMNode } from "./types.ts";
+/**
+ * XML 文字列を POMNode 配列に変換する。
+ *
+ * XML タグは POM ノードタイプにマッピングされ、属性値は Zod スキーマを参照して
+ * 適切な型（number, boolean, array, object）に変換される。
+ * 組み込みノード以外のタグ名はカスタムコンポーネントとして扱われる。
+ *
+ * @example
+ * ```typescript
+ * import { parseXml, buildPptx } from "@hirokisakabe/pom";
+ *
+ * const xml = `
+ *   <VStack gap="16" padding="32">
+ *     <Text fontPx="32" bold="true">売上レポート</Text>
+ *   </VStack>
+ * `;
+ *
+ * const nodes = parseXml(xml);
+ * const pptx = await buildPptx(nodes, { w: 1280, h: 720 });
+ * ```
+ */
+export declare function parseXml(xmlString: string): POMNode[];
+//# sourceMappingURL=parseXml.d.ts.map

package/dist/parseXml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseXml.d.ts","sourceRoot":"","sources":["../src/parseXml.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAoX1C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,EAAE,CAuBrD"}

package/dist/parseXml.js

@@ -0,0 +1,332 @@
+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, } from "./types.js";
+// ===== Tag name → POM node type mapping =====
+const TAG_TO_TYPE = {
+    Text: "text",
+    Image: "image",
+    Table: "table",
+    Shape: "shape",
+    Chart: "chart",
+    Timeline: "timeline",
+    Matrix: "matrix",
+    Tree: "tree",
+    Flow: "flow",
+    ProcessArrow: "processArrow",
+    Line: "line",
+    Box: "box",
+    VStack: "vstack",
+    HStack: "hstack",
+    Layer: "layer",
+};
+function extractShape(schema) {
+    return schema.shape;
+}
+const leafNodeShapes = {
+    text: extractShape(inputTextNodeSchema),
+    image: extractShape(inputImageNodeSchema),
+    table: extractShape(inputTableNodeSchema),
+    shape: extractShape(inputShapeNodeSchema),
+    chart: extractShape(inputChartNodeSchema),
+    timeline: extractShape(inputTimelineNodeSchema),
+    matrix: extractShape(inputMatrixNodeSchema),
+    tree: extractShape(inputTreeNodeSchema),
+    flow: extractShape(inputFlowNodeSchema),
+    processArrow: extractShape(inputProcessArrowNodeSchema),
+    line: extractShape(inputLineNodeSchema),
+};
+const containerShapes = {
+    box: extractShape(inputBaseNodeSchema.extend({ shadow: shadowStyleSchema.optional() })),
+    vstack: extractShape(inputBaseNodeSchema.extend({
+        gap: z.number().optional(),
+        alignItems: alignItemsSchema.optional(),
+        justifyContent: justifyContentSchema.optional(),
+    })),
+    hstack: extractShape(inputBaseNodeSchema.extend({
+        gap: z.number().optional(),
+        alignItems: alignItemsSchema.optional(),
+        justifyContent: justifyContentSchema.optional(),
+    })),
+    layer: extractShape(inputBaseNodeSchema),
+};
+const CONTAINER_TYPES = new Set(["box", "vstack", "hstack", "layer"]);
+const TEXT_CONTENT_NODES = new Set(["text", "shape"]);
+function getDef(schema) {
+    return schema._def;
+}
+function getPropertySchema(nodeType, propertyName) {
+    const shape = leafNodeShapes[nodeType] ?? containerShapes[nodeType];
+    if (!shape)
+        return undefined;
+    return shape[propertyName];
+}
+function getZodType(schema) {
+    const def = getDef(schema);
+    return (def.type ?? def.typeName ?? "");
+}
+function unwrapSchema(schema) {
+    const typeName = getZodType(schema);
+    const def = getDef(schema);
+    switch (typeName) {
+        case "optional":
+        case "default":
+        case "nullable":
+            return unwrapSchema(def.innerType);
+        case "lazy":
+            return unwrapSchema(def.getter());
+        case "pipe":
+            return unwrapSchema(def.in);
+        default:
+            return schema;
+    }
+}
+function resolveZodTypeName(schema) {
+    return getZodType(unwrapSchema(schema));
+}
+// ===== Value coercion =====
+function coerceValue(value, schema) {
+    const unwrapped = unwrapSchema(schema);
+    const typeName = getZodType(unwrapped);
+    const def = getDef(unwrapped);
+    switch (typeName) {
+        case "number": {
+            const num = Number(value);
+            if (isNaN(num)) {
+                throw new Error(`Cannot convert "${value}" to number`);
+            }
+            return num;
+        }
+        case "boolean":
+            if (value !== "true" && value !== "false") {
+                throw new Error(`Cannot convert "${value}" to boolean (expected "true" or "false")`);
+            }
+            return value === "true";
+        case "string":
+        case "enum":
+            return value;
+        case "literal": {
+            const values = def.values;
+            const singleValue = def.value;
+            return values?.[0] ?? singleValue;
+        }
+        case "array":
+        case "object":
+        case "record":
+        case "tuple":
+            return JSON.parse(value);
+        case "union": {
+            const options = def.options;
+            return coerceUnionValue(value, options);
+        }
+        default:
+            return coerceFallback(value);
+    }
+}
+function coerceUnionValue(value, options) {
+    const typeNames = options.map((opt) => resolveZodTypeName(opt));
+    // Try boolean
+    if ((value === "true" || value === "false") &&
+        typeNames.includes("boolean")) {
+        return value === "true";
+    }
+    // Try number
+    if (typeNames.includes("number")) {
+        const num = Number(value);
+        if (!isNaN(num) && value !== "") {
+            return num;
+        }
+    }
+    // Try literal
+    for (let i = 0; i < options.length; i++) {
+        if (typeNames[i] === "literal") {
+            const unwrapped = unwrapSchema(options[i]);
+            const def = getDef(unwrapped);
+            const values = def.values;
+            const singleValue = def.value;
+            const litVal = values?.[0] ?? singleValue;
+            if (litVal != null && `${litVal}` === value)
+                return litVal;
+        }
+    }
+    // Try JSON parse for objects/arrays
+    if (typeNames.some((t) => ["array", "object", "record", "tuple"].includes(t))) {
+        if (value.startsWith("{") || value.startsWith("[")) {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    // Fallback to string
+    return value;
+}
+function coerceFallback(value) {
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    const num = Number(value);
+    if (value !== "" && !isNaN(num))
+        return num;
+    if (value.startsWith("{") || value.startsWith("[")) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return value;
+}
+// ===== XML node helpers =====
+function isTextNode(node) {
+    return "#text" in node;
+}
+function getTagName(node) {
+    for (const key of Object.keys(node)) {
+        if (key !== ":@")
+            return key;
+    }
+    throw new Error("No tag name found in XML element");
+}
+function getAttributes(node) {
+    const attrs = {};
+    const rawAttrs = node[":@"];
+    if (rawAttrs) {
+        for (const [key, value] of Object.entries(rawAttrs)) {
+            const attrName = key.startsWith("@_") ? key.slice(2) : key;
+            attrs[attrName] = value;
+        }
+    }
+    return attrs;
+}
+function getChildElements(node) {
+    const tagName = getTagName(node);
+    const children = node[tagName];
+    if (!children)
+        return [];
+    return children.filter((child) => !isTextNode(child));
+}
+function getTextContent(node) {
+    const tagName = getTagName(node);
+    const children = node[tagName];
+    if (!children)
+        return undefined;
+    const textParts = [];
+    for (const child of children) {
+        if (isTextNode(child)) {
+            textParts.push(child["#text"]);
+        }
+    }
+    return textParts.length > 0 ? textParts.join("") : undefined;
+}
+// ===== Node conversion =====
+function convertElement(node) {
+    const tagName = getTagName(node);
+    const nodeType = TAG_TO_TYPE[tagName];
+    const attrs = getAttributes(node);
+    const childElements = getChildElements(node);
+    const textContent = getTextContent(node);
+    if (nodeType) {
+        return convertPomNode(nodeType, attrs, childElements, textContent);
+    }
+    else {
+        return convertComponentNode(tagName, attrs, childElements, textContent);
+    }
+}
+function convertPomNode(nodeType, attrs, childElements, textContent) {
+    const result = { type: nodeType };
+    for (const [key, value] of Object.entries(attrs)) {
+        if (key === "type")
+            continue;
+        const propSchema = getPropertySchema(nodeType, key);
+        if (propSchema) {
+            result[key] = coerceValue(value, propSchema);
+        }
+        else {
+            result[key] = coerceFallback(value);
+        }
+    }
+    // Text content → text property for nodes that support it
+    if (textContent !== undefined && TEXT_CONTENT_NODES.has(nodeType)) {
+        if (!("text" in result)) {
+            result.text = textContent;
+        }
+    }
+    // Children for container nodes
+    if (CONTAINER_TYPES.has(nodeType) && childElements.length > 0) {
+        const convertedChildren = childElements.map(convertElement);
+        if (nodeType === "box") {
+            if (childElements.length !== 1) {
+                throw new Error(`<Box> must have exactly 1 child element, but got ${childElements.length}`);
+            }
+            result.children = convertedChildren[0];
+        }
+        else {
+            result.children = convertedChildren;
+        }
+    }
+    return result;
+}
+function convertComponentNode(tagName, attrs, childElements, textContent) {
+    const props = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        props[key] = coerceFallback(value);
+    }
+    if (childElements.length > 0) {
+        props.children = childElements.map(convertElement);
+    }
+    else if (textContent !== undefined) {
+        props.children = textContent;
+    }
+    return {
+        type: "component",
+        name: tagName,
+        props,
+    };
+}
+/**
+ * XML 文字列を POMNode 配列に変換する。
+ *
+ * XML タグは POM ノードタイプにマッピングされ、属性値は Zod スキーマを参照して
+ * 適切な型（number, boolean, array, object）に変換される。
+ * 組み込みノード以外のタグ名はカスタムコンポーネントとして扱われる。
+ *
+ * @example
+ * ```typescript
+ * import { parseXml, buildPptx } from "@hirokisakabe/pom";
+ *
+ * const xml = `
+ *   <VStack gap="16" padding="32">
+ *     <Text fontPx="32" bold="true">売上レポート</Text>
+ *   </VStack>
+ * `;
+ *
+ * const nodes = parseXml(xml);
+ * const pptx = await buildPptx(nodes, { w: 1280, h: 720 });
+ * ```
+ */
+export function parseXml(xmlString) {
+    if (!xmlString.trim())
+        return [];
+    const parser = new XMLParser({
+        preserveOrder: true,
+        ignoreAttributes: false,
+        attributeNamePrefix: "@_",
+        parseAttributeValue: false,
+        parseTagValue: false,
+        trimValues: true,
+    });
+    const wrappedXml = `<__root__>${xmlString}</__root__>`;
+    const parsed = parser.parse(wrappedXml);
+    if (!parsed || parsed.length === 0)
+        return [];
+    const rootElement = parsed[0];
+    const rootChildren = (rootElement["__root__"] ?? []);
+    return rootChildren
+        .filter((child) => !isTextNode(child))
+        .map((child) => convertElement(child));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hirokisakabe/pom",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "PowerPoint Object Model - A declarative TypeScript library for creating PowerPoint presentations",
   "type": "module",
   "main": "./dist/index.js",
@@ -88,6 +88,7 @@
     "vitest": "^4.0.8"
   },
   "dependencies": {
+    "fast-xml-parser": "^5.3.7",
     "image-size": "2.0.2",
     "opentype.js": "^1.3.4",
     "pptxgenjs": "4.0.1",