@gjsify/web-globals 0.0.3 → 0.1.0

package/README.md

@@ -1,6 +1,26 @@
-# @gjsify/web-events
+# @gjsify/web-globals
 
-## Inspirations and credits
-- https://deno.land/manual@v1.25.0/runtime/program_lifecycle
-- https://github.com/jsdom/jsdom/tree/master/lib/jsdom/living/events
-- https://github.com/capricorn86/happy-dom/tree/master/packages/happy-dom/src/event
+Re-exports Web API globals from dom-events and abort-controller for GJS.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/web-globals
+# or
+yarn add @gjsify/web-globals
+```
+
+## Usage
+
+```typescript
+import '@gjsify/web-globals';
+
+// Web API globals like Event, CustomEvent, EventTarget,
+// AbortController, and AbortSignal are now available.
+```
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -1,2 +1,54 @@
+import "@gjsify/dom-exception";
 import "@gjsify/dom-events";
 import "@gjsify/abort-controller";
+import "@gjsify/web-streams";
+import "@gjsify/compression-streams";
+import "@gjsify/webcrypto";
+import "@gjsify/eventsource";
+import { URL, URLSearchParams } from "@gjsify/url";
+if (typeof globalThis.URL !== "function") {
+  Object.defineProperty(globalThis, "URL", { value: URL, writable: true, configurable: true });
+}
+if (typeof globalThis.URLSearchParams !== "function") {
+  Object.defineProperty(globalThis, "URLSearchParams", { value: URLSearchParams, writable: true, configurable: true });
+}
+import { Blob, File } from "@gjsify/buffer";
+if (typeof globalThis.Blob !== "function") {
+  Object.defineProperty(globalThis, "Blob", { value: Blob, writable: true, configurable: true });
+}
+if (typeof globalThis.File !== "function") {
+  Object.defineProperty(globalThis, "File", { value: File, writable: true, configurable: true });
+}
+import { FormData } from "@gjsify/formdata";
+if (typeof globalThis.FormData !== "function") {
+  Object.defineProperty(globalThis, "FormData", { value: FormData, writable: true, configurable: true });
+}
+import { performance, PerformanceObserver } from "@gjsify/perf_hooks";
+if (!globalThis.performance) {
+  Object.defineProperty(globalThis, "performance", { value: performance, writable: true, configurable: true });
+}
+if (typeof globalThis.PerformanceObserver !== "function") {
+  Object.defineProperty(globalThis, "PerformanceObserver", { value: PerformanceObserver, writable: true, configurable: true });
+}
+import { DOMException } from "@gjsify/dom-exception";
+import { Event, EventTarget, CustomEvent } from "@gjsify/dom-events";
+import { AbortController, AbortSignal } from "@gjsify/abort-controller";
+import { URL as URL2, URLSearchParams as URLSearchParams2 } from "@gjsify/url";
+import { Blob as Blob2, File as File2 } from "@gjsify/buffer";
+import { FormData as FormData2 } from "@gjsify/formdata";
+import { performance as performance2, PerformanceObserver as PerformanceObserver2 } from "@gjsify/perf_hooks";
+export {
+  AbortController,
+  AbortSignal,
+  Blob2 as Blob,
+  CustomEvent,
+  DOMException,
+  Event,
+  EventTarget,
+  File2 as File,
+  FormData2 as FormData,
+  PerformanceObserver2 as PerformanceObserver,
+  URL2 as URL,
+  URLSearchParams2 as URLSearchParams,
+  performance2 as performance
+};

package/lib/types/index.d.ts

@@ -0,0 +1,14 @@
+import '@gjsify/dom-exception';
+import '@gjsify/dom-events';
+import '@gjsify/abort-controller';
+import '@gjsify/web-streams';
+import '@gjsify/compression-streams';
+import '@gjsify/webcrypto';
+import '@gjsify/eventsource';
+export { DOMException } from '@gjsify/dom-exception';
+export { Event, EventTarget, CustomEvent } from '@gjsify/dom-events';
+export { AbortController, AbortSignal } from '@gjsify/abort-controller';
+export { URL, URLSearchParams } from '@gjsify/url';
+export { Blob, File } from '@gjsify/buffer';
+export { FormData } from '@gjsify/formdata';
+export { performance, PerformanceObserver } from '@gjsify/perf_hooks';

package/package.json

@@ -1,42 +1,49 @@
 {
   "name": "@gjsify/web-globals",
-  "version": "0.0.3",
-  "description": "Web global module for Gjs",
-  "main": "lib/cjs/index.js",
+  "version": "0.1.0",
+  "description": "Unified Web API globals for GJS — single import for all Web standard polyfills",
   "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/web-events'",
-    "build": "yarn print:name && yarn build:gjsify",
+    "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",
-    "build:test": "yarn build:test:gjs && yarn build:test:node",
+    "build:types": "tsc",
+    "build:test": "yarn build:test:gjs",
     "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:gjs": "gjs -m test.gjs.mjs",
-    "test:node": "node test.node.mjs"
+    "test": "yarn build:gjsify && yarn build:test && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs"
   },
   "keywords": [
     "gjs",
-    "node",
-    "fs"
+    "web-globals",
+    "polyfill",
+    "web-apis"
   ],
+  "dependencies": {
+    "@gjsify/abort-controller": "^0.1.0",
+    "@gjsify/buffer": "^0.1.0",
+    "@gjsify/compression-streams": "^0.1.0",
+    "@gjsify/dom-events": "^0.1.0",
+    "@gjsify/dom-exception": "^0.1.0",
+    "@gjsify/eventsource": "^0.1.0",
+    "@gjsify/formdata": "^0.1.0",
+    "@gjsify/perf_hooks": "^0.1.0",
+    "@gjsify/url": "^0.1.0",
+    "@gjsify/web-streams": "^0.1.0",
+    "@gjsify/webcrypto": "^0.1.0"
+  },
   "devDependencies": {
-    "@gjsify/cli": "^0.0.3",
-    "@gjsify/unit": "^0.0.3",
-    "@types/node": "^20.3.1"
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   }
 }

package/src/index.spec.ts

@@ -1,9 +1,276 @@
+// Tests for @gjsify/web-globals — verify all Web API globals are registered
 import { describe, it, expect } from '@gjsify/unit';
 
+// Side-effect import — registers all globals
+import '@gjsify/web-globals';
+
 export default async () => {
-	await describe('web-events', async () => {
-		await it('should be true', async () => {
-			expect(true).toBeTruthy()
-		});
-	});
-}
+  await describe('web-globals', async () => {
+
+    // ==================== DOMException ====================
+    await describe('DOMException', async () => {
+      await it('should be available as global', async () => {
+        expect(typeof globalThis.DOMException).toBe('function');
+      });
+
+      await it('should be constructable with message and name', async () => {
+        const err = new DOMException('test', 'AbortError');
+        expect(err.message).toBe('test');
+        expect(err.name).toBe('AbortError');
+        expect(err.code).toBe(20);
+      });
+
+      await it('should have standard error codes', async () => {
+        expect(new DOMException('', 'NotFoundError').code).toBe(8);
+        expect(new DOMException('', 'NotSupportedError').code).toBe(9);
+        expect(new DOMException('', 'InvalidStateError').code).toBe(11);
+        expect(new DOMException('', 'SyntaxError').code).toBe(12);
+        expect(new DOMException('', 'TimeoutError').code).toBe(23);
+        expect(new DOMException('', 'DataCloneError').code).toBe(25);
+      });
+
+      await it('should be an instance of Error', async () => {
+        const err = new DOMException('test');
+        expect(err instanceof Error).toBe(true);
+      });
+    });
+
+    // ==================== DOM Events ====================
+    await describe('DOM Events', async () => {
+      await it('Event should be available as global', async () => {
+        expect(typeof globalThis.Event).toBe('function');
+      });
+
+      await it('EventTarget should be available as global', async () => {
+        expect(typeof globalThis.EventTarget).toBe('function');
+      });
+
+      await it('Event should be constructable', async () => {
+        const event = new Event('test');
+        expect(event.type).toBe('test');
+        expect(event.bubbles).toBe(false);
+        expect(event.cancelable).toBe(false);
+      });
+
+      await it('EventTarget should dispatch events', async () => {
+        const target = new EventTarget();
+        let called = false;
+        target.addEventListener('test', () => { called = true; });
+        target.dispatchEvent(new Event('test'));
+        expect(called).toBe(true);
+      });
+    });
+
+    // ==================== AbortController / AbortSignal ====================
+    await describe('AbortController', async () => {
+      await it('AbortController should be available as global', async () => {
+        expect(typeof globalThis.AbortController).toBe('function');
+      });
+
+      await it('AbortSignal should be available as global', async () => {
+        expect(typeof globalThis.AbortSignal).toBe('function');
+      });
+
+      await it('should create controller with signal', async () => {
+        const ac = new AbortController();
+        expect(ac.signal).toBeDefined();
+        expect(ac.signal.aborted).toBe(false);
+      });
+
+      await it('abort() should set signal.aborted to true', async () => {
+        const ac = new AbortController();
+        ac.abort();
+        expect(ac.signal.aborted).toBe(true);
+      });
+    });
+
+    // ==================== Web Streams ====================
+    await describe('Web Streams', async () => {
+      await it('ReadableStream should be available as global', async () => {
+        expect(typeof globalThis.ReadableStream).toBe('function');
+      });
+
+      await it('WritableStream should be available as global', async () => {
+        expect(typeof globalThis.WritableStream).toBe('function');
+      });
+
+      await it('TransformStream should be available as global', async () => {
+        expect(typeof globalThis.TransformStream).toBe('function');
+      });
+
+      await it('ReadableStream should be constructable', async () => {
+        const rs = new ReadableStream({
+          start(controller) {
+            controller.enqueue('test');
+            controller.close();
+          },
+        });
+        expect(rs).toBeDefined();
+        const reader = rs.getReader();
+        const { value } = await reader.read();
+        expect(value).toBe('test');
+      });
+
+      await it('WritableStream should be constructable', async () => {
+        let received = '';
+        const ws = new WritableStream({
+          write(chunk) { received += chunk; },
+        });
+        const writer = ws.getWriter();
+        await writer.write('hello');
+        await writer.close();
+        expect(received).toBe('hello');
+      });
+
+      await it('TransformStream should be constructable', async () => {
+        const ts = new TransformStream({
+          transform(chunk, controller) {
+            controller.enqueue(String(chunk).toUpperCase());
+          },
+        });
+        expect(ts.readable).toBeDefined();
+        expect(ts.writable).toBeDefined();
+      });
+    });
+
+    // ==================== TextEncoderStream / TextDecoderStream ====================
+    await describe('Encoding Streams', async () => {
+      await it('TextEncoderStream should be available as global', async () => {
+        expect(typeof globalThis.TextEncoderStream).toBe('function');
+      });
+
+      await it('TextDecoderStream should be available as global', async () => {
+        expect(typeof globalThis.TextDecoderStream).toBe('function');
+      });
+    });
+
+    // ==================== Compression Streams ====================
+    await describe('Compression Streams', async () => {
+      await it('CompressionStream should be available as global', async () => {
+        expect(typeof globalThis.CompressionStream).toBe('function');
+      });
+
+      await it('DecompressionStream should be available as global', async () => {
+        expect(typeof globalThis.DecompressionStream).toBe('function');
+      });
+    });
+
+    // ==================== WebCrypto ====================
+    await describe('WebCrypto', async () => {
+      await it('crypto should be available as global', async () => {
+        expect(typeof globalThis.crypto).toBe('object');
+      });
+
+      await it('crypto.subtle should be available', async () => {
+        expect(globalThis.crypto.subtle).toBeDefined();
+      });
+
+      await it('crypto.getRandomValues should work', async () => {
+        const buf = new Uint8Array(16);
+        crypto.getRandomValues(buf);
+        // At least one byte should be non-zero (statistically almost certain)
+        expect(buf.some(b => b !== 0)).toBe(true);
+      });
+
+      await it('crypto.randomUUID should return a UUID string', async () => {
+        const uuid = crypto.randomUUID();
+        expect(typeof uuid).toBe('string');
+        expect(uuid.length).toBe(36);
+        expect(uuid[8]).toBe('-');
+        expect(uuid[13]).toBe('-');
+      });
+    });
+
+    // ==================== EventSource ====================
+    await describe('EventSource', async () => {
+      await it('EventSource should be available as global', async () => {
+        expect(typeof globalThis.EventSource).toBe('function');
+      });
+
+      await it('EventSource should have readyState constants', async () => {
+        expect(EventSource.CONNECTING).toBe(0);
+        expect(EventSource.OPEN).toBe(1);
+        expect(EventSource.CLOSED).toBe(2);
+      });
+    });
+
+    // ==================== URL / URLSearchParams ====================
+    await describe('URL', async () => {
+      await it('URL should be available as global', async () => {
+        expect(typeof globalThis.URL).toBe('function');
+      });
+
+      await it('should parse URLs correctly', async () => {
+        const u = new URL('https://example.com:8080/path?q=1#hash');
+        expect(u.hostname).toBe('example.com');
+        expect(u.port).toBe('8080');
+        expect(u.pathname).toBe('/path');
+        expect(u.search).toBe('?q=1');
+        expect(u.hash).toBe('#hash');
+      });
+
+      await it('URLSearchParams should be available as global', async () => {
+        expect(typeof globalThis.URLSearchParams).toBe('function');
+      });
+
+      await it('URLSearchParams should work', async () => {
+        const params = new URLSearchParams('a=1&b=2');
+        expect(params.get('a')).toBe('1');
+        expect(params.get('b')).toBe('2');
+      });
+    });
+
+    // ==================== Blob / File ====================
+    await describe('Blob', async () => {
+      await it('Blob should be available as global', async () => {
+        expect(typeof globalThis.Blob).toBe('function');
+      });
+
+      await it('should create Blob with correct size', async () => {
+        const blob = new Blob(['hello']);
+        expect(blob.size).toBe(5);
+        expect(blob.type).toBe('');
+      });
+
+      await it('should support type option', async () => {
+        const blob = new Blob(['{}'], { type: 'application/json' });
+        expect(blob.type).toBe('application/json');
+      });
+
+      await it('File should be available as global', async () => {
+        expect(typeof (globalThis as any).File).toBe('function');
+      });
+    });
+
+    // ==================== FormData ====================
+    await describe('FormData', async () => {
+      await it('FormData should be available as global', async () => {
+        expect(typeof globalThis.FormData).toBe('function');
+      });
+
+      await it('should support append and get', async () => {
+        const fd = new FormData();
+        fd.append('key', 'value');
+        expect(fd.get('key')).toBe('value');
+      });
+    });
+
+    // ==================== Performance ====================
+    await describe('Performance', async () => {
+      await it('performance should be available as global', async () => {
+        expect(globalThis.performance).toBeDefined();
+      });
+
+      await it('performance.now() should return a number', async () => {
+        const t = performance.now();
+        expect(typeof t).toBe('number');
+        expect(t).toBeGreaterThan(0);
+      });
+
+      await it('performance.timeOrigin should be a number', async () => {
+        expect(typeof performance.timeOrigin).toBe('number');
+        expect(performance.timeOrigin).toBeGreaterThan(0);
+      });
+    });
+  });
+};

package/src/index.ts

@@ -1,6 +1,69 @@
+// Unified Web API globals for GJS
+// Importing each package triggers its global registration (e.g. globalThis.Event = ...)
+// On Node.js, these are no-ops since natives are already available.
+
+// DOMException (WebIDL standard)
+import '@gjsify/dom-exception';
+
+// DOM Events: Event, EventTarget, CustomEvent
 import '@gjsify/dom-events';
+
+// AbortController, AbortSignal
 import '@gjsify/abort-controller';
 
-// TODO: Use url module from deno
-// import 'core-js/features/url/';
-// import 'core-js/features/url-search-params/';
+// WHATWG Streams: ReadableStream, WritableStream, TransformStream,
+// TextEncoderStream, TextDecoderStream, queuing strategies
+import '@gjsify/web-streams';
+
+// CompressionStream, DecompressionStream
+import '@gjsify/compression-streams';
+
+// WebCrypto: crypto.subtle, getRandomValues, randomUUID
+import '@gjsify/webcrypto';
+
+// EventSource (Server-Sent Events)
+import '@gjsify/eventsource';
+
+// --- Newly consolidated globals ---
+
+// URL, URLSearchParams (WHATWG URL Standard, GLib.Uri-based)
+import { URL, URLSearchParams } from '@gjsify/url';
+if (typeof globalThis.URL !== 'function') {
+  Object.defineProperty(globalThis, 'URL', { value: URL, writable: true, configurable: true });
+}
+if (typeof globalThis.URLSearchParams !== 'function') {
+  Object.defineProperty(globalThis, 'URLSearchParams', { value: URLSearchParams, writable: true, configurable: true });
+}
+
+// Blob, File (WHATWG File API)
+import { Blob, File } from '@gjsify/buffer';
+if (typeof globalThis.Blob !== 'function') {
+  Object.defineProperty(globalThis, 'Blob', { value: Blob, writable: true, configurable: true });
+}
+if (typeof (globalThis as any).File !== 'function') {
+  Object.defineProperty(globalThis, 'File', { value: File, writable: true, configurable: true });
+}
+
+// FormData (WHATWG XMLHttpRequest Standard)
+import { FormData } from '@gjsify/formdata';
+if (typeof globalThis.FormData !== 'function') {
+  Object.defineProperty(globalThis, 'FormData', { value: FormData, writable: true, configurable: true });
+}
+
+// Performance (Web Performance API)
+import { performance, PerformanceObserver } from '@gjsify/perf_hooks';
+if (!globalThis.performance) {
+  Object.defineProperty(globalThis, 'performance', { value: performance, writable: true, configurable: true });
+}
+if (typeof (globalThis as any).PerformanceObserver !== 'function') {
+  Object.defineProperty(globalThis, 'PerformanceObserver', { value: PerformanceObserver, writable: true, configurable: true });
+}
+
+// Re-export key types for convenience
+export { DOMException } from '@gjsify/dom-exception';
+export { Event, EventTarget, CustomEvent } from '@gjsify/dom-events';
+export { AbortController, AbortSignal } from '@gjsify/abort-controller';
+export { URL, URLSearchParams } from '@gjsify/url';
+export { Blob, File } from '@gjsify/buffer';
+export { FormData } from '@gjsify/formdata';
+export { performance, PerformanceObserver } from '@gjsify/perf_hooks';

package/src/test.mts

@@ -1,4 +1,4 @@
-
+import '@gjsify/node-globals';
 import { run } from '@gjsify/unit';
 
 import testSuite from './index.spec.js';

package/tsconfig.json

@@ -1,18 +1,31 @@
 {
   "compilerOptions": {
-    "module": "ESNext",
-    "types": ["node"],
+    "module": "NodeNext",
+    "types": [
+      "node"
+    ],
     "target": "ESNext",
     "moduleResolution": "NodeNext",
     "experimentalDecorators": true,
+    "emitDeclarationOnly": true,
+    "declaration": true,
     "outDir": "lib",
     "rootDir": "src",
-    "composite": true
+    "declarationDir": "lib/types",
+    "composite": true,
+    "skipLibCheck": true,
+    "allowJs": true,
+    "checkJs": false,
+    "strict": false
   },
-  "skipLibCheck": true,
-  "allowJs": true,
-  "checkJs": false,
   "reflection": false,
-  "include": ["src/**/*.ts"],
-  "exclude": ["src/test.mts", "src/**/*.spec.ts"]
-}
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "src/test.ts",
+    "src/test.mts",
+    "src/**/*.spec.ts",
+    "src/**/*.spec.mts"
+  ]
+}