hybridtm 0.3.0 → 0.5.0

package/dist/xliffhandler.js

@@ -1,522 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2025-2026 Maxprograms.
- *
- * This program and the accompanying materials
- * are made available under the terms of the Eclipse   License 1.0
- * which accompanies this distribution, and is available at
- * https://www.eclipse.org/org/documents/epl-v10.html
- *
- * Contributors:
- *     Maxprograms - initial API and implementation
- *******************************************************************************/
-import { createWriteStream } from "node:fs";
-import { CData, TextNode, XMLElement } from "typesxml";
-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;
-    options;
-    constructor(tempFilePath, options = DEFAULT_IMPORT_OPTIONS) {
-        this.writeStream = createWriteStream(tempFilePath, { encoding: 'utf8' });
-        this.completionPromise = new Promise((resolve, reject) => {
-            this.writeStream.once('finish', resolve);
-            this.writeStream.once('error', reject);
-        });
-        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
-        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>");
-            }
-            const trgLang = element.getAttribute("trgLang");
-            if (!trgLang) {
-                throw new Error("Missing @trgLang attribute in <xliff>");
-            }
-            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>");
-            }
-            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);
-        });
-        if (segmentCount > 1) {
-            this.writeMergedEntry(unitId, segments);
-        }
-    }
-    buildSegments(unitId, unit, segmentElements) {
-        const segments = [];
-        segmentElements.forEach((segment) => {
-            const processed = this.buildSegmentData(unitId, unit, segment);
-            if (processed) {
-                segments.push(processed);
-            }
-        });
-        return segments;
-    }
-    buildSegmentData(unitId, unit, segment) {
-        const sourceElement = segment.getChild('source');
-        const targetElement = segment.getChild('target');
-        if (!sourceElement || !targetElement) {
-            return null;
-        }
-        const pureSource = Utils.getPureText(sourceElement);
-        const pureTarget = Utils.getPureText(targetElement);
-        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 minRank = this.getStateRankFromOption(this.options.minState);
-        if (stateRank > 0 && stateRank < minRank) {
-            return null;
-        }
-        if (stateRank === 0 && this.options.skipUnconfirmed) {
-            return null;
-        }
-        const segmentId = segment.getAttribute('id')?.getValue();
-        const metadata = this.options.extractMetadata
-            ? this.extractMetadata(unitId, unit, segment, rawState, segmentId)
-            : undefined;
-        return {
-            source: sourceElement,
-            target: targetElement,
-            pureSource,
-            pureTarget,
-            metadata,
-            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);
-        this.writeEntry({
-            language: this.srcLang,
-            fileId: this.fileId,
-            unitId,
-            original: this.original,
-            pureText: segment.pureSource,
-            element: segment.source.toString(),
-            segmentIndex,
-            segmentCount,
-            metadata
-        });
-        this.writeEntry({
-            language: this.tgtLang,
-            fileId: this.fileId,
-            unitId,
-            original: this.original,
-            pureText: segment.pureTarget,
-            element: segment.target.toString(),
-            segmentIndex,
-            segmentCount,
-            metadata
-        });
-    }
-    applySegmentPosition(metadata, unitId, explicitSegmentId, segmentIndex, segmentCount) {
-        if (!metadata) {
-            return undefined;
-        }
-        if (!metadata.segment) {
-            metadata.segment = {
-                provider: 'xliff',
-                fileId: this.fileId,
-                unitId,
-                segmentId: explicitSegmentId
-            };
-        }
-        else {
-            metadata.segment.provider = metadata.segment.provider || 'xliff';
-            metadata.segment.fileId = metadata.segment.fileId || this.fileId;
-            metadata.segment.unitId = metadata.segment.unitId || unitId;
-            if (!metadata.segment.segmentId && explicitSegmentId) {
-                metadata.segment.segmentId = explicitSegmentId;
-            }
-        }
-        if (!metadata.segment.segmentId && segmentIndex > 0) {
-            metadata.segment.segmentId = explicitSegmentId || segmentIndex.toString();
-        }
-        metadata.segment.segmentIndex = segmentIndex;
-        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);
-        if (pureSource.trim().length === 0) {
-            return;
-        }
-        if (this.options.skipEmpty && pureTarget.trim().length === 0) {
-            return;
-        }
-        this.writeEntry({
-            language: this.srcLang,
-            fileId: this.fileId,
-            unitId,
-            original: this.original,
-            pureText: pureSource,
-            element: mergedSource.toString(),
-            segmentIndex: 0,
-            segmentCount: segments.length
-        });
-        this.writeEntry({
-            language: this.tgtLang,
-            fileId: this.fileId,
-            unitId,
-            original: this.original,
-            pureText: pureTarget,
-            element: mergedTarget.toString(),
-            segmentIndex: 0,
-            segmentCount: segments.length
-        });
-    }
-    writeEntry(entry) {
-        const payload = {
-            language: entry.language,
-            fileId: entry.fileId,
-            original: entry.original,
-            unitId: entry.unitId,
-            pureText: entry.pureText,
-            element: entry.element,
-            segmentIndex: entry.segmentIndex,
-            segmentCount: entry.segmentCount
-        };
-        if (this.hasMetadata(entry.metadata)) {
-            payload.metadata = entry.metadata;
-        }
-        this.writeStream.write(JSON.stringify(payload) + '\n');
-        this.entryCount++;
-    }
-    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) {
-        const metadata = {};
-        if (this.isTranslationState(rawState)) {
-            metadata.state = rawState;
-        }
-        const subState = this.readSubState(segment);
-        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 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) {
-                const contextKey = Object.keys(properties).find((key) => key.toLowerCase().includes('context'));
-                if (contextKey) {
-                    metadata.context = properties[contextKey];
-                }
-            }
-        }
-        metadata.segment = {
-            provider: 'xliff',
-            fileId: this.fileId,
-            unitId,
-            segmentId
-        };
-        return metadata;
-    }
-    assignMetadataString(metadata, key, value) {
-        if (value && value.length > 0) {
-            metadata[key] = value;
-        }
-    }
-    readAttribute(element, name) {
-        const attribute = element.getAttribute(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);
-                        }
-                    }
-                });
-            }
-        });
-    }
-    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;
-                        }
-                    });
-                });
-            }
-        });
-    }
-    getStateRank(rawState) {
-        if (!this.isTranslationState(rawState)) {
-            return 0;
-        }
-        return this.getStateRankFromOption(rawState);
-    }
-    getStateRankFromOption(state) {
-        if (!state) {
-            return 0;
-        }
-        switch (state) {
-            case 'initial':
-                return 0;
-            case 'translated':
-                return 1;
-            case 'reviewed':
-                return 2;
-            case 'final':
-                return 3;
-            default:
-                return 0;
-        }
-    }
-    isTranslationState(value) {
-        return value === 'initial'
-            || value === 'translated'
-            || value === 'reviewed'
-            || value === 'final';
-    }
-    getGrammar() {
-        return undefined;
-    }
-}
-//# sourceMappingURL=xliffHandler.js.map

package/dist/xliffreader.d.ts

@@ -1,25 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2025-2026 Maxprograms.
- *
- * This program and the accompanying materials
- * are made available under the terms of the Eclipse   License 1.0
- * which accompanies this distribution, and is available at
- * https://www.eclipse.org/org/documents/epl-v10.html
- *
- * Contributors:
- *     Maxprograms - initial API and implementation
- *******************************************************************************/
-import { SAXParser } from "typesxml";
-import { ImportOptions } from './importOptions.js';
-import { XLIFFHandler } from './xliffHandler.js';
-export declare class XLIFFReader {
-    parser: SAXParser;
-    tempFilePath: string;
-    handler: XLIFFHandler;
-    filePath: string;
-    private readonly options;
-    constructor(filePath: string, options?: ImportOptions);
-    parse(): Promise<void>;
-    getTempFilePath(): string;
-    getEntryCount(): number;
-}

package/dist/xliffreader.js

@@ -1,50 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2025-2026 Maxprograms.
- *
- * This program and the accompanying materials
- * are made available under the terms of the Eclipse   License 1.0
- * which accompanies this distribution, and is available at
- * https://www.eclipse.org/org/documents/epl-v10.html
- *
- * Contributors:
- *     Maxprograms - initial API and implementation
- *******************************************************************************/
-import { tmpdir } from "node:os";
-import { join } from 'node:path';
-import { SAXParser } from "typesxml";
-import { DEFAULT_IMPORT_OPTIONS, resolveImportOptions } from './importOptions.js';
-import { XLIFFHandler } from './xliffHandler.js';
-export class XLIFFReader {
-    parser;
-    tempFilePath;
-    handler;
-    filePath;
-    options;
-    constructor(filePath, options = DEFAULT_IMPORT_OPTIONS) {
-        this.filePath = filePath;
-        this.options = resolveImportOptions(options);
-        // Generate temp file path
-        const tempDir = tmpdir();
-        const tempFileName = 'xliff_' + Date.now() + '_' + Math.random().toString(36).substring(7) + '.jsonl';
-        this.tempFilePath = join(tempDir, tempFileName);
-        this.parser = new SAXParser();
-        this.handler = new XLIFFHandler(this.tempFilePath, this.options);
-        this.parser.setContentHandler(this.handler);
-    }
-    async parse() {
-        try {
-            this.parser.parseFile(this.filePath);
-            await this.handler.waitForCompletion();
-        }
-        catch (error) {
-            throw error instanceof Error ? error : new Error(String(error));
-        }
-    }
-    getTempFilePath() {
-        return this.tempFilePath;
-    }
-    getEntryCount() {
-        return this.handler.getEntryCount();
-    }
-}
-//# sourceMappingURL=xliffReader.js.map

package/dist/xlifftest.d.ts

@@ -1,54 +0,0 @@
-export declare class XLIFFTest {
-    private static readonly NAME;
-    private static readonly DB_PATH;
-    private static readonly SAMPLE_XLIFF;
-    runTest(): Promise<void>;
-    private resetEnvironment;
-    private verifyEntry;
-    private expectTranslationMatch;
-    private expectConcordanceMatch;
-    private verifyMetadataRoundtrip;
-    private assertMetadataEquals;
-}
-/*******************************************************************************
- 
-Follow the steps to create a translation project from your DITA map
-
-I need to edit the name or description of a translation memory
-
-How do I add more target languages to my project?
-
-What should I do after updating my DITA content?
-
-Export a memory as a TMX file to save the translation data
-
-Associate existing memories with the new project to reuse translations
-
-I want to permanently remove a project from the system
-
-Select a name and location for the TMX file containing memory data
-
-Import a TMX file into a memory from the command line
-
-Fluenta recovers exact matches from translations stored in the previous cycle
-
-You don't need to pay again for translation of content that didn't change
-
-A company specialized in providing translation and localization services
-
-Before using the Command Line Interface you must start Fluenta from the GUI at least once
-
-Create a JSON file containing the data required for creating the memory
-
-An XLIFF file is generated for each selected target language
-
-Check your email and register the evaluation key using the instructions
-
-Additional configurations can be added by the user as required
-
-Use the buttons in the dialog to update the configuration file
-
-The configuration file is automatically updated as you add or remove elements
-
-Avoid using folders that could be modified by other programs while you work
-*/