@fin.cx/einvoice 6.2.0 → 7.0.1

package/dist_ts/formats/validation/schematron.validator.js

@@ -1,151 +1,162 @@
 import * as plugins from '../../plugins.js';
-import { loadSaxonJS } from '../../vendor/saxonjs.js';
 /**
- * Schematron validation engine using Saxon-JS
- * Provides official standards validation through Schematron rules
+ * Turns one failed assertion or fired report into a ValidationResult.
+ */
+export function schematronFailureToValidationResult(failure) {
+    const flag = (failure.flag || failure.role || '').toLowerCase();
+    let severity = failure.kind === 'assert' ? 'error' : 'warning';
+    if (flag.includes('fatal') || flag.includes('error')) {
+        severity = 'error';
+    }
+    else if (flag.includes('warning')) {
+        severity = 'warning';
+    }
+    else if (flag.includes('info')) {
+        severity = 'info';
+    }
+    const btMatch = failure.message.match(/\[BT-(\d+)\]/);
+    const bgMatch = failure.message.match(/\[BG-(\d+)\]/);
+    return {
+        ruleId: failure.id || failure.patternId || 'UNKNOWN',
+        source: 'SCHEMATRON',
+        severity,
+        message: failure.message,
+        syntaxPath: failure.location,
+        expected: failure.test,
+        btReference: btMatch ? `BT-${btMatch[1]}` : undefined,
+        bgReference: bgMatch ? `BG-${bgMatch[1]}` : undefined,
+    };
+}
+/**
+ * Turns a whole report into results. An expression the engine could not evaluate has
+ * proven nothing, so it is reported as an error rather than passing silently.
+ */
+export function schematronReportToValidationResults(report) {
+    return [
+        ...report.failures.map(schematronFailureToValidationResult),
+        ...report.engineErrors.map((engineError) => ({
+            ruleId: 'SCHEMATRON-ENGINE-ERROR',
+            source: 'SCHEMATRON',
+            severity: 'error',
+            message: `${engineError.message} (at ${engineError.origin})`,
+            expected: engineError.expression,
+        })),
+    ];
+}
+/**
+ * Applies the reporting options of a validation call to a result list.
+ */
+export function applySchematronOptions(results, options) {
+    const filtered = options.includeWarnings
+        ? results
+        : results.filter((result) => result.severity !== 'warning');
+    if (options.maxErrors &&
+        filtered.filter((result) => result.severity === 'error').length > options.maxErrors) {
+        return filtered.slice(0, options.maxErrors);
+    }
+    return filtered;
+}
+/**
+ * Schematron validation engine.
+ *
+ * The rules are interpreted on the XPath engine of `@push.rocks/smartxml`, so the
+ * published `.sch` files of CEN, KoSIT and PEPPOL run as they are downloaded; no
+ * XSLT processor and no precompiled stylesheet is involved.
  */
 export class SchematronValidator {
     schematronRules;
-    sourceKind = 'none';
-    stylesheetFileName;
-    stylesheetInternal;
+    schema;
+    schemaError;
+    baseUri;
+    /** one compiled schema per activated phase; a phase selects patterns at compile time */
+    schemasByPhase = new Map();
     constructor(schematronRules) {
         this.schematronRules = schematronRules || '';
+        if (this.schematronRules) {
+            this.compile();
+        }
     }
     /**
      * Load Schematron rules from file or string
      */
     async loadSchematron(source, isFilePath = true) {
-        let sourceContent;
-        if (isFilePath) {
-            sourceContent = await plugins.fs.readFile(source, 'utf-8');
-        }
-        else {
-            sourceContent = source;
-        }
-        this.schematronRules = sourceContent;
-        this.sourceKind = this.detectSourceKind(source, sourceContent, isFilePath);
-        this.stylesheetFileName = undefined;
-        this.stylesheetInternal = undefined;
-        if (this.sourceKind === 'sef') {
-            if (isFilePath) {
-                this.stylesheetFileName = source;
-            }
-            else {
-                this.stylesheetInternal = JSON.parse(sourceContent);
-            }
-        }
+        this.schematronRules = isFilePath ? await plugins.fs.readFile(source, 'utf-8') : source;
+        this.baseUri = isFilePath ? source : undefined;
+        this.compile();
     }
     /**
-     * Validate an XML document against loaded Schematron rules
+     * Compiles the loaded rules. A schema that does not compile keeps its reason, so
+     * validate() can report it instead of load failing far from the cause.
      */
-    async validate(xmlContent, options = {}) {
-        if (!this.schematronRules) {
-            throw new Error('No Schematron rules loaded');
+    compile() {
+        this.schema = undefined;
+        this.schemaError = undefined;
+        this.schemasByPhase.clear();
+        const trimmed = this.schematronRules.trim();
+        if (!trimmed) {
+            return;
         }
-        const results = [];
-        if (!this.canValidate()) {
-            return [this.createUnavailableResult()];
+        if (trimmed.startsWith('{')) {
+            this.schemaError =
+                'the source is a compiled XSLT stylesheet (SEF); load the Schematron .sch file instead, it is executed directly';
+            return;
         }
         try {
-            const transformOptions = {
-                sourceText: xmlContent,
-                destination: 'serialized',
-                stylesheetParams: options.parameters || {}
-            };
-            if (this.stylesheetFileName) {
-                transformOptions.stylesheetFileName = this.stylesheetFileName;
-            }
-            else {
-                transformOptions.stylesheetInternal = this.stylesheetInternal;
-            }
-            // Transform the XML with a precompiled Saxon-JS SEF stylesheet.
-            const SaxonJS = await loadSaxonJS();
-            const transformResult = await SaxonJS.transform(transformOptions, 'async');
-            // Parse the SVRL (Schematron Validation Report Language) output
-            results.push(...this.parseSVRL(transformResult.principalResult));
-            // Apply options filters
-            if (!options.includeWarnings) {
-                return results.filter(r => r.severity !== 'warning');
-            }
-            if (options.maxErrors && results.filter(r => r.severity === 'error').length > options.maxErrors) {
-                return results.slice(0, options.maxErrors);
-            }
-            return results;
+            this.schema = this.compileForPhase(undefined);
+            this.schemasByPhase.set('', this.schema);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            results.push({
-                ruleId: 'SCHEMATRON-ERROR',
-                source: 'SCHEMATRON',
-                severity: 'error',
-                message: `Schematron validation failed: ${errorMessage}`,
-                btReference: undefined,
-                bgReference: undefined
-            });
-            return results;
+            this.schemaError = error instanceof Error ? error.message : String(error);
         }
     }
+    compileForPhase(phase) {
+        return plugins.smartxmlSchematron.Schematron.fromString(this.schematronRules, {
+            phase,
+            baseUri: this.baseUri,
+            // the published rule sets split their patterns over sch:include files
+            resolveInclude: (href, base) => plugins.readFileSync(plugins.path.resolve(plugins.path.dirname(base ?? this.baseUri ?? '.'), href), 'utf-8'),
+        });
+    }
     /**
-     * Parse SVRL output to ValidationResult array
+     * The schema for one phase. A phase activates a subset of the patterns, which the
+     * engine resolves while compiling, so each phase gets its own compiled schema.
      */
-    parseSVRL(svrlXml) {
-        const results = [];
-        // Parse SVRL XML
-        const parser = new plugins.xmldom.DOMParser();
-        const doc = parser.parseFromString(svrlXml, 'text/xml');
-        // Get all failed assertions and successful reports
-        const failedAsserts = doc.getElementsByTagName('svrl:failed-assert');
-        const successfulReports = doc.getElementsByTagName('svrl:successful-report');
-        // Process failed assertions (these are errors)
-        for (let i = 0; i < failedAsserts.length; i++) {
-            const assert = failedAsserts[i];
-            const result = this.extractValidationResult(assert, 'error');
-            if (result)
-                results.push(result);
-        }
-        // Process successful reports (these can be warnings or info)
-        for (let i = 0; i < successfulReports.length; i++) {
-            const report = successfulReports[i];
-            const result = this.extractValidationResult(report, 'warning');
-            if (result)
-                results.push(result);
+    schemaForPhase(phase) {
+        const key = phase ?? '';
+        const cached = this.schemasByPhase.get(key);
+        if (cached) {
+            return cached;
         }
-        return results;
+        const compiled = this.compileForPhase(phase);
+        this.schemasByPhase.set(key, compiled);
+        return compiled;
     }
     /**
-     * Extract ValidationResult from SVRL element
+     * Validate an XML document against loaded Schematron rules
      */
-    extractValidationResult(element, defaultSeverity) {
-        const text = element.getElementsByTagName('svrl:text')[0]?.textContent || '';
-        const location = element.getAttribute('location') || undefined;
-        const test = element.getAttribute('test') || '';
-        const id = element.getAttribute('id') || element.getAttribute('role') || 'UNKNOWN';
-        const flag = element.getAttribute('flag') || defaultSeverity;
-        // Determine severity from flag attribute
-        let severity = defaultSeverity;
-        if (flag.toLowerCase().includes('fatal') || flag.toLowerCase().includes('error')) {
-            severity = 'error';
+    async validate(xmlContent, options = {}) {
+        if (!this.schematronRules) {
+            throw new Error('No Schematron rules loaded');
         }
-        else if (flag.toLowerCase().includes('warning')) {
-            severity = 'warning';
+        if (!this.schema) {
+            return [this.createUnusableResult()];
         }
-        else if (flag.toLowerCase().includes('info')) {
-            severity = 'info';
+        let results = [];
+        try {
+            results = schematronReportToValidationResults(this.schemaForPhase(options.phase).validate(xmlContent));
         }
-        // Extract BT/BG references if present
-        const btMatch = text.match(/\[BT-(\d+)\]/);
-        const bgMatch = text.match(/\[BG-(\d+)\]/);
-        return {
-            ruleId: id,
-            source: 'EN16931',
-            severity,
-            message: text,
-            syntaxPath: location,
-            btReference: btMatch ? `BT-${btMatch[1]}` : undefined,
-            bgReference: bgMatch ? `BG-${bgMatch[1]}` : undefined,
-            profile: 'EN16931'
-        };
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return [
+                {
+                    ruleId: 'SCHEMATRON-ERROR',
+                    source: 'SCHEMATRON',
+                    severity: 'error',
+                    message: `Schematron validation failed: ${errorMessage}`,
+                },
+            ];
+        }
+        return applySchematronOptions(results, options);
     }
     /**
      * Check if validator has rules loaded
@@ -154,31 +165,18 @@ export class SchematronValidator {
         return !!this.schematronRules;
     }
     /**
-     * Check if loaded rules can be executed by Saxon-JS.
+     * Check whether the loaded rules compiled and can be executed.
      */
     canValidate() {
-        return this.sourceKind === 'sef' && Boolean(this.stylesheetFileName || this.stylesheetInternal);
-    }
-    detectSourceKind(source, sourceContent, isFilePath) {
-        const trimmed = sourceContent.trim();
-        if (!trimmed) {
-            return 'none';
-        }
-        if (isFilePath && /\.sef\.json$/i.test(source)) {
-            return 'sef';
-        }
-        if (trimmed.startsWith('{')) {
-            return 'sef';
-        }
-        return 'schematron';
+        return Boolean(this.schema);
     }
-    createUnavailableResult() {
+    createUnusableResult() {
         return {
-            ruleId: 'SCHEMATRON-UNCOMPILED',
+            ruleId: 'SCHEMATRON-UNUSABLE',
             source: 'SCHEMATRON',
             severity: 'error',
-            message: 'Schematron validation requires a precompiled Saxon-JS SEF JSON stylesheet. Raw .sch files are loaded for inspection only and are not executed.',
-            remediation: 'Compile Schematron rules to .sef.json with Saxon tooling and load the compiled SEF resource.'
+            message: `Schematron rules could not be compiled: ${this.schemaError ?? 'the source is empty'}`,
+            remediation: 'Load a Schematron schema whose sch:include files sit next to it.',
         };
     }
     /**
@@ -275,7 +273,7 @@ export class HybridValidator {
         }
         // Deduplicate results by ruleId
         const seen = new Set();
-        return results.filter(r => {
+        return results.filter((r) => {
             if (seen.has(r.ruleId))
                 return false;
             seen.add(r.ruleId);
@@ -283,4 +281,4 @@ export class HybridValidator {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schematron.validator.js","sourceRoot":"","sources":["../../../ts/formats/validation/schematron.validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,WAAW,EAA+D,MAAM,yBAAyB,CAAC;AAcnH;;;GAGG;AACH,MAAM,OAAO,mBAAmB;IACtB,eAAe,CAAS;IACxB,UAAU,GAA0B,MAAM,CAAC;IAC3C,kBAAkB,CAAU;IAC5B,kBAAkB,CAAW;IAErC,YAAY,eAAwB;QAClC,IAAI,CAAC,eAAe,GAAG,eAAe,IAAI,EAAE,CAAC;IAC/C,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,cAAc,CAAC,MAAc,EAAE,aAAsB,IAAI;QACpE,IAAI,aAAqB,CAAC;QAE1B,IAAI,UAAU,EAAE,CAAC;YACf,aAAa,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC7D,CAAC;aAAM,CAAC;YACN,aAAa,GAAG,MAAM,CAAC;QACzB,CAAC;QAED,IAAI,CAAC,eAAe,GAAG,aAAa,CAAC;QACrC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC;QAC3E,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;QACpC,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;QAEpC,IAAI,IAAI,CAAC,UAAU,KAAK,KAAK,EAAE,CAAC;YAC9B,IAAI,UAAU,EAAE,CAAC;gBACf,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC;YACnC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,QAAQ,CACnB,UAAkB,EAClB,UAA6B,EAAE;QAE/B,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAChD,CAAC;QAED,MAAM,OAAO,GAAuB,EAAE,CAAC;QAEvC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;YACxB,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;QAC1C,CAAC;QAED,IAAI,CAAC;YACH,MAAM,gBAAgB,GAA6B;gBACjD,UAAU,EAAE,UAAU;gBACtB,WAAW,EAAE,YAAY;gBACzB,gBAAgB,EAAE,OAAO,CAAC,UAAU,IAAI,EAAE;aAC3C,CAAC;YAEF,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC5B,gBAAgB,CAAC,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC;YAChE,CAAC;iBAAM,CAAC;gBACN,gBAAgB,CAAC,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC;YAChE,CAAC;YAED,gEAAgE;YAChE,MAAM,OAAO,GAAG,MAAM,WAAW,EAAE,CAAC;YACpC,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,gBAAgB,EAAE,OAAO,CAA4B,CAAC;YAEtG,gEAAgE;YAChE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC;YAEjE,wBAAwB;YACxB,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;gBAC7B,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC;YACvD,CAAC;YAED,IAAI,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;gBAChG,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;YAC7C,CAAC;YAED,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC5E,OAAO,CAAC,IAAI,CAAC;gBACX,MAAM,EAAE,kBAAkB;gBAC1B,MAAM,EAAE,YAAY;gBACpB,QAAQ,EAAE,OAAO;gBACjB,OAAO,EAAE,iCAAiC,YAAY,EAAE;gBACxD,WAAW,EAAE,SAAS;gBACtB,WAAW,EAAE,SAAS;aACvB,CAAC,CAAC;YACH,OAAO,OAAO,CAAC;QACjB,CAAC;IACH,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,OAAe;QAC/B,MAAM,OAAO,GAAuB,EAAE,CAAC;QAEvC,iBAAiB;QACjB,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;QAC9C,MAAM,GAAG,GAAG,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QAExD,mDAAmD;QACnD,MAAM,aAAa,GAAG,GAAG,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,CAAC;QACrE,MAAM,iBAAiB,GAAG,GAAG,CAAC,oBAAoB,CAAC,wBAAwB,CAAC,CAAC;QAE7E,+CAA+C;QAC/C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;YAChC,MAAM,MAAM,GAAG,IAAI,CAAC,uBAAuB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC7D,IAAI,MAAM;gBAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnC,CAAC;QAED,6DAA6D;QAC7D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAClD,MAAM,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC;YACpC,MAAM,MAAM,GAAG,IAAI,CAAC,uBAAuB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YAC/D,IAAI,MAAM;gBAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnC,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACK,uBAAuB,CAC7B,OAAgB,EAChB,eAAoC;QAEpC,MAAM,IAAI,GAAG,OAAO,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,IAAI,EAAE,CAAC;QAC7E,MAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,SAAS,CAAC;QAC/D,MAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAChD,MAAM,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC;QACnF,MAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,eAAe,CAAC;QAE7D,yCAAyC;QACzC,IAAI,QAAQ,GAAiC,eAAe,CAAC;QAC7D,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YACjF,QAAQ,GAAG,OAAO,CAAC;QACrB,CAAC;aAAM,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;YAClD,QAAQ,GAAG,SAAS,CAAC;QACvB,CAAC;aAAM,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/C,QAAQ,GAAG,MAAM,CAAC;QACpB,CAAC;QAED,sCAAsC;QACtC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QAE3C,OAAO;YACL,MAAM,EAAE,EAAE;YACV,MAAM,EAAE,SAAS;YACjB,QAAQ;YACR,OAAO,EAAE,IAAI;YACb,UAAU,EAAE,QAAQ;YACpB,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS;YACrD,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS;YACrD,OAAO,EAAE,SAAS;SACnB,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,QAAQ;QACb,OAAO,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO,IAAI,CAAC,UAAU,KAAK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAClG,CAAC;IAEO,gBAAgB,CAAC,MAAc,EAAE,aAAqB,EAAE,UAAmB;QACjF,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,EAAE,CAAC;QACrC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,IAAI,UAAU,IAAI,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/C,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,uBAAuB;QAC7B,OAAO;YACL,MAAM,EAAE,uBAAuB;YAC/B,MAAM,EAAE,YAAY;YACpB,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,gJAAgJ;YACzJ,WAAW,EAAE,8FAA8F;SAC5G,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,SAAS;QACpB,IAAI,CAAC,IAAI,CAAC,eAAe;YAAE,OAAO,EAAE,CAAC;QAErC,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;QAC9C,MAAM,GAAG,GAAG,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;QACrE,MAAM,MAAM,GAAG,GAAG,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAErD,MAAM,UAAU,GAAa,EAAE,CAAC;QAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YACxC,IAAI,EAAE;gBAAE,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC9B,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,iBAAiB,CAC5B,UAAkB,EAClB,KAAa,EACb,UAA6B,EAAE;QAE/B,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IAC1D,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,QAAwD;IAExD,MAAM,SAAS,GAAG,IAAI,mBAAmB,EAAE,CAAC;IAE5C,gDAAgD;IAChD,mEAAmE;IACnE,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,SAAS;YACZ,sDAAsD;YACtD,MAAM,SAAS,CAAC,cAAc,CAAC,iEAAiE,CAAC,CAAC;YAClG,MAAM;QACR,KAAK,WAAW;YACd,mDAAmD;YACnD,MAAM,SAAS,CAAC,cAAc,CAAC,qEAAqE,CAAC,CAAC;YACtG,MAAM;QACR,KAAK,QAAQ;YACX,kDAAkD;YAClD,MAAM,SAAS,CAAC,cAAc,CAAC,4DAA4D,CAAC,CAAC;YAC7F,MAAM;QACR,KAAK,SAAS;YACZ,+CAA+C;YAC/C,MAAM,SAAS,CAAC,cAAc,CAAC,sEAAsE,CAAC,CAAC;YACvG,MAAM;IACV,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,eAAe;IAClB,mBAAmB,CAAsB;IACzC,YAAY,GAA6D,EAAE,CAAC;IAEpF,YAAY,mBAAyC;QACnD,IAAI,CAAC,mBAAmB,GAAG,mBAAmB,IAAI,IAAI,mBAAmB,EAAE,CAAC;IAC9E,CAAC;IAED;;OAEG;IACI,cAAc,CAAC,SAA4D;QAChF,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,QAAQ,CACnB,UAAkB,EAClB,UAA6B,EAAE;QAE/B,MAAM,OAAO,GAAuB,EAAE,CAAC;QAEvC,sDAAsD;QACtD,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YAC1C,IAAI,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;YAClD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC5E,OAAO,CAAC,IAAI,CAAC,wBAAwB,YAAY,EAAE,CAAC,CAAC;YACvD,CAAC;QACH,CAAC;QAED,yCAAyC;QACzC,IAAI,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,EAAE,CAAC;YACxC,IAAI,CAAC;gBACH,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBACvF,OAAO,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC,CAAC;YACrC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC5E,OAAO,CAAC,IAAI,CAAC,iCAAiC,YAAY,EAAE,CAAC,CAAC;YAChE,CAAC;QACH,CAAC;QAED,gCAAgC;QAChC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;QAC/B,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;YACxB,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;gBAAE,OAAO,KAAK,CAAC;YACrC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;YACnB,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schematron.validator.js","sourceRoot":"","sources":["../../../ts/formats/validation/schematron.validator.ts"],"names":[],"mappings":"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"}

package/dist_ts/formats/validation/schematron.worker.d.ts

@@ -1,5 +1,5 @@
 import type { ValidationResult } from './validation.types.js';
-import type { SchematronOptions } from './schematron.validator.js';
+import { type SchematronOptions } from './schematron.validator.js';
 export interface ISchematronWorkerPoolInitializeOptions {
     isFilePath?: boolean;
 }
@@ -12,18 +12,25 @@ export declare class SchematronWorkerPool {
     private availableWorkers;
     private taskQueue;
     private maxWorkers;
-    private stylesheetFileName?;
-    private stylesheetInternal?;
+    private schematronSource?;
+    private baseUri?;
+    /** the task each busy worker is holding, so a thread that dies fails its task */
+    private tasksByWorker;
     constructor(maxWorkers?: number);
     /**
      * Initialize worker pool
      */
-    initialize(stylesheetSource: string, options?: ISchematronWorkerPoolInitializeOptions): Promise<void>;
-    private loadStylesheet;
+    initialize(schematronSource: string, options?: ISchematronWorkerPoolInitializeOptions): Promise<void>;
+    private loadSchematron;
     /**
      * Create a new worker
      */
     private createWorker;
+    /**
+     * Drops a thread that died, failing the task it was holding so no caller waits
+     * for an answer that can never come.
+     */
+    private retireWorker;
     /**
      * Validate XML using worker pool
      */
@@ -32,10 +39,6 @@ export declare class SchematronWorkerPool {
      * Process queued validation tasks
      */
     private processTasks;
-    /**
-     * Parse SVRL output
-     */
-    private parseSVRL;
     /**
      * Terminate all workers
      */