odf.js 6.1.2 → 6.2.0

package/dist/ooo1/transform.js

@@ -0,0 +1,401 @@
+import { bytesToBase64 } from "../util/base64.js";
+import { ODF_NAMESPACES } from "../ns.js";
+import { rootElement } from "../xml/query.js";
+import { OOO1_NAMESPACES, isOoo1Package, odfMediaTypeForOoo1MediaType } from "./ns.js";
+import { propertyTypesForContainer, splitStyleProperties } from "./properties.js";
+//#region src/ooo1/transform.ts
+const CANONICAL_PREFIX_BY_URI = new Map([...Object.entries(OOO1_NAMESPACES).map(([prefix, uri]) => [uri, prefix]), ...Object.entries(ODF_NAMESPACES).map(([prefix, uri]) => [uri, prefix])]);
+function isOdfNamespacePrefix(prefix) {
+	return Object.hasOwn(ODF_NAMESPACES, prefix);
+}
+const GENRE_ELEMENT_BY_CLASS = /* @__PURE__ */ new Map([
+	["text", "office:text"],
+	["text-global", "office:text"],
+	["spreadsheet", "office:spreadsheet"],
+	["presentation", "office:presentation"],
+	["drawing", "office:drawing"],
+	["chart", "office:chart"]
+]);
+const RENAMED_ELEMENTS = /* @__PURE__ */ new Map([
+	["office:font-decls", "office:font-face-decls"],
+	["office:script", "office:scripts"],
+	["office:script-data", "office:script"],
+	["office:events", "office:event-listeners"],
+	["style:page-master", "style:page-layout"],
+	["text:ordered-list", "text:list"],
+	["text:unordered-list", "text:list"],
+	["text:tab-stop", "text:tab"],
+	["text:footnote-body", "text:note-body"],
+	["text:endnote-body", "text:note-body"],
+	["text:footnote-citation", "text:note-citation"],
+	["text:endnote-citation", "text:note-citation"],
+	["text:database-select", "text:database-row-select"],
+	["text:index-entry-chapter-number", "text:index-entry-chapter"],
+	["table:dependences", "table:dependencies"],
+	["table:dependence", "table:dependency"]
+]);
+const NOTE_ELEMENTS = /* @__PURE__ */ new Map([
+	["text:footnote", {
+		tag: "text:note",
+		noteClass: "footnote"
+	}],
+	["text:endnote", {
+		tag: "text:note",
+		noteClass: "endnote"
+	}],
+	["text:footnote-ref", {
+		tag: "text:note-ref",
+		noteClass: "footnote"
+	}],
+	["text:endnote-ref", {
+		tag: "text:note-ref",
+		noteClass: "endnote"
+	}],
+	["text:footnotes-configuration", {
+		tag: "text:notes-configuration",
+		noteClass: "footnote"
+	}],
+	["text:endnotes-configuration", {
+		tag: "text:notes-configuration",
+		noteClass: "endnote"
+	}]
+]);
+const RENAMED_ATTRIBUTES = /* @__PURE__ */ new Map([
+	["style:page-master-name", "style:page-layout-name"],
+	["style:leader-char", "style:leader-text"],
+	["text:count-in-floating-frames", "text:count-in-text-boxes"],
+	["form:service-name", "form:control-implementation"],
+	["form:column-style-name", "form:text-style-name"],
+	["form:property-type", "office:value-type"]
+]);
+const VALUE_ATTRIBUTE_LOCAL_NAMES = [
+	"value-type",
+	"value",
+	"currency",
+	"date-value",
+	"time-value",
+	"boolean-value",
+	"string-value"
+];
+const CELL_ELEMENTS = /* @__PURE__ */ new Set([
+	"table:table-cell",
+	"table:covered-table-cell",
+	"table:change-track-table-cell"
+]);
+const TEXT_VALUE_ELEMENTS = /* @__PURE__ */ new Set([
+	"text:variable-decl",
+	"text:variable-set",
+	"text:variable-input",
+	"text:variable-get",
+	"text:user-field-decl",
+	"text:user-field-get",
+	"text:user-field-input",
+	"text:expression"
+]);
+const FRAME_SHAPES = /* @__PURE__ */ new Set([
+	"draw:text-box",
+	"draw:image",
+	"draw:object",
+	"draw:object-ole",
+	"draw:applet",
+	"draw:plugin",
+	"draw:floating-frame"
+]);
+const FRAME_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"draw:z-index",
+	"draw:id",
+	"draw:layer",
+	"draw:style-name",
+	"presentation:style-name",
+	"draw:transform",
+	"draw:name",
+	"table:end-cell-address",
+	"table:end-x",
+	"table:end-y",
+	"table:table-background",
+	"text:anchor-type",
+	"text:anchor-page-number",
+	"draw:text-style-name",
+	"svg:x",
+	"svg:y",
+	"svg:width",
+	"svg:height",
+	"style:rel-width",
+	"style:rel-height",
+	"presentation:class",
+	"presentation:placeholder",
+	"presentation:user-transformed"
+]);
+const FRAME_CHILD_ELEMENTS = /* @__PURE__ */ new Set([
+	"office:event-listeners",
+	"draw:glue-point",
+	"draw:image-map",
+	"svg:desc",
+	"svg:title",
+	"draw:contour-polygon",
+	"draw:contour-path"
+]);
+const PACKAGE_HREF_ELEMENTS = /* @__PURE__ */ new Set([
+	"draw:image",
+	"draw:object",
+	"draw:object-ole",
+	"draw:applet",
+	"draw:plugin",
+	"draw:floating-frame",
+	"draw:fill-image",
+	"style:background-image",
+	"text:list-level-style-image"
+]);
+const INCH_TOKEN = /(^|\s)(-?(?:\d+(?:\.\d+)?|\.\d+))inch(?=\s|$)/g;
+function carriesNoLength(attributeName) {
+	return attributeName.endsWith("name") || attributeName === "xlink:href";
+}
+function normaliseAttributeValue(name, value) {
+	if (carriesNoLength(name)) return value;
+	return value.replace(INCH_TOKEN, "$1$2in");
+}
+function renameQName(qname, prefixes) {
+	const colon = qname.indexOf(":");
+	if (colon < 0) return qname;
+	const canonical = prefixes.get(qname.slice(0, colon));
+	return canonical === void 0 ? qname : `${canonical}:${qname.slice(colon + 1)}`;
+}
+function transformNamespaceDeclaration(attribute) {
+	const canonical = CANONICAL_PREFIX_BY_URI.get(attribute.value);
+	if (canonical === void 0 || !isOdfNamespacePrefix(canonical)) return attribute;
+	return {
+		name: attribute.name === "xmlns" ? "xmlns" : `xmlns:${canonical}`,
+		value: ODF_NAMESPACES[canonical]
+	};
+}
+const DOCUMENT_ROOT_ELEMENTS = /* @__PURE__ */ new Set([
+	"office:document",
+	"office:document-content",
+	"office:document-styles",
+	"office:document-meta",
+	"office:document-settings"
+]);
+function transformAttributes(element, tag, prefixes) {
+	const out = [];
+	for (const attribute of element.attributes) {
+		if (attribute.name === "xmlns" || attribute.name.startsWith("xmlns:")) {
+			out.push(transformNamespaceDeclaration(attribute));
+			continue;
+		}
+		const name = renameQName(attribute.name, prefixes);
+		if (name === "office:class" && DOCUMENT_ROOT_ELEMENTS.has(tag)) continue;
+		const value = normaliseAttributeValue(name, attribute.value);
+		out.push({
+			name: renameAttributeFor(tag, name),
+			value: rewriteHref(tag, name, value)
+		});
+	}
+	return out;
+}
+function renameAttributeFor(tag, name) {
+	const renamed = RENAMED_ATTRIBUTES.get(name);
+	if (renamed !== void 0) return renamed;
+	if (name === "text:level" && (tag === "text:h" || tag === "text:p")) return "text:outline-level";
+	if (CELL_ELEMENTS.has(tag)) {
+		if (name === "table:validation-name") return "table:content-validation-name";
+		for (const local of VALUE_ATTRIBUTE_LOCAL_NAMES) if (name === `table:${local}`) return `office:${local}`;
+	}
+	if (TEXT_VALUE_ELEMENTS.has(tag)) {
+		for (const local of VALUE_ATTRIBUTE_LOCAL_NAMES) if (name === `text:${local}`) return `office:${local}`;
+	}
+	if (tag === "style:column") {
+		if (name === "fo:margin-left") return "fo:start-indent";
+		if (name === "fo:margin-right") return "fo:end-indent";
+	}
+	return name;
+}
+function rewriteHref(tag, name, value) {
+	if (name === "xlink:href" && value.startsWith("#") && PACKAGE_HREF_ELEMENTS.has(tag)) return value.slice(1);
+	return value;
+}
+function withoutAttributes(attributes, drop) {
+	return attributes.filter((attribute) => !drop.has(attribute.name));
+}
+function element(tag, attributes, children) {
+	return {
+		type: "element",
+		tag,
+		attributes,
+		children
+	};
+}
+function textElement(tag, value) {
+	return element(tag, [], [{
+		type: "text",
+		value
+	}]);
+}
+const MOVED_TO_CHILD_ELEMENT = /* @__PURE__ */ new Map([["office:annotation", /* @__PURE__ */ new Map([
+	["office:author", "dc:creator"],
+	["office:create-date", "dc:date"],
+	["office:create-date-string", "meta:date-string"]
+])], ["office:change-info", /* @__PURE__ */ new Map([["office:chg-author", "dc:creator"], ["office:chg-date-time", "dc:date"]])]]);
+function transformNodes(nodes, context) {
+	const out = [];
+	for (const node of nodes) {
+		if (node.type !== "element") {
+			out.push(node);
+			continue;
+		}
+		out.push(...transformElement(node, context));
+	}
+	return out;
+}
+function transformElement(source, context) {
+	const renamedTag = renameQName(source.tag, context.prefixes);
+	if (renamedTag === "style:properties") {
+		const staged = element(renamedTag, transformAttributes(source, renamedTag, context.prefixes), transformNodes(source.children, {
+			...context,
+			propertyTypes: void 0
+		}));
+		if (context.propertyTypes === void 0) return [staged];
+		return splitStyleProperties(staged, context.propertyTypes);
+	}
+	if (renamedTag === "meta:keywords") return transformNodes(source.children, {
+		...context,
+		propertyTypes: void 0
+	});
+	const attributes = transformAttributes(source, renamedTag, context.prefixes);
+	const childContext = {
+		...context,
+		propertyTypes: propertyTypesForContainer({
+			...source,
+			tag: renamedTag,
+			attributes
+		})
+	};
+	const children = transformNodes(source.children, childContext);
+	if (renamedTag === "office:body") return [buildBody(attributes, children, context.documentClass)];
+	const note = NOTE_ELEMENTS.get(renamedTag);
+	if (note !== void 0) return [element(note.tag, [...attributes, {
+		name: "text:note-class",
+		value: note.noteClass
+	}], children)];
+	if (renamedTag === "table:sub-table") return [element("table:table", [...attributes, {
+		name: "table:is-sub-table",
+		value: "true"
+	}], children)];
+	if (renamedTag === "style:font-decl") return [element("style:font-face", attributes.map((attribute) => {
+		if (attribute.name === "fo:font-family") return {
+			name: "svg:font-family",
+			value: attribute.value
+		};
+		if (attribute.name === "style:font-style-name") return {
+			name: "style:font-adornments",
+			value: attribute.value
+		};
+		return attribute;
+	}), children)];
+	const moved = MOVED_TO_CHILD_ELEMENT.get(renamedTag);
+	if (moved !== void 0) {
+		const promoted = [];
+		for (const [from, to] of moved) {
+			const value = attributes.find((attribute) => attribute.name === from)?.value;
+			if (value !== void 0) promoted.push(textElement(to, value));
+		}
+		return [element(renamedTag, withoutAttributes(attributes, new Set(moved.keys())), [...promoted, ...children])];
+	}
+	if (FRAME_SHAPES.has(renamedTag)) return [buildFrame(renamedTag, attributes, children)];
+	if (renamedTag === "form:property") return [element(renamedTag, withoutAttributes(attributes, /* @__PURE__ */ new Set(["form:property-is-list"])), children)];
+	const renamed = RENAMED_ELEMENTS.get(renamedTag);
+	if (renamed !== void 0) return [element(renamed, attributes, children)];
+	return [element(renamedTag, attributes, children)];
+}
+function buildBody(attributes, children, documentClass) {
+	const genre = documentClass === void 0 ? void 0 : GENRE_ELEMENT_BY_CLASS.get(documentClass);
+	if (genre === void 0) return element("office:body", attributes, children);
+	return element("office:body", attributes, [element(genre, [], children)]);
+}
+function buildFrame(tag, attributes, children) {
+	const frameAttributes = attributes.filter((attribute) => FRAME_ATTRIBUTES.has(attribute.name));
+	const shapeAttributes = attributes.filter((attribute) => !FRAME_ATTRIBUTES.has(attribute.name));
+	const frameChildren = [];
+	const shapeChildren = [];
+	for (const child of children) if (child.type === "element" && FRAME_CHILD_ELEMENTS.has(child.tag)) frameChildren.push(child);
+	else shapeChildren.push(child);
+	return element("draw:frame", frameAttributes, [element(tag, shapeAttributes, shapeChildren), ...frameChildren]);
+}
+function prefixRenames(root) {
+	const renames = /* @__PURE__ */ new Map();
+	for (const attribute of root.attributes) {
+		if (!attribute.name.startsWith("xmlns:")) continue;
+		const declared = attribute.name.slice(6);
+		const canonical = CANONICAL_PREFIX_BY_URI.get(attribute.value);
+		if (canonical !== void 0 && canonical !== declared) renames.set(declared, canonical);
+	}
+	return renames;
+}
+function transformXmlPart(nodes) {
+	const root = rootElement(nodes);
+	if (root === void 0) return [...nodes];
+	const prefixes = prefixRenames(root);
+	const classAttributeName = [...prefixes.entries()].find(([, canonical]) => canonical === "office")?.[0];
+	return transformNodes(nodes, {
+		prefixes,
+		documentClass: root.attributes.find((attribute) => attribute.name === "office:class" || classAttributeName !== void 0 && attribute.name === `${classAttributeName}:class`)?.value
+	});
+}
+const MANIFEST_PATH = "META-INF/manifest.xml";
+const MIMETYPE_PATH = "mimetype";
+function odfMediaTypeOf(pkg) {
+	const manifest = pkg.parts[MANIFEST_PATH];
+	if (manifest?.kind !== "xml") return;
+	const root = rootElement(manifest.nodes);
+	if (root === void 0) return;
+	for (const entry of root.children) {
+		if (entry.type !== "element" || !entry.tag.endsWith(":file-entry")) continue;
+		if (entry.attributes.find((attribute) => attribute.name.endsWith(":full-path"))?.value !== "/") continue;
+		const mediaType = entry.attributes.find((attribute) => attribute.name.endsWith(":media-type"))?.value;
+		return mediaType === void 0 ? void 0 : odfMediaTypeForOoo1MediaType(mediaType);
+	}
+}
+function rewriteManifestMediaType(nodes, odfMediaType) {
+	return nodes.map((node) => {
+		if (node.type !== "element") return node;
+		return {
+			...node,
+			children: node.children.map((entry) => {
+				if (entry.type !== "element" || entry.tag !== "manifest:file-entry") return entry;
+				if (entry.attributes.find((attribute) => attribute.name === "manifest:full-path")?.value !== "/") return entry;
+				return {
+					...entry,
+					attributes: entry.attributes.map((attribute) => attribute.name === "manifest:media-type" ? {
+						name: attribute.name,
+						value: odfMediaType
+					} : attribute)
+				};
+			})
+		};
+	});
+}
+function transformOoo1Package(pkg) {
+	if (!isOoo1Package(pkg)) return pkg;
+	const odfMediaType = odfMediaTypeOf(pkg);
+	const parts = {};
+	for (const [path, part] of Object.entries(pkg.parts)) {
+		if (part.kind !== "xml") {
+			parts[path] = part;
+			continue;
+		}
+		const nodes = transformXmlPart(part.nodes);
+		parts[path] = path === MANIFEST_PATH && odfMediaType !== void 0 ? {
+			kind: "xml",
+			nodes: rewriteManifestMediaType(nodes, odfMediaType)
+		} : {
+			kind: "xml",
+			nodes
+		};
+	}
+	if (odfMediaType !== void 0 && parts[MIMETYPE_PATH] === void 0) parts[MIMETYPE_PATH] = {
+		kind: "binary",
+		base64: bytesToBase64(new TextEncoder().encode(odfMediaType))
+	};
+	return { parts };
+}
+//#endregion
+export { transformOoo1Package };

package/dist/read-3yy5EFV_.d.ts

@@ -0,0 +1,17 @@
+import { r as Package } from "./package-otZYrxiO.js";
+import { t as OdpDocument } from "./read-DUOJ-1hX.js";
+import { i as OdtReadOptions, t as OdtDocument } from "./read-BcxAWBB5.js";
+import { t as OdgDocument } from "./read-D3wLfr-7.js";
+import { t as OdsDocument } from "./read-Bo1GBjSE.js";
+import { DocumentTree } from "document-schema.js";
+//#region src/ooo1/read.d.ts
+declare function readSxwContent(pkg: Package, options?: OdtReadOptions): OdtDocument;
+declare function readSxw(pkg: Package, options?: OdtReadOptions): DocumentTree;
+declare function readSxcContent(pkg: Package): OdsDocument;
+declare function readSxc(pkg: Package): DocumentTree;
+declare function readSxiContent(pkg: Package): OdpDocument;
+declare function readSxi(pkg: Package): DocumentTree;
+declare function readSxdContent(pkg: Package): OdgDocument;
+declare function readSxd(pkg: Package): DocumentTree;
+//#endregion
+export { readSxi as a, readSxwContent as c, readSxdContent as i, readSxcContent as n, readSxiContent as o, readSxd as r, readSxw as s, readSxc as t };

package/dist/read-RFqq4ckj.d.cts

@@ -0,0 +1,17 @@
+import { r as Package } from "./package-DMk9fuTI.cjs";
+import { t as OdpDocument } from "./read-DHOQqjOZ.cjs";
+import { i as OdtReadOptions, t as OdtDocument } from "./read-Dy5p1OMb.cjs";
+import { t as OdgDocument } from "./read-DSyz0YLj.cjs";
+import { t as OdsDocument } from "./read-tpfiT_n4.cjs";
+import { DocumentTree } from "document-schema.js";
+//#region src/ooo1/read.d.ts
+declare function readSxwContent(pkg: Package, options?: OdtReadOptions): OdtDocument;
+declare function readSxw(pkg: Package, options?: OdtReadOptions): DocumentTree;
+declare function readSxcContent(pkg: Package): OdsDocument;
+declare function readSxc(pkg: Package): DocumentTree;
+declare function readSxiContent(pkg: Package): OdpDocument;
+declare function readSxi(pkg: Package): DocumentTree;
+declare function readSxdContent(pkg: Package): OdgDocument;
+declare function readSxd(pkg: Package): DocumentTree;
+//#endregion
+export { readSxi as a, readSxwContent as c, readSxdContent as i, readSxcContent as n, readSxiContent as o, readSxd as r, readSxw as s, readSxc as t };

package/dist/transform-DRr76JEu.d.ts

@@ -0,0 +1,5 @@
+import { r as Package } from "./package-otZYrxiO.js";
+//#region src/ooo1/transform.d.ts
+declare function transformOoo1Package(pkg: Package): Package;
+//#endregion
+export { transformOoo1Package as t };

package/dist/transform-SDysw9wx.d.cts

@@ -0,0 +1,5 @@
+import { r as Package } from "./package-DMk9fuTI.cjs";
+//#region src/ooo1/transform.d.ts
+declare function transformOoo1Package(pkg: Package): Package;
+//#endregion
+export { transformOoo1Package as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "odf.js",
-  "version": "6.1.2",
-  "description": "Type-safe, lossless round-trip conversion between OpenDocument Format packages (odt, ods, odp) and JSON, hand-written and dependency-minimal, built on Zod 4 codecs.",
+  "version": "6.2.0",
+  "description": "Type-safe, lossless round-trip conversion between OpenDocument Format packages (odt, ods, odp) and JSON, plus read support for the pre-OASIS OpenOffice.org 1.x documents ODF was based on (sxw, sxc, sxi, sxd), hand-written and dependency-minimal, built on Zod 4 codecs.",
   "type": "module",
   "repository": {
     "type": "git",
@@ -72,6 +72,12 @@
     "odt",
     "ods",
     "odp",
+    "sxw",
+    "sxc",
+    "sxi",
+    "sxd",
+    "openoffice",
+    "staroffice",
     "round-trip",
     "zod",
     "codec"
@@ -79,7 +85,7 @@
   "license": "MIT",
   "packageManager": "pnpm@11.6.0",
   "dependencies": {
-    "document-schema.js": "^5.3.0",
+    "document-schema.js": "^5.4.0",
     "fast-xml-parser": "^5.10.1",
     "fflate": "^0.8.3",
     "zod": "^4.4.3"