@docx4j/core-ts 0.1.0

package/dist/parts/wml/index.mjs

@@ -0,0 +1,213 @@
+import { XmlPart } from '../XmlPart.mjs';
+import { ContentTypes } from '../../opc/ContentTypes.mjs';
+import { Namespaces } from '../Namespaces.mjs';
+import { DefaultXmlPart } from '../DefaultXmlPart.mjs';
+import { ThemePart } from '../dml/index.mjs';
+import { Body } from '../../model/content/Body.mjs';
+import { Docx4JException } from '../../opc/exceptions.mjs';
+const bodies = new WeakMap();
+/** The Body view of a part's block-level container, one per container object. */
+function bodyOf(part, container, prefix) {
+    if (!container)
+        throw new Docx4JException(`${part.partName} has no content yet; await getContents() first, or set contents`);
+    let body = bodies.get(container);
+    if (!body) {
+        body = new Body(part, container, prefix, part.package);
+        bodies.set(container, body);
+    }
+    return body;
+}
+const W = Namespaces.NS_WORD12;
+const W15 = 'http://schemas.microsoft.com/office/word/2012/wordml';
+const W16CID = 'http://schemas.microsoft.com/office/word/2016/wordml/cid';
+const WNE = 'http://schemas.microsoft.com/office/word/2006/wordml';
+/**
+ * Shared by the main document and the glossary document (docx4j DocumentPart): the shortcuts
+ * to styles, numbering, fonts, settings, theme, comments and notes.
+ */
+export class DocumentPart extends XmlPart {
+    setPartShortcut(part, relationshipType) {
+        switch (relationshipType) {
+            case Namespaces.STYLES:
+                this.styleDefinitionsPart = part;
+                return true;
+            case Namespaces.NUMBERING:
+                this.numberingDefinitionsPart = part;
+                return true;
+            case Namespaces.FONT_TABLE:
+                this.fontTablePart = part;
+                return true;
+            case Namespaces.THEME:
+                this.themePart = part;
+                return true;
+            case Namespaces.SETTINGS:
+                this.documentSettingsPart = part;
+                return true;
+            case Namespaces.WEB_SETTINGS:
+                this.webSettingsPart = part;
+                return true;
+            case Namespaces.COMMENTS:
+                this.commentsPart = part;
+                return true;
+            case Namespaces.COMMENTS_EXTENDED:
+                this.commentsExtendedPart = part;
+                return true;
+            case Namespaces.COMMENTS_IDS:
+                this.commentsIdsPart = part;
+                return true;
+            case Namespaces.FOOTNOTES:
+                this.footnotesPart = part;
+                return true;
+            case Namespaces.ENDNOTES:
+                this.endnotesPart = part;
+                return true;
+            case Namespaces.OFFICE_2011_PEOPLE:
+                this.peoplePart = part;
+                return true;
+            default: return false;
+        }
+    }
+    /** Header parts related from this document, in relationship order. */
+    get headerParts() {
+        return this.targets(Namespaces.HEADER);
+    }
+    get footerParts() {
+        return this.targets(Namespaces.FOOTER);
+    }
+    targets(relationshipType) {
+        const rp = this.relationshipsPart;
+        if (!rp)
+            return [];
+        return rp.getRelationshipsByType(relationshipType).map((r) => rp.getPart(r)).filter((p) => p !== undefined);
+    }
+}
+/** `/word/document.xml` (docx4j MainDocumentPart). */
+export class MainDocumentPart extends DocumentPart {
+    constructor(partName = '/word/document.xml', contentType = ContentTypes.WORDPROCESSINGML_DOCUMENT) {
+        super(partName, contentType, Namespaces.DOCUMENT, { namespaceURI: W, localPart: 'document' });
+    }
+    setPartShortcut(part, relationshipType) {
+        if (relationshipType === Namespaces.GLOSSARY_DOCUMENT) {
+            this.glossaryDocumentPart = part;
+            return true;
+        }
+        return super.setPartShortcut(part, relationshipType);
+    }
+    /** The Office JS-shaped view of `w:body`; the part must be unmarshalled (`getBody()` does that). */
+    get body() {
+        var _a;
+        const doc = this.contents;
+        (_a = doc.body) !== null && _a !== void 0 ? _a : (doc.body = { TYPE_NAME: 'org_docx4j_wml.Body' });
+        return bodyOf(this, doc.body, 'body');
+    }
+    async getBody() {
+        await this.getContents();
+        return this.body;
+    }
+}
+/** `/word/glossary/document.xml` (docx4j GlossaryDocumentPart). */
+export class GlossaryDocumentPart extends DocumentPart {
+    constructor(partName = '/word/glossary/document.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_GLOSSARYDOCUMENT, Namespaces.GLOSSARY_DOCUMENT, { namespaceURI: W, localPart: 'glossaryDocument' });
+    }
+}
+export class StyleDefinitionsPart extends XmlPart {
+    constructor(partName = '/word/styles.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_STYLES, Namespaces.STYLES, { namespaceURI: W, localPart: 'styles' });
+    }
+}
+export class NumberingDefinitionsPart extends XmlPart {
+    constructor(partName = '/word/numbering.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_NUMBERING, Namespaces.NUMBERING, { namespaceURI: W, localPart: 'numbering' });
+    }
+}
+export class FontTablePart extends XmlPart {
+    constructor(partName = '/word/fontTable.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_FONTTABLE, Namespaces.FONT_TABLE, { namespaceURI: W, localPart: 'fonts' });
+    }
+}
+export class DocumentSettingsPart extends XmlPart {
+    constructor(partName = '/word/settings.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_SETTINGS, Namespaces.SETTINGS, { namespaceURI: W, localPart: 'settings' });
+    }
+}
+export class WebSettingsPart extends XmlPart {
+    constructor(partName = '/word/webSettings.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_WEBSETTINGS, Namespaces.WEB_SETTINGS, { namespaceURI: W, localPart: 'webSettings' });
+    }
+}
+export class HeaderPart extends XmlPart {
+    constructor(partName = '/word/header1.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_HEADER, Namespaces.HEADER, { namespaceURI: W, localPart: 'hdr' });
+    }
+    /** The header's content as a Body; addresses are 'header:<relId>/n'. */
+    get body() {
+        var _a, _b;
+        return bodyOf(this, this.contents, `header:${(_b = (_a = this.sourceRelationship) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : this.partName.fileName}`);
+    }
+    async getBody() {
+        await this.getContents();
+        return this.body;
+    }
+}
+export class FooterPart extends XmlPart {
+    constructor(partName = '/word/footer1.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_FOOTER, Namespaces.FOOTER, { namespaceURI: W, localPart: 'ftr' });
+    }
+    /** The footer's content as a Body; addresses are 'footer:<relId>/n'. */
+    get body() {
+        var _a, _b;
+        return bodyOf(this, this.contents, `footer:${(_b = (_a = this.sourceRelationship) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : this.partName.fileName}`);
+    }
+    async getBody() {
+        await this.getContents();
+        return this.body;
+    }
+}
+export class FootnotesPart extends XmlPart {
+    constructor(partName = '/word/footnotes.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_FOOTNOTES, Namespaces.FOOTNOTES, { namespaceURI: W, localPart: 'footnotes' });
+    }
+}
+export class EndnotesPart extends XmlPart {
+    constructor(partName = '/word/endnotes.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_ENDNOTES, Namespaces.ENDNOTES, { namespaceURI: W, localPart: 'endnotes' });
+    }
+}
+export class CommentsPart extends XmlPart {
+    constructor(partName = '/word/comments.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_COMMENTS, Namespaces.COMMENTS, { namespaceURI: W, localPart: 'comments' });
+    }
+}
+export class CommentsExtendedPart extends XmlPart {
+    constructor(partName = '/word/commentsExtended.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_COMMENTS_EXTENDED, Namespaces.COMMENTS_EXTENDED, { namespaceURI: W15, localPart: 'commentsEx' });
+    }
+}
+export class CommentsIdsPart extends XmlPart {
+    constructor(partName = '/word/commentsIds.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_COMMENTS_IDS, Namespaces.COMMENTS_IDS, { namespaceURI: W16CID, localPart: 'commentsIds' });
+    }
+}
+export class PeoplePart extends XmlPart {
+    constructor(partName = '/word/people.xml') {
+        super(partName, ContentTypes.WORDPROCESSINGML_PEOPLE, Namespaces.OFFICE_2011_PEOPLE, { namespaceURI: W15, localPart: 'people' });
+    }
+}
+export class KeyMapCustomizationsPart extends XmlPart {
+    constructor(partName = '/word/customizations.xml') {
+        super(partName, ContentTypes.MS_WORD_KEYMAP, Namespaces.KEYMAP, { namespaceURI: WNE, localPart: 'tcg' });
+    }
+}
+export class VbaDataPart extends XmlPart {
+    constructor(partName = '/word/vbaData.xml') {
+        super(partName, ContentTypes.OFFICEDOCUMENT_VBA_DATA, Namespaces.VBA_DATA_WORD, { namespaceURI: WNE, localPart: 'vbaSuppData' });
+    }
+}
+/** A VML drawing (`/word/vmlDrawing1.vml`, docx4j VMLPart), as a DOM: the root `<xml>` is docx4j's own wrapper, not typed here yet. */
+export class VMLPart extends DefaultXmlPart {
+    constructor(partName) {
+        super(partName, ContentTypes.VML_DRAWING, Namespaces.VML);
+    }
+}
+export { ThemePart };

package/dist/xml/dom.d.mts

@@ -0,0 +1,22 @@
+/** The declaration docx4j writes on every XML part. */
+export declare const XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
+/** Parses XML text to a DOM document; throws on malformed input. */
+export declare function parseXml(text: string): Document;
+/** Serialises a node (document or element) without an XML declaration. */
+export declare function serializeXml(node: Node): string;
+export declare function createDocument(): Document;
+/** XML declaration plus the serialised document element, as one string. */
+export declare function serializeXmlPart(node: Node): string;
+/** UTF-8 bytes of a string. */
+export declare function encodeText(text: string): Uint8Array;
+/**
+ * Text of an XML part's bytes: honours a UTF-8 or UTF-16 byte order mark, else assumes UTF-8
+ * (the only encoding Office writes without a BOM). The BOM is not part of the result.
+ */
+export declare function decodeXmlText(bytes: Uint8Array): string;
+/** Removes an XML declaration (and a leading BOM) from XML text. */
+export declare function stripXmlDeclaration(text: string): string;
+export declare function base64Encode(bytes: Uint8Array): string;
+export declare function base64Decode(text: string): Uint8Array;
+/** Element children of a node, in order. */
+export declare function childElements(node: Node): Element[];

package/dist/xml/dom.mjs

@@ -0,0 +1,92 @@
+// DOM, text and base64 helpers over the runtime's DOM implementation. In Node the runtime brings
+// @xmldom/xmldom; in browsers it uses the native DOM. Jsonix.DOM is not in the runtime's typings
+// yet (a jsonix CR candidate), hence the cast here, kept to this one module.
+import { Jsonix } from '@docx4j/generated-objects-ts';
+const DOM = Jsonix.DOM;
+/** The declaration docx4j writes on every XML part. */
+export const XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+/** Parses XML text to a DOM document; throws on malformed input. */
+export function parseXml(text) {
+    return DOM.parse(text);
+}
+/** Serialises a node (document or element) without an XML declaration. */
+export function serializeXml(node) {
+    return DOM.serialize(node);
+}
+export function createDocument() {
+    return DOM.createDocument();
+}
+/** XML declaration plus the serialised document element, as one string. */
+export function serializeXmlPart(node) {
+    const el = node.nodeType === 9 ? node.documentElement : node;
+    return XML_DECLARATION + serializeXml(el);
+}
+const utf8Encoder = new TextEncoder();
+/** UTF-8 bytes of a string. */
+export function encodeText(text) {
+    return utf8Encoder.encode(text);
+}
+/**
+ * Text of an XML part's bytes: honours a UTF-8 or UTF-16 byte order mark, else assumes UTF-8
+ * (the only encoding Office writes without a BOM). The BOM is not part of the result.
+ */
+export function decodeXmlText(bytes) {
+    if (bytes.length >= 2) {
+        if (bytes[0] === 0xff && bytes[1] === 0xfe)
+            return new TextDecoder('utf-16le').decode(bytes.subarray(2));
+        if (bytes[0] === 0xfe && bytes[1] === 0xff)
+            return new TextDecoder('utf-16be').decode(bytes.subarray(2));
+    }
+    if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        return new TextDecoder('utf-8').decode(bytes.subarray(3));
+    }
+    return new TextDecoder('utf-8').decode(bytes);
+}
+/** Removes an XML declaration (and a leading BOM) from XML text. */
+export function stripXmlDeclaration(text) {
+    return text.replace(/^\uFEFF?\s*<\?xml[^>]*\?>\s*/, '');
+}
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const B64_LOOKUP = new Uint8Array(128);
+for (let i = 0; i < B64.length; i++)
+    B64_LOOKUP[B64.charCodeAt(i)] = i;
+export function base64Encode(bytes) {
+    let out = '';
+    let i = 0;
+    for (; i + 2 < bytes.length; i += 3) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        out += B64[n >> 18] + B64[(n >> 12) & 63] + B64[(n >> 6) & 63] + B64[n & 63];
+    }
+    if (i < bytes.length) {
+        const n = (bytes[i] << 16) | ((i + 1 < bytes.length ? bytes[i + 1] : 0) << 8);
+        out += B64[n >> 18] + B64[(n >> 12) & 63] + (i + 1 < bytes.length ? B64[(n >> 6) & 63] : '=') + '=';
+    }
+    return out;
+}
+export function base64Decode(text) {
+    const clean = text.replace(/[^A-Za-z0-9+/]/g, '');
+    const out = new Uint8Array(Math.floor((clean.length * 3) / 4));
+    let o = 0;
+    for (let i = 0; i < clean.length; i += 4) {
+        const a = B64_LOOKUP[clean.charCodeAt(i)];
+        const b = i + 1 < clean.length ? B64_LOOKUP[clean.charCodeAt(i + 1)] : 0;
+        const c = i + 2 < clean.length ? B64_LOOKUP[clean.charCodeAt(i + 2)] : 0;
+        const d = i + 3 < clean.length ? B64_LOOKUP[clean.charCodeAt(i + 3)] : 0;
+        const n = (a << 18) | (b << 12) | (c << 6) | d;
+        if (o < out.length)
+            out[o++] = (n >> 16) & 255;
+        if (i + 2 < clean.length && o < out.length)
+            out[o++] = (n >> 8) & 255;
+        if (i + 3 < clean.length && o < out.length)
+            out[o++] = n & 255;
+    }
+    return out.subarray(0, o);
+}
+/** Element children of a node, in order. */
+export function childElements(node) {
+    const out = [];
+    for (let c = node.firstChild; c; c = c.nextSibling)
+        if (c.nodeType === 1)
+            out.push(c);
+    return out;
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@docx4j/core-ts",
+  "version": "0.1.0",
+  "description": "docx4j-core for TypeScript: Open Packaging (docx/pptx/xlsx zip and flat OPC), typed parts and relationships, style, numbering and font resolution over @docx4j/generated-objects-ts. Node, browsers, Word add-ins.",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./opc": {
+      "types": "./dist/opc/index.d.mts",
+      "import": "./dist/opc/index.mjs"
+    },
+    "./parts": {
+      "types": "./dist/parts/index.d.mts",
+      "import": "./dist/parts/index.mjs"
+    },
+    "./packages": {
+      "types": "./dist/packages/index.d.mts",
+      "import": "./dist/packages/index.mjs"
+    },
+    "./model": {
+      "types": "./dist/model/index.d.mts",
+      "import": "./dist/model/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "npm run build && tsc -p test/nodenext/tsconfig.json && node --test test/*.test.mjs",
+    "prepublishOnly": "npm run typecheck && npm test"
+  },
+  "keywords": [
+    "docx4j",
+    "ooxml",
+    "openxml",
+    "office open xml",
+    "docx",
+    "pptx",
+    "xlsx",
+    "opc",
+    "wordprocessingml",
+    "office-js",
+    "word-addin",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/plutext/docx4j-core-ts.git"
+  },
+  "homepage": "https://github.com/plutext/docx4j-core-ts",
+  "bugs": {
+    "url": "https://github.com/plutext/docx4j-core-ts/issues"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@docx4j/generated-objects-ts": "^0.1.1",
+    "fflate": "^0.8.2"
+  },
+  "devDependencies": {
+    "typescript": "~5.6.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}