Move away from Node.js built-ins

This makes it possible to easily build this project using tools such as Webpack 5.

Saxes does not support lenient parsing mode so the strict option is now mandatory in this change.

Author: Tpt

.github/workflows/ci.yml

@@ -89,4 +89,18 @@ jobs:
         run: yarn install
       - name: Build project
         run: yarn run build
-      - run: yarn run spec
+      - run: yarn run spec
+
+  webpack:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
+        with:
+          path: '**/node_modules'
+          key: ${{ runner.os }}-webpack-modules-${{ hashFiles('**/yarn.lock') }}
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+      - run: yarn install
+      - run: npx webpack

lib/ParseError.ts

@@ -1,4 +1,4 @@
-import {SAXParser} from "sax";
+import {SaxesParser} from "saxes";
 import {RdfXmlParser} from "./RdfXmlParser";
 
 /**
@@ -7,8 +7,8 @@ import {RdfXmlParser} from "./RdfXmlParser";
 export class ParseError extends Error {
 
   constructor(parser: RdfXmlParser, message: string) {
-    const saxParser: SAXParser = (<any> (<any> parser).saxStream)._parser;
-    super(parser.trackPosition ? `Line ${saxParser.line + 1} column ${saxParser.column + 1}: ${message}` : message);
+    const saxParser: SaxesParser = (<any>parser).saxParser;
+    super(parser.trackPosition ? `Line ${saxParser.line} column ${saxParser.column + 1}: ${message}` : message);
   }
 
 }

lib/RdfXmlParser.ts

@@ -1,7 +1,7 @@
 import * as RDF from "@rdfjs/types";
 import {resolve} from "relative-to-absolute-iri";
-import {createStream, SAXStream, Tag} from "sax";
-import {PassThrough, Transform, TransformCallback} from "stream";
+import {SaxesParser, SaxesTagPlain} from "saxes";
+import {PassThrough, Transform} from "readable-stream";
 import EventEmitter = NodeJS.EventEmitter;
 import {ParseError} from "./ParseError";
 import {DataFactory} from "rdf-data-factory";
@@ -52,9 +52,8 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
   private readonly dataFactory: RDF.DataFactory;
   private readonly baseIRI: string;
   private readonly defaultGraph?: RDF.Quad_Graph;
-  private readonly strict?: boolean;
   private readonly allowDuplicateRdfIds?: boolean;
-  private readonly saxStream: SAXStream;
+  private readonly saxParser: SaxesParser;
 
   private readonly activeTagStack: IActiveTag[] = [];
   private readonly nodeIds: {[id: string]: boolean} = {};
@@ -76,25 +75,20 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
       this.defaultGraph = this.dataFactory.defaultGraph();
     }
 
-    this.saxStream = createStream(this.strict, { xmlns: false, position: this.trackPosition });
-
-    // Workaround for an issue in SAX where non-strict mode either lower- or upper-cases all tags.
-    if (!this.strict) {
-      (<any> this.saxStream)._parser.looseCase = 'toString';
-    }
+    this.saxParser = new SaxesParser({ xmlns: false, position: this.trackPosition });
 
     this.attachSaxListeners();
   }
 
   /**
    * Parse the namespace of the given tag,
    * and take into account the namespace of the parent tag that was already parsed.
-   * @param {Tag} tag A tag to parse the namespace from.
+   * @param {SaxesTagPlain} tag A tag to parse the namespace from.
    * @param {IActiveTag} parentTag The parent tag, or null if this tag is the root.
    * @return {{[p: string]: string}[]} An array of namespaces,
    *                                   where the last ones have a priority over the first ones.
    */
-  public static parseNamespace(tag: Tag, parentTag?: IActiveTag): {[prefix: string]: string}[] {
+  public static parseNamespace(tag: SaxesTagPlain, parentTag?: IActiveTag): {[prefix: string]: string}[] {
     const thisNs: {[prefix: string]: string} = {};
     let hasNs: boolean = false;
     for (const attributeKey in tag.attributes) {
@@ -184,9 +178,9 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
     return parsed;
   }
 
-  public _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback) {
+  public _transform(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null, data?: any) => void) {
     try {
-      this.saxStream.write(chunk, encoding);
+      this.saxParser.write(chunk);
     } catch (e) {
       return callback(e);
     }
@@ -244,18 +238,18 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
   }
 
   protected attachSaxListeners() {
-    this.saxStream.on('error', (error) => this.emit('error', error));
-    this.saxStream.on('opentag', this.onTag.bind(this));
-    this.saxStream.on('text', this.onText.bind(this));
-    this.saxStream.on('closetag', this.onCloseTag.bind(this));
-    this.saxStream.on('doctype', this.onDoctype.bind(this));
+    this.saxParser.on('error', (error) => this.emit('error', error));
+    this.saxParser.on('opentag', this.onTag.bind(this));
+    this.saxParser.on('text', this.onText.bind(this));
+    this.saxParser.on('closetag', this.onCloseTag.bind(this));
+    this.saxParser.on('doctype', this.onDoctype.bind(this));
   }
 
   /**
    * Handle the given tag.
-   * @param {QualifiedTag} tag A SAX tag.
+   * @param {SaxesTagPlain} tag A SAX tag.
    */
-  protected onTag(tag: Tag) {
+  protected onTag(tag: SaxesTagPlain) {
     // Get parent tag
     const parentTag: IActiveTag = this.activeTagStack.length
       ? this.activeTagStack[this.activeTagStack.length - 1] : null;
@@ -306,12 +300,12 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
 
   /**
    * Handle the given node element in resource-mode.
-   * @param {QualifiedTag} tag A SAX tag.
+   * @param {SaxesTagPlain} tag A SAX tag.
    * @param {IActiveTag} activeTag The currently active tag.
    * @param {IActiveTag} parentTag The parent tag or null.
    * @param {boolean} rootTag If we are currently processing the root tag.
    */
-  protected onTagResource(tag: Tag, activeTag: IActiveTag, parentTag: IActiveTag, rootTag: boolean) {
+  protected onTagResource(tag: SaxesTagPlain, activeTag: IActiveTag, parentTag: IActiveTag, rootTag: boolean) {
     const tagExpanded: IExpandedPrefix = RdfXmlParser.expandPrefixedTerm(tag.name, activeTag.ns, this);
 
     activeTag.childrenParseType = ParseType.PROPERTY;
@@ -342,7 +336,7 @@ export class RdfXmlParser extends Transform implements RDF.Sink<EventEmitter, RD
     let subjectValueBlank: boolean = false;
     let explicitType: string = null;
     for (const attributeKey in tag.attributes) {
-      const attributeValue: string = tag.attributes[attributeKey];
+      const attributeValue = tag.attributes[attributeKey];
       const attributeKeyExpanded: IExpandedPrefix = RdfXmlParser.expandPrefixedTerm(attributeKey, activeTag.ns, this);
       if (parentTag && attributeKeyExpanded.uri === RdfXmlParser.RDF) {
         switch (attributeKeyExpanded.local) {
@@ -475,11 +469,11 @@ while ${attributeValue} and ${activeSubjectValue} where found.`);
 
   /**
    * Handle the given property element in property-mode.
-   * @param {QualifiedTag} tag A SAX tag.
+   * @param {SaxesTagPlain} tag A SAX tag.
    * @param {IActiveTag} activeTag The currently active tag.
    * @param {IActiveTag} parentTag The parent tag or null.
    */
-  protected onTagProperty(tag: Tag, activeTag: IActiveTag, parentTag: IActiveTag) {
+  protected onTagProperty(tag: SaxesTagPlain, activeTag: IActiveTag, parentTag: IActiveTag) {
     const tagExpanded: IExpandedPrefix = RdfXmlParser.expandPrefixedTerm(tag.name, activeTag.ns, this);
 
     activeTag.childrenParseType = ParseType.RESOURCE;
@@ -508,11 +502,11 @@ while ${attributeValue} and ${activeSubjectValue} where found.`);
     // Collect all attributes as triples
     // Assign subject value only after all attributes have been processed, because baseIRI may change the final val
     let activeSubSubjectValue: string = null;
-    let subSubjectValueBlank: boolean = true;
+    let subSubjectValueBlank = true;
     const predicates: RDF.NamedNode[] = [];
     const objects: (RDF.NamedNode | RDF.BlankNode | RDF.Literal)[] = [];
     for (const propertyAttributeKey in tag.attributes) {
-      const propertyAttributeValue: string = tag.attributes[propertyAttributeKey];
+      const propertyAttributeValue = tag.attributes[propertyAttributeKey];
       const propertyAttributeKeyExpanded: IExpandedPrefix = RdfXmlParser
         .expandPrefixedTerm(propertyAttributeKey, activeTag.ns, this);
       if (propertyAttributeKeyExpanded.uri === RdfXmlParser.RDF) {
@@ -755,7 +749,7 @@ while ${attributeValue} and ${activeSubjectValue} where found.`);
    */
   protected onDoctype(doctype: string) {
     doctype.replace(/<!ENTITY\s+([^\s]+)\s+["']([^"']+)["']\s*>/g, (match, prefix, uri) => {
-      (<any> this.saxStream)._parser.ENTITIES[prefix] = uri;
+      this.saxParser.ENTITIES[prefix] = uri;
       return '';
     });
   }
@@ -780,10 +774,6 @@ export interface IRdfXmlParserArgs {
    * The default graph for constructing quads.
    */
   defaultGraph?: RDF.Term;
-  /**
-   * If the internal SAX parser should parse XML in strict mode, and error if it is invalid.
-   */
-  strict?: boolean;
   /**
    * If the internal position (line, column) should be tracked an emitted in error messages.
    */

package.json

@@ -46,9 +46,12 @@
     "streamify-array": "^1.0.0",
     "streamify-string": "^1.0.1",
     "ts-jest": "^28.0.5",
+    "ts-loader": "^9.3.1",
     "tslint": "^6.0.0",
     "tslint-eslint-rules": "^5.3.1",
-    "typescript": "^4.3.5"
+    "typescript": "^4.3.5",
+    "webpack": "^5.73.0",
+    "webpack-cli": "^4.10.0"
   },
   "jest": {
     "globals": {
@@ -87,9 +90,12 @@
   },
   "dependencies": {
     "@rdfjs/types": "*",
+    "@types/readable-stream": "^2.3.13",
+    "buffer": "^6.0.3",
     "rdf-data-factory": "^1.1.0",
     "relative-to-absolute-iri": "^1.0.0",
-    "sax": "^1.2.4"
+    "readable-stream": "^4.0.0",
+    "saxes": "^6.0.0"
   },
   "sideEffects": false
 }

test/RdfXmlParser-test.ts

@@ -1,6 +1,6 @@
 import "jest-rdf";
 import * as RDF from "@rdfjs/types";
-import {SAXStream, Tag} from "sax";
+import {SaxesParser, SaxesTagPlain} from "saxes";
 import {PassThrough} from "stream";
 import {RdfXmlParser} from "../lib/RdfXmlParser";
 import {DataFactory} from "rdf-data-factory";
@@ -24,8 +24,7 @@ describe('RdfXmlParser', () => {
     expect((<any> instance).dataFactory).toBeInstanceOf(DataFactory);
     expect((<any> instance).baseIRI).toBe('');
     expect((<any> instance).defaultGraph).toBe(DF.defaultGraph());
-    expect((<any> instance).strict).toBeFalsy();
-    expect((<any> instance).saxStream).toBeInstanceOf(SAXStream);
+    expect((<any> instance).saxParser).toBeInstanceOf(SaxesParser);
   });
 
   it('should be constructable with empty args', () => {
@@ -34,8 +33,7 @@ describe('RdfXmlParser', () => {
     expect((<any> instance).dataFactory).toBeInstanceOf(DataFactory);
     expect((<any> instance).baseIRI).toBe('');
     expect((<any> instance).defaultGraph).toBe(DF.defaultGraph());
-    expect((<any> instance).strict).toBeFalsy();
-    expect((<any> instance).saxStream).toBeInstanceOf(SAXStream);
+    expect((<any> instance).saxParser).toBeInstanceOf(SaxesParser);
   });
 
   it('should be constructable with args with a custom data factory', () => {
@@ -45,8 +43,7 @@ describe('RdfXmlParser', () => {
     expect((<any> instance).dataFactory).toBe(dataFactory);
     expect((<any> instance).baseIRI).toBe('');
     expect((<any> instance).defaultGraph).toBe('abc');
-    expect((<any> instance).strict).toBeFalsy();
-    expect((<any> instance).saxStream).toBeInstanceOf(SAXStream);
+    expect((<any> instance).saxParser).toBeInstanceOf(SaxesParser);
   });
 
   it('should be constructable with args with a custom base IRI', () => {
@@ -55,8 +52,7 @@ describe('RdfXmlParser', () => {
     expect((<any> instance).dataFactory).toBeInstanceOf(DataFactory);
     expect((<any> instance).baseIRI).toEqual('myBaseIRI');
     expect((<any> instance).defaultGraph).toBe(DF.defaultGraph());
-    expect((<any> instance).strict).toBeFalsy();
-    expect((<any> instance).saxStream).toBeInstanceOf(SAXStream);
+    expect((<any> instance).saxParser).toBeInstanceOf(SaxesParser);
   });
 
   it('should be constructable with args with a custom default graph', () => {
@@ -66,35 +62,23 @@ describe('RdfXmlParser', () => {
     expect((<any> instance).dataFactory).toBeInstanceOf(DataFactory);
     expect((<any> instance).baseIRI).toEqual('');
     expect((<any> instance).defaultGraph).toBe(defaultGraph);
-    expect((<any> instance).strict).toBeFalsy();
-    expect((<any> instance).saxStream).toBeInstanceOf(SAXStream);
+    expect((<any> instance).saxParser).toBeInstanceOf(SaxesParser);
   });
 
-  it('should be constructable with args with strict mode', () => {
-    const instance = new RdfXmlParser({ strict: true });
-    expect(instance).toBeInstanceOf(RdfXmlParser);
-    expect((<any> instance).dataFactory).toBeInstanceOf(DataFactory);
-    expect((<any> instance).baseIRI).toEqual('');
-    expect((<any> instance).defaultGraph).toBe(DF.defaultGraph());
-    expect((<any> instance).strict).toBe(true);
-    expect((<any> instance).saxStream).toBeInstanceOf(SAXStream);
-  });
-
-  it('should be constructable with args with a custom data factory, base IRI, strict and default graph', () => {
+  it('should be constructable with args with a custom data factory and default graph', () => {
     const dataFactory: any = { defaultGraph: () => 'abc' };
     const defaultGraph = DF.namedNode('abc');
-    const instance = new RdfXmlParser({ dataFactory, baseIRI: 'myBaseIRI', defaultGraph, strict: true });
+    const instance = new RdfXmlParser({ dataFactory, baseIRI: 'myBaseIRI', defaultGraph });
     expect(instance).toBeInstanceOf(RdfXmlParser);
     expect((<any> instance).dataFactory).toBe(dataFactory);
     expect((<any> instance).baseIRI).toEqual('myBaseIRI');
     expect((<any> instance).defaultGraph).toBe(defaultGraph);
-    expect((<any> instance).strict).toBe(true);
-    expect((<any> instance).saxStream).toBeInstanceOf(SAXStream);
+    expect((<any> instance).saxParser).toBeInstanceOf(SaxesParser);
   });
 
   describe('#parseNamespace', () => {
     it('should parse a tag without attributes', () => {
-      const tag: Tag = { name: 'a', isSelfClosing: false, attributes: {} };
+      const tag: SaxesTagPlain = { name: 'a', isSelfClosing: false, attributes: {} };
       return expect(RdfXmlParser.parseNamespace(tag, null)).toEqual([
         {
           xml: 'http://www.w3.org/XML/1998/namespace',
@@ -103,7 +87,7 @@ describe('RdfXmlParser', () => {
     });
 
     it('should parse a tag with non-xmlns attributes', () => {
-      const tag: Tag = {
+      const tag: SaxesTagPlain = {
         attributes: {
           a: 'b',
           c: 'd',
@@ -121,7 +105,7 @@ describe('RdfXmlParser', () => {
     });
 
     it('should parse a tag with a default xmlns attribute', () => {
-      const tag: Tag = {
+      const tag: SaxesTagPlain = {
         attributes: {
           xmlns: 'a',
         },
@@ -139,7 +123,7 @@ describe('RdfXmlParser', () => {
     });
 
     it('should parse a tag with a xmlns attributes', () => {
-      const tag: Tag = {
+      const tag: SaxesTagPlain = {
         attributes: {
           'xmlns:a': '1',
           'xmlns:b': '2',
@@ -161,7 +145,7 @@ describe('RdfXmlParser', () => {
     });
 
     it('should parse a tag with a xmlns attributes and a parent tag without ns', () => {
-      const tag: Tag = {
+      const tag: SaxesTagPlain = {
         attributes: {
           'xmlns:a': '1',
           'xmlns:b': '2',
@@ -183,7 +167,7 @@ describe('RdfXmlParser', () => {
     });
 
     it('should parse a tag with a xmlns attributes and a parent tag with ns', () => {
-      const tag: Tag = {
+      const tag: SaxesTagPlain = {
         attributes: {
           'xmlns:a': '1',
           'xmlns:b': '2',
@@ -218,7 +202,7 @@ describe('RdfXmlParser', () => {
       { a: 'b' },
     ];
     const parser: any = {
-      saxStream: {
+      saxParser: {
         _parser: {
           column: 2,
           line: 1,
@@ -306,7 +290,7 @@ describe('RdfXmlParser', () => {
     });
 
     it('should delegate xml errors', () => {
-      return expect(parse(new RdfXmlParser({ strict: true }), `
+      return expect(parse(new RdfXmlParser(), `
 abc`)).rejects.toBeTruthy();
     });
 
@@ -2157,7 +2141,7 @@ abc`)).rejects.toBeTruthy();
   <rdf:Description rdf:about="http://example.org/">
     <ex:prop1 ex:prop2="abc">
       <rdf:Description rdf:about="http://example.org/2" />
-    </ex:prop>
+    </ex:prop1>
   </rdf:Description>
 </rdf:RDF>`);
         return expect(array)