@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/docx/shapeParser.js

@@ -0,0 +1,272 @@
+import { findAllDeep, findChildByLocalName, findChildrenByLocalName, getAttribute, parseNumericAttribute } from "./xmlParser.js";
+import { ShapeOutlineStyleSchema, ShapeTypeSchema, narrowEnum } from "./parserEnums.js";
+import { parseAnchorPosition, parseAnchorWrap, parseColorElement, parseFill } from "./drawingUtils.js";
+//#region src/docx/shapeParser.ts
+/** Convert OOXML rotation (1/60000ths of a degree) to degrees. */
+function rotToDegrees(rot) {
+	if (rot === null || rot === void 0) return;
+	const val = Number.parseInt(rot, 10);
+	return Number.isNaN(val) ? void 0 : val / 6e4;
+}
+/**
+* Parse a fill with full gradient stop capture (eigenpal #21).
+* Falls through to `drawingUtils.parseFill` for solid / none cases.
+*/
+function parseShapeFill(spPr) {
+	const base = parseFill(spPr);
+	if (base?.type !== "gradient" || !spPr) return base;
+	const gradFill = findChildByLocalName(spPr, "gradFill");
+	if (!gradFill) return base;
+	return parseGradientFill(gradFill);
+}
+function parseGradientFill(gradFill) {
+	let gradientType = "linear";
+	let angle;
+	const lin = findChildByLocalName(gradFill, "lin");
+	if (lin) {
+		gradientType = "linear";
+		const ang = getAttribute(lin, null, "ang");
+		if (ang) {
+			const parsed = Number.parseInt(ang, 10);
+			angle = Number.isNaN(parsed) ? void 0 : parsed / 6e4;
+		}
+	}
+	const path = findChildByLocalName(gradFill, "path");
+	if (path) {
+		const pathType = getAttribute(path, null, "path");
+		if (pathType === "circle") gradientType = "radial";
+		else if (pathType === "rect") gradientType = "rectangular";
+		else gradientType = "path";
+	}
+	const stops = [];
+	const gsLst = findChildByLocalName(gradFill, "gsLst");
+	if (gsLst) for (const gs of findChildrenByLocalName(gsLst, "gs")) {
+		const pos = getAttribute(gs, null, "pos");
+		const position = pos ? Number.parseInt(pos, 10) : 0;
+		const color = parseColorElement(gs);
+		if (color) stops.push({
+			position: Number.isNaN(position) ? 0 : position,
+			color
+		});
+	}
+	return {
+		type: "gradient",
+		gradient: {
+			type: gradientType,
+			...angle !== void 0 ? { angle } : {},
+			stops
+		}
+	};
+}
+const LINE_END_TYPES = /* @__PURE__ */ new Set([
+	"none",
+	"triangle",
+	"stealth",
+	"diamond",
+	"oval",
+	"arrow"
+]);
+function narrowLineEndType(value) {
+	if (value === null || value === void 0) return "none";
+	for (const allowed of LINE_END_TYPES) if (allowed === value) return allowed;
+	return "none";
+}
+function narrowLineEndSize(value) {
+	if (value === "sm" || value === "med" || value === "lg") return value;
+}
+function parseLineEnd(element) {
+	const type = narrowLineEndType(getAttribute(element, null, "type"));
+	const width = narrowLineEndSize(getAttribute(element, null, "w"));
+	const length = narrowLineEndSize(getAttribute(element, null, "len"));
+	return {
+		type,
+		...width !== void 0 ? { width } : {},
+		...length !== void 0 ? { length } : {}
+	};
+}
+/**
+* Parse a shape outline with cap, join, and arrow end fidelity. Returns
+* `undefined` when the spPr has no `<a:ln>`, an explicit `<a:noFill/>`,
+* or no usable attributes.
+*/
+function parseShapeOutline(spPr) {
+	const ln = findChildByLocalName(spPr, "ln");
+	if (!ln) return;
+	if (findChildByLocalName(ln, "noFill")) return;
+	const outline = {};
+	const w = getAttribute(ln, null, "w");
+	if (w) {
+		const parsed = Number.parseInt(w, 10);
+		if (!Number.isNaN(parsed)) outline.width = parsed;
+	}
+	const cap = getAttribute(ln, null, "cap");
+	if (cap === "flat") outline.cap = "flat";
+	else if (cap === "rnd") outline.cap = "round";
+	else if (cap === "sq") outline.cap = "square";
+	if (findChildByLocalName(ln, "bevel")) outline.join = "bevel";
+	else if (findChildByLocalName(ln, "round")) outline.join = "round";
+	else if (findChildByLocalName(ln, "miter")) outline.join = "miter";
+	const solidFill = findChildByLocalName(ln, "solidFill");
+	if (solidFill) {
+		const color = parseColorElement(solidFill);
+		if (color) outline.color = color;
+	}
+	const prstDash = findChildByLocalName(ln, "prstDash");
+	if (prstDash) {
+		const narrowed = narrowEnum(getAttribute(prstDash, null, "val"), ShapeOutlineStyleSchema);
+		if (narrowed !== void 0) outline.style = narrowed;
+	}
+	const headEnd = findChildByLocalName(ln, "headEnd");
+	if (headEnd) outline.headEnd = parseLineEnd(headEnd);
+	const tailEnd = findChildByLocalName(ln, "tailEnd");
+	if (tailEnd) outline.tailEnd = parseLineEnd(tailEnd);
+	if (outline.width === void 0 && outline.color === void 0 && outline.cap === void 0 && outline.join === void 0 && outline.style === void 0 && outline.headEnd === void 0 && outline.tailEnd === void 0) return;
+	return outline;
+}
+function parseTransform(xfrm) {
+	if (!xfrm) return { size: {
+		width: 0,
+		height: 0
+	} };
+	const ext = findChildByLocalName(xfrm, "ext");
+	const size = {
+		width: parseNumericAttribute(ext, null, "cx") ?? 0,
+		height: parseNumericAttribute(ext, null, "cy") ?? 0
+	};
+	const rotation = rotToDegrees(getAttribute(xfrm, null, "rot"));
+	const flipH = getAttribute(xfrm, null, "flipH") === "1";
+	const flipV = getAttribute(xfrm, null, "flipV") === "1";
+	if (rotation === void 0 && !flipH && !flipV) return { size };
+	const transform = {};
+	if (rotation !== void 0) transform.rotation = rotation;
+	if (flipH) transform.flipH = true;
+	if (flipV) transform.flipV = true;
+	return {
+		size,
+		transform
+	};
+}
+/**
+* Read `<a:prstGeom prst="…">` and narrow to the typed `ShapeType` union.
+* Unsupported geometry is not consumed as an editable shape because
+* `ShapeContent` currently serializes fresh preset geometry.
+*/
+function parseShapeType(spPr) {
+	if (!spPr) return "rect";
+	const prstGeom = findChildByLocalName(spPr, "prstGeom");
+	if (prstGeom) {
+		const narrowed = narrowEnum(getAttribute(prstGeom, null, "prst"), ShapeTypeSchema);
+		if (narrowed) return narrowed;
+	}
+	return "rect";
+}
+function hasUnsupportedGeometry(spPr) {
+	if (!spPr) return false;
+	const prstGeom = findChildByLocalName(spPr, "prstGeom");
+	if (!prstGeom) return findChildByLocalName(spPr, "custGeom") !== null;
+	if (findChildByLocalName(prstGeom, "avLst")?.elements?.some((child) => child.type === "element")) return true;
+	return narrowEnum(getAttribute(prstGeom, null, "prst"), ShapeTypeSchema) === void 0;
+}
+function hasUnsupportedRgbColorModifiers(spPr) {
+	for (const color of findAllDeep(spPr, "a", "srgbClr")) if (color.elements?.some((child) => child.type === "element")) return true;
+	return false;
+}
+function hasUnmodeledFill(spPr) {
+	return findChildByLocalName(spPr, "pattFill") !== null || findChildByLocalName(spPr, "blipFill") !== null || findChildByLocalName(spPr, "grpFill") !== null;
+}
+function colorNeedsRawPreservation(color) {
+	return color !== void 0 && color.rgb === void 0;
+}
+function fillNeedsRawPreservation(fill) {
+	if (!fill) return false;
+	if (fill.type === "solid") return colorNeedsRawPreservation(fill.color);
+	if (fill.type === "gradient") return fill.gradient?.stops.some((stop) => colorNeedsRawPreservation(stop.color)) ?? false;
+	return false;
+}
+function outlineNeedsRawPreservation(outline) {
+	return colorNeedsRawPreservation(outline?.color);
+}
+/**
+* Parse a `<wps:wsp>` element into a Shape model. Does NOT pick up the
+* extent / position / wrap fields — those live on the wrapping
+* `<wp:inline>` / `<wp:anchor>` and are handled by `parseShapeFromDrawing`.
+*/
+function parseShape(node) {
+	const cNvPr = findChildByLocalName(node, "cNvPr");
+	const spPr = findChildByLocalName(node, "spPr");
+	const shapeType = parseShapeType(spPr);
+	const { size, transform } = parseTransform(findChildByLocalName(spPr, "xfrm"));
+	const fill = parseShapeFill(spPr);
+	const outline = parseShapeOutline(spPr);
+	const id = cNvPr ? getAttribute(cNvPr, null, "id") ?? void 0 : void 0;
+	const name = cNvPr ? getAttribute(cNvPr, null, "name") ?? void 0 : void 0;
+	const shape = {
+		type: "shape",
+		shapeType,
+		size
+	};
+	if (id !== void 0) shape.id = id;
+	if (name !== void 0) shape.name = name;
+	if (fill !== void 0) shape.fill = fill;
+	if (outline !== void 0) shape.outline = outline;
+	if (transform !== void 0) shape.transform = transform;
+	return shape;
+}
+/**
+* Parse a `<w:drawing>` element as a shape (i.e. the `<a:graphicData>` payload
+* is `<wps:wsp>`, not `<pic:pic>` or a text-box). Returns null when the
+* drawing is not a shape, or when it is a text-box (delegated to
+* `textBoxParser.parseTextBox`).
+*/
+function parseShapeFromDrawing(drawingEl) {
+	const inline = findChildByLocalName(drawingEl, "inline");
+	const anchor = findChildByLocalName(drawingEl, "anchor");
+	const container = inline ?? anchor;
+	if (!container) return null;
+	const graphic = findChildByLocalName(container, "graphic");
+	if (!graphic) return null;
+	const graphicData = findChildByLocalName(graphic, "graphicData");
+	if (!graphicData) return null;
+	const wsp = findChildByLocalName(graphicData, "wsp");
+	if (!wsp) return null;
+	if (findChildByLocalName(wsp, "txbx") !== null) return null;
+	const spPr = findChildByLocalName(wsp, "spPr");
+	if (hasUnsupportedGeometry(spPr) || hasUnsupportedRgbColorModifiers(spPr) || hasUnmodeledFill(spPr) || fillNeedsRawPreservation(parseShapeFill(spPr)) || outlineNeedsRawPreservation(parseShapeOutline(spPr))) return null;
+	const shape = parseShape(wsp);
+	const extent = findChildByLocalName(container, "extent");
+	if (extent) shape.size = {
+		width: parseNumericAttribute(extent, null, "cx") ?? shape.size.width,
+		height: parseNumericAttribute(extent, null, "cy") ?? shape.size.height
+	};
+	if (container === anchor) {
+		const position = parseAnchorPosition(container);
+		if (position) shape.position = position;
+		const wrap = parseAnchorWrap(container);
+		if (wrap) shape.wrap = wrap;
+	} else shape.wrap = { type: "inline" };
+	const docPr = findChildByLocalName(container, "docPr");
+	if (docPr) {
+		const id = getAttribute(docPr, null, "id");
+		const name = getAttribute(docPr, null, "name");
+		if (id !== null) shape.id = id;
+		if (name !== null) shape.name = name;
+	}
+	return shape;
+}
+function shouldPreserveRawShapeDrawing(drawingEl) {
+	const inline = findChildByLocalName(drawingEl, "inline");
+	const anchor = findChildByLocalName(drawingEl, "anchor");
+	const container = inline ?? anchor;
+	if (!container) return false;
+	const graphic = findChildByLocalName(container, "graphic");
+	const graphicData = graphic ? findChildByLocalName(graphic, "graphicData") : null;
+	const wsp = graphicData ? findChildByLocalName(graphicData, "wsp") : null;
+	if (!wsp || findChildByLocalName(wsp, "txbx") !== null) return false;
+	const spPr = findChildByLocalName(wsp, "spPr");
+	if (hasUnsupportedGeometry(spPr)) return true;
+	if (hasUnsupportedRgbColorModifiers(spPr)) return true;
+	if (hasUnmodeledFill(spPr)) return true;
+	return fillNeedsRawPreservation(parseShapeFill(spPr)) || outlineNeedsRawPreservation(parseShapeOutline(spPr));
+}
+//#endregion
+export { parseShape, parseShapeFromDrawing, shouldPreserveRawShapeDrawing };

package/dist/docx/styleParser.d.ts

@@ -0,0 +1,50 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/styleParser.d.ts
+/**
+ * Style map keyed by styleId
+ */
+type StyleMap = Map<string, document_d_exports.Style>;
+type ParsedStylesPackage = {
+  styleDefinitions: document_d_exports.StyleDefinitions;
+  styles: StyleMap;
+};
+/**
+ * Parse styles.xml content
+ *
+ * @param stylesXml - XML content of styles.xml
+ * @param theme - Parsed theme for resolving theme references
+ * @returns StyleMap with resolved inheritance
+ */
+declare function parseStyles(stylesXml: string, theme: document_d_exports.Theme | null): StyleMap;
+/**
+ * Parse complete style definitions including docDefaults
+ *
+ * @param stylesXml - XML content of styles.xml
+ * @param theme - Parsed theme for resolving theme references
+ * @returns StyleDefinitions with docDefaults and resolved styles
+ */
+declare function parseStyleDefinitions(stylesXml: string, theme: document_d_exports.Theme | null, resolvedStyles?: StyleMap): document_d_exports.StyleDefinitions;
+declare function parseStylesPackage(stylesXml: string, theme: document_d_exports.Theme | null): ParsedStylesPackage;
+/**
+ * Get the resolved properties for a style
+ *
+ * @param styleId - Style ID to look up
+ * @param styleMap - Style map from parseStyles
+ * @returns Resolved style or undefined
+ */
+declare function getResolvedStyle(styleId: string, styleMap: StyleMap): document_d_exports.Style | undefined;
+/**
+ * Get the default paragraph style
+ */
+declare function getDefaultParagraphStyle(styleMap: StyleMap): document_d_exports.Style | undefined;
+/**
+ * Get the default character style
+ */
+declare function getDefaultCharacterStyle(styleMap: StyleMap): document_d_exports.Style | undefined;
+/**
+ * Get all styles of a specific type
+ */
+declare function getStylesByType(styleMap: StyleMap, type: document_d_exports.StyleType): document_d_exports.Style[];
+//#endregion
+export { ParsedStylesPackage, StyleMap, getDefaultCharacterStyle, getDefaultParagraphStyle, getResolvedStyle, getStylesByType, parseStyleDefinitions, parseStyles, parseStylesPackage };