@fin.cx/einvoice 5.2.0 → 5.2.1

package/ts/formats/pdf/pdf.extractor.ts

@@ -1,9 +1,4 @@
-import {
-  BaseXMLExtractor,
-  StandardXMLExtractor,
-  AssociatedFilesExtractor,
-  TextXMLExtractor
-} from './extractors/index.js';
+import type { BaseXMLExtractor } from './extractors/base.extractor.js';
 import { FormatDetector } from '../utils/format.detector.js';
 import { InvoiceFormat } from '../../interfaces/common.js';
 
@@ -36,18 +31,30 @@ export interface PDFExtractResult {
  * Uses multiple specialized extractors in sequence to maximize success rate
  */
 export class PDFExtractor {
-  private extractors: BaseXMLExtractor[] = [];
+  private extractors?: BaseXMLExtractor[];
 
   /**
    * Constructor initializes the chain of extractors
    */
-  constructor() {
-    // Add extractors in order of preference/likelihood of success
-    this.extractors.push(
-      new StandardXMLExtractor(),      // Standard PDF/A-3 embedded files
-      new AssociatedFilesExtractor(),  // Associated files (ZUGFeRD v1, some Factur-X)
-      new TextXMLExtractor()           // Text-based extraction (fallback)
-    );
+  constructor() {}
+
+  private async getExtractors(): Promise<BaseXMLExtractor[]> {
+    if (!this.extractors) {
+      const [standardModule, associatedModule, textModule] = await Promise.all([
+        import('./extractors/standard.extractor.js'),
+        import('./extractors/associated.extractor.js'),
+        import('./extractors/text.extractor.js')
+      ]);
+
+      // Add extractors in order of preference/likelihood of success
+      this.extractors = [
+        new standardModule.StandardXMLExtractor(),      // Standard PDF/A-3 embedded files
+        new associatedModule.AssociatedFilesExtractor(), // Associated files (ZUGFeRD v1, some Factur-X)
+        new textModule.TextXMLExtractor()               // Text-based extraction (fallback)
+      ];
+    }
+
+    return this.extractors;
   }
 
   /**
@@ -69,7 +76,8 @@ export class PDFExtractor {
       const pdfBufferArray = Buffer.isBuffer(pdfBuffer) ? new Uint8Array(pdfBuffer) : pdfBuffer;
 
       // Try each extractor in sequence
-      for (const extractor of this.extractors) {
+      const extractors = await this.getExtractors();
+      for (const extractor of extractors) {
         const extractorName = extractor.constructor.name;
         console.log(`Trying extraction with ${extractorName}...`);
 
@@ -138,4 +146,4 @@ export class PDFExtractor {
       }
     };
   }
-}
+}

package/ts/formats/validation/schematron.downloader.ts

@@ -79,7 +79,6 @@ export const SCHEMATRON_SOURCES: Record<string, SchematronSource[]> = {
  */
 export class SchematronDownloader {
   private cacheDir: string;
-  private smartfile: any;
   
   constructor(cacheDir: string = 'assets_downloaded/schematron') {
     this.cacheDir = cacheDir;
@@ -90,7 +89,6 @@ export class SchematronDownloader {
    */
   public async initialize(): Promise<void> {
     // Ensure cache directory exists
-    this.smartfile = await import('@push.rocks/smartfile');
     await fs.mkdir(this.cacheDir, { recursive: true });
   }
   

package/ts/formats/validation/schematron.integration.ts

@@ -61,10 +61,13 @@ export class IntegratedValidator {
     try {
       await fs.access(schematronPath);
     } catch {
-      throw new Error(`Schematron file not found: ${schematronPath}. Run 'npm run download-schematron' first.`);
+      throw new Error(`Schematron file not found: ${schematronPath}. Run 'pnpm run download-schematron' first.`);
     }
     
     await this.schematronValidator.loadSchematron(schematronPath, true);
+    if (!this.schematronValidator.canValidate()) {
+      throw new Error(`Schematron file is not a precompiled Saxon-JS SEF resource: ${schematronPath}`);
+    }
     this.schematronLoaded = true;
   }
   

package/ts/formats/validation/schematron.validator.ts

@@ -1,5 +1,6 @@
 import * as plugins from '../../plugins.js';
 import type { ValidationResult } from './validation.types.js';
+import { loadSaxonJS, type ISaxonJSTransformOptions, type ISaxonJSTransformResult } from '../../vendor/saxonjs.js';
 
 /**
  * Schematron validation options
@@ -11,14 +12,17 @@ export interface SchematronOptions {
   maxErrors?: number; // Maximum errors before stopping
 }
 
+type TSchematronSourceKind = 'none' | 'schematron' | 'sef';
+
 /**
  * Schematron validation engine using Saxon-JS
  * Provides official standards validation through Schematron rules
  */
 export class SchematronValidator {
-  private compiledStylesheet: any;
   private schematronRules: string;
-  private isCompiled: boolean = false;
+  private sourceKind: TSchematronSourceKind = 'none';
+  private stylesheetFileName?: string;
+  private stylesheetInternal?: unknown;
   
   constructor(schematronRules?: string) {
     this.schematronRules = schematronRules || '';
@@ -28,42 +32,25 @@ export class SchematronValidator {
    * Load Schematron rules from file or string
    */
   public async loadSchematron(source: string, isFilePath: boolean = true): Promise<void> {
+    let sourceContent: string;
+
     if (isFilePath) {
-      this.schematronRules = await plugins.fs.readFile(source, 'utf-8');
+      sourceContent = await plugins.fs.readFile(source, 'utf-8');
     } else {
-      // Use provided string
-      this.schematronRules = source;
+      sourceContent = source;
     }
-    
-    // Reset compilation state
-    this.isCompiled = false;
-  }
-  
-  /**
-   * Compile Schematron to XSLT using ISO Schematron skeleton
-   */
-  private async compileSchematron(): Promise<void> {
-    if (this.isCompiled) return;
-    
-    // The Schematron to XSLT transformation requires the ISO Schematron skeleton
-    // For now, we'll use a simplified approach with direct XSLT generation
-    // In production, we would use the official ISO Schematron skeleton XSLTs
-    
-    try {
-      // Convert Schematron to XSLT
-      // This is a simplified version - in production we'd use the full ISO skeleton
-      const xslt = this.generateXSLTFromSchematron(this.schematronRules);
-      
-      // Compile the XSLT with Saxon-JS
-      this.compiledStylesheet = await plugins.SaxonJS.compile({
-        stylesheetText: xslt,
-        warnings: 'silent'
-      });
-      
-      this.isCompiled = true;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to compile Schematron: ${errorMessage}`);
+
+    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);
+      }
     }
   }
   
@@ -78,19 +65,28 @@ export class SchematronValidator {
       throw new Error('No Schematron rules loaded');
     }
     
-    // Ensure Schematron is compiled
-    await this.compileSchematron();
-    
     const results: ValidationResult[] = [];
+
+    if (!this.canValidate()) {
+      return [this.createUnavailableResult()];
+    }
     
     try {
-      // Transform the XML with the compiled Schematron XSLT
-      const transformResult = await plugins.SaxonJS.transform({
-        stylesheetInternal: this.compiledStylesheet,
+      const transformOptions: ISaxonJSTransformOptions = {
         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') as ISaxonJSTransformResult;
       
       // Parse the SVRL (Schematron Validation Report Language) output
       results.push(...this.parseSVRL(transformResult.principalResult));
@@ -189,43 +185,46 @@ export class SchematronValidator {
     };
   }
   
-  /**
-   * Generate simplified XSLT from Schematron
-   * This is a placeholder - in production, use ISO Schematron skeleton
-   */
-  private generateXSLTFromSchematron(schematron: string): string {
-    // This is a simplified transformation
-    // In production, we would use the official ISO Schematron skeleton XSLTs
-    // (iso_schematron_skeleton.xsl, iso_svrl_for_xslt2.xsl, etc.)
-    
-    // For now, return a basic XSLT that creates SVRL output
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<xsl:stylesheet version="3.0" 
-    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-    xmlns:svrl="http://purl.oclc.org/dsdl/svrl">
-    
-  <xsl:output method="xml" indent="yes"/>
-  
-  <xsl:template match="/">
-    <svrl:schematron-output>
-      <!-- This is a placeholder transformation -->
-      <!-- Real implementation would process Schematron patterns and rules -->
-      <svrl:active-pattern>
-        <xsl:attribute name="document">
-          <xsl:value-of select="base-uri(/)"/>
-        </xsl:attribute>
-      </svrl:active-pattern>
-    </svrl:schematron-output>
-  </xsl:template>
-</xsl:stylesheet>`;
-  }
-  
   /**
    * Check if validator has rules loaded
    */
   public hasRules(): boolean {
     return !!this.schematronRules;
   }
+
+  /**
+   * Check if loaded rules can be executed by Saxon-JS.
+   */
+  public canValidate(): boolean {
+    return this.sourceKind === 'sef' && Boolean(this.stylesheetFileName || this.stylesheetInternal);
+  }
+
+  private detectSourceKind(source: string, sourceContent: string, isFilePath: boolean): TSchematronSourceKind {
+    const trimmed = sourceContent.trim();
+    if (!trimmed) {
+      return 'none';
+    }
+
+    if (isFilePath && /\.sef\.json$/i.test(source)) {
+      return 'sef';
+    }
+
+    if (trimmed.startsWith('{')) {
+      return 'sef';
+    }
+
+    return 'schematron';
+  }
+
+  private createUnavailableResult(): ValidationResult {
+    return {
+      ruleId: 'SCHEMATRON-UNCOMPILED',
+      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.'
+    };
+  }
   
   /**
    * Get list of available phases from Schematron

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

@@ -1,8 +1,11 @@
 import { Worker } from 'worker_threads';
-import * as path from 'path';
 import type { ValidationResult } from './validation.types.js';
 import type { SchematronOptions } from './schematron.validator.js';
 
+export interface ISchematronWorkerPoolInitializeOptions {
+  isFilePath?: boolean;
+}
+
 /**
  * Worker pool for Schematron validation
  * Provides non-blocking validation in worker threads
@@ -17,7 +20,8 @@ export class SchematronWorkerPool {
     reject: (error: Error) => void;
   }> = [];
   private maxWorkers: number;
-  private schematronRules: string = '';
+  private stylesheetFileName?: string;
+  private stylesheetInternal?: unknown;
   
   constructor(maxWorkers: number = 4) {
     this.maxWorkers = maxWorkers;
@@ -26,48 +30,81 @@ export class SchematronWorkerPool {
   /**
    * Initialize worker pool
    */
-  public async initialize(schematronRules: string): Promise<void> {
-    this.schematronRules = schematronRules;
+  public async initialize(
+    stylesheetSource: string,
+    options: ISchematronWorkerPoolInitializeOptions = {}
+  ): Promise<void> {
+    this.loadStylesheet(stylesheetSource, options);
     
     // Create workers
     for (let i = 0; i < this.maxWorkers; i++) {
       await this.createWorker();
     }
   }
+
+  private loadStylesheet(
+    stylesheetSource: string,
+    options: ISchematronWorkerPoolInitializeOptions
+  ): void {
+    const source = stylesheetSource.trim();
+    const isFilePath = options.isFilePath ?? /\.sef\.json$/i.test(stylesheetSource);
+
+    this.stylesheetFileName = undefined;
+    this.stylesheetInternal = undefined;
+
+    if (isFilePath) {
+      if (!/\.sef\.json$/i.test(stylesheetSource)) {
+        throw new Error('Schematron worker validation requires a precompiled Saxon-JS SEF JSON stylesheet file.');
+      }
+      this.stylesheetFileName = stylesheetSource;
+      return;
+    }
+
+    if (!source.startsWith('{')) {
+      throw new Error('Schematron worker validation requires a precompiled Saxon-JS SEF JSON stylesheet. Raw .sch files are not executed.');
+    }
+
+    this.stylesheetInternal = JSON.parse(source);
+  }
   
   /**
    * Create a new worker
    */
   private async createWorker(): Promise<void> {
-    const workerPath = path.join(import.meta.url, 'schematron.worker.impl.js');
-    
     const worker = new Worker(`
       const { parentPort } = require('worker_threads');
       const SaxonJS = require('saxon-js');
       
-      let compiledStylesheet = null;
+      let stylesheetFileName = null;
+      let stylesheetInternal = null;
       
       parentPort.on('message', async (msg) => {
         try {
           if (msg.type === 'init') {
-            // Compile Schematron to XSLT
-            compiledStylesheet = await SaxonJS.compile({
-              stylesheetText: msg.xslt,
-              warnings: 'silent'
-            });
+            stylesheetFileName = msg.stylesheetFileName || null;
+            stylesheetInternal = msg.stylesheetInternal || null;
+            if (!stylesheetFileName && !stylesheetInternal) {
+              throw new Error('Worker not initialized with a SEF stylesheet');
+            }
             parentPort.postMessage({ type: 'ready' });
           } else if (msg.type === 'validate') {
-            if (!compiledStylesheet) {
+            if (!stylesheetFileName && !stylesheetInternal) {
               throw new Error('Worker not initialized');
             }
-            
-            // Transform XML with compiled Schematron
-            const result = await SaxonJS.transform({
-              stylesheetInternal: compiledStylesheet,
+
+            const transformOptions = {
               sourceText: msg.xmlContent,
               destination: 'serialized',
               stylesheetParams: msg.options.parameters || {}
-            });
+            };
+
+            if (stylesheetFileName) {
+              transformOptions.stylesheetFileName = stylesheetFileName;
+            } else {
+              transformOptions.stylesheetInternal = stylesheetInternal;
+            }
+
+            const result = await SaxonJS.transform(transformOptions, 'async');
             
             parentPort.postMessage({
               type: 'result',
@@ -83,7 +120,7 @@ export class SchematronWorkerPool {
       });
     `, { eval: true });
     
-    // Initialize worker with Schematron rules
+    // Initialize worker with a precompiled SEF stylesheet.
     await new Promise<void>((resolve, reject) => {
       worker.once('message', (msg) => {
         if (msg.type === 'ready') {
@@ -96,7 +133,8 @@ export class SchematronWorkerPool {
       // Send initialization message
       worker.postMessage({
         type: 'init',
-        xslt: this.generateXSLTFromSchematron(this.schematronRules)
+        stylesheetFileName: this.stylesheetFileName,
+        stylesheetInternal: this.stylesheetInternal
       });
     });
     
@@ -174,26 +212,6 @@ export class SchematronWorkerPool {
     return results;
   }
   
-  /**
-   * Generate XSLT from Schematron (simplified)
-   */
-  private generateXSLTFromSchematron(schematron: string): string {
-    // Simplified - would use ISO Schematron skeleton in production
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<xsl:stylesheet version="3.0" 
-    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-    xmlns:svrl="http://purl.oclc.org/dsdl/svrl">
-    
-  <xsl:output method="xml" indent="yes"/>
-  
-  <xsl:template match="/">
-    <svrl:schematron-output>
-      <svrl:active-pattern document="{base-uri(/)}"/>
-    </svrl:schematron-output>
-  </xsl:template>
-</xsl:stylesheet>`;
-  }
-  
   /**
    * Terminate all workers
    */
@@ -218,4 +236,4 @@ export class SchematronWorkerPool {
       queuedTasks: this.taskQueue.length
     };
   }
-}
+}

package/ts/plugins.ts

@@ -9,24 +9,10 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as crypto from 'crypto';
 
-// PDF-related imports
-import { 
-  PDFDocument, 
-  PDFDict, 
-  PDFName, 
-  PDFRawStream, 
-  PDFArray, 
-  PDFString,
-  AFRelationship
-} from 'pdf-lib';
-
 // XML-related imports
 import { DOMParser, XMLSerializer, xmldom } from './vendor/xmldom.js';
 import * as xpath from 'xpath';
 
-// XSLT/Schematron imports
-import { SaxonJS } from './vendor/saxonjs.js';
-
 // Compression-related imports
 import { pako } from './vendor/pako.js';
 
@@ -40,24 +26,12 @@ export {
   path,
   crypto,
   
-  // PDF-lib exports
-  PDFDocument,
-  PDFDict,
-  PDFName,
-  PDFRawStream,
-  PDFArray,
-  PDFString,
-  AFRelationship,
-  
   // XML-related exports
   DOMParser,
   XMLSerializer,
   xmldom,
   xpath,
   
-  // XSLT/Schematron exports
-  SaxonJS,
-  
   // Compression-related exports
   pako,
   

package/ts/readme.md

@@ -53,3 +53,24 @@ const xml = await invoice.exportXml('facturx');
 
 - `../readme.md`: full package README for end users
 - `../ts_install/readme.md`: install-time resource bootstrap module
+
+## License and Legal Information
+
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [license](../license) file.
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
+
+### Company Information
+
+Task Venture Capital GmbH<br>
+Registered at District Court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

package/ts/vendor/pdflib.ts

@@ -0,0 +1,12 @@
+export type TPdfLibModule = typeof import('pdf-lib');
+
+let cachedPdfLib: Promise<TPdfLibModule> | undefined;
+
+// Use pdf-lib's bundled UMD build; the package entry requires JSON font assets,
+// which some TS runners corrupt with require hooks.
+const nativeImport = Function('specifier', 'return import(specifier)') as (specifier: string) => Promise<TPdfLibModule>;
+
+export const loadPdfLib = async (): Promise<TPdfLibModule> => {
+  cachedPdfLib ||= nativeImport('pdf-lib/dist/pdf-lib.js');
+  return cachedPdfLib;
+};

package/ts/vendor/saxonjs.ts

@@ -1,5 +1,3 @@
-import * as saxonJSRuntime from 'saxon-js';
-
 export interface ISaxonJSCompileOptions {
   stylesheetText: string;
   warnings?: string;
@@ -8,6 +6,7 @@ export interface ISaxonJSCompileOptions {
 
 export interface ISaxonJSTransformOptions {
   stylesheetInternal?: unknown;
+  stylesheetFileName?: string;
   sourceText: string;
   destination?: string;
   stylesheetParams?: Record<string, unknown>;
@@ -20,9 +19,18 @@ export interface ISaxonJSTransformResult {
 }
 
 export interface ISaxonJSModule {
-  compile(options: ISaxonJSCompileOptions): Promise<unknown>;
-  transform(options: ISaxonJSTransformOptions): Promise<ISaxonJSTransformResult>;
+  compile?: (options: ISaxonJSCompileOptions) => Promise<unknown>;
+  transform(options: ISaxonJSTransformOptions, executionMode?: 'async' | 'sync'): Promise<ISaxonJSTransformResult> | ISaxonJSTransformResult;
   [key: string]: unknown;
 }
 
-export const SaxonJS: ISaxonJSModule = saxonJSRuntime as unknown as ISaxonJSModule;
+let cachedSaxonJS: Promise<ISaxonJSModule> | undefined;
+
+export const loadSaxonJS = async (): Promise<ISaxonJSModule> => {
+  cachedSaxonJS ||= import('saxon-js').then((saxonJSRuntime) => {
+    const runtime = (saxonJSRuntime as any).default ?? saxonJSRuntime;
+    return runtime as ISaxonJSModule;
+  });
+
+  return cachedSaxonJS;
+};