@gjsify/dom-events 0.0.4 → 0.1.1

package/lib/types/index.d.ts

@@ -1 +1,307 @@
-export * from '@gjsify/deno-runtime/ext/web/02_event';
+import { DOMException } from '@gjsify/dom-exception';
+export { DOMException };
+type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+interface EventListener {
+    (evt: Event): void;
+}
+interface EventListenerObject {
+    handleEvent(evt: Event): void;
+}
+interface AddEventListenerOptions extends EventListenerOptions {
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+}
+interface EventListenerOptions {
+    capture?: boolean;
+}
+interface EventInit {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}
+interface CustomEventInit<T = any> extends EventInit {
+    detail?: T;
+}
+declare const kType: unique symbol;
+declare const kBubbles: unique symbol;
+declare const kCancelable: unique symbol;
+declare const kComposed: unique symbol;
+declare const kTarget: unique symbol;
+declare const kCurrentTarget: unique symbol;
+declare const kEventPhase: unique symbol;
+declare const kDefaultPrevented: unique symbol;
+declare const kIsTrusted: unique symbol;
+declare const kTimeStamp: unique symbol;
+declare const kStop: unique symbol;
+declare const kImmediateStop: unique symbol;
+declare const kDispatching: unique symbol;
+declare const kInPassiveListener: unique symbol;
+export declare class Event {
+    private [kType];
+    private [kBubbles];
+    private [kCancelable];
+    private [kComposed];
+    private [kTarget];
+    private [kCurrentTarget];
+    private [kEventPhase];
+    private [kDefaultPrevented];
+    private [kIsTrusted];
+    private [kTimeStamp];
+    private [kStop];
+    private [kImmediateStop];
+    private [kDispatching];
+    private [kInPassiveListener];
+    get type(): string;
+    get bubbles(): boolean;
+    get cancelable(): boolean;
+    get composed(): boolean;
+    get target(): EventTarget | null;
+    get currentTarget(): EventTarget | null;
+    get eventPhase(): number;
+    get defaultPrevented(): boolean;
+    get timeStamp(): number;
+    get cancelBubble(): boolean;
+    set cancelBubble(value: boolean);
+    get returnValue(): boolean;
+    set returnValue(value: boolean);
+    get srcElement(): EventTarget | null;
+    static readonly NONE = 0;
+    static readonly CAPTURING_PHASE = 1;
+    static readonly AT_TARGET = 2;
+    static readonly BUBBLING_PHASE = 3;
+    readonly NONE: 0;
+    readonly CAPTURING_PHASE: 1;
+    readonly AT_TARGET: 2;
+    readonly BUBBLING_PHASE: 3;
+    get [Symbol.toStringTag](): string;
+    constructor(type: string, eventInitDict?: EventInit);
+    composedPath(): EventTarget[];
+    preventDefault(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+}
+export declare class CustomEvent<T = any> extends Event {
+    readonly detail: T;
+    constructor(type: string, eventInitDict?: CustomEventInit<T>);
+}
+interface MessageEventInit<T = any> extends EventInit {
+    data?: T;
+    origin?: string;
+    lastEventId?: string;
+    source?: EventTarget | null;
+    ports?: MessagePort[];
+}
+export declare class MessageEvent<T = any> extends Event {
+    readonly data: T;
+    readonly origin: string;
+    readonly lastEventId: string;
+    readonly source: EventTarget | null;
+    readonly ports: readonly MessagePort[];
+    constructor(type: string, eventInitDict?: MessageEventInit<T>);
+    get [Symbol.toStringTag](): string;
+}
+interface ErrorEventInit extends EventInit {
+    message?: string;
+    filename?: string;
+    lineno?: number;
+    colno?: number;
+    error?: unknown;
+}
+export declare class ErrorEvent extends Event {
+    readonly message: string;
+    readonly filename: string;
+    readonly lineno: number;
+    readonly colno: number;
+    readonly error: unknown;
+    constructor(type: string, eventInitDict?: ErrorEventInit);
+    get [Symbol.toStringTag](): string;
+}
+interface CloseEventInit extends EventInit {
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+}
+export declare class CloseEvent extends Event {
+    readonly code: number;
+    readonly reason: string;
+    readonly wasClean: boolean;
+    constructor(type: string, eventInitDict?: CloseEventInit);
+    get [Symbol.toStringTag](): string;
+}
+interface ProgressEventInit extends EventInit {
+    lengthComputable?: boolean;
+    loaded?: number;
+    total?: number;
+}
+export declare class ProgressEvent extends Event {
+    readonly lengthComputable: boolean;
+    readonly loaded: number;
+    readonly total: number;
+    constructor(type: string, eventInitDict?: ProgressEventInit);
+    get [Symbol.toStringTag](): string;
+}
+export declare class EventTarget {
+    private _listeners;
+    get [Symbol.toStringTag](): string;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    dispatchEvent(event: Event): boolean;
+}
+interface UIEventInit extends EventInit {
+    detail?: number;
+    view?: null;
+}
+export declare class UIEvent extends Event {
+    readonly detail: number;
+    readonly view: null;
+    constructor(type: string, eventInitDict?: UIEventInit);
+    get [Symbol.toStringTag](): string;
+}
+interface MouseEventInit extends UIEventInit {
+    altKey?: boolean;
+    button?: number;
+    buttons?: number;
+    clientX?: number;
+    clientY?: number;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    movementX?: number;
+    movementY?: number;
+    offsetX?: number;
+    offsetY?: number;
+    screenX?: number;
+    screenY?: number;
+    shiftKey?: boolean;
+    relatedTarget?: EventTarget | null;
+}
+export declare class MouseEvent extends UIEvent {
+    readonly altKey: boolean;
+    readonly button: number;
+    readonly buttons: number;
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    readonly movementX: number;
+    readonly movementY: number;
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly screenX: number;
+    readonly screenY: number;
+    readonly shiftKey: boolean;
+    readonly relatedTarget: EventTarget | null;
+    get pageX(): number;
+    get pageY(): number;
+    get x(): number;
+    get y(): number;
+    constructor(type: string, eventInitDict?: MouseEventInit);
+    getModifierState(key: string): boolean;
+    get [Symbol.toStringTag](): string;
+}
+interface PointerEventInit extends MouseEventInit {
+    pointerId?: number;
+    width?: number;
+    height?: number;
+    pressure?: number;
+    tangentialPressure?: number;
+    tiltX?: number;
+    tiltY?: number;
+    twist?: number;
+    altitudeAngle?: number;
+    azimuthAngle?: number;
+    pointerType?: string;
+    isPrimary?: boolean;
+}
+export declare class PointerEvent extends MouseEvent {
+    readonly pointerId: number;
+    readonly width: number;
+    readonly height: number;
+    readonly pressure: number;
+    readonly tangentialPressure: number;
+    readonly tiltX: number;
+    readonly tiltY: number;
+    readonly twist: number;
+    readonly altitudeAngle: number;
+    readonly azimuthAngle: number;
+    readonly pointerType: string;
+    readonly isPrimary: boolean;
+    constructor(type: string, eventInitDict?: PointerEventInit);
+    getCoalescedEvents(): PointerEvent[];
+    getPredictedEvents(): PointerEvent[];
+    get [Symbol.toStringTag](): string;
+}
+interface KeyboardEventInit extends UIEventInit {
+    altKey?: boolean;
+    code?: string;
+    ctrlKey?: boolean;
+    isComposing?: boolean;
+    key?: string;
+    location?: number;
+    metaKey?: boolean;
+    repeat?: boolean;
+    shiftKey?: boolean;
+    keyCode?: number;
+    which?: number;
+}
+export declare class KeyboardEvent extends UIEvent {
+    readonly altKey: boolean;
+    readonly code: string;
+    readonly ctrlKey: boolean;
+    readonly isComposing: boolean;
+    readonly key: string;
+    readonly location: number;
+    readonly metaKey: boolean;
+    readonly repeat: boolean;
+    readonly shiftKey: boolean;
+    readonly keyCode: number;
+    readonly which: number;
+    static readonly DOM_KEY_LOCATION_STANDARD = 0;
+    static readonly DOM_KEY_LOCATION_LEFT = 1;
+    static readonly DOM_KEY_LOCATION_RIGHT = 2;
+    static readonly DOM_KEY_LOCATION_NUMPAD = 3;
+    constructor(type: string, eventInitDict?: KeyboardEventInit);
+    getModifierState(key: string): boolean;
+    get [Symbol.toStringTag](): string;
+}
+interface WheelEventInit extends MouseEventInit {
+    deltaX?: number;
+    deltaY?: number;
+    deltaZ?: number;
+    deltaMode?: number;
+}
+export declare class WheelEvent extends MouseEvent {
+    readonly deltaX: number;
+    readonly deltaY: number;
+    readonly deltaZ: number;
+    readonly deltaMode: number;
+    static readonly DOM_DELTA_PIXEL = 0;
+    static readonly DOM_DELTA_LINE = 1;
+    static readonly DOM_DELTA_PAGE = 2;
+    constructor(type: string, eventInitDict?: WheelEventInit);
+    get [Symbol.toStringTag](): string;
+}
+interface FocusEventInit extends UIEventInit {
+    relatedTarget?: EventTarget | null;
+}
+export declare class FocusEvent extends UIEvent {
+    readonly relatedTarget: EventTarget | null;
+    constructor(type: string, eventInitDict?: FocusEventInit);
+    get [Symbol.toStringTag](): string;
+}
+declare const _default: {
+    Event: typeof Event;
+    CustomEvent: typeof CustomEvent;
+    EventTarget: typeof EventTarget;
+    MessageEvent: typeof MessageEvent;
+    ErrorEvent: typeof ErrorEvent;
+    CloseEvent: typeof CloseEvent;
+    ProgressEvent: typeof ProgressEvent;
+    UIEvent: typeof UIEvent;
+    MouseEvent: typeof MouseEvent;
+    PointerEvent: typeof PointerEvent;
+    KeyboardEvent: typeof KeyboardEvent;
+    WheelEvent: typeof WheelEvent;
+    FocusEvent: typeof FocusEvent;
+};
+export default _default;

package/package.json

@@ -1,32 +1,26 @@
 {
   "name": "@gjsify/dom-events",
-  "version": "0.0.4",
+  "version": "0.1.1",
   "description": "Web events module for Gjs",
-  "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
-  "types": "lib/types/index.d.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"
+    },
+    "./globals": "./globals.mjs"
   },
   "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo test.gjs.mjs",
-    "print:name": "echo '@gjsify/dom-events'",
-    "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",
     "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.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"
   },
   "keywords": [
@@ -34,13 +28,13 @@
     "node",
     "event"
   ],
-  "devDependencies": {
-    "@gjsify/cli": "^0.0.4",
-    "@gjsify/unit": "^0.0.4",
-    "@types/node": "^20.10.5",
-    "typescript": "^5.3.3"
-  },
   "dependencies": {
-    "@gjsify/deno-runtime": "^0.0.4"
+    "@gjsify/dom-exception": "^0.1.1"
+  },
+  "devDependencies": {
+    "@gjsify/cli": "^0.1.1",
+    "@gjsify/unit": "^0.1.1",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   }
 }

package/src/error-handler.spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, assert, spy, on } from '@gjsify/unit';
 
-import { Event, EventTarget } from "@gjsify/dom-events";
-import process from 'process';
+import { Event, EventTarget } from "dom-events";
+import process from 'node:process';
 
 export const ErrorHandlerTest = async () => {
     await describe("The default error handler", async () => {

package/src/event-target.spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, assert, Spy, spy, beforeEach } from '@gjsify/unit';
 
-import { Event, EventTarget } from "@gjsify/dom-events";
-import { AbortSignal } from "@gjsify/abort-controller";
+import { Event, EventTarget } from "dom-events";
+import { AbortSignal } from "abort-controller";
 
 export const EventTargetTest = async () => {
     await describe("EventTarget.constructor", async () => {

package/src/event.spec.ts

@@ -1,9 +1,10 @@
 import { describe, it, expect, assert } from '@gjsify/unit';
 
-import { Event, EventTarget } from '@gjsify/dom-events';
+import { Event, EventTarget } from 'dom-events';
 
 
-// Credits https://github.com/mysticatea/event-target-shim/blob/master/test/event.ts
+// Ported from event-target-shim (https://github.com/mysticatea/event-target-shim/blob/master/test/event.ts)
+// Original: MIT license, Toru Nagashima
 
 export const EventTest = async () => {