@hpcc-js/wasm-expat 1.9.0 → 1.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hpcc-js/wasm-expat",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "hpcc-js - WASM expat",
   "type": "module",
   "exports": {
@@ -26,7 +26,7 @@
     "build-dev": "run-p gen-types bundle-dev",
     "build": "run-p gen-types bundle",
     "lint-skypack": "npx -y @skypack/package-check",
-    "lint-eslint": "eslint src/**/*.ts tests/**/*.ts",
+    "lint-eslint": "eslint \"src/**/*.ts\" \"tests/**/*.ts\"",
     "lint": "run-p lint-eslint",
     "test-browser": "vitest run --project browser",
     "test-node": "vitest run --project node",
@@ -36,7 +36,8 @@
     "update-major": "npx -y npm-check-updates -u"
   },
   "devDependencies": {
-    "@hpcc-js/esbuild-plugins": "1.7.0"
+    "@hpcc-js/esbuild-plugins": "1.7.0",
+    "@hpcc-js/wasm-util": "1.0.0"
   },
   "keywords": [
     "graphviz",
@@ -54,5 +55,5 @@
   },
   "homepage": "https://hpcc-systems.github.io/hpcc-js-wasm/",
   "license": "Apache-2.0",
-  "gitHead": "3fa48df3d5a7a6c43bf4f0c8839f1f9df27080da"
+  "gitHead": "11395f5acfc865accde71905509bb45d5c79b11b"
 }

package/src/expat.ts

@@ -1,5 +1,7 @@
 // @ts-expect-error importing from a wasm file is resolved via a custom esbuild plugin
-import load, { reset } from "../../../build/packages/expat/src-cpp/expatlib/expatlib.wasm";
+import load, { reset } from "../../../build/packages/expat/expatlib.wasm";
+import type { MainModule, map_string_string } from "../types/expatlib.js";
+import { MainModuleEx } from "@hpcc-js/wasm-util";
 
 export type Attributes = { [key: string]: string };
 export interface IParser {
@@ -8,18 +10,20 @@ export interface IParser {
     characterData(content: string): void;
 }
 
-function parseAttrs(attrs: string): Attributes {
+function parseAttrs(attrs: map_string_string): Attributes {
     const retVal: Attributes = {};
-    const keys = attrs;
-    const sep = `${String.fromCharCode(1)}`;
-    const sep2 = `${sep}${sep}`;
-    keys.split(sep2).filter((key: string) => !!key).forEach((key: string) => {
-        const parts = key.split(sep);
-        retVal[parts[0]] = parts[1];
-    });
+    const keys = attrs.keys();
+    const size = keys.size();
+    for (let i = 0; i < size; ++i) {
+        const key = keys.get(i);
+        const value = attrs.get(key!);
+        retVal[key!] = value!;
+    }
     return retVal;
 }
 
+let g_expat: Promise<Expat>;
+
 /**
  * Expat XML parser WASM library, provides a simplified wrapper around the Expat XML Parser library.  
  * 
@@ -46,9 +50,10 @@ function parseAttrs(attrs: string): Attributes {
  * ```
  
  */
-export class Expat {
+export class Expat extends MainModuleEx<MainModule> {
 
-    private constructor(protected _module: any) {
+    private constructor(_module: MainModule) {
+        super(_module);
     }
 
     /**
@@ -61,9 +66,10 @@ export class Expat {
      * @returns A promise to an instance of the Expat class.
      */
     static load(): Promise<Expat> {
-        return load().then((module: any) => {
-            return new Expat(module);
-        });
+        if (!g_expat) {
+            g_expat = (load() as Promise<MainModule>).then((module) => new Expat(module));
+        }
+        return g_expat;
     }
 
     /**
@@ -78,7 +84,7 @@ export class Expat {
      * @returns The Expat c++ version
      */
     version(): string {
-        return this._module.CExpat.prototype.version();
+        return this._module.version();
     }
 
     /**
@@ -93,21 +99,11 @@ export class Expat {
      * @returns `true`|`false` if the XML parse succeeds.
      */
     parse(xml: string, callback: IParser): boolean {
-        const parser = new this._module.CExpatJS();
-        parser.startElement = function () {
-            callback.startElement(this.tag(), parseAttrs(this.attrs()));
-        };
-        parser.endElement = function () {
-            callback.endElement(this.tag());
-        };
-        parser.characterData = function () {
-            callback.characterData(this.content());
-        };
-        parser.create();
-        const retVal = parser.parse(xml);
-        parser.destroy();
-        this._module.destroy(parser);
-        return retVal;
+        return this._module.parse(xml, {
+            startElement: (tag: string, attrs: map_string_string) => callback.startElement(tag, parseAttrs(attrs)),
+            endElement: (tag: string) => callback.endElement(tag),
+            characterData: (content: string) => callback.characterData(content)
+        });
     }
 }
 

package/types/expat.d.ts

@@ -1,3 +1,5 @@
+import type { MainModule } from "../types/expatlib.js";
+import { MainModuleEx } from "@hpcc-js/wasm-util";
 export type Attributes = {
     [key: string]: string;
 };
@@ -32,8 +34,7 @@ export interface IParser {
  * ```
  
  */
-export declare class Expat {
-    protected _module: any;
+export declare class Expat extends MainModuleEx<MainModule> {
     private constructor();
     /**
      * Compiles and instantiates the raw wasm.

package/types/expatlib.d.ts

@@ -0,0 +1,65 @@
+// TypeScript bindings for emscripten-generated code.  Automatically generated at compile time.
+declare namespace RuntimeExports {
+    /**
+     * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
+     * emscripten HEAP, returns a copy of that string as a Javascript String object.
+     *
+     * @param {number} ptr
+     * @param {number=} maxBytesToRead - An optional length that specifies the
+     *   maximum number of bytes to read. You can omit this parameter to scan the
+     *   string until the first 0 byte. If maxBytesToRead is passed, and the string
+     *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
+     *   string will cut short at that byte index.
+     * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
+     * @return {string}
+     */
+    function UTF8ToString(ptr: number, maxBytesToRead?: number | undefined, ignoreNul?: boolean | undefined): string;
+    function lengthBytesUTF8(str: any): number;
+    function stringToUTF8(str: any, outPtr: any, maxBytesToWrite: any): any;
+    let HEAPU8: any;
+}
+interface WasmModule {
+  _malloc(_0: number): number;
+  _free(_0: number): void;
+}
+
+type EmbindString = ArrayBuffer|Uint8Array|Uint8ClampedArray|Int8Array|string;
+export interface ClassHandle {
+  isAliasOf(other: ClassHandle): boolean;
+  delete(): void;
+  deleteLater(): this;
+  isDeleted(): boolean;
+  // @ts-ignore - If targeting lower than ESNext, this symbol might not exist.
+  [Symbol.dispose](): void;
+  clone(): this;
+}
+export interface vector_string extends ClassHandle {
+  size(): number;
+  get(_0: number): string | undefined;
+  push_back(_0: EmbindString): void;
+  resize(_0: number, _1: EmbindString): void;
+  set(_0: number, _1: EmbindString): boolean;
+}
+
+export interface map_string_string extends ClassHandle {
+  keys(): vector_string;
+  size(): number;
+  get(_0: EmbindString): string | undefined;
+  set(_0: EmbindString, _1: EmbindString): void;
+}
+
+type IParser = {startElement: (tag: string, attrs: map_string_string) => void, endElement: (tag: string) => void, characterData: (content: string) => void};
+
+interface EmbindModule {
+  vector_string: {
+    new(): vector_string;
+  };
+  map_string_string: {
+    new(): map_string_string;
+  };
+  version(): string;
+  parse(_0: EmbindString, _1: IParser): boolean;
+}
+
+export type MainModule = WasmModule & typeof RuntimeExports & EmbindModule;
+export default function MainModuleFactory (options?: unknown): Promise<MainModule>;