@lynx-js/tasm 0.0.20 → 0.0.22

package/ChangeLog.md

@@ -1,3 +1,11 @@
+# CHANGELOG
+
+# 0.0.22
+* Change `path.resolve` to `require.resolve` for webpack pre-bundle
+
+# 0.0.21
+* supports to resolve `compilerOption` in a tasm file.
+
 # 0.0.20
 * support LEPUS_Eval with filename for sourcemap.
 

package/index.js

@@ -44,8 +44,7 @@ async function encode_wasm(options) {
   return res;
 }
 function encode_napi(options) {
-  const bindingPath = path.resolve(__dirname, `./build/${process.platform}/Release/lepus.node`);
-  const lepus = require(bindingPath);
+  const lepus = require(`./build/${process.platform}/Release/lepus.node`);
   const res = lepus.encode(JSON.stringify({...options}));
   if (res.status !== 0) {
     throw new Error(`encode error: ${res.error_msg}`);
@@ -69,15 +68,13 @@ function getEncodeMode(os) {
 }
 
 function encrypt(plain) {
-  const bindingPath = path.resolve(__dirname, `./build/${process.platform}/Release/lepus.node`);
-  const lepus = require(bindingPath);
+  const lepus = require(`./build/${process.platform}/Release/lepus.node`);
   const res = lepus.encrypt(plain);
   return res
 }
 
 function decrypt(cipher) {
-  const bindingPath = path.resolve(__dirname, `./build/${process.platform}/Release/lepus.node`);
-  const lepus = require(bindingPath);
+  const lepus = require(`./build/${process.platform}/Release/lepus.node`);
   const res = lepus.decrypt(cipher);
   return res
 }
@@ -96,8 +93,7 @@ function decrypt_wasm(plain) {
 
 function decode_napi(templateJS) {
   const templateArray = Uint8Array.from(templateJS);
-  const bindingPath = path.resolve(__dirname, `./build/${process.platform}/Release/lepus.node`);
-  const lepus = require(bindingPath);
+  const lepus = require(`./build/${process.platform}/Release/lepus.node`);
   const res = lepus.decode(templateArray);
   if (res.status !== 0) {
     throw new Error(`decode error: ${res.error_msg}`);
@@ -126,6 +122,27 @@ function decode_wasm(buffer) {
   return JSON.parse(res.result);
 }
 
+function decode_wasm(buffer) {
+  const Module = loadModule();
+  // console.log(templateJs);
+  // const uint8array = new Uint8Array(templateJs.size());
+  // const res = m._decode(uint8array);
+  const byteArray = new Uint8Array(buffer);
+  const byteArrayLength = byteArray.length;
+  // Allocate memory in the Emscripten heap
+  const byteArrayPtr = Module._malloc(byteArrayLength);
+  // Copy the data to the Emscripten heap
+  Module.HEAPU8.set(byteArray, byteArrayPtr);
+  // Call the C++ function
+  const res = Module._decode(byteArrayPtr, byteArrayLength);
+  // Free the allocated memory
+  Module._free(byteArrayPtr);
+  if (res.status !== 0) {
+    throw new Error(`decode error: ${res.result}`);
+  }
+  return res;
+}
+
 let encode = encode_napi;
 module.exports = {
   supportNapi,

package/lepus.d.ts

@@ -0,0 +1,85 @@
+// TypeScript bindings for emscripten-generated code.  Automatically generated at compile time.
+declare namespace RuntimeExports {
+    /**
+     * @param {string=} returnType
+     * @param {Array=} argTypes
+     * @param {Object=} opts
+     */
+    function cwrap(ident: any, returnType?: string, argTypes?: any[], opts?: any): any;
+    /**
+     * @param {string|null=} returnType
+     * @param {Array=} argTypes
+     * @param {Array=} args
+     * @param {Object=} opts
+     */
+    function ccall(ident: any, returnType?: string, argTypes?: any[], args?: any[], opts?: any): any;
+    function allocateUTF8(...args: any[]): any;
+    /**
+     * 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, ignoreNul?: boolean): string;
+}
+interface WasmModule {
+  _quickjsCheck(_0: number): void;
+  _createBufferPool(): number;
+  _dropBufferPool(_0: number): void;
+  _readBufferPool_data(_0: number, _1: number): number;
+  _readBufferPool_len(_0: number, _1: number): number;
+  _reencode_template_debug(_0: number, _1: number, _2: number, _3: number): number;
+  _lepusCheck(_0: number, _1: number, _2: number): number;
+}
+
+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 VectorUInt8 extends ClassHandle {
+  push_back(_0: number): void;
+  resize(_0: number, _1: number): void;
+  size(): number;
+  get(_0: number): number | undefined;
+  set(_0: number, _1: number): boolean;
+}
+
+export type EncodeResult = {
+  status: number,
+  error_msg: EmbindString,
+  buffer: VectorUInt8,
+  lepus_code: EmbindString,
+  lepus_debug: EmbindString,
+  section_size: EmbindString
+};
+
+export type DecodeResult = {
+  status: number,
+  result: EmbindString
+};
+
+interface EmbindModule {
+  VectorUInt8: {
+    new(): VectorUInt8;
+  };
+  _encode(_0: EmbindString): EncodeResult;
+  _quickjsCheck(_0: EmbindString): string;
+  _encode_ssr(_0: number, _1: number, _2: EmbindString): EncodeResult;
+  _decode(_0: number, _1: number): DecodeResult;
+}
+
+export type MainModule = WasmModule & typeof RuntimeExports & EmbindModule;
+export default function MainModuleFactory (options?: unknown): MainModule;