@office-open/core 0.3.0

package/dist/_chunks/xml-components-DazgCiyL.mjs

@@ -0,0 +1,364 @@
+import { hpsMeasureValue } from "../values.mjs";
+import { xml2js } from "@office-open/xml";
+//#region src/xml-components/base.ts
+/**
+* Abstract base class for all XML components.
+*/
+var BaseXmlComponent = class {
+	/** The XML element name for this component (e.g., "w:p" for paragraph). */
+	rootKey;
+	constructor(rootKey) {
+		this.rootKey = rootKey;
+	}
+};
+//#endregion
+//#region src/xml-components/component.ts
+/**
+* Core XML Component classes for building OOXML element trees.
+*
+* @module
+*/
+/**
+* Empty object singleton used for empty XML elements.
+*
+* @internal
+*/
+const EMPTY_OBJECT = Object.seal({});
+/**
+* Base class for all XML components in OOXML documents.
+*/
+var XmlComponent = class extends BaseXmlComponent {
+	/**
+	* Array of child components, text nodes, and attributes.
+	*/
+	root;
+	constructor(rootKey) {
+		super(rootKey);
+		this.root = new Array();
+	}
+	/**
+	* Prepares this component and its children for XML serialization.
+	*/
+	prepForXml(context) {
+		context.stack.push(this);
+		const children = [];
+		for (const comp of this.root) if (comp instanceof BaseXmlComponent) {
+			const prepared = comp.prepForXml(context);
+			if (prepared !== void 0) children.push(prepared);
+		} else children.push(comp);
+		context.stack.pop();
+		return { [this.rootKey]: children.length ? children.length === 1 && children[0] && typeof children[0] === "object" && "_attr" in children[0] ? children[0] : children : EMPTY_OBJECT };
+	}
+	/**
+	* @deprecated Internal use only.
+	*/
+	addChildElement(child) {
+		this.root.push(child);
+		return this;
+	}
+};
+/**
+* XML component that is excluded from output if it has no meaningful content.
+*/
+var IgnoreIfEmptyXmlComponent = class extends XmlComponent {
+	includeIfEmpty;
+	constructor(rootKey, includeIfEmpty) {
+		super(rootKey);
+		this.includeIfEmpty = includeIfEmpty;
+	}
+	prepForXml(context) {
+		const result = super.prepForXml(context);
+		if (this.includeIfEmpty) return result;
+		if (result && (typeof result[this.rootKey] !== "object" || Object.keys(result[this.rootKey]).length)) return result;
+	}
+};
+//#endregion
+//#region src/xml-components/attributes.ts
+/**
+* XML attribute components for OOXML document generation.
+*
+* @module
+*/
+/**
+* Base class for creating XML attributes with automatic name mapping.
+*/
+var XmlAttributeComponent = class extends BaseXmlComponent {
+	/** Optional mapping from property names to XML attribute names. */
+	xmlKeys;
+	constructor(root) {
+		super("_attr");
+		this.root = root;
+	}
+	prepForXml(_) {
+		const attrs = {};
+		Object.entries(this.root).forEach(([key, value]) => {
+			if (value !== void 0) {
+				const newKey = this.xmlKeys && this.xmlKeys[key] || key;
+				attrs[newKey] = value;
+			}
+		});
+		return { _attr: attrs };
+	}
+};
+/**
+* Next-generation attribute component with explicit key-value pairs.
+*/
+var NextAttributeComponent = class extends BaseXmlComponent {
+	constructor(root) {
+		super("_attr");
+		this.root = root;
+	}
+	prepForXml(_) {
+		return { _attr: Object.values(this.root).filter(({ value }) => value !== void 0).reduce((acc, { key, value }) => ({
+			...acc,
+			[key]: value
+		}), {}) };
+	}
+};
+//#endregion
+//#region src/xml-components/elements.ts
+/**
+* Simple XML element types for common OOXML patterns.
+*
+* @module
+*/
+const ON_OFF_TRUE_CACHE = /* @__PURE__ */ new Map();
+/**
+* Build a CT_OnOff XML object without allocating any XmlComponent.
+* `val=true` returns a frozen singleton (cached per name).
+*/
+function onOffObj(name, val = true) {
+	if (val === true) {
+		let cached = ON_OFF_TRUE_CACHE.get(name);
+		if (!cached) {
+			cached = Object.freeze({ [name]: Object.freeze({}) });
+			ON_OFF_TRUE_CACHE.set(name, cached);
+		}
+		return cached;
+	}
+	const ns = name.split(":")[0];
+	return { [name]: { _attr: { [`${ns}:val`]: val } } };
+}
+/**
+* Build a CT_HpsMeasure XML object (half-point size) without allocation.
+*/
+function hpsMeasureObj(name, val) {
+	const ns = name.split(":")[0];
+	return { [name]: { _attr: { [`${ns}:val`]: hpsMeasureValue(val) } } };
+}
+/**
+* Build a CT_String XML object (string value attribute) without allocation.
+*/
+function stringValObj(name, val) {
+	const ns = name.split(":")[0];
+	return { [name]: { _attr: { [`${ns}:val`]: val } } };
+}
+/**
+* Build a numeric value attribute XML object without allocation.
+*/
+function numberValObj(name, val) {
+	const ns = name.split(":")[0];
+	return { [name]: { _attr: { [`${ns}:val`]: val } } };
+}
+/**
+* Build a string enum value attribute XML object without allocation.
+*/
+function stringEnumValObj(name, val) {
+	const ns = name.split(":")[0];
+	return { [name]: { _attr: { [`${ns}:val`]: val } } };
+}
+/**
+* Build an element wrapping a text string without allocation.
+*/
+function stringContainerObj(name, val) {
+	return { [name]: [val] };
+}
+/**
+* XML element representing a boolean on/off value (CT_OnOff).
+* @deprecated Use `onOffObj()` for hot-path code.
+*/
+var OnOffElement = class extends XmlComponent {
+	constructor(name, val = true) {
+		super(name);
+		if (val !== true) this.root.push(new NextAttributeComponent({ val: {
+			key: `${name.split(":")[0]}:val`,
+			value: val
+		} }));
+	}
+};
+/**
+* XML element representing a half-point size measurement (CT_HpsMeasure).
+* @deprecated Use `hpsMeasureObj()` for hot-path code.
+*/
+var HpsMeasureElement = class extends XmlComponent {
+	constructor(name, val) {
+		super(name);
+		const ns = name.split(":")[0];
+		this.root.push(new NextAttributeComponent({ val: {
+			key: `${ns}:val`,
+			value: hpsMeasureValue(val)
+		} }));
+	}
+};
+/**
+* XML element representing an empty element (CT_Empty).
+*/
+var EmptyElement = class extends XmlComponent {};
+/**
+* XML element with a string value attribute (CT_String).
+* @deprecated Use `stringValObj()` for hot-path code.
+*/
+var StringValueElement = class extends XmlComponent {
+	constructor(name, val) {
+		super(name);
+		const ns = name.split(":")[0];
+		this.root.push(new NextAttributeComponent({ val: {
+			key: `${ns}:val`,
+			value: val
+		} }));
+	}
+};
+/**
+* XML element with a numeric value attribute.
+* @deprecated Use `numberValObj()` for hot-path code.
+*/
+var NumberValueElement = class extends XmlComponent {
+	constructor(name, val) {
+		super(name);
+		const ns = name.split(":")[0];
+		this.root.push(new NextAttributeComponent({ val: {
+			key: `${ns}:val`,
+			value: val
+		} }));
+	}
+};
+/**
+* XML element with a string enum value attribute.
+* @deprecated Use `stringEnumValObj()` for hot-path code.
+*/
+var StringEnumValueElement = class extends XmlComponent {
+	constructor(name, val) {
+		super(name);
+		const ns = name.split(":")[0];
+		this.root.push(new NextAttributeComponent({ val: {
+			key: `${ns}:val`,
+			value: val
+		} }));
+	}
+};
+/**
+* XML element containing text content.
+* @deprecated Use `stringContainerObj()` for hot-path code.
+*/
+var StringContainer = class extends XmlComponent {
+	constructor(name, val) {
+		super(name);
+		this.root.push(val);
+	}
+};
+/**
+* Flexible XML element builder with explicit attribute and child configuration.
+*/
+var BuilderElement = class extends XmlComponent {
+	constructor({ name, attributes, children }) {
+		super(name);
+		if (attributes) this.root.push(new NextAttributeComponent(attributes));
+		if (children) this.root.push(...children);
+	}
+};
+/**
+* Creates a NextAttributeComponent with explicit XML attribute keys.
+*/
+const chartAttr = (attrs) => new NextAttributeComponent(Object.fromEntries(Object.entries(attrs).map(([key, value]) => [key, {
+	key,
+	value
+}])));
+/**
+* Wraps a component in a named XmlComponent element.
+*/
+function wrapEl(elementName, child) {
+	const el = new class extends XmlComponent {
+		constructor(name) {
+			super(name);
+		}
+	}(elementName);
+	el["root"].push(child);
+	return el;
+}
+//#endregion
+//#region src/xml-components/imported.ts
+/**
+* Imported XML Component module for handling external XML content.
+*
+* @module
+*/
+/**
+* Converts an xml-js Element into an XmlComponent tree.
+*/
+const convertToXmlComponent = (element) => {
+	switch (element.type) {
+		case void 0:
+		case "element": {
+			const xmlComponent = new ImportedXmlComponent(element.name, element.attributes);
+			const childElements = element.elements || [];
+			for (const childElm of childElements) {
+				const child = convertToXmlComponent(childElm);
+				if (child !== void 0) xmlComponent.push(child);
+			}
+			return xmlComponent;
+		}
+		case "text": return element.text;
+		default: return;
+	}
+};
+/**
+* Internal attribute component for imported XML elements.
+* @internal
+*/
+var ImportedXmlComponentAttributes = class extends XmlAttributeComponent {};
+/**
+* XML component representing imported XML content.
+*/
+var ImportedXmlComponent = class extends XmlComponent {
+	static fromXmlString(importedContent) {
+		const xmlObj = xml2js(importedContent, { compact: false });
+		return convertToXmlComponent(xmlObj.elements?.[0] ?? xmlObj);
+	}
+	constructor(rootKey, _attr) {
+		super(rootKey);
+		if (_attr) this.root.push(new ImportedXmlComponentAttributes(_attr));
+	}
+	push(xmlComponent) {
+		this.root.push(xmlComponent);
+	}
+};
+/**
+* Represents attributes for imported root elements.
+*/
+var ImportedRootElementAttributes = class extends XmlComponent {
+	constructor(_attr) {
+		super("");
+		this._attr = _attr;
+	}
+	prepForXml(_) {
+		return { _attr: this._attr };
+	}
+};
+//#endregion
+//#region src/xml-components/initializable.ts
+/**
+* Initializable XML Component module.
+*
+* @module
+*/
+/**
+* XML component that can be initialized from another component.
+*/
+var InitializableXmlComponent = class extends XmlComponent {
+	constructor(rootKey, initComponent) {
+		super(rootKey);
+		if (initComponent instanceof XmlComponent) this.root = initComponent.root;
+	}
+};
+//#endregion
+export { EMPTY_OBJECT as C, BaseXmlComponent as E, XmlAttributeComponent as S, XmlComponent as T, stringContainerObj as _, BuilderElement as a, wrapEl as b, NumberValueElement as c, StringEnumValueElement as d, StringValueElement as f, onOffObj as g, numberValObj as h, convertToXmlComponent as i, OnOffElement as l, hpsMeasureObj as m, ImportedRootElementAttributes as n, EmptyElement as o, chartAttr as p, ImportedXmlComponent as r, HpsMeasureElement as s, InitializableXmlComponent as t, StringContainer as u, stringEnumValObj as v, IgnoreIfEmptyXmlComponent as w, NextAttributeComponent as x, stringValObj as y };

package/dist/archive.d.mts

@@ -0,0 +1,42 @@
+import { Element } from "@office-open/xml";
+
+//#region src/archive.d.ts
+/**
+ * Unzip an OOXML file (.docx, .pptx) into a Map of path → Uint8Array.
+ */
+declare function unzipToMap(data: Uint8Array): Map<string, Uint8Array>;
+/**
+ * Read a file from the zip as a UTF-8 string.
+ */
+declare function readTextFromZip(zip: Map<string, Uint8Array>, path: string): string | undefined;
+/**
+ * Parse an XML file from the zip into an Element tree.
+ */
+declare function readXmlFromZip(zip: Map<string, Uint8Array>, path: string): Element | undefined;
+/**
+ * Read a binary file from the zip.
+ */
+declare function readBinaryFromZip(zip: Map<string, Uint8Array>, path: string): Uint8Array | undefined;
+/**
+ * List all files in the zip matching a prefix.
+ */
+declare function listFiles(zip: Map<string, Uint8Array>, prefix: string): string[];
+/**
+ * Convert Uint8Array to base64 string.
+ */
+declare function uint8ToBase64(data: Uint8Array): string;
+/**
+ * Determine image type from file extension.
+ */
+declare function getImageType(fileName: string): string;
+interface Relationship {
+  id: string;
+  target: string;
+  type: string;
+  targetMode?: string;
+}
+declare function parseRels(zip: Map<string, Uint8Array>, path: string): Relationship[];
+declare function findRel(rels: Relationship[], id: string): Relationship | undefined;
+declare function findRelsByType(rels: Relationship[], typeSubstring: string): Relationship[];
+//#endregion
+export { Relationship, findRel, findRelsByType, getImageType, listFiles, parseRels, readBinaryFromZip, readTextFromZip, readXmlFromZip, uint8ToBase64, unzipToMap };

package/dist/archive.mjs

@@ -0,0 +1,101 @@
+import { attr, xml2js } from "@office-open/xml";
+import { strFromU8, unzipSync } from "fflate";
+//#region src/archive.ts
+const XML_PARSE_OPTIONS = {
+	nativeTypeAttributes: true,
+	captureSpacesBetweenElements: true
+};
+/**
+* Unzip an OOXML file (.docx, .pptx) into a Map of path → Uint8Array.
+*/
+function unzipToMap(data) {
+	const entries = unzipSync(data);
+	const map = /* @__PURE__ */ new Map();
+	for (const [path, bytes] of Object.entries(entries)) map.set(path, bytes);
+	return map;
+}
+/**
+* Read a file from the zip as a UTF-8 string.
+*/
+function readTextFromZip(zip, path) {
+	const data = zip.get(path);
+	if (data === void 0) return void 0;
+	return strFromU8(data);
+}
+/**
+* Parse an XML file from the zip into an Element tree.
+*/
+function readXmlFromZip(zip, path) {
+	const text = readTextFromZip(zip, path);
+	if (text === void 0) return void 0;
+	return xml2js(text, XML_PARSE_OPTIONS).elements?.find((e) => e.type === "element");
+}
+/**
+* Read a binary file from the zip.
+*/
+function readBinaryFromZip(zip, path) {
+	return zip.get(path);
+}
+/**
+* List all files in the zip matching a prefix.
+*/
+function listFiles(zip, prefix) {
+	const result = [];
+	for (const path of zip.keys()) if (path.startsWith(prefix)) result.push(path);
+	return result;
+}
+/**
+* Convert Uint8Array to base64 string.
+*/
+function uint8ToBase64(data) {
+	let binary = "";
+	for (let i = 0; i < data.length; i++) binary += String.fromCharCode(data[i]);
+	return btoa(binary);
+}
+/**
+* Determine image type from file extension.
+*/
+function getImageType(fileName) {
+	const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
+	if ([
+		"png",
+		"jpg",
+		"jpeg",
+		"gif",
+		"bmp",
+		"tif",
+		"tiff",
+		"ico",
+		"emf",
+		"wmf",
+		"svg"
+	].includes(ext)) return ext === "jpeg" ? "jpg" : ext;
+	return "png";
+}
+function parseRels(zip, path) {
+	const xml = readXmlFromZip(zip, path);
+	if (!xml) return [];
+	const result = [];
+	for (const rel of xml.elements ?? []) {
+		if (rel.name !== "Relationship") continue;
+		const id = attr(rel, "Id");
+		const target = attr(rel, "Target");
+		const type = attr(rel, "Type");
+		const targetMode = attr(rel, "TargetMode");
+		if (id && target) result.push({
+			id,
+			target,
+			type: type ?? "",
+			...targetMode ? { targetMode } : {}
+		});
+	}
+	return result;
+}
+function findRel(rels, id) {
+	return rels.find((r) => r.id === id);
+}
+function findRelsByType(rels, typeSubstring) {
+	return rels.filter((r) => r.type.includes(typeSubstring));
+}
+//#endregion
+export { findRel, findRelsByType, getImageType, listFiles, parseRels, readBinaryFromZip, readTextFromZip, readXmlFromZip, uint8ToBase64, unzipToMap };

package/dist/chart/index.d.mts

@@ -0,0 +1,83 @@
+import { O as XmlComponent } from "../_chunks/index-3uVYzs32.mjs";
+
+//#region src/chart/chart-collection.d.ts
+interface IChartData {
+  readonly key: string;
+  readonly chartSpace: XmlComponent;
+}
+declare class ChartCollection {
+  private readonly map;
+  constructor();
+  addChart(key: string, chartData: IChartData): void;
+  get Array(): readonly IChartData[];
+}
+//#endregion
+//#region src/chart/chart-types/area-chart.d.ts
+interface IAreaChartOptions {
+  readonly categories: readonly string[];
+  readonly series: readonly IChartSeriesData[];
+}
+declare class AreaChart extends XmlComponent {
+  constructor(options: IAreaChartOptions);
+}
+//#endregion
+//#region src/chart/chart-types/bar-chart.d.ts
+interface IBarChartOptions {
+  readonly barDirection: "col" | "bar";
+  readonly categories: readonly string[];
+  readonly series: readonly IChartSeriesData[];
+}
+declare class BarChart extends XmlComponent {
+  constructor(options: IBarChartOptions);
+}
+//#endregion
+//#region src/chart/chart-types/line-chart.d.ts
+interface ILineChartOptions {
+  readonly categories: readonly string[];
+  readonly series: readonly IChartSeriesData[];
+}
+declare class LineChart extends XmlComponent {
+  constructor(options: ILineChartOptions);
+}
+//#endregion
+//#region src/chart/chart-types/pie-chart.d.ts
+interface IPieChartOptions {
+  readonly categories: readonly string[];
+  readonly series: readonly IChartSeriesData[];
+}
+declare class PieChart extends XmlComponent {
+  constructor(options: IPieChartOptions);
+}
+//#endregion
+//#region src/chart/chart-types/scatter-chart.d.ts
+interface IScatterChartOptions {
+  readonly categories: readonly string[];
+  readonly series: readonly IChartSeriesData[];
+}
+declare class ScatterChart extends XmlComponent {
+  constructor(options: IScatterChartOptions);
+}
+//#endregion
+//#region src/chart/create-chart-type.d.ts
+interface IChartSeriesData {
+  readonly name: string;
+  readonly values: readonly number[];
+}
+type ChartType = "column" | "bar" | "line" | "pie" | "area" | "scatter";
+interface IChartTypeOptions {
+  readonly type: ChartType;
+  readonly series: readonly IChartSeriesData[];
+  readonly categories: readonly string[];
+}
+declare const createChartType: (options: IChartTypeOptions) => BarChart | LineChart | PieChart | AreaChart | ScatterChart;
+//#endregion
+//#region src/chart/series/series-data.d.ts
+declare const createStrRef: (values: string | readonly string[]) => XmlComponent;
+declare const createNumRef: (values: readonly number[]) => XmlComponent;
+//#endregion
+//#region src/chart/title.d.ts
+declare class ChartTitle extends XmlComponent {
+  constructor(title: string);
+}
+//#endregion
+export { AreaChart, BarChart, ChartCollection, ChartTitle, ChartType, IChartData, IChartSeriesData, IChartTypeOptions, LineChart, PieChart, ScatterChart, createChartType, createNumRef, createStrRef };