@gjsify/abort-controller 0.0.4 → 0.1.1

package/README.md

@@ -1,4 +1,32 @@
 # @gjsify/abort-controller
 
-Web abort-controller module for Gjs
+GJS implementation of the AbortController and AbortSignal Web APIs.
 
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/abort-controller
+# or
+yarn add @gjsify/abort-controller
+```
+
+## Usage
+
+```typescript
+import { AbortController, AbortSignal } from '@gjsify/abort-controller';
+
+const controller = new AbortController();
+const signal = controller.signal;
+
+signal.addEventListener('abort', () => {
+  console.log('Aborted!');
+});
+
+controller.abort();
+```
+
+## License
+
+MIT

package/globals.mjs

@@ -0,0 +1,6 @@
+/**
+ * Re-exports native AbortController/AbortSignal globals for use in Node.js builds.
+ * On Node.js, AbortController and AbortSignal are native globals.
+ */
+export const AbortController = globalThis.AbortController;
+export const AbortSignal = globalThis.AbortSignal;

package/lib/esm/index.js

@@ -1,2 +1,94 @@
-import "@gjsify/dom-events";
-export * from "@gjsify/deno-runtime/ext/web/03_abort_signal";
+import { Event, EventTarget, DOMException } from "@gjsify/dom-events";
+const kAbort = /* @__PURE__ */ Symbol("abort");
+const kInternal = /* @__PURE__ */ Symbol("internal");
+class AbortSignal extends EventTarget {
+  #aborted = false;
+  reason = void 0;
+  onabort = null;
+  constructor(key) {
+    super();
+    if (key !== kInternal) {
+      throw new TypeError("Illegal constructor.");
+    }
+  }
+  get aborted() {
+    if (!(this instanceof AbortSignal)) {
+      throw new TypeError("'get aborted' called on an object that is not a valid instance of AbortSignal.");
+    }
+    return this.#aborted;
+  }
+  get [Symbol.toStringTag]() {
+    return "AbortSignal";
+  }
+  throwIfAborted() {
+    if (this.#aborted) {
+      throw this.reason;
+    }
+  }
+  [kAbort](reason) {
+    if (this.#aborted) return;
+    this.#aborted = true;
+    this.reason = reason ?? new DOMException("The operation was aborted.", "AbortError");
+    const event = new Event("abort");
+    if (typeof this.onabort === "function") {
+      this.onabort.call(this, event);
+    }
+    this.dispatchEvent(event);
+  }
+  static abort(reason) {
+    const signal = new AbortSignal(kInternal);
+    signal[kAbort](reason);
+    return signal;
+  }
+  static timeout(milliseconds) {
+    const signal = new AbortSignal(kInternal);
+    setTimeout(() => {
+      signal[kAbort](new DOMException("The operation timed out.", "TimeoutError"));
+    }, milliseconds);
+    return signal;
+  }
+  static any(signals) {
+    const combined = new AbortSignal(kInternal);
+    for (const signal of signals) {
+      if (signal.aborted) {
+        combined[kAbort](signal.reason);
+        return combined;
+      }
+    }
+    const onAbort = () => {
+      if (!combined.aborted) {
+        const aborted = signals.find((s) => s.aborted);
+        combined[kAbort](aborted?.reason);
+      }
+    };
+    for (const signal of signals) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    return combined;
+  }
+}
+class AbortController {
+  signal;
+  constructor() {
+    this.signal = new AbortSignal(kInternal);
+  }
+  abort(reason) {
+    if (!(this instanceof AbortController)) {
+      throw new TypeError("'abort' called on an object that is not a valid instance of AbortController.");
+    }
+    this.signal[kAbort](reason);
+  }
+}
+if (typeof globalThis.AbortController === "undefined") {
+  globalThis.AbortController = AbortController;
+}
+if (typeof globalThis.AbortSignal === "undefined") {
+  globalThis.AbortSignal = AbortSignal;
+}
+var index_default = { AbortController, AbortSignal };
+export {
+  AbortController,
+  AbortSignal,
+  DOMException,
+  index_default as default
+};

package/lib/types/index.d.ts

@@ -1,2 +1,26 @@
-import '@gjsify/dom-events';
-export * from '@gjsify/deno-runtime/ext/web/03_abort_signal';
+import { Event, EventTarget, DOMException } from '@gjsify/dom-events';
+declare const kAbort: unique symbol;
+export declare class AbortSignal extends EventTarget {
+    #private;
+    reason: any;
+    onabort: ((this: AbortSignal, ev: Event) => any) | null;
+    constructor(key?: symbol);
+    get aborted(): boolean;
+    get [Symbol.toStringTag](): string;
+    throwIfAborted(): void;
+    [kAbort](reason?: any): void;
+    static abort(reason?: any): AbortSignal;
+    static timeout(milliseconds: number): AbortSignal;
+    static any(signals: AbortSignal[]): AbortSignal;
+}
+export declare class AbortController {
+    readonly signal: AbortSignal;
+    constructor();
+    abort(reason?: any): void;
+}
+export { DOMException };
+declare const _default: {
+    AbortController: typeof AbortController;
+    AbortSignal: typeof AbortSignal;
+};
+export default _default;

package/package.json

@@ -1,33 +1,27 @@
 {
   "name": "@gjsify/abort-controller",
-  "version": "0.0.4",
+  "version": "0.1.1",
   "description": "Web AbortController 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"
+    },
+    "./globals": "./globals.mjs"
   },
   "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "print:name": "echo '@gjsify/abort-controller'",
-    "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:gjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:gjs",
     "test:gjs": "gjs -m test.gjs.mjs",
     "test:node": "node test.node.mjs"
   },
@@ -37,14 +31,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.1",
+    "@gjsify/unit": "^0.1.1",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   },
   "dependencies": {
-    "@gjsify/deno-runtime": "^0.0.4",
-    "@gjsify/deno_std": "^0.0.4",
-    "@gjsify/dom-events": "^0.0.4"
+    "@gjsify/dom-events": "^0.1.1"
   }
 }

package/src/abort-controller.spec.ts

@@ -1,13 +1,13 @@
 import { describe, it, expect, assert } from '@gjsify/unit';
 
-// TODO add a fake module for node and deno to run this tests also in his runtime?
-import { AbortController, AbortSignal } from '@gjsify/abort-controller';
+import { AbortController, AbortSignal } from 'abort-controller';
 
 const HAS_EVENT_TARGET_INTERFACE = typeof EventTarget !== "undefined"
 
 export default async () => {
 
-	// Credits https://github.com/mysticatea/abort-controller/tree/master/test
+	// Ported from abort-controller (https://github.com/mysticatea/abort-controller/tree/master/test)
+	// Original: MIT license, Toru Nagashima
 
 	await describe('AbortController', async () => {
 		await it('should have a callable constructor', async () => {
@@ -23,18 +23,10 @@ export default async () => {
 		await it('should have 2 properties', async () => {
 			const controller = new AbortController();
 
-			const keys = new Set()
-			keys.add("signal")
-			keys.add("abort")
-	
-			for (const key in controller) {
-				assert(keys.has(key), `'${key}' found, but should not have it`);
-				keys.delete(key)
+			const expected = ["signal", "abort"];
+			for (const key of expected) {
+				assert(key in controller, `'${key}' not found`);
 			}
-
-			keys.forEach((key) => {
-				assert(false, `'${key}' not found`);
-			})
 		});
 
 		// TODO
@@ -46,11 +38,11 @@ export default async () => {
 		await describe("'signal' property", async () => {
 			const controller = new AbortController();
 			const signal = controller.signal
-	
+
 			await it("should return the same instance always", async () => {
 				expect(signal === controller.signal).toBeTruthy()
 			})
-	
+
 			await it("should be a AbortSignal object", async () => {
 				expect(signal instanceof AbortSignal).toBeTruthy()
 			})
@@ -60,7 +52,7 @@ export default async () => {
 					expect(signal instanceof EventTarget).toBeTruthy()
 				})
 			}
-	
+
 			await it("should have 5 properties", async () => {
 				const keys = new Set<string>()
 				keys.add("addEventListener")
@@ -68,13 +60,13 @@ export default async () => {
 				keys.add("dispatchEvent")
 				keys.add("aborted")
 				keys.add("onabort")
-	
+
 				// TODO
 				// for (const key in signal) {
 				// 	assert(keys.has(key), `'${key}' found, but should not have it`);
 				// 	keys.delete(key)
 				// }
-	
+
 				keys.forEach(key => {
 					// WORKAROUND for getter / setter
 					const exists = (signal as any)[key] !== undefined;
@@ -82,16 +74,16 @@ export default async () => {
 					assert(exists, `'${key}' not found, but should have it: `);
 				})
 			})
-	
+
 			await it("should have 'aborted' property which is false by default", async () => {
 				expect(signal.aborted).toBeFalsy();
 			})
-	
+
 			await it("should have 'onabort' property which is null by default", async () => {
 				// TODO:
 				expect((signal as any).onabort).toBeNull()
 			})
-	
+
 			await it("should throw a TypeError if 'signal.aborted' getter is called with non AbortSignal object", async () => {
 				const getAborted = Object.getOwnPropertyDescriptor(
 					(signal as any).__proto__,
@@ -116,7 +108,7 @@ export default async () => {
 				controller.abort()
 				assert(controller.signal.aborted)
 			})
-	
+
 			await it("should fire 'abort' event on 'signal' (addEventListener)", async () => {
 				const controller = new AbortController();
 
@@ -125,10 +117,10 @@ export default async () => {
 					++calls;
 				});
 				controller.abort()
-	
+
 				assert(calls === 1)
 			})
-	
+
 			await it("should fire 'abort' event on 'signal' (onabort)", async () => {
 				const controller = new AbortController();
 
@@ -138,10 +130,10 @@ export default async () => {
 					++calls;
 				}
 				controller.abort()
-	
+
 				assert(calls === 1)
 			})
-	
+
 			await it("should not fire 'abort' event twice", async () => {
 				const controller = new AbortController();
 
@@ -152,10 +144,10 @@ export default async () => {
 				controller.abort()
 				controller.abort()
 				controller.abort()
-	
+
 				assert(calls === 1)
 			})
-	
+
 			await it("should throw a TypeError if 'this' is not an AbortController object", async () => {
 				const controller = new AbortController();
 

package/src/abort-signal.spec.ts

@@ -1,13 +1,14 @@
 import { describe, it, expect } from '@gjsify/unit';
 
-import { AbortSignal } from '@gjsify/abort-controller';
+import { AbortSignal } from 'abort-controller';
 
 // Use build in AbortSignal on Node.js tests and the custom implementation on Gjs
 // export const AbortSignal = globalThis.AbortSignal || GjsifyAbortSignal;
 
 export default async () => {
 
-	// Credits https://github.com/mysticatea/abort-controller/tree/master/test
+	// Ported from abort-controller (https://github.com/mysticatea/abort-controller/tree/master/test)
+	// Original: MIT license, Toru Nagashima
 
 	await describe("AbortSignal", async () => {
 		await it("should not be callable", async () => {

package/src/index.ts

@@ -1,2 +1,114 @@
-import '@gjsify/dom-events'
-export * from '@gjsify/deno-runtime/ext/web/03_abort_signal'
+// Reference: W3C DOM Abort API
+// Reimplemented for GJS
+
+import { Event, EventTarget, DOMException } from '@gjsify/dom-events';
+
+const kAbort = Symbol('abort');
+const kInternal = Symbol('internal');
+
+export class AbortSignal extends EventTarget {
+  #aborted: boolean = false;
+  reason: any = undefined;
+
+  onabort: ((this: AbortSignal, ev: Event) => any) | null = null;
+
+  constructor(key?: symbol) {
+    super();
+    if (key !== kInternal) {
+      throw new TypeError('Illegal constructor.');
+    }
+  }
+
+  get aborted(): boolean {
+    if (!(this instanceof AbortSignal)) {
+      throw new TypeError("'get aborted' called on an object that is not a valid instance of AbortSignal.");
+    }
+    return this.#aborted;
+  }
+
+  get [Symbol.toStringTag]() { return 'AbortSignal'; }
+
+  throwIfAborted(): void {
+    if (this.#aborted) {
+      throw this.reason;
+    }
+  }
+
+  [kAbort](reason?: any): void {
+    if (this.#aborted) return;
+
+    this.#aborted = true;
+    this.reason = reason ?? new DOMException('The operation was aborted.', 'AbortError');
+
+    const event = new Event('abort');
+    if (typeof this.onabort === 'function') {
+      this.onabort.call(this, event);
+    }
+    this.dispatchEvent(event);
+  }
+
+  static abort(reason?: any): AbortSignal {
+    const signal = new AbortSignal(kInternal);
+    signal[kAbort](reason);
+    return signal;
+  }
+
+  static timeout(milliseconds: number): AbortSignal {
+    const signal = new AbortSignal(kInternal);
+    setTimeout(() => {
+      signal[kAbort](new DOMException('The operation timed out.', 'TimeoutError'));
+    }, milliseconds);
+    return signal;
+  }
+
+  static any(signals: AbortSignal[]): AbortSignal {
+    const combined = new AbortSignal(kInternal);
+
+    for (const signal of signals) {
+      if (signal.aborted) {
+        combined[kAbort](signal.reason);
+        return combined;
+      }
+    }
+
+    const onAbort = () => {
+      if (!combined.aborted) {
+        const aborted = signals.find(s => s.aborted);
+        combined[kAbort](aborted?.reason);
+      }
+    };
+
+    for (const signal of signals) {
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+
+    return combined;
+  }
+}
+
+export class AbortController {
+  readonly signal: AbortSignal;
+
+  constructor() {
+    this.signal = new AbortSignal(kInternal);
+  }
+
+  abort(reason?: any): void {
+    if (!(this instanceof AbortController)) {
+      throw new TypeError("'abort' called on an object that is not a valid instance of AbortController.");
+    }
+    this.signal[kAbort](reason);
+  }
+}
+
+export { DOMException };
+
+// Register globals on GJS if needed (pattern: @gjsify/web-streams)
+if (typeof globalThis.AbortController === 'undefined') {
+  (globalThis as any).AbortController = AbortController;
+}
+if (typeof globalThis.AbortSignal === 'undefined') {
+  (globalThis as any).AbortSignal = AbortSignal;
+}
+
+export default { AbortController, AbortSignal };

package/tsconfig.json

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