@gjsify/buffer 0.0.4 → 0.1.0

package/lib/types/blob.d.ts

@@ -0,0 +1,17 @@
+declare class BlobPolyfill implements Blob {
+    _parts: BlobPart[];
+    readonly size: number;
+    readonly type: string;
+    constructor(parts?: BlobPart[], options?: BlobPropertyBag);
+    bytes(): Promise<Uint8Array<ArrayBuffer>>;
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    slice(start?: number, end?: number, type?: string): Blob;
+    stream(): ReadableStream;
+}
+declare const Blob: typeof BlobPolyfill | {
+    new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+    prototype: Blob;
+};
+declare const File: any;
+export { Blob, File };

package/lib/types/buffer.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Node.js-compatible Buffer class.
+ */
+export declare class Buffer extends Uint8Array {
+    private static readonly _isBuffer;
+    static alloc(size: number, fill?: number | string | Uint8Array | Buffer, encoding?: string): Buffer;
+    static allocUnsafe(size: number): Buffer;
+    static allocUnsafeSlow(size: number): Buffer;
+    static from(arrayLike: ArrayLike<number>): Buffer;
+    static from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: unknown): Buffer;
+    static from(elements: Iterable<number>): Buffer;
+    static from(value: string, encoding?: string): Buffer;
+    static from(value: ArrayBuffer | SharedArrayBuffer, byteOffset?: number, length?: number): Buffer;
+    static from(value: Uint8Array | Buffer): Buffer;
+    static isBuffer(obj: unknown): obj is Buffer;
+    static isEncoding(encoding: unknown): encoding is BufferEncoding;
+    static byteLength(string: string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView, encoding?: string): number;
+    static compare(buf1: Buffer | Uint8Array, buf2: Buffer | Uint8Array): -1 | 0 | 1;
+    static concat(list: (Buffer | Uint8Array)[], totalLength?: number): Buffer;
+    static poolSize: number;
+    toString(encoding?: string, start?: number, end?: number): string;
+    toJSON(): {
+        type: 'Buffer';
+        data: number[];
+    };
+    equals(otherBuffer: Buffer | Uint8Array): boolean;
+    compare(target: Buffer | Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1;
+    copy(target: Buffer | Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+    slice(start?: number, end?: number): Buffer;
+    subarray(start?: number, end?: number): Buffer;
+    write(string: string, offset?: number, length?: number, encoding?: string): number;
+    fill(value: number | string | Uint8Array | Buffer, offset?: number, end?: number, encoding?: string): this;
+    indexOf(value: number | string | Uint8Array | Buffer, byteOffset?: number, encoding?: string): number;
+    lastIndexOf(value: number | string | Uint8Array | Buffer, byteOffset?: number, encoding?: string): number;
+    includes(value: number | string | Uint8Array | Buffer, byteOffset?: number, encoding?: string): boolean;
+    readUInt8(offset?: number): number;
+    readUInt16BE(offset?: number): number;
+    readUInt16LE(offset?: number): number;
+    readUInt32BE(offset?: number): number;
+    readUInt32LE(offset?: number): number;
+    readInt8(offset?: number): number;
+    readInt16BE(offset?: number): number;
+    readInt16LE(offset?: number): number;
+    readInt32BE(offset?: number): number;
+    readInt32LE(offset?: number): number;
+    readFloatBE(offset?: number): number;
+    readFloatLE(offset?: number): number;
+    readDoubleBE(offset?: number): number;
+    readDoubleLE(offset?: number): number;
+    readBigInt64BE(offset?: number): bigint;
+    readBigInt64LE(offset?: number): bigint;
+    readBigUInt64BE(offset?: number): bigint;
+    readBigUInt64LE(offset?: number): bigint;
+    readUIntBE(offset: number, byteLength: number): number;
+    readUIntLE(offset: number, byteLength: number): number;
+    readIntBE(offset: number, byteLength: number): number;
+    readIntLE(offset: number, byteLength: number): number;
+    writeUInt8(value: number, offset?: number): number;
+    writeUInt16BE(value: number, offset?: number): number;
+    writeUInt16LE(value: number, offset?: number): number;
+    writeUInt32BE(value: number, offset?: number): number;
+    writeUInt32LE(value: number, offset?: number): number;
+    writeInt8(value: number, offset?: number): number;
+    writeInt16BE(value: number, offset?: number): number;
+    writeInt16LE(value: number, offset?: number): number;
+    writeInt32BE(value: number, offset?: number): number;
+    writeInt32LE(value: number, offset?: number): number;
+    writeFloatBE(value: number, offset?: number): number;
+    writeFloatLE(value: number, offset?: number): number;
+    writeDoubleBE(value: number, offset?: number): number;
+    writeDoubleLE(value: number, offset?: number): number;
+    writeBigInt64BE(value: bigint, offset?: number): number;
+    writeBigInt64LE(value: bigint, offset?: number): number;
+    writeBigUInt64BE(value: bigint, offset?: number): number;
+    writeBigUInt64LE(value: bigint, offset?: number): number;
+    swap16(): this;
+    swap32(): this;
+    swap64(): this;
+}
+export declare const kMaxLength: number;
+export declare const kStringMaxLength: number;
+export declare const constants: {
+    MAX_LENGTH: number;
+    MAX_STRING_LENGTH: number;
+};
+/** @deprecated Use Buffer.alloc() instead */
+export declare class SlowBuffer extends Buffer {
+    constructor(size: number);
+}

package/lib/types/index.d.ts

@@ -1,3 +1,37 @@
-export * from '@gjsify/deno_std/node/buffer';
-import buffer from '@gjsify/deno_std/node/buffer';
-export default buffer;
+import { Buffer, SlowBuffer, kMaxLength, kStringMaxLength, constants } from './buffer.js';
+export { Buffer, SlowBuffer, kMaxLength, kStringMaxLength, constants, };
+import { Blob as BlobImpl, File as FileImpl } from './blob.js';
+export { BlobImpl as Blob, FileImpl as File };
+export declare const atob: typeof globalThis.atob;
+export declare const btoa: typeof globalThis.btoa;
+export declare const INSPECT_MAX_BYTES = 50;
+declare const _default: {
+    Buffer: typeof Buffer;
+    SlowBuffer: typeof SlowBuffer;
+    Blob: {
+        new (parts?: BlobPart[], options?: BlobPropertyBag): {
+            _parts: BlobPart[];
+            readonly size: number;
+            readonly type: string;
+            bytes(): Promise<Uint8Array<ArrayBuffer>>;
+            text(): Promise<string>;
+            arrayBuffer(): Promise<ArrayBuffer>;
+            slice(start?: number, end?: number, type?: string): Blob;
+            stream(): ReadableStream;
+        };
+    } | {
+        new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+        prototype: Blob;
+    };
+    File: any;
+    atob: typeof globalThis.atob;
+    btoa: typeof globalThis.btoa;
+    kMaxLength: number;
+    kStringMaxLength: number;
+    constants: {
+        MAX_LENGTH: number;
+        MAX_STRING_LENGTH: number;
+    };
+    INSPECT_MAX_BYTES: number;
+};
+export default _default;

package/package.json

@@ -1,32 +1,26 @@
 {
   "name": "@gjsify/buffer",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Node.js buffer module for Gjs",
   "type": "module",
-  "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
   "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/buffer'",
-    "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,12 +30,12 @@
     "buffer"
   ],
   "devDependencies": {
-    "@gjsify/cli": "^0.0.4",
-    "@gjsify/unit": "^0.0.4",
-    "@types/node": "^20.10.5",
-    "typescript": "^5.3.3"
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   },
   "dependencies": {
-    "@gjsify/deno_std": "^0.0.4"
+    "@gjsify/utils": "^0.1.0"
   }
 }

package/src/blob.ts

@@ -0,0 +1,77 @@
+// WHATWG Blob/File polyfill for GJS
+// Reference: Node.js lib/buffer.js (Blob), refs/deno/ext/web/09_file.js
+// Node.js exports Blob from 'node:buffer' since v18.
+// On GJS, globalThis.Blob is not available — this provides a minimal polyfill.
+
+const _encoder = new TextEncoder();
+
+class BlobPolyfill implements Blob {
+  _parts: BlobPart[];
+  readonly size: number;
+  readonly type: string;
+
+  constructor(parts?: BlobPart[], options?: BlobPropertyBag) {
+    this._parts = parts || [];
+    this.type = options?.type || '';
+    this.size = this._parts.reduce((acc: number, part: BlobPart) => {
+      if (typeof part === 'string') return acc + _encoder.encode(part).byteLength;
+      if (part instanceof ArrayBuffer) return acc + part.byteLength;
+      if (ArrayBuffer.isView(part)) return acc + part.byteLength;
+      if (part && typeof (part as Blob).size === 'number') return acc + (part as Blob).size;
+      return acc;
+    }, 0);
+  }
+
+  async bytes(): Promise<Uint8Array<ArrayBuffer>> {
+    const ab = await this.arrayBuffer();
+    return new Uint8Array(ab);
+  }
+
+  async text(): Promise<string> {
+    return new TextDecoder().decode(await this.arrayBuffer());
+  }
+
+  async arrayBuffer(): Promise<ArrayBuffer> {
+    const chunks: Uint8Array[] = [];
+    for (const part of this._parts) {
+      if (typeof part === 'string') chunks.push(_encoder.encode(part));
+      else if (part instanceof ArrayBuffer) chunks.push(new Uint8Array(part));
+      else if (ArrayBuffer.isView(part)) chunks.push(new Uint8Array(part.buffer as ArrayBuffer, part.byteOffset, part.byteLength));
+      else if (part && typeof (part as Blob).arrayBuffer === 'function') {
+        const ab = await (part as Blob).arrayBuffer();
+        chunks.push(new Uint8Array(ab));
+      }
+    }
+    const total = chunks.reduce((a, c) => a + c.byteLength, 0);
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) { result.set(c, offset); offset += c.byteLength; }
+    return result.buffer as ArrayBuffer;
+  }
+
+  slice(start?: number, end?: number, type?: string): Blob {
+    return new BlobPolyfill([], { type }) as unknown as Blob;
+  }
+
+  stream(): ReadableStream {
+    throw new Error('Blob.stream() not implemented');
+  }
+}
+
+class FilePolyfill extends BlobPolyfill {
+  readonly name: string;
+  readonly lastModified: number;
+  readonly webkitRelativePath: string = '';
+
+  constructor(parts: BlobPart[], name: string, options?: FilePropertyBag) {
+    super(parts, options);
+    this.name = name;
+    this.lastModified = options?.lastModified ?? Date.now();
+  }
+}
+
+// Use native if available, polyfill otherwise
+const Blob = globalThis.Blob ?? BlobPolyfill;
+const File = (globalThis as any).File ?? FilePolyfill;
+
+export { Blob, File };