@gjsify/zlib 0.0.4 → 0.1.0

package/README.md

@@ -1,8 +1,34 @@
 # @gjsify/zlib
 
-Node.js zlib module for Gjs
+GJS implementation of the Node.js `zlib` module. Provides gzip/deflate via Web Compression API with Gio.ZlibCompressor fallback.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/zlib
+# or
+yarn add @gjsify/zlib
+```
+
+## Usage
+
+```typescript
+import { gzipSync, gunzipSync, deflateSync, inflateSync } from '@gjsify/zlib';
+
+const compressed = gzipSync(Buffer.from('hello world'));
+const decompressed = gunzipSync(compressed);
+console.log(decompressed.toString()); // 'hello world'
+```
+
 ## Inspirations and credits
+
 - https://nodejs.org/api/zlib.html
 - https://github.com/geut/brode/blob/main/packages/browser-node-core/src/zlib.js
 - https://github.com/browserify/browserify-zlib
-- https://github.com/denoland/deno_std/blob/main/node/zlib.ts
+- https://github.com/denoland/deno_std/blob/main/node/zlib.ts
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -1,6 +1,278 @@
-export * from "@gjsify/deno_std/node/zlib";
-import util from "@gjsify/deno_std/node/zlib";
-var src_default = util;
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+const hasWebCompression = typeof globalThis.CompressionStream !== "undefined";
+function getGioFormat(format) {
+  switch (format) {
+    case "gzip":
+      return Gio.ZlibCompressorFormat.GZIP;
+    case "deflate":
+      return Gio.ZlibCompressorFormat.ZLIB;
+    case "deflate-raw":
+      return Gio.ZlibCompressorFormat.RAW;
+  }
+}
+function compressWithGio(data, format) {
+  const compressor = new Gio.ZlibCompressor({ format: getGioFormat(format) });
+  const converter = new Gio.ConverterOutputStream({
+    base_stream: Gio.MemoryOutputStream.new_resizable(),
+    converter: compressor
+  });
+  converter.write_bytes(new GLib.Bytes(data), null);
+  converter.close(null);
+  const memStream = converter.get_base_stream();
+  const bytes = memStream.steal_as_bytes();
+  return new Uint8Array(bytes.get_data() ?? []);
+}
+function decompressStreamWithGio(data, format) {
+  const decompressor = new Gio.ZlibDecompressor({ format: getGioFormat(format) });
+  const memInput = Gio.MemoryInputStream.new_from_bytes(new GLib.Bytes(data));
+  const converter = new Gio.ConverterInputStream({
+    base_stream: memInput,
+    converter: decompressor
+  });
+  const chunks = [];
+  const bufSize = 4096;
+  while (true) {
+    const bytes = converter.read_bytes(bufSize, null);
+    const size = bytes.get_size();
+    if (size === 0) break;
+    chunks.push(new Uint8Array(bytes.get_data()));
+  }
+  converter.close(null);
+  const totalLength = chunks.reduce((acc, c) => acc + c.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function findGzipMemberEnd(data) {
+  const decompressor = new Gio.ZlibDecompressor({ format: Gio.ZlibCompressorFormat.GZIP });
+  const outBuf = new Uint8Array(65536);
+  let totalRead = 0;
+  let finished = false;
+  while (!finished) {
+    const input = data.subarray(totalRead);
+    try {
+      const [result, bytesRead] = decompressor.convert(input, outBuf, Gio.ConverterFlags.NONE);
+      totalRead += bytesRead;
+      if (result === Gio.ConverterResult.FINISHED) finished = true;
+    } catch {
+      finished = true;
+    }
+  }
+  return totalRead;
+}
+function decompressWithGio(data, format) {
+  if (format !== "gzip") {
+    return decompressStreamWithGio(data, format);
+  }
+  const allChunks = [];
+  let inputOffset = 0;
+  while (inputOffset < data.length) {
+    if (data.length - inputOffset < 2 || data[inputOffset] !== 31 || data[inputOffset + 1] !== 139) {
+      break;
+    }
+    const memberData = data.subarray(inputOffset);
+    const consumed = findGzipMemberEnd(memberData);
+    if (consumed <= 0) break;
+    const decompressed = decompressStreamWithGio(memberData.subarray(0, consumed), "gzip");
+    allChunks.push(decompressed);
+    inputOffset += consumed;
+  }
+  if (allChunks.length === 0) {
+    return decompressStreamWithGio(data, "gzip");
+  }
+  const totalLength = allChunks.reduce((acc, c) => acc + c.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of allChunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+async function compressWithWeb(data, format) {
+  const cs = new CompressionStream(format);
+  const writer = cs.writable.getWriter();
+  writer.write(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+  writer.close();
+  const chunks = [];
+  const reader = cs.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((acc, c) => acc + c.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+async function decompressWithWeb(data, format) {
+  const ds = new DecompressionStream(format);
+  const writer = ds.writable.getWriter();
+  writer.write(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+  writer.close();
+  const chunks = [];
+  const reader = ds.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((acc, c) => acc + c.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+async function compress(data, format) {
+  if (hasWebCompression) {
+    return compressWithWeb(data, format);
+  }
+  return compressWithGio(data, format);
+}
+async function decompress(data, format) {
+  if (hasWebCompression) {
+    return decompressWithWeb(data, format);
+  }
+  return decompressWithGio(data, format);
+}
+function toUint8Array(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  return data;
+}
+function gzip(data, optionsOrCallback, callback) {
+  const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+  compress(toUint8Array(data), "gzip").then(
+    (result) => cb(null, result),
+    (err) => cb(err instanceof Error ? err : new Error(String(err)), new Uint8Array(0))
+  );
+}
+function gunzip(data, optionsOrCallback, callback) {
+  const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+  decompress(toUint8Array(data), "gzip").then(
+    (result) => cb(null, result),
+    (err) => cb(err instanceof Error ? err : new Error(String(err)), new Uint8Array(0))
+  );
+}
+function deflate(data, optionsOrCallback, callback) {
+  const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+  compress(toUint8Array(data), "deflate").then(
+    (result) => cb(null, result),
+    (err) => cb(err instanceof Error ? err : new Error(String(err)), new Uint8Array(0))
+  );
+}
+function inflate(data, optionsOrCallback, callback) {
+  const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+  decompress(toUint8Array(data), "deflate").then(
+    (result) => cb(null, result),
+    (err) => cb(err instanceof Error ? err : new Error(String(err)), new Uint8Array(0))
+  );
+}
+function deflateRaw(data, optionsOrCallback, callback) {
+  const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+  compress(toUint8Array(data), "deflate-raw").then(
+    (result) => cb(null, result),
+    (err) => cb(err instanceof Error ? err : new Error(String(err)), new Uint8Array(0))
+  );
+}
+function inflateRaw(data, optionsOrCallback, callback) {
+  const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+  decompress(toUint8Array(data), "deflate-raw").then(
+    (result) => cb(null, result),
+    (err) => cb(err instanceof Error ? err : new Error(String(err)), new Uint8Array(0))
+  );
+}
+function gzipSync(data, _options) {
+  return compressWithGio(toUint8Array(data), "gzip");
+}
+function gunzipSync(data, _options) {
+  return decompressWithGio(toUint8Array(data), "gzip");
+}
+function deflateSync(data, _options) {
+  return compressWithGio(toUint8Array(data), "deflate");
+}
+function inflateSync(data, _options) {
+  return decompressWithGio(toUint8Array(data), "deflate");
+}
+function deflateRawSync(data, _options) {
+  return compressWithGio(toUint8Array(data), "deflate-raw");
+}
+function inflateRawSync(data, _options) {
+  return decompressWithGio(toUint8Array(data), "deflate-raw");
+}
+const constants = {
+  Z_NO_FLUSH: 0,
+  Z_PARTIAL_FLUSH: 1,
+  Z_SYNC_FLUSH: 2,
+  Z_FULL_FLUSH: 3,
+  Z_FINISH: 4,
+  Z_BLOCK: 5,
+  Z_TREES: 6,
+  Z_OK: 0,
+  Z_STREAM_END: 1,
+  Z_NEED_DICT: 2,
+  Z_ERRNO: -1,
+  Z_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_MEM_ERROR: -4,
+  Z_BUF_ERROR: -5,
+  Z_VERSION_ERROR: -6,
+  Z_NO_COMPRESSION: 0,
+  Z_BEST_SPEED: 1,
+  Z_BEST_COMPRESSION: 9,
+  Z_DEFAULT_COMPRESSION: -1,
+  Z_FILTERED: 1,
+  Z_HUFFMAN_ONLY: 2,
+  Z_RLE: 3,
+  Z_FIXED: 4,
+  Z_DEFAULT_STRATEGY: 0,
+  Z_DEFLATED: 8
+};
+var index_default = {
+  gzip,
+  gunzip,
+  deflate,
+  inflate,
+  deflateRaw,
+  inflateRaw,
+  gzipSync,
+  gunzipSync,
+  deflateSync,
+  inflateSync,
+  deflateRawSync,
+  inflateRawSync,
+  constants
+};
 export {
-  src_default as default
+  constants,
+  index_default as default,
+  deflate,
+  deflateRaw,
+  deflateRawSync,
+  deflateSync,
+  gunzip,
+  gunzipSync,
+  gzip,
+  gzipSync,
+  inflate,
+  inflateRaw,
+  inflateRawSync,
+  inflateSync
 };

package/lib/types/index.d.ts

@@ -1,3 +1,91 @@
-export * from '@gjsify/deno_std/node/zlib';
-import util from '@gjsify/deno_std/node/zlib';
-export default util;
+import type { ZlibOptions } from 'node:zlib';
+type ZlibCallback = (error: Error | null, result: Uint8Array) => void;
+export declare function gzip(data: string | Uint8Array | ArrayBuffer, callback: ZlibCallback): void;
+export declare function gzip(data: string | Uint8Array | ArrayBuffer, options: ZlibOptions, callback: ZlibCallback): void;
+export declare function gunzip(data: string | Uint8Array | ArrayBuffer, callback: ZlibCallback): void;
+export declare function gunzip(data: string | Uint8Array | ArrayBuffer, options: ZlibOptions, callback: ZlibCallback): void;
+export declare function deflate(data: string | Uint8Array | ArrayBuffer, callback: ZlibCallback): void;
+export declare function deflate(data: string | Uint8Array | ArrayBuffer, options: ZlibOptions, callback: ZlibCallback): void;
+export declare function inflate(data: string | Uint8Array | ArrayBuffer, callback: ZlibCallback): void;
+export declare function inflate(data: string | Uint8Array | ArrayBuffer, options: ZlibOptions, callback: ZlibCallback): void;
+export declare function deflateRaw(data: string | Uint8Array | ArrayBuffer, callback: ZlibCallback): void;
+export declare function deflateRaw(data: string | Uint8Array | ArrayBuffer, options: ZlibOptions, callback: ZlibCallback): void;
+export declare function inflateRaw(data: string | Uint8Array | ArrayBuffer, callback: ZlibCallback): void;
+export declare function inflateRaw(data: string | Uint8Array | ArrayBuffer, options: ZlibOptions, callback: ZlibCallback): void;
+export declare function gzipSync(data: string | Uint8Array | ArrayBuffer, _options?: ZlibOptions): Uint8Array;
+export declare function gunzipSync(data: string | Uint8Array | ArrayBuffer, _options?: ZlibOptions): Uint8Array;
+export declare function deflateSync(data: string | Uint8Array | ArrayBuffer, _options?: ZlibOptions): Uint8Array;
+export declare function inflateSync(data: string | Uint8Array | ArrayBuffer, _options?: ZlibOptions): Uint8Array;
+export declare function deflateRawSync(data: string | Uint8Array | ArrayBuffer, _options?: ZlibOptions): Uint8Array;
+export declare function inflateRawSync(data: string | Uint8Array | ArrayBuffer, _options?: ZlibOptions): Uint8Array;
+export declare const constants: {
+    Z_NO_FLUSH: number;
+    Z_PARTIAL_FLUSH: number;
+    Z_SYNC_FLUSH: number;
+    Z_FULL_FLUSH: number;
+    Z_FINISH: number;
+    Z_BLOCK: number;
+    Z_TREES: number;
+    Z_OK: number;
+    Z_STREAM_END: number;
+    Z_NEED_DICT: number;
+    Z_ERRNO: number;
+    Z_STREAM_ERROR: number;
+    Z_DATA_ERROR: number;
+    Z_MEM_ERROR: number;
+    Z_BUF_ERROR: number;
+    Z_VERSION_ERROR: number;
+    Z_NO_COMPRESSION: number;
+    Z_BEST_SPEED: number;
+    Z_BEST_COMPRESSION: number;
+    Z_DEFAULT_COMPRESSION: number;
+    Z_FILTERED: number;
+    Z_HUFFMAN_ONLY: number;
+    Z_RLE: number;
+    Z_FIXED: number;
+    Z_DEFAULT_STRATEGY: number;
+    Z_DEFLATED: number;
+};
+declare const _default: {
+    gzip: typeof gzip;
+    gunzip: typeof gunzip;
+    deflate: typeof deflate;
+    inflate: typeof inflate;
+    deflateRaw: typeof deflateRaw;
+    inflateRaw: typeof inflateRaw;
+    gzipSync: typeof gzipSync;
+    gunzipSync: typeof gunzipSync;
+    deflateSync: typeof deflateSync;
+    inflateSync: typeof inflateSync;
+    deflateRawSync: typeof deflateRawSync;
+    inflateRawSync: typeof inflateRawSync;
+    constants: {
+        Z_NO_FLUSH: number;
+        Z_PARTIAL_FLUSH: number;
+        Z_SYNC_FLUSH: number;
+        Z_FULL_FLUSH: number;
+        Z_FINISH: number;
+        Z_BLOCK: number;
+        Z_TREES: number;
+        Z_OK: number;
+        Z_STREAM_END: number;
+        Z_NEED_DICT: number;
+        Z_ERRNO: number;
+        Z_STREAM_ERROR: number;
+        Z_DATA_ERROR: number;
+        Z_MEM_ERROR: number;
+        Z_BUF_ERROR: number;
+        Z_VERSION_ERROR: number;
+        Z_NO_COMPRESSION: number;
+        Z_BEST_SPEED: number;
+        Z_BEST_COMPRESSION: number;
+        Z_DEFAULT_COMPRESSION: number;
+        Z_FILTERED: number;
+        Z_HUFFMAN_ONLY: number;
+        Z_RLE: number;
+        Z_FIXED: number;
+        Z_DEFAULT_STRATEGY: number;
+        Z_DEFLATED: number;
+    };
+};
+export default _default;

package/package.json

@@ -1,33 +1,26 @@
 {
   "name": "@gjsify/zlib",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Node.js zlib module for Gjs",
-  "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
   "types": "lib/types/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/esm/index.js"
-      },
-      "require": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/cjs/index.js"
-      }
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
     }
   },
   "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "print:name": "echo '@gjsify/zlib'",
-    "build": "yarn print:name && yarn build:gjsify && yarn build:types",
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
     "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
-    "build:types": "tsc --project tsconfig.types.json || exit 0",
+    "build:types": "tsc",
     "build:test": "yarn build:test:gjs && yarn build:test:node",
     "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
     "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
-    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
     "test:gjs": "gjs -m test.gjs.mjs",
     "test:node": "node test.node.mjs"
   },
@@ -36,13 +29,14 @@
     "node",
     "zlib"
   ],
-  "devDependencies": {
-    "@gjsify/cli": "^0.0.4",
-    "@gjsify/unit": "^0.0.4",
-    "@types/node": "^20.10.5",
-    "typescript": "^5.3.3"
-  },
   "dependencies": {
-    "@gjsify/deno_std": "^0.0.4"
+    "@girs/gio-2.0": "^2.88.0-4.0.0-beta.42",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-beta.42"
+  },
+  "devDependencies": {
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   }
 }