hybridtm 0.6.0 → 0.7.0

package/dist/xliffHandler.js

@@ -10,17 +10,11 @@
  *     Maxprograms - initial API and implementation
  *******************************************************************************/
 import { createWriteStream } from "node:fs";
-import { CData, TextNode, XMLElement } from "typesxml";
+import { XliffGroup, XliffMeta, XliffMrk, XliffPc, XliffSegment, XliffSource, XliffTarget } from "typesxliff";
 import { DEFAULT_IMPORT_OPTIONS, resolveImportOptions } from './importOptions.js';
-import { Utils } from './utils.js';
 export class XLIFFHandler {
-    inCdData = false;
-    currentCData = new CData('');
-    stack = [];
     srcLang = '';
     tgtLang = '';
-    original = '';
-    fileId = '';
     writeStream;
     completionPromise;
     entryCount = 0;
@@ -33,172 +27,84 @@ export class XLIFFHandler {
         });
         this.options = resolveImportOptions(options);
     }
-    setGrammar(grammar) {
-        // do nothing
-    }
     getEntryCount() {
         return this.entryCount;
     }
     waitForCompletion() {
         return this.completionPromise;
     }
-    initialize() {
-        this.stack = new Array();
-        this.inCdData = false;
-    }
-    setCatalog(catalog) {
-        // do nothing
-    }
-    startDocument() {
-        // do nothing
-    }
-    endDocument() {
-        // Close the write stream when document ends
+    process(document) {
+        this.srcLang = document.getSrcLang();
+        this.tgtLang = document.getTrgLang() ?? '';
+        document.getFiles().forEach((file) => {
+            const fileId = file.getId();
+            const original = file.getOriginal() ?? '';
+            this.collectUnits(file.getEntries()).forEach((unit) => {
+                this.processUnit(fileId, original, unit);
+            });
+        });
         this.writeStream.end();
     }
-    xmlDeclaration(version, encoding, standalone) {
-        // do nothing
-    }
-    startElement(name, atts) {
-        const element = new XMLElement(name);
-        atts.forEach((att) => {
-            element.setAttribute(att);
-        });
-        if ("xliff" === name) {
-            const version = element.getAttribute("version");
-            if (!version || !version.getValue().startsWith("2.")) {
-                throw new Error("Unsupported XLIFF version");
-            }
-            const srcLang = element.getAttribute("srcLang");
-            if (!srcLang) {
-                throw new Error("Missing @srcLang attribute in <xliff>");
+    collectUnits(entries) {
+        const units = [];
+        entries.forEach((entry) => {
+            if (entry instanceof XliffGroup) {
+                units.push(...this.collectUnits(entry.getEntries()));
             }
-            const trgLang = element.getAttribute("trgLang");
-            if (!trgLang) {
-                throw new Error("Missing @trgLang attribute in <xliff>");
+            else {
+                units.push(entry);
             }
-            this.srcLang = srcLang.getValue();
-            this.tgtLang = trgLang.getValue();
-        }
-        if ("file" === name) {
-            const original = element.getAttribute("original");
-            this.original = original ? original.getValue() : '';
-            const id = element.getAttribute("id");
-            if (!id) {
-                throw new Error("Missing @id attribute in <file>");
+        });
+        return units;
+    }
+    processUnit(fileId, original, unit) {
+        const unitId = unit.getId();
+        const items = unit.getItems();
+        const segmentItems = items.filter((item) => item instanceof XliffSegment);
+        const segments = this.buildSegments(fileId, unitId, unit, segmentItems);
+        if (segmentItems.length === 1) {
+            // A unit with exactly one <segment> has no distinct "whole unit" content:
+            // store one entry, framed as the unit entry, filtered/annotated using the
+            // same criteria (state, skipEmpty, skipUnconfirmed, metadata) a segment
+            // entry would use.
+            if (segments.length === 1) {
+                this.writeUnitEntry(fileId, original, unitId, items, segments[0].metadata, segments[0].segmentId);
             }
-            this.fileId = id.getValue();
-        }
-        if (this.stack.length > 0) {
-            this.stack[this.stack.length - 1].addElement(element);
-        }
-        this.stack.push(element);
-    }
-    endElement(name) {
-        if ("unit" === name) {
-            const unit = this.stack[this.stack.length - 1];
-            this.processUnit(unit);
-        }
-        this.stack.pop();
-    }
-    internalSubset(declaration) {
-        // do nothing
-    }
-    characters(ch) {
-        if (this.inCdData) {
-            this.currentCData.setValue(this.currentCData.getValue() + ch);
             return;
         }
-        const textNode = new TextNode(ch);
-        // ignore characters outside of elements
-        if (this.stack.length > 0) {
-            this.stack[this.stack.length - 1].addTextNode(textNode);
-        }
-    }
-    ignorableWhitespace(ch) {
-        const textNode = new TextNode(ch);
-        // ignore characters outside of elements
-        if (this.stack.length > 0) {
-            this.stack[this.stack.length - 1].addTextNode(textNode);
-        }
-    }
-    comment(ch) {
-        // do nothing
-    }
-    processingInstruction(target, data) {
-        // do nothing
-    }
-    startCDATA() {
-        this.inCdData = true;
-    }
-    endCDATA() {
-        this.inCdData = false;
-    }
-    startDTD(name, publicId, systemId) {
-        // do nothing
-    }
-    endDTD() {
-        // do nothing
-    }
-    skippedEntity(name) {
-        // do nothing
-    }
-    processUnit(unit) {
-        const id = unit.getAttribute('id');
-        if (!id) {
-            throw new Error('Missing @id attribute in <unit>');
-        }
-        const unitId = id.getValue();
-        const segmentElements = unit.getChildren().filter((child) => child.getName() === 'segment');
-        let segments = [];
-        if (segmentElements.length > 0) {
-            segments = this.buildSegments(unitId, unit, segmentElements);
-            if (segments.length === 0) {
-                return;
-            }
-        }
-        else {
-            const fallback = this.buildSingleSegment(unitId, unit);
-            if (!fallback) {
-                return;
-            }
-            segments = [fallback];
-        }
         const segmentCount = segments.length;
         segments.forEach((segment, index) => {
             const segmentIndex = index + 1;
-            this.writeSegmentEntries(unitId, segmentIndex, segmentCount, segment);
+            this.writeSegmentEntries(fileId, original, unitId, segmentIndex, segmentCount, segment);
         });
-        if (segmentCount > 1) {
-            this.writeMergedEntry(unitId, segments);
-        }
+        this.writeUnitEntry(fileId, original, unitId, items);
     }
-    buildSegments(unitId, unit, segmentElements) {
+    buildSegments(fileId, unitId, unit, segmentItems) {
         const segments = [];
-        segmentElements.forEach((segment) => {
-            const processed = this.buildSegmentData(unitId, unit, segment);
+        segmentItems.forEach((segment) => {
+            const processed = this.buildSegmentData(fileId, unitId, unit, segment);
             if (processed) {
                 segments.push(processed);
             }
         });
         return segments;
     }
-    buildSegmentData(unitId, unit, segment) {
-        const sourceElement = segment.getChild('source');
-        const targetElement = segment.getChild('target');
+    buildSegmentData(fileId, unitId, unit, segment) {
+        const sourceElement = segment.getSource();
+        const targetElement = segment.getTarget();
         if (!sourceElement || !targetElement) {
             return null;
         }
-        const pureSource = Utils.getPureText(sourceElement);
-        const pureTarget = Utils.getPureText(targetElement);
+        const pureSource = XLIFFHandler.getPureText(sourceElement.getContent());
+        const pureTarget = XLIFFHandler.getPureText(targetElement.getContent());
         if (pureSource.trim().length === 0) {
             return null;
         }
         if (this.options.skipEmpty && pureTarget.trim().length === 0) {
             return null;
         }
-        const rawState = segment.getAttribute('state')?.getValue();
-        const stateRank = this.getStateRank(rawState);
+        const state = segment.getState();
+        const stateRank = this.getStateRank(state);
         const minRank = this.getStateRankFromOption(this.options.minState);
         if (stateRank > 0 && stateRank < minRank) {
             return null;
@@ -206,9 +112,9 @@ export class XLIFFHandler {
         if (stateRank === 0 && this.options.skipUnconfirmed) {
             return null;
         }
-        const segmentId = segment.getAttribute('id')?.getValue();
+        const segmentId = segment.getId();
         const metadata = this.options.extractMetadata
-            ? this.extractMetadata(unitId, unit, segment, rawState, segmentId)
+            ? this.extractMetadata(fileId, unitId, unit, segment, state, segmentId)
             : undefined;
         return {
             source: sourceElement,
@@ -219,80 +125,46 @@ export class XLIFFHandler {
             segmentId
         };
     }
-    buildSingleSegment(unitId, unit) {
-        const combinedSource = new XMLElement('source');
-        const combinedTarget = new XMLElement('target');
-        unit.getChildren().forEach((child) => {
-            if (child.getName() === 'segment' || child.getName() === 'ignorable') {
-                const source = child.getChild('source');
-                if (source) {
-                    this.appendElementContent(combinedSource, source);
-                }
-                const target = child.getChild('target');
-                if (target) {
-                    this.appendElementContent(combinedTarget, target);
-                }
-            }
-        });
-        const pureSource = Utils.getPureText(combinedSource);
-        const pureTarget = Utils.getPureText(combinedTarget);
-        if (pureSource.trim().length === 0) {
-            return null;
-        }
-        if (this.options.skipEmpty && pureTarget.trim().length === 0) {
-            return null;
-        }
-        const metadata = this.options.extractMetadata
-            ? this.extractMetadata(unitId, unit, unit)
-            : undefined;
-        return {
-            source: combinedSource,
-            target: combinedTarget,
-            pureSource,
-            pureTarget,
-            metadata
-        };
-    }
-    writeSegmentEntries(unitId, segmentIndex, segmentCount, segment) {
-        const metadata = this.applySegmentPosition(segment.metadata, unitId, segment.segmentId, segmentIndex, segmentCount);
+    writeSegmentEntries(fileId, original, unitId, segmentIndex, segmentCount, segment) {
+        const metadata = this.applySegmentPosition(segment.metadata, fileId, unitId, segment.segmentId, segmentIndex, segmentCount);
         this.writeEntry({
             language: this.srcLang,
-            fileId: this.fileId,
+            fileId,
             unitId,
-            original: this.original,
+            original,
             pureText: segment.pureSource,
-            element: segment.source.toString(),
+            element: segment.source.toElement().toString(),
             segmentIndex,
             segmentCount,
             metadata
         });
         this.writeEntry({
             language: this.tgtLang,
-            fileId: this.fileId,
+            fileId,
             unitId,
-            original: this.original,
+            original,
             pureText: segment.pureTarget,
-            element: segment.target.toString(),
+            element: segment.target.toElement().toString(),
             segmentIndex,
             segmentCount,
             metadata
         });
     }
-    applySegmentPosition(metadata, unitId, explicitSegmentId, segmentIndex, segmentCount) {
+    applySegmentPosition(metadata, fileId, unitId, explicitSegmentId, segmentIndex, segmentCount) {
         if (!metadata) {
             return undefined;
         }
         if (!metadata.segment) {
             metadata.segment = {
                 provider: 'xliff',
-                fileId: this.fileId,
+                fileId,
                 unitId,
                 segmentId: explicitSegmentId
             };
         }
         else {
             metadata.segment.provider = metadata.segment.provider || 'xliff';
-            metadata.segment.fileId = metadata.segment.fileId || this.fileId;
+            metadata.segment.fileId = metadata.segment.fileId || fileId;
             metadata.segment.unitId = metadata.segment.unitId || unitId;
             if (!metadata.segment.segmentId && explicitSegmentId) {
                 metadata.segment.segmentId = explicitSegmentId;
@@ -305,42 +177,68 @@ export class XLIFFHandler {
         metadata.segment.segmentCount = segmentCount;
         return metadata;
     }
-    writeMergedEntry(unitId, segments) {
-        const mergedSource = new XMLElement('source');
-        const mergedTarget = new XMLElement('target');
-        segments.forEach((segment) => {
-            this.appendElementContent(mergedSource, segment.source);
-            this.appendElementContent(mergedTarget, segment.target);
-        });
-        const pureSource = Utils.getPureText(mergedSource);
-        const pureTarget = Utils.getPureText(mergedTarget);
+    writeUnitEntry(fileId, original, unitId, items, metadata, segmentId) {
+        const mergedSource = this.mergeSource(items);
+        const mergedTarget = this.mergeTarget(items);
+        const pureSource = XLIFFHandler.getPureText(mergedSource.getContent());
+        const pureTarget = XLIFFHandler.getPureText(mergedTarget.getContent());
         if (pureSource.trim().length === 0) {
             return;
         }
         if (this.options.skipEmpty && pureTarget.trim().length === 0) {
             return;
         }
+        const segmentCount = items.filter((item) => item instanceof XliffSegment).length;
+        const resolvedMetadata = this.applySegmentPosition(metadata, fileId, unitId, segmentId, 0, segmentCount);
         this.writeEntry({
             language: this.srcLang,
-            fileId: this.fileId,
+            fileId,
             unitId,
-            original: this.original,
+            original,
             pureText: pureSource,
-            element: mergedSource.toString(),
+            element: mergedSource.toElement().toString(),
             segmentIndex: 0,
-            segmentCount: segments.length
+            segmentCount,
+            metadata: resolvedMetadata
         });
         this.writeEntry({
             language: this.tgtLang,
-            fileId: this.fileId,
+            fileId,
             unitId,
-            original: this.original,
+            original,
             pureText: pureTarget,
-            element: mergedTarget.toString(),
+            element: mergedTarget.toElement().toString(),
             segmentIndex: 0,
-            segmentCount: segments.length
+            segmentCount,
+            metadata: resolvedMetadata
         });
     }
+    mergeSource(items) {
+        const merged = new XliffSource();
+        items.forEach((item) => {
+            const source = item.getSource();
+            if (source) {
+                merged.getContent().push(...source.getContent());
+            }
+        });
+        return merged;
+    }
+    mergeTarget(items) {
+        // @order re-sequences a target relative to the source when a unit is resegmented
+        // differently on the target side; items without @order keep their document position.
+        const ordered = items
+            .map((item, index) => ({ item, position: item.getTarget()?.getOrder() ?? (index + 1) }))
+            .filter((entry) => entry.item.getTarget() !== undefined)
+            .sort((a, b) => Number(a.position) - Number(b.position));
+        const merged = new XliffTarget();
+        ordered.forEach(({ item }) => {
+            const target = item.getTarget();
+            if (target) {
+                merged.getContent().push(...target.getContent());
+            }
+        });
+        return merged;
+    }
     writeEntry(entry) {
         const payload = {
             language: entry.language,
@@ -361,42 +259,31 @@ export class XLIFFHandler {
     hasMetadata(metadata) {
         return !!metadata && Object.keys(metadata).length > 0;
     }
-    appendElementContent(target, element) {
-        const content = element.getContent();
-        content.forEach((node) => {
-            if (node instanceof TextNode) {
-                target.addTextNode(node);
-            }
-            else if (node instanceof XMLElement) {
-                target.addElement(node);
-            }
-        });
-    }
-    extractMetadata(unitId, unit, segment, rawState, segmentId) {
+    extractMetadata(fileId, unitId, unit, segment, state, segmentId) {
         const metadata = {};
-        if (this.isTranslationState(rawState)) {
-            metadata.state = rawState;
+        if (this.isTranslationState(state)) {
+            metadata.state = state;
         }
-        const subState = this.readSubState(segment);
+        const subState = segment.getSubState();
         if (subState) {
             metadata.subState = subState;
         }
-        this.assignMetadataString(metadata, 'creationDate', this.readAttribute(segment, 'creationDate') || this.readAttribute(unit, 'creationDate'));
-        this.assignMetadataString(metadata, 'creationId', this.readAttribute(segment, 'creationId') || this.readAttribute(unit, 'creationId'));
-        this.assignMetadataString(metadata, 'changeDate', this.readAttribute(segment, 'changeDate') || this.readAttribute(unit, 'changeDate'));
-        this.assignMetadataString(metadata, 'changeId', this.readAttribute(segment, 'changeId') || this.readAttribute(unit, 'changeId'));
-        this.assignMetadataString(metadata, 'creationTool', this.readAttribute(segment, 'creationTool') || this.readAttribute(unit, 'creationTool'));
-        this.assignMetadataString(metadata, 'creationToolVersion', this.readAttribute(segment, 'creationToolVersion') || this.readAttribute(unit, 'creationToolVersion'));
-        this.assignMetadataString(metadata, 'context', this.readAttribute(segment, 'context') || this.readAttribute(unit, 'context'));
+        const unitAttrs = unit.getOtherAttributes();
+        const segmentAttrs = segment.getOtherAttributes();
+        this.assignMetadataString(metadata, 'creationDate', this.readOtherAttribute(segmentAttrs, 'creationDate') || this.readOtherAttribute(unitAttrs, 'creationDate'));
+        this.assignMetadataString(metadata, 'creationId', this.readOtherAttribute(segmentAttrs, 'creationId') || this.readOtherAttribute(unitAttrs, 'creationId'));
+        this.assignMetadataString(metadata, 'changeDate', this.readOtherAttribute(segmentAttrs, 'changeDate') || this.readOtherAttribute(unitAttrs, 'changeDate'));
+        this.assignMetadataString(metadata, 'changeId', this.readOtherAttribute(segmentAttrs, 'changeId') || this.readOtherAttribute(unitAttrs, 'changeId'));
+        this.assignMetadataString(metadata, 'creationTool', this.readOtherAttribute(segmentAttrs, 'creationTool') || this.readOtherAttribute(unitAttrs, 'creationTool'));
+        this.assignMetadataString(metadata, 'creationToolVersion', this.readOtherAttribute(segmentAttrs, 'creationToolVersion') || this.readOtherAttribute(unitAttrs, 'creationToolVersion'));
+        this.assignMetadataString(metadata, 'context', this.readOtherAttribute(segmentAttrs, 'context') || this.readOtherAttribute(unitAttrs, 'context'));
         const notes = [];
         this.collectNotes(unit, notes);
-        this.collectNotes(segment, notes);
         if (notes.length > 0) {
             metadata.notes = notes;
         }
         const properties = {};
         this.collectMetadataProperties(unit, properties);
-        this.collectMetadataProperties(segment, properties);
         if (Object.keys(properties).length > 0) {
             metadata.properties = properties;
             if (!metadata.context) {
@@ -408,7 +295,7 @@ export class XLIFFHandler {
         }
         metadata.segment = {
             provider: 'xliff',
-            fileId: this.fileId,
+            fileId,
             unitId,
             segmentId
         };
@@ -419,78 +306,47 @@ export class XLIFFHandler {
             metadata[key] = value;
         }
     }
-    readAttribute(element, name) {
-        const attribute = element.getAttribute(name);
+    readOtherAttribute(otherAttributes, name) {
+        const attribute = otherAttributes.find((att) => att.getName() === name);
         if (!attribute) {
             return undefined;
         }
         const value = attribute.getValue();
         return value && value.length > 0 ? value : undefined;
     }
-    readSubState(segment) {
-        const direct = this.readAttribute(segment, 'subState');
-        if (direct) {
-            return direct;
-        }
-        const target = segment.getChild('target');
-        if (target) {
-            const targetValue = this.readAttribute(target, 'subState');
-            if (targetValue) {
-                return targetValue;
-            }
-        }
-        const source = segment.getChild('source');
-        if (source) {
-            const sourceValue = this.readAttribute(source, 'subState');
-            if (sourceValue) {
-                return sourceValue;
-            }
-        }
-        return undefined;
-    }
-    collectNotes(element, accumulator) {
-        element.getChildren().forEach((child) => {
-            if (child.getName() === 'notes') {
-                child.getChildren().forEach((noteElement) => {
-                    if (noteElement.getName() === 'note') {
-                        const value = Utils.getPureText(noteElement).trim();
-                        if (value.length > 0) {
-                            accumulator.push(value);
-                        }
-                    }
-                });
+    collectNotes(unit, accumulator) {
+        const notes = unit.getNotes()?.getNotes() ?? [];
+        notes.forEach((note) => {
+            const value = note.getText().trim();
+            if (value.length > 0) {
+                accumulator.push(value);
             }
         });
     }
-    collectMetadataProperties(element, properties) {
-        element.getChildren().forEach((child) => {
-            const name = child.getName();
-            if (name.endsWith('metadata')) {
-                child.getChildren().forEach((metaGroup) => {
-                    if (!metaGroup.getName().endsWith('metaGroup')) {
-                        return;
-                    }
-                    const category = metaGroup.getAttribute('category')?.getValue();
-                    metaGroup.getChildren().forEach((meta) => {
-                        if (!meta.getName().endsWith('meta')) {
-                            return;
-                        }
-                        const typeValue = meta.getAttribute('type')?.getValue();
-                        const key = category ? category + ':' + (typeValue || '') : (typeValue || '');
-                        const content = Utils.getPureText(meta).trim();
-                        if (key.length > 0 && content.length > 0) {
-                            properties[key] = content;
-                        }
-                    });
-                });
+    collectMetadataProperties(unit, properties) {
+        const metaGroups = unit.getMetadata()?.getMetaGroups() ?? [];
+        metaGroups.forEach((metaGroup) => this.collectFromMetaGroup(metaGroup, properties));
+    }
+    collectFromMetaGroup(metaGroup, properties) {
+        const category = metaGroup.getCategory();
+        metaGroup.getItems().forEach((item) => {
+            if (item instanceof XliffMeta) {
+                const key = category ? category + ':' + item.getType() : item.getType();
+                const content = item.getText().trim();
+                if (key.length > 0 && content.length > 0) {
+                    properties[key] = content;
+                }
+            }
+            else {
+                this.collectFromMetaGroup(item, properties);
             }
         });
     }
-    getStateRank(rawState) {
-        if (!this.isTranslationState(rawState)) {
+    getStateRank(state) {
+        if (!this.isTranslationState(state)) {
             return 0;
         }
-        return this.getStateRankFromOption(rawState);
+        return this.getStateRankFromOption(state);
     }
     getStateRankFromOption(state) {
         if (!state) {
@@ -515,18 +371,18 @@ export class XLIFFHandler {
             || value === 'reviewed'
             || value === 'final';
     }
-    getGrammar() {
-        return undefined;
-    }
-    getCurrentText() {
-        let test = '';
-        let content = this.stack.length > 0 ? this.stack[this.stack.length - 1].getContent() : [];
-        content.forEach((node) => {
-            if (node instanceof TextNode) {
-                test += node.getValue();
+    static getPureText(content) {
+        let text = '';
+        content.forEach((item) => {
+            if (typeof item === 'string') {
+                text += item;
+            }
+            else if (item instanceof XliffPc || item instanceof XliffMrk) {
+                text += XLIFFHandler.getPureText(item.getContent());
             }
+            // ph, sc, ec, sm, em and cp purposely ignored, matching prior pure-text extraction
         });
-        return test;
+        return text;
     }
 }
 //# sourceMappingURL=xliffHandler.js.map