@gjsify/abort-controller 0.0.2

package/README.md

@@ -0,0 +1,4 @@
+# @gjsify/abort-controller
+
+Web abort-controller module for Gjs
+

package/lib/cjs/index.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+var import_dom_events = require("@gjsify/dom-events");
+__reExport(src_exports, require("@gjsify/deno-runtime/ext/web/03_abort_signal"), module.exports);

package/lib/esm/index.js

@@ -0,0 +1,2 @@
+import "@gjsify/dom-events";
+export * from "@gjsify/deno-runtime/ext/web/03_abort_signal";

package/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+import '@gjsify/dom-events';
+export * from '@gjsify/deno-runtime/ext/web/03_abort_signal';

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@gjsify/abort-controller",
+  "version": "0.0.2",
+  "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"
+      }
+    }
+  },
+  "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",
+    "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: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:gjs": "gjs -m test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "buffer"
+  ],
+  "devDependencies": {
+    "@gjsify/cli": "^0.0.2",
+    "@gjsify/unit": "^0.0.2",
+    "@types/node": "^20.3.1",
+    "typescript": "^5.1.3"
+  },
+  "dependencies": {
+    "@gjsify/deno-runtime": "^0.0.2",
+    "@gjsify/deno_std": "^0.0.2",
+    "@gjsify/dom-events": "^0.0.2"
+  }
+}

package/src/abort-controller.spec.ts

@@ -0,0 +1,169 @@
+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';
+
+const HAS_EVENT_TARGET_INTERFACE = typeof EventTarget !== "undefined"
+
+export default async () => {
+
+	// Credits https://github.com/mysticatea/abort-controller/tree/master/test
+
+	await describe('AbortController', async () => {
+		await it('should have a callable constructor', async () => {
+			expect(() => {
+				new AbortController();
+			}).not.toThrow();
+		});
+
+		await it('should not be callable', async () => {
+			expect(AbortController).toThrow();
+		});
+
+		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)
+			}
+
+			keys.forEach((key) => {
+				assert(false, `'${key}' not found`);
+			})
+		});
+
+		// TODO
+		// await it('should be stringified as [object AbortController]', async () => {
+		// 	const controller = new AbortController();
+		// 	expect(controller.toString()).toBe("[object AbortController]")
+		// });
+
+		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()
+			})
+
+			if(HAS_EVENT_TARGET_INTERFACE) {
+				await it("should be a EventTarget object", async () => {
+					expect(signal instanceof EventTarget).toBeTruthy()
+				})
+			}
+	
+			await it("should have 5 properties", async () => {
+				const keys = new Set<string>()
+				keys.add("addEventListener")
+				keys.add("removeEventListener")
+				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;
+
+					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__,
+					"aborted",
+				)!.get
+
+				expect(() => {
+					getAborted!.call({})
+				}).toThrow(TypeError);
+			});
+
+			await it("should be stringified as [object AbortSignal]", async () => {
+				expect(signal.toString()).toBe("[object AbortSignal]")
+			});
+		});
+
+		await describe("'abort' method", async () => {
+
+			await it("should set true to 'signal.aborted' property", async () => {
+				const controller = new AbortController();
+
+				controller.abort()
+				assert(controller.signal.aborted)
+			})
+	
+			await it("should fire 'abort' event on 'signal' (addEventListener)", async () => {
+				const controller = new AbortController();
+
+				let calls = 0;
+				controller.signal.addEventListener("abort", () => {
+					++calls;
+				});
+				controller.abort()
+	
+				assert(calls === 1)
+			})
+	
+			await it("should fire 'abort' event on 'signal' (onabort)", async () => {
+				const controller = new AbortController();
+
+				let calls = 0;
+				// TODO:
+				(controller.signal as any).onabort = () => {
+					++calls;
+				}
+				controller.abort()
+	
+				assert(calls === 1)
+			})
+	
+			await it("should not fire 'abort' event twice", async () => {
+				const controller = new AbortController();
+
+				let calls = 0;
+				controller.signal.addEventListener("abort", () => {
+					++calls;
+				});
+				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();
+
+				expect(() => {
+					controller.abort.call({})
+				}).toThrow(TypeError)
+			})
+		})
+
+	});
+}

package/src/abort-signal.spec.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from '@gjsify/unit';
+
+import { AbortSignal } from '@gjsify/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
+
+	await describe("AbortSignal", async () => {
+		await it("should not be callable", async () => {
+			expect(() => {
+				(AbortSignal as any)()
+			}).toThrow(TypeError);
+		});
+	
+		await it("should throw a TypeError when it's constructed directly", async () => {
+			expect(() => {
+				new AbortSignal()
+			}).toThrow(TypeError);
+		});
+	})
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+import '@gjsify/dom-events'
+export * from '@gjsify/deno-runtime/ext/web/03_abort_signal'

package/src/test.mts

@@ -0,0 +1,6 @@
+import { run } from '@gjsify/unit';
+
+import abortControllerTestSuite from './abort-controller.spec.js';
+import abortSignalTestSuite from './abort-signal.spec.js';
+
+run({abortControllerTestSuite, abortSignalTestSuite});