@stll/folio-core 0.45.0 → 0.47.0

package/dist/docx/shadingParser.js

@@ -1,5 +1,8 @@
 import { isValidHexColor } from "../utils/colorResolver.js";
-import { ShadingPatternSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
+import { readAttributeBag } from "./attributeRemainder.js";
+import { ShadingPatternSchema, narrowEnum } from "./parserEnums.js";
+import { SHADING_ATTRIBUTES } from "./propertyElementAttributes.js";
+import { parseThemeColorAttribute } from "./themeColorAttribute.js";
 import { getAttribute } from "./xmlParser.js";
 //#region src/docx/shadingParser.ts
 /** `ST_HexColor`'s reserved "let the consumer decide" token. */
@@ -8,25 +11,58 @@ const parseHexColor = (value) => {
 	if (value === AUTOMATIC_COLOR) return { auto: true };
 	if (value && isValidHexColor(value)) return { rgb: value };
 };
-function parseShading(shd) {
+function parseShading(shd, context) {
 	if (!shd) return;
 	const props = {};
 	const color = parseHexColor(getAttribute(shd, "w", "color"));
 	if (color) props.color = color;
 	const fill = parseHexColor(getAttribute(shd, "w", "fill"));
 	if (fill) props.fill = fill;
-	const themeFill = narrowEnum(getAttribute(shd, "w", "themeFill"), ThemeColorSlotSchema);
-	if (themeFill) {
+	const element = shd.name ?? "w:shd";
+	const themeColor = parseThemeColorAttribute({
+		raw: getAttribute(shd, "w", "themeColor"),
+		element,
+		context
+	});
+	if (themeColor !== void 0) {
+		props.color ??= {};
+		props.color.themeColor = themeColor;
+	}
+	const themeTint = getAttribute(shd, "w", "themeTint");
+	if (themeTint) {
+		props.color ??= {};
+		props.color.themeTint = themeTint;
+	}
+	const themeShade = getAttribute(shd, "w", "themeShade");
+	if (themeShade) {
+		props.color ??= {};
+		props.color.themeShade = themeShade;
+	}
+	const themeFill = parseThemeColorAttribute({
+		raw: getAttribute(shd, "w", "themeFill"),
+		element,
+		context
+	});
+	if (themeFill !== void 0) {
 		props.fill ??= {};
 		props.fill.themeColor = themeFill;
 	}
 	const themeFillTint = getAttribute(shd, "w", "themeFillTint");
-	if (themeFillTint && props.fill) props.fill.themeTint = themeFillTint;
+	if (themeFillTint) {
+		props.fill ??= {};
+		props.fill.themeTint = themeFillTint;
+	}
 	const themeFillShade = getAttribute(shd, "w", "themeFillShade");
-	if (themeFillShade && props.fill) props.fill.themeShade = themeFillShade;
+	if (themeFillShade) {
+		props.fill ??= {};
+		props.fill.themeShade = themeFillShade;
+	}
 	const pattern = narrowEnum(getAttribute(shd, "w", "val"), ShadingPatternSchema);
 	if (pattern) props.pattern = pattern;
-	return Object.keys(props).length > 0 ? props : void 0;
+	if (Object.keys(props).length === 0) return;
+	const preservedAttributes = readAttributeBag(shd, SHADING_ATTRIBUTES);
+	if (preservedAttributes) props.preservedAttributes = preservedAttributes;
+	return props;
 }
 //#endregion
 export { parseShading };

package/dist/docx/shapeParser.js

@@ -1,4 +1,5 @@
-import { parseAnchorPosition, parseAnchorWrap, parseFill, parseOutline } from "./drawingUtils.js";
+import { parseDrawingAnchor } from "./drawingAnchor.js";
+import { parseAnchorPosition, parseAnchorWrap, parseFill, parseInlineWrap, parseOutline } from "./drawingUtils.js";
 import { parseNonVisualDrawingNames } from "./nonVisualDrawingProps.js";
 import { ShapeTypeSchema, narrowEnum } from "./parserEnums.js";
 import { findAllDeep, findChildByLocalName, findChildren, getAttribute, getChildElements, parseNumericAttribute, parseOnOffAttribute } from "./xmlParser.js";
@@ -27,13 +28,13 @@ function parseTransform(xfrm) {
 		height: parseNumericAttribute(ext, null, "cy") ?? 0
 	};
 	const rotation = rotToDegrees(getAttribute(xfrm, null, "rot"));
-	const flipH = parseOnOffAttribute(xfrm, null, "flipH") === true;
-	const flipV = parseOnOffAttribute(xfrm, null, "flipV") === true;
-	if (rotation === void 0 && !flipH && !flipV) return { size };
+	const flipH = parseOnOffAttribute(xfrm, null, "flipH");
+	const flipV = parseOnOffAttribute(xfrm, null, "flipV");
+	if (rotation === void 0 && flipH === void 0 && flipV === void 0) return { size };
 	const transform = {};
 	if (rotation !== void 0) transform.rotation = rotation;
-	if (flipH) transform.flipH = true;
-	if (flipV) transform.flipV = true;
+	if (flipH !== void 0) transform.flipH = flipH;
+	if (flipV !== void 0) transform.flipV = flipV;
 	return {
 		size,
 		transform
@@ -140,11 +141,13 @@ function parseShape(node) {
 	const fill = parseShapeFill(spPr);
 	const outline = parseOutline(spPr);
 	const id = cNvPr ? getAttribute(cNvPr, null, "id") ?? void 0 : void 0;
+	const names = parseNonVisualDrawingNames(cNvPr);
 	const shape = {
 		type: "shape",
 		shapeType,
 		size,
-		...parseNonVisualDrawingNames(cNvPr)
+		...names,
+		...Object.keys(names).length > 0 ? { shapeNames: names } : {}
 	};
 	const geometryAdjustments = parseGeometryAdjustments(spPr);
 	if (geometryAdjustments !== void 0) shape.geometryAdjustments = geometryAdjustments;
@@ -189,7 +192,9 @@ function parseShapeFromDrawing(drawingEl) {
 		if (position) shape.position = position;
 		const wrap = parseAnchorWrap(container);
 		if (wrap) shape.wrap = wrap;
-	} else shape.wrap = { type: "inline" };
+		const drawingAnchor = parseDrawingAnchor(container);
+		if (drawingAnchor) shape.anchor = drawingAnchor;
+	} else shape.wrap = parseInlineWrap(container);
 	const docPr = findChildByLocalName(container, "docPr");
 	if (docPr) {
 		const id = getAttribute(docPr, null, "id");

package/dist/docx/strictNames.d.ts

@@ -0,0 +1,11 @@
+import { XmlElement } from "./xmlParser.js";
+import { RenamedSlot } from "./strictNames.gen.js";
+//#region src/docx/strictNames.d.ts
+/** A renamed child of `parent`, in whichever spelling the document used. */
+declare const findChildAnySpelling: (parent: XmlElement | null | undefined, slot: RenamedSlot) => XmlElement | null;
+/** A renamed attribute's number, in whichever spelling the document used. */
+declare const numericAttributeAnySpelling: (element: XmlElement | null | undefined, slot: RenamedSlot) => number | undefined;
+/** Whether the element carries a renamed attribute under either spelling. */
+declare const hasAttributeAnySpelling: (element: XmlElement | null | undefined, slot: RenamedSlot) => boolean;
+//#endregion
+export { findChildAnySpelling, hasAttributeAnySpelling, numericAttributeAnySpelling };

package/dist/docx/strictNames.gen.d.ts

@@ -0,0 +1,45 @@
+//#region src/docx/strictNames.gen.d.ts
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * The WordprocessingML names ECMA-376 Part 1 spells by writing direction and
+ * Part 4 spells by physical side, derived from the cited list in
+ * `specifications/strict-names/renames.ts` and the committed schema graph by
+ * `scripts/generate-strict-names.ts`. Regenerate with:
+ *
+ *   bun run generate:strict-names
+ *
+ * A key is the complex type the name belongs to — the element's own type, or
+ * the attribute's owner — then the local name, marked `@` for an attribute.
+ * The comment above each entry names the types that declare the pair.
+ */
+/** What folio writes for a name a Strict producer spelled by writing direction. */
+declare const TRANSITIONAL_NAME_BY_STRICT_NAME: {
+  readonly "CT_Border end": "right";
+  readonly "CT_Border start": "left";
+  readonly "CT_Ind @end": "right";
+  readonly "CT_Ind @endChars": "rightChars";
+  readonly "CT_Ind @start": "left";
+  readonly "CT_Ind @startChars": "leftChars";
+  readonly "CT_TblWidth end": "right";
+  readonly "CT_TblWidth start": "left";
+};
+/** A name Part 1 renamed, keyed by the complex type it belongs to. */
+type StrictName = keyof typeof TRANSITIONAL_NAME_BY_STRICT_NAME;
+/** The same keys as a list, so a consumer can walk them without widening them. */
+declare const STRICT_NAMES: readonly ["CT_Border end", "CT_Border start", "CT_Ind @end", "CT_Ind @endChars", "CT_Ind @start", "CT_Ind @startChars", "CT_TblWidth end", "CT_TblWidth start"];
+/** What a Strict producer may have written where folio writes the Transitional name. */
+declare const STRICT_NAMES_BY_TRANSITIONAL_NAME: {
+  readonly "CT_Border left": readonly ["start"];
+  readonly "CT_Border right": readonly ["end"];
+  readonly "CT_Ind @left": readonly ["start"];
+  readonly "CT_Ind @leftChars": readonly ["startChars"];
+  readonly "CT_Ind @right": readonly ["end"];
+  readonly "CT_Ind @rightChars": readonly ["endChars"];
+  readonly "CT_TblWidth left": readonly ["start"];
+  readonly "CT_TblWidth right": readonly ["end"];
+};
+/** A slot a reader must take in either spelling, keyed the same way. */
+type RenamedSlot = keyof typeof STRICT_NAMES_BY_TRANSITIONAL_NAME;
+//#endregion
+export { RenamedSlot, STRICT_NAMES, STRICT_NAMES_BY_TRANSITIONAL_NAME, StrictName, TRANSITIONAL_NAME_BY_STRICT_NAME };

package/dist/docx/strictNames.gen.js

@@ -0,0 +1,50 @@
+//#region src/docx/strictNames.gen.ts
+/**
+* GENERATED FILE — do not edit.
+*
+* The WordprocessingML names ECMA-376 Part 1 spells by writing direction and
+* Part 4 spells by physical side, derived from the cited list in
+* `specifications/strict-names/renames.ts` and the committed schema graph by
+* `scripts/generate-strict-names.ts`. Regenerate with:
+*
+*   bun run generate:strict-names
+*
+* A key is the complex type the name belongs to — the element's own type, or
+* the attribute's owner — then the local name, marked `@` for an attribute.
+* The comment above each entry names the types that declare the pair.
+*/
+/** What folio writes for a name a Strict producer spelled by writing direction. */
+const TRANSITIONAL_NAME_BY_STRICT_NAME = {
+	"CT_Border end": "right",
+	"CT_Border start": "left",
+	"CT_Ind @end": "right",
+	"CT_Ind @endChars": "rightChars",
+	"CT_Ind @start": "left",
+	"CT_Ind @startChars": "leftChars",
+	"CT_TblWidth end": "right",
+	"CT_TblWidth start": "left"
+};
+/** The same keys as a list, so a consumer can walk them without widening them. */
+const STRICT_NAMES = [
+	"CT_Border end",
+	"CT_Border start",
+	"CT_Ind @end",
+	"CT_Ind @endChars",
+	"CT_Ind @start",
+	"CT_Ind @startChars",
+	"CT_TblWidth end",
+	"CT_TblWidth start"
+];
+/** What a Strict producer may have written where folio writes the Transitional name. */
+const STRICT_NAMES_BY_TRANSITIONAL_NAME = {
+	"CT_Border left": ["start"],
+	"CT_Border right": ["end"],
+	"CT_Ind @left": ["start"],
+	"CT_Ind @leftChars": ["startChars"],
+	"CT_Ind @right": ["end"],
+	"CT_Ind @rightChars": ["endChars"],
+	"CT_TblWidth left": ["start"],
+	"CT_TblWidth right": ["end"]
+};
+//#endregion
+export { STRICT_NAMES, STRICT_NAMES_BY_TRANSITIONAL_NAME, TRANSITIONAL_NAME_BY_STRICT_NAME };

package/dist/docx/strictNames.js

@@ -0,0 +1,43 @@
+import { STRICT_NAMES_BY_TRANSITIONAL_NAME } from "./strictNames.gen.js";
+import { findChild, getAttribute, parseNumericAttribute } from "./xmlParser.js";
+//#region src/docx/strictNames.ts
+/**
+* Reading a slot whose name a Strict producer spells by writing direction.
+*
+* ECMA-376 Part 1 names a horizontal edge `start`/`end` where Part 4 names it
+* `left`/`right`, and Part 4 declares both so a Transitional consumer reads
+* either. folio's model holds one direction and every save writes the physical
+* name, so the tolerance belongs on the way in — once, over the generated
+* table, rather than as a `?? findChild(…, "start")` at each reader. A slot the
+* table does not name is not a renamed slot, and passing one here is a compile
+* error rather than a lookup that silently finds nothing.
+*/
+/**
+* The spellings a document may have used for a slot, folio's own first.
+*
+* The key carries the complex type, so the local name is what follows the
+* space, without the `@` that marks an attribute.
+*/
+const spellingsOf = (slot) => {
+	const local = slot.slice(slot.indexOf(" ") + 1);
+	return [local.startsWith("@") ? local.slice(1) : local, ...STRICT_NAMES_BY_TRANSITIONAL_NAME[slot]];
+};
+/** A renamed child of `parent`, in whichever spelling the document used. */
+const findChildAnySpelling = (parent, slot) => {
+	for (const spelling of spellingsOf(slot)) {
+		const child = findChild(parent, "w", spelling);
+		if (child !== null) return child;
+	}
+	return null;
+};
+/** A renamed attribute's number, in whichever spelling the document used. */
+const numericAttributeAnySpelling = (element, slot) => {
+	for (const spelling of spellingsOf(slot)) {
+		const value = parseNumericAttribute(element, "w", spelling);
+		if (value !== void 0) return value;
+	}
+};
+/** Whether the element carries a renamed attribute under either spelling. */
+const hasAttributeAnySpelling = (element, slot) => spellingsOf(slot).some((spelling) => getAttribute(element, "w", spelling) !== null);
+//#endregion
+export { findChildAnySpelling, hasAttributeAnySpelling, numericAttributeAnySpelling };