@solid-primitives/event-listener - npm Package Compare versions

Comparing version 3.0.0-next.1 to 3.0.0-next.2

dist/callbackWrappers.d.ts

@@ -0,48 +1,52 @@
+/* @ts-self-types="./callbackWrappers.d.ts" */
+//#region src/callbackWrappers.d.ts
 /**
- * Calls `e.preventDefault()` on the `Event` and calls the {@link callback}
- *
- * @param callback Event handler
- * @returns Event handler matching {@link callback}'s type
- * @example
- * ```tsx
- * const handleClick = (e) => {
- *    concole.log("Click!", e)
- * }
- * makeEventListener(window, "click", preventDefault(handleClick), true);
- * // or in jsx:
- * <div onClick={preventDefault(handleClick)} />
- * ```
- */
-export declare const preventDefault: <E extends Event>(callback: (event: E) => void) => ((event: E) => void);
+* Calls `e.preventDefault()` on the `Event` and calls the {@link callback}
+*
+* @param callback Event handler
+* @returns Event handler matching {@link callback}'s type
+* @example
+* ```tsx
+* const handleClick = (e) => {
+*    concole.log("Click!", e)
+* }
+* makeEventListener(window, "click", preventDefault(handleClick), true);
+* // or in jsx:
+* <div onClick={preventDefault(handleClick)} />
+* ```
+*/
+declare const preventDefault: <E extends Event>(callback: (event: E) => void) => ((event: E) => void);
 /**
- * Calls `e.stopPropagation()` on the `Event` and calls the {@link callback}
- *
- * @param callback Event handler
- * @returns Event handler matching {@link callback}'s type
- * @example
- * ```tsx
- * const handleClick = (e) => {
- *    concole.log("Click!", e)
- * }
- * makeEventListener(window, "click", stopPropagation(handleClick), true);
- * // or in jsx:
- * <div onClick={stopPropagation(handleClick)} />
- * ```
- */
-export declare const stopPropagation: <E extends Event>(callback: (event: E) => void) => ((event: E) => void);
+* Calls `e.stopPropagation()` on the `Event` and calls the {@link callback}
+*
+* @param callback Event handler
+* @returns Event handler matching {@link callback}'s type
+* @example
+* ```tsx
+* const handleClick = (e) => {
+*    concole.log("Click!", e)
+* }
+* makeEventListener(window, "click", stopPropagation(handleClick), true);
+* // or in jsx:
+* <div onClick={stopPropagation(handleClick)} />
+* ```
+*/
+declare const stopPropagation: <E extends Event>(callback: (event: E) => void) => ((event: E) => void);
 /**
- * Calls `e.stopImmediatePropagation()` on the `Event` and calls the {@link callback}
- *
- * @param callback Event handler
- * @returns Event handler matching {@link callback}'s type
- * @example
- * ```tsx
- * const handleClick = (e) => {
- *    concole.log("Click!", e)
- * }
- * makeEventListener(window, "click", stopImmediatePropagation(handleClick), true);
- * // or in jsx:
- * <div onClick={stopImmediatePropagation(handleClick)} />
- * ```
- */
-export declare const stopImmediatePropagation: <E extends Event>(callback: (event: E) => void) => ((event: E) => void);
+* Calls `e.stopImmediatePropagation()` on the `Event` and calls the {@link callback}
+*
+* @param callback Event handler
+* @returns Event handler matching {@link callback}'s type
+* @example
+* ```tsx
+* const handleClick = (e) => {
+*    concole.log("Click!", e)
+* }
+* makeEventListener(window, "click", stopImmediatePropagation(handleClick), true);
+* // or in jsx:
+* <div onClick={stopImmediatePropagation(handleClick)} />
+* ```
+*/
+declare const stopImmediatePropagation: <E extends Event>(callback: (event: E) => void) => ((event: E) => void);
+//#endregion
+export { preventDefault, stopImmediatePropagation, stopPropagation };

dist/callbackWrappers.js

@@ -0,57 +1,61 @@
+/* @ts-self-types="./callbackWrappers.d.ts" */
+//#region src/callbackWrappers.ts
 /**
- * Calls `e.preventDefault()` on the `Event` and calls the {@link callback}
- *
- * @param callback Event handler
- * @returns Event handler matching {@link callback}'s type
- * @example
- * ```tsx
- * const handleClick = (e) => {
- *    concole.log("Click!", e)
- * }
- * makeEventListener(window, "click", preventDefault(handleClick), true);
- * // or in jsx:
- * <div onClick={preventDefault(handleClick)} />
- * ```
- */
-export const preventDefault = (callback) => e => {
-    e.preventDefault();
-    callback(e);
+* Calls `e.preventDefault()` on the `Event` and calls the {@link callback}
+*
+* @param callback Event handler
+* @returns Event handler matching {@link callback}'s type
+* @example
+* ```tsx
+* const handleClick = (e) => {
+*    concole.log("Click!", e)
+* }
+* makeEventListener(window, "click", preventDefault(handleClick), true);
+* // or in jsx:
+* <div onClick={preventDefault(handleClick)} />
+* ```
+*/
+const preventDefault = (callback) => (e) => {
+	e.preventDefault();
+	callback(e);
 };
 /**
- * Calls `e.stopPropagation()` on the `Event` and calls the {@link callback}
- *
- * @param callback Event handler
- * @returns Event handler matching {@link callback}'s type
- * @example
- * ```tsx
- * const handleClick = (e) => {
- *    concole.log("Click!", e)
- * }
- * makeEventListener(window, "click", stopPropagation(handleClick), true);
- * // or in jsx:
- * <div onClick={stopPropagation(handleClick)} />
- * ```
- */
-export const stopPropagation = (callback) => e => {
-    e.stopPropagation();
-    callback(e);
+* Calls `e.stopPropagation()` on the `Event` and calls the {@link callback}
+*
+* @param callback Event handler
+* @returns Event handler matching {@link callback}'s type
+* @example
+* ```tsx
+* const handleClick = (e) => {
+*    concole.log("Click!", e)
+* }
+* makeEventListener(window, "click", stopPropagation(handleClick), true);
+* // or in jsx:
+* <div onClick={stopPropagation(handleClick)} />
+* ```
+*/
+const stopPropagation = (callback) => (e) => {
+	e.stopPropagation();
+	callback(e);
 };
 /**
- * Calls `e.stopImmediatePropagation()` on the `Event` and calls the {@link callback}
- *
- * @param callback Event handler
- * @returns Event handler matching {@link callback}'s type
- * @example
- * ```tsx
- * const handleClick = (e) => {
- *    concole.log("Click!", e)
- * }
- * makeEventListener(window, "click", stopImmediatePropagation(handleClick), true);
- * // or in jsx:
- * <div onClick={stopImmediatePropagation(handleClick)} />
- * ```
- */
-export const stopImmediatePropagation = (callback) => e => {
-    e.stopImmediatePropagation();
-    callback(e);
+* Calls `e.stopImmediatePropagation()` on the `Event` and calls the {@link callback}
+*
+* @param callback Event handler
+* @returns Event handler matching {@link callback}'s type
+* @example
+* ```tsx
+* const handleClick = (e) => {
+*    concole.log("Click!", e)
+* }
+* makeEventListener(window, "click", stopImmediatePropagation(handleClick), true);
+* // or in jsx:
+* <div onClick={stopImmediatePropagation(handleClick)} />
+* ```
+*/
+const stopImmediatePropagation = (callback) => (e) => {
+	e.stopImmediatePropagation();
+	callback(e);
 };
+//#endregion
+export { preventDefault, stopImmediatePropagation, stopPropagation };

dist/components.d.ts

@@ -1,25 +0,26 @@
-import { type Component } from "solid-js";
-export type WindowEventProps = {
-    [K in keyof WindowEventMap as `on${Capitalize<K>}` | `on${K}`]?: (event: WindowEventMap[K]) => void;
-};
-export type DocumentEventProps = {
-    [K in keyof DocumentEventMap as `on${Capitalize<K>}` | `on${K}`]?: (event: DocumentEventMap[K]) => void;
-};
+/* @ts-self-types="./components.d.ts" */
+import { Component } from "solid-js";
+
+//#region src/components.d.ts
+type WindowEventProps = { [K in keyof WindowEventMap as `on${Capitalize<K>}` | `on${K}`]?: (event: WindowEventMap[K]) => void };
+type DocumentEventProps = { [K in keyof DocumentEventMap as `on${Capitalize<K>}` | `on${K}`]?: (event: DocumentEventMap[K]) => void };
 /**
- * Listen to the `window` DOM Events, using a component.
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#WindowEventListener
- *
- * @example
- * <WindowEventListener onMouseMove={e => console.log(e.x, e.y)} />
- */
-export declare const WindowEventListener: Component<WindowEventProps>;
+* Listen to the `window` DOM Events, using a component.
+*
+* @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#WindowEventListener
+*
+* @example
+* <WindowEventListener onMouseMove={e => console.log(e.x, e.y)} />
+*/
+declare const WindowEventListener: Component<WindowEventProps>;
 /**
- * Listen to the `document` DOM Events, using a component.
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#DocumentEventListener
- *
- * @example
- * <DocumentEventListener onMouseMove={e => console.log(e.x, e.y)} />
- */
-export declare const DocumentEventListener: Component<DocumentEventProps>;
+* Listen to the `document` DOM Events, using a component.
+*
+* @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#DocumentEventListener
+*
+* @example
+* <DocumentEventListener onMouseMove={e => console.log(e.x, e.y)} />
+*/
+declare const DocumentEventListener: Component<DocumentEventProps>;
+//#endregion
+export { DocumentEventListener, DocumentEventProps, WindowEventListener, WindowEventProps };

dist/components.js

@@ -0,36 +1,37 @@
+/* @ts-self-types="./components.d.ts" */
+import { makeEventListener } from "./eventListener.js";
 import { isServer } from "@solidjs/web";
 import { keys } from "@solid-primitives/utils";
-import {} from "solid-js";
-import { makeEventListener } from "./eventListener.js";
+import "solid-js";
+//#region src/components.ts
 const attachPropListeners = (target, props) => {
-    keys(props).forEach(attr => {
-        if (attr.startsWith("on") && typeof props[attr] === "function")
-            makeEventListener(target, attr.substring(2).toLowerCase(), props[attr]);
-    });
+	keys(props).forEach((attr) => {
+		if (attr.startsWith("on") && typeof props[attr] === "function") makeEventListener(target, attr.substring(2).toLowerCase(), props[attr]);
+	});
 };
 /**
- * Listen to the `window` DOM Events, using a component.
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#WindowEventListener
- *
- * @example
- * <WindowEventListener onMouseMove={e => console.log(e.x, e.y)} />
- */
-export const WindowEventListener = props => {
-    if (isServer)
-        return null;
-    attachPropListeners(window, props);
+* Listen to the `window` DOM Events, using a component.
+*
+* @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#WindowEventListener
+*
+* @example
+* <WindowEventListener onMouseMove={e => console.log(e.x, e.y)} />
+*/
+const WindowEventListener = (props) => {
+	if (isServer) return null;
+	attachPropListeners(window, props);
 };
 /**
- * Listen to the `document` DOM Events, using a component.
- *
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#DocumentEventListener
- *
- * @example
- * <DocumentEventListener onMouseMove={e => console.log(e.x, e.y)} />
- */
-export const DocumentEventListener = props => {
-    if (isServer)
-        return null;
-    attachPropListeners(document, props);
+* Listen to the `document` DOM Events, using a component.
+*
+* @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#DocumentEventListener
+*
+* @example
+* <DocumentEventListener onMouseMove={e => console.log(e.x, e.y)} />
+*/
+const DocumentEventListener = (props) => {
+	if (isServer) return null;
+	attachPropListeners(document, props);
 };
+//#endregion
+export { DocumentEventListener, WindowEventListener };

dist/eventListener.d.ts

@@ -1,66 +0,71 @@
-import { type Many, type MaybeAccessor, type Directive } from "@solid-primitives/utils";
-import { type Accessor } from "solid-js";
-import type { EventListenerDirectiveProps, EventMapOf, TargetWithEventMap, EventListenerOptions } from "./types.js";
+/* @ts-self-types="./eventListener.d.ts" */
+import { EventListenerDirectiveProps, EventListenerOptions, EventMapOf, TargetWithEventMap } from "./types.js";
+import { Directive, Many, MaybeAccessor } from "@solid-primitives/utils";
+import { Accessor } from "solid-js";
+
+//#region src/eventListener.d.ts
 /**
- * Creates an event listener, that will be automatically disposed on cleanup.
- * @param target - ref to HTMLElement, EventTarget
- * @param type - name of the handled event
- * @param handler - event handler
- * @param options - addEventListener options
- * @returns Function clearing all event listeners form targets
- * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#makeEventListener
- * @example
- * const clear = makeEventListener(element, 'click', e => { ... }, { passive: true })
- * // remove listener (will also happen on cleanup)
- * clear()
- */
-export declare function makeEventListener<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>, EventType extends keyof EventMap>(target: Target, type: EventType, handler: (event: EventMap[EventType]) => void, options?: EventListenerOptions): VoidFunction;
-export declare function makeEventListener<EventMap extends Record<string, Event>, EventType extends keyof EventMap = keyof EventMap>(target: EventTarget, type: EventType, handler: (event: EventMap[EventType]) => void, options?: EventListenerOptions): VoidFunction;
+* Creates an event listener, that will be automatically disposed on cleanup.
+* @param target - ref to HTMLElement, EventTarget
+* @param type - name of the handled event
+* @param handler - event handler
+* @param options - addEventListener options
+* @returns Function clearing all event listeners form targets
+* @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
+* @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#makeEventListener
+* @example
+* const clear = makeEventListener(element, 'click', e => { ... }, { passive: true })
+* // remove listener (will also happen on cleanup)
+* clear()
+*/
+declare function makeEventListener<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>, EventType extends keyof EventMap>(target: Target, type: EventType, handler: (event: EventMap[EventType]) => void, options?: EventListenerOptions): VoidFunction;
+declare function makeEventListener<EventMap extends Record<string, Event>, EventType extends keyof EventMap = keyof EventMap>(target: EventTarget, type: EventType, handler: (event: EventMap[EventType]) => void, options?: EventListenerOptions): VoidFunction;
 /**
- * Creates a reactive event listener, that will be automatically disposed on cleanup,
- * and can take reactive arguments to attach listeners to new targets once changed.
- * @param target - ref to HTMLElement, EventTarget or Array thereof
- * @param type - name of the handled event
- * @param handler - event handler
- * @param options - addEventListener options
- * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#createEventListener
- * @example
- * const [targets, setTargets] = createSignal([element])
- * createEventListener(targets, 'click', e => { ... }, { passive: true })
- * setTargets([]) // <- removes listeners from previous target
- * setTargets([element, button]) // <- adds listeners to new targets
- */
-export declare function createEventListener<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>, EventType extends keyof EventMap>(target: MaybeAccessor<Many<Target | undefined>>, type: MaybeAccessor<Many<EventType>>, handler: (event: EventMap[EventType]) => void, options?: EventListenerOptions): void;
-export declare function createEventListener<EventMap extends Record<string, Event>, EventType extends keyof EventMap = keyof EventMap>(target: MaybeAccessor<Many<EventTarget | undefined>>, type: MaybeAccessor<Many<EventType>>, handler: (event: EventMap[EventType]) => void, options?: EventListenerOptions): void;
+* Creates a reactive event listener, that will be automatically disposed on cleanup,
+* and can take reactive arguments to attach listeners to new targets once changed.
+* @param target - ref to HTMLElement, EventTarget or Array thereof
+* @param type - name of the handled event
+* @param handler - event handler
+* @param options - addEventListener options
+* @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
+* @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#createEventListener
+* @example
+* const [targets, setTargets] = createSignal([element])
+* createEventListener(targets, 'click', e => { ... }, { passive: true })
+* setTargets([]) // <- removes listeners from previous target
+* setTargets([element, button]) // <- adds listeners to new targets
+*/
+declare function createEventListener<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>, EventType extends keyof EventMap>(target: MaybeAccessor<Many<Target | undefined>>, type: MaybeAccessor<Many<EventType>>, handler: (event: EventMap[EventType]) => void, options?: EventListenerOptions): void;
+declare function createEventListener<EventMap extends Record<string, Event>, EventType extends keyof EventMap = keyof EventMap>(target: MaybeAccessor<Many<EventTarget | undefined>>, type: MaybeAccessor<Many<EventType>>, handler: (event: EventMap[EventType]) => void, options?: EventListenerOptions): void;
 /**
- * Provides an reactive signal of last captured event.
- *
- * @param target - ref to HTMLElement, EventTarget or Array thereof
- * @param type - name of the handled event
- * @param options - addEventListener options
- *
- * @returns Signal of last captured event & function clearing all event listeners
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#createEventSignal
- *
- * @example
- * const lastEvent = createEventSignal(el, 'click', { passive: true })
- *
- * createEffect(() => {
- *    console.log(lastEvent())
- * })
- */
-export declare function createEventSignal<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>, EventType extends keyof EventMap>(target: MaybeAccessor<Many<Target>>, type: MaybeAccessor<Many<EventType>>, options?: EventListenerOptions): Accessor<EventMap[EventType]>;
-export declare function createEventSignal<EventMap extends Record<string, Event>, EventType extends keyof EventMap = keyof EventMap>(target: MaybeAccessor<Many<EventTarget>>, type: MaybeAccessor<Many<EventType>>, options?: EventListenerOptions): Accessor<EventMap[EventType]>;
+* Provides an reactive signal of last captured event.
+*
+* @param target - ref to HTMLElement, EventTarget or Array thereof
+* @param type - name of the handled event
+* @param options - addEventListener options
+*
+* @returns Signal of last captured event & function clearing all event listeners
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
+* @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#createEventSignal
+*
+* @example
+* const lastEvent = createEventSignal(el, 'click', { passive: true })
+*
+* createEffect(() => {
+*    console.log(lastEvent())
+* })
+*/
+declare function createEventSignal<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>, EventType extends keyof EventMap>(target: MaybeAccessor<Many<Target>>, type: MaybeAccessor<Many<EventType>>, options?: EventListenerOptions): Accessor<EventMap[EventType]>;
+declare function createEventSignal<EventMap extends Record<string, Event>, EventType extends keyof EventMap = keyof EventMap>(target: MaybeAccessor<Many<EventTarget>>, type: MaybeAccessor<Many<EventType>>, options?: EventListenerOptions): Accessor<EventMap[EventType]>;
 /**
- * Directive Usage. Creates an event listener, that will be automatically disposed on cleanup.
- *
- * @param props [eventType, handler, options]
- *
- * @example
- * <button use:eventListener={["click", () => {...}]}>Click me!</button>
- */
-export declare const eventListener: Directive<EventListenerDirectiveProps>;
+* Directive Usage. Creates an event listener, that will be automatically disposed on cleanup.
+*
+* @param props [eventType, handler, options]
+*
+* @example
+* <button use:eventListener={["click", () => {...}]}>Click me!</button>
+*/
+declare const eventListener: Directive<EventListenerDirectiveProps>;
+//#endregion
+export { createEventListener, createEventSignal, eventListener, makeEventListener };

dist/eventListener.js

@@ -1,80 +0,48 @@
-import { access, asArray, tryOnCleanup, } from "@solid-primitives/utils";
+/* @ts-self-types="./eventListener.d.ts" */
+import { isServer } from "@solidjs/web";
+import { access, asArray, tryOnCleanup } from "@solid-primitives/utils";
 import { createEffect, createRenderEffect, createSignal } from "solid-js";
-import { isServer } from "@solidjs/web";
-export function makeEventListener(target, type, handler, options) {
-    target.addEventListener(type, handler, options);
-    return tryOnCleanup(target.removeEventListener.bind(target, type, handler, options));
+//#region src/eventListener.ts
+function makeEventListener(target, type, handler, options) {
+	target?.addEventListener?.(type, handler, options);
+	return tryOnCleanup(target?.removeEventListener?.bind(target, type, handler, options));
 }
-export function createEventListener(targets, type, handler, options) {
-    if (isServer)
-        return;
-    const compute = () => ({
-        els: asArray(access(targets)).filter(x => !!x),
-        types: asArray(access(type)),
-    });
-    const apply = ({ els, types }) => {
-        const cleanups = [];
-        for (const el of els)
-            for (const t of types) {
-                el.addEventListener(t, handler, options);
-                cleanups.push(el.removeEventListener.bind(el, t, handler, options));
-            }
-        return () => cleanups.forEach(c => c());
-    };
-    // if the target is an accessor the listeners will be added on the first effect (after mount)
-    // so that when passed a jsx ref it will be available
-    if (typeof targets === "function")
-        createEffect(compute, apply);
-    // if the target prop is NOT an accessor, the event listeners can be added right away
-    else
-        createRenderEffect(compute, apply);
+function createEventListener(targets, type, handler, options) {
+	if (isServer) return;
+	const compute = () => ({
+		els: asArray(access(targets)).filter((x) => !!x),
+		types: asArray(access(type))
+	});
+	const apply = ({ els, types }) => {
+		const cleanups = [];
+		for (const el of els) for (const t of types) {
+			el.addEventListener(t, handler, options);
+			cleanups.push(el.removeEventListener.bind(el, t, handler, options));
+		}
+		return () => cleanups.forEach((c) => c());
+	};
+	if (typeof targets === "function") createEffect(compute, apply);
+	else createRenderEffect(compute, apply);
 }
-export function createEventSignal(target, type, options) {
-    if (isServer) {
-        return () => undefined;
-    }
-    const [lastEvent, setLastEvent] = createSignal();
-    createEventListener(target, type, setLastEvent, options);
-    return lastEvent;
+function createEventSignal(target, type, options) {
+	if (isServer) return () => void 0;
+	const [lastEvent, setLastEvent] = createSignal();
+	createEventListener(target, type, setLastEvent, options);
+	return lastEvent;
 }
 /**
- * Directive Usage. Creates an event listener, that will be automatically disposed on cleanup.
- *
- * @param props [eventType, handler, options]
- *
- * @example
- * <button use:eventListener={["click", () => {...}]}>Click me!</button>
- */
-export const eventListener = (target, props) => {
-    createEffect(props, ([type, handler, options]) => {
-        target.addEventListener(type, handler, options);
-        return () => target.removeEventListener(type, handler, options);
-    });
+* Directive Usage. Creates an event listener, that will be automatically disposed on cleanup.
+*
+* @param props [eventType, handler, options]
+*
+* @example
+* <button use:eventListener={["click", () => {...}]}>Click me!</button>
+*/
+const eventListener = (target, props) => {
+	createEffect(props, ([type, handler, options]) => {
+		target.addEventListener(type, handler, options);
+		return () => target.removeEventListener(type, handler, options);
+	});
 };
-// // /* TypeCheck */
-// const mouseHandler = (e: MouseEvent) => {};
-// const touchHandler = (e: TouchEvent) => {};
-// const el = document.createElement("div");
-// // dom events
-// createEventListener(window as Window | undefined, "mousemove", mouseHandler);
-// createEventListener(document, "touchstart", touchHandler);
-// createEventListener(el, "mousemove", mouseHandler);
-// createEventListener(() => el, "touchstart", touchHandler);
-// const mouseSignal = createEventSignal(window, "mousemove");
-// const touchSignal = createEventSignal(() => document, "touchstart");
-// // custom events
-// createEventListener<{ test: MouseEvent }>(window, "test", mouseHandler);
-// createEventListener<{ test: Event; custom: MouseEvent }, "custom">(
-//   () => el,
-//   "custom",
-//   mouseHandler
-// );
-// createEventListener<{ test: Event }>(new EventTarget(), "test", () => console.log("test"));
-// const testSignal = createEventSignal<{ test: MouseEvent }>(window, "test");
-// const customSignal = createEventSignal<{ test: Event; custom: MouseEvent }, "custom">(
-//   () => document,
-//   "custom"
-// );
-// // directive
-// eventListener(el, () => ["mousemove", mouseHandler, { passive: true }]);
-// eventListener(el, () => ["custom", e => {}]);
+//#endregion
+export { createEventListener, createEventSignal, eventListener, makeEventListener };

dist/eventListenerMap.d.ts

@@ -1,24 +0,27 @@
-import { type Many, type MaybeAccessor } from "@solid-primitives/utils";
-import type { EventMapOf, TargetWithEventMap, EventListenerOptions } from "./types.js";
-export type EventHandlersMap<EventMap> = {
-    [EventName in keyof EventMap]: (event: EventMap[EventName]) => void;
-};
+/* @ts-self-types="./eventListenerMap.d.ts" */
+import { EventListenerOptions, EventMapOf, TargetWithEventMap } from "./types.js";
+import { Many, MaybeAccessor } from "@solid-primitives/utils";
+
+//#region src/eventListenerMap.d.ts
+type EventHandlersMap<EventMap> = { [EventName in keyof EventMap]: (event: EventMap[EventName]) => void };
 /**
- * A helpful primitive that listens to a map of events. Handle them by individual callbacks.
- *
- * @param target accessor or variable of multiple or single event targets
- * @param handlersMap e.g. `{ mousemove: e => {}, click: e => {} }`
- * @param options e.g. `{ passive: true }`
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
- * @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#createEventListenerMap
- *
- * @example
- * createEventListenerMap(element, {
- *   mousemove: mouseHandler,
- *   mouseenter: e => {},
- *   touchend: touchHandler
- * });
- */
-export declare function createEventListenerMap<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>, HandlersMap extends Partial<EventHandlersMap<EventMap>>>(target: MaybeAccessor<Many<Target>>, handlersMap: HandlersMap, options?: EventListenerOptions): void;
-export declare function createEventListenerMap<EventMap extends Record<string, Event>>(target: MaybeAccessor<Many<EventTarget>>, handlersMap: Partial<EventHandlersMap<EventMap>>, options?: EventListenerOptions): void;
+* A helpful primitive that listens to a map of events. Handle them by individual callbacks.
+*
+* @param target accessor or variable of multiple or single event targets
+* @param handlersMap e.g. `{ mousemove: e => {}, click: e => {} }`
+* @param options e.g. `{ passive: true }`
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
+* @see https://github.com/solidjs-community/solid-primitives/tree/main/packages/event-listener#createEventListenerMap
+*
+* @example
+* createEventListenerMap(element, {
+*   mousemove: mouseHandler,
+*   mouseenter: e => {},
+*   touchend: touchHandler
+* });
+*/
+declare function createEventListenerMap<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>, HandlersMap extends Partial<EventHandlersMap<EventMap>>>(target: MaybeAccessor<Many<Target>>, handlersMap: HandlersMap, options?: EventListenerOptions): void;
+declare function createEventListenerMap<EventMap extends Record<string, Event>>(target: MaybeAccessor<Many<EventTarget>>, handlersMap: Partial<EventHandlersMap<EventMap>>, options?: EventListenerOptions): void;
+//#endregion
+export { EventHandlersMap, createEventListenerMap };

dist/eventListenerMap.js

@@ -1,33 +0,11 @@
-import { entries } from "@solid-primitives/utils";
+/* @ts-self-types="./eventListenerMap.d.ts" */
 import { createEventListener } from "./eventListener.js";
 import { isServer } from "@solidjs/web";
-export function createEventListenerMap(targets, handlersMap, options) {
-    if (isServer) {
-        return;
-    }
-    for (const [eventName, handler] of entries(handlersMap)) {
-        if (handler)
-            createEventListener(targets, eventName, handler, options);
-    }
+import { entries } from "@solid-primitives/utils";
+//#region src/eventListenerMap.ts
+function createEventListenerMap(targets, handlersMap, options) {
+	if (isServer) return;
+	for (const [eventName, handler] of entries(handlersMap)) if (handler) createEventListener(targets, eventName, handler, options);
 }
-// /* TypeCheck */
-// const el = document.createElement("div");
-// createEventListenerMap(el, {
-//   mouseenter: e => e.clientX,
-//   touchend: e => e.touches,
-//   // @ts-expect-error
-//   keydown: e => e.clientX,
-// });
-// createEventListenerMap(el, {
-//   keydown: e => e.key,
-// });
-// createEventListenerMap<{
-//   test: Event;
-//   custom: KeyboardEvent;
-//   unused: Event;
-// }>(el, {
-//   test: e => e,
-//   custom: e => e.key,
-//   // @ts-expect-error
-//   wrong: () => {},
-// });
+//#endregion
+export { createEventListenerMap };

dist/eventListenerStack.d.ts

@@ -1,18 +0,23 @@
-import type { EventMapOf, TargetWithEventMap, EventListenerOptions } from "./types.js";
-export type EventListenerStackOn<EventMap extends Record<string, any>> = {
-    <T extends keyof EventMap>(type: T, handler: (event: EventMap[T]) => void, options?: EventListenerOptions): VoidFunction;
+/* @ts-self-types="./eventListenerStack.d.ts" */
+import { EventListenerOptions, EventMapOf, TargetWithEventMap } from "./types.js";
+
+//#region src/eventListenerStack.d.ts
+type EventListenerStackOn<EventMap extends Record<string, any>> = {
+  <T extends keyof EventMap>(type: T, handler: (event: EventMap[T]) => void, options?: EventListenerOptions): VoidFunction;
 };
 /**
- * Creates a stack of event listeners, that will be automatically disposed on cleanup.
- * @param target - ref to HTMLElement, EventTarget
- * @param options - addEventListener options
- * @returns Function clearing all event listeners form targets
- * @example
- * const [listen, clear] = makeEventListenerStack(target, { passive: true });
- * listen("mousemove", handleMouse);
- * listen("dragover", handleMouse);
- * // remove listener (will also happen on cleanup)
- * clear()
- */
-export declare function makeEventListenerStack<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>>(target: Target, options?: EventListenerOptions): [listen: EventListenerStackOn<EventMap>, clear: VoidFunction];
-export declare function makeEventListenerStack<EventMap extends Record<string, Event>>(target: EventTarget, options?: EventListenerOptions): [listen: EventListenerStackOn<EventMap>, clear: VoidFunction];
+* Creates a stack of event listeners, that will be automatically disposed on cleanup.
+* @param target - ref to HTMLElement, EventTarget
+* @param options - addEventListener options
+* @returns Function clearing all event listeners form targets
+* @example
+* const [listen, clear] = makeEventListenerStack(target, { passive: true });
+* listen("mousemove", handleMouse);
+* listen("dragover", handleMouse);
+* // remove listener (will also happen on cleanup)
+* clear()
+*/
+declare function makeEventListenerStack<Target extends TargetWithEventMap, EventMap extends EventMapOf<Target>>(target: Target, options?: EventListenerOptions): [listen: EventListenerStackOn<EventMap>, clear: VoidFunction];
+declare function makeEventListenerStack<EventMap extends Record<string, Event>>(target: EventTarget, options?: EventListenerOptions): [listen: EventListenerStackOn<EventMap>, clear: VoidFunction];
+//#endregion
+export { EventListenerStackOn, makeEventListenerStack };

dist/eventListenerStack.js

@@ -0,18 +1,17 @@
+/* @ts-self-types="./eventListenerStack.d.ts" */
+import { makeEventListener } from "./eventListener.js";
+import { isServer } from "@solidjs/web";
 import { createCallbackStack } from "@solid-primitives/utils";
 import { onCleanup } from "solid-js";
-import { makeEventListener } from "./eventListener.js";
-import { isServer } from "@solidjs/web";
-export function makeEventListenerStack(target, options) {
-    if (isServer) {
-        return [() => () => void 0, () => void 0];
-    }
-    const { push, execute } = createCallbackStack();
-    return [
-        (type, handler, overwriteOptions) => {
-            const clear = makeEventListener(target, type, handler, overwriteOptions ?? options);
-            push(clear);
-            return clear;
-        },
-        onCleanup(execute),
-    ];
+//#region src/eventListenerStack.ts
+function makeEventListenerStack(target, options) {
+	if (isServer) return [() => () => void 0, () => void 0];
+	const { push, execute } = createCallbackStack();
+	return [(type, handler, overwriteOptions) => {
+		const clear = makeEventListener(target, type, handler, overwriteOptions ?? options);
+		push(clear);
+		return clear;
+	}, onCleanup(execute)];
 }
+//#endregion
+export { makeEventListenerStack };

dist/index.d.ts

@@ -1,6 +0,8 @@
-export * from "./eventListener.js";
-export * from "./eventListenerMap.js";
-export * from "./components.js";
-export * from "./eventListenerStack.js";
-export * from "./callbackWrappers.js";
-export * from "./types.js";
+/* @ts-self-types="./index.d.ts" */
+import { preventDefault, stopImmediatePropagation, stopPropagation } from "./callbackWrappers.js";
+import { DocumentEventListener, DocumentEventProps, WindowEventListener, WindowEventProps } from "./components.js";
+import { EventListenerDirectiveProps, EventListenerOptions, EventMapOf, TargetWithEventMap } from "./types.js";
+import { createEventListener, createEventSignal, eventListener, makeEventListener } from "./eventListener.js";
+import { EventHandlersMap, createEventListenerMap } from "./eventListenerMap.js";
+import { EventListenerStackOn, makeEventListenerStack } from "./eventListenerStack.js";
+export { DocumentEventListener, DocumentEventProps, EventHandlersMap, EventListenerDirectiveProps, EventListenerOptions, EventListenerStackOn, EventMapOf, TargetWithEventMap, WindowEventListener, WindowEventProps, createEventListener, createEventListenerMap, createEventSignal, eventListener, makeEventListener, makeEventListenerStack, preventDefault, stopImmediatePropagation, stopPropagation };

dist/index.js

@@ -1,11 +0,7 @@
-export * from "./eventListener.js";
-export * from "./eventListenerMap.js";
-export * from "./components.js";
-export * from "./eventListenerStack.js";
-export * from "./callbackWrappers.js";
-export * from "./types.js";
-export { makeEventListener, createEventListener, createEventSignal, eventListener } from "./eventListener.js";
-export { createEventListenerMap } from "./eventListenerMap.js";
-export { WindowEventListener, DocumentEventListener } from "./components.js";
-export { makeEventListenerStack } from "./eventListenerStack.js";
-export { preventDefault, stopPropagation, stopImmediatePropagation } from "./callbackWrappers.js";
+/* @ts-self-types="./index.d.ts" */
+import { preventDefault, stopImmediatePropagation, stopPropagation } from "./callbackWrappers.js";
+import { createEventListener, createEventSignal, eventListener, makeEventListener } from "./eventListener.js";
+import { DocumentEventListener, WindowEventListener } from "./components.js";
+import { createEventListenerMap } from "./eventListenerMap.js";
+import { makeEventListenerStack } from "./eventListenerStack.js";
+export { DocumentEventListener, WindowEventListener, createEventListener, createEventListenerMap, createEventSignal, eventListener, makeEventListener, makeEventListenerStack, preventDefault, stopImmediatePropagation, stopPropagation };

dist/types.d.ts

@@ -1,17 +0,8 @@
-import type { JSX } from "@solidjs/web";
-export type EventListenerOptions = boolean | AddEventListenerOptions;
-export type TargetWithEventMap = Window | Document | XMLDocument | HTMLBodyElement | HTMLMediaElement | HTMLVideoElement | HTMLElement | SVGSVGElement | SVGElement | MathMLElement | Element | AbortSignal | AbstractWorker | Animation | BroadcastChannel | CSSAnimation | CSSTransition | FileReader | IDBDatabase | IDBOpenDBRequest | IDBRequest | IDBTransaction | MediaDevices | MediaKeySession | MediaQueryList | MediaRecorder | MediaSource | MediaStream | MediaStreamTrack | MessagePort | Notification | PaymentRequest | Performance | PermissionStatus | PictureInPictureWindow | RemotePlayback | ScreenOrientation | ServiceWorker | ServiceWorkerContainer | ServiceWorkerRegistration | ShadowRoot | SharedWorker | SourceBuffer | SourceBufferList | SpeechSynthesis | SpeechSynthesisUtterance | VisualViewport | WebSocket | Worker | XMLHttpRequest | XMLHttpRequestEventTarget | XMLHttpRequestUpload | EventSource;
-export type EventMapOf<Target> = Target extends Window ? WindowEventMap : Target extends Document | XMLDocument ? DocumentEventMap : Target extends HTMLBodyElement ? HTMLBodyElementEventMap : Target extends HTMLMediaElement ? HTMLMediaElementEventMap : Target extends HTMLVideoElement ? HTMLVideoElementEventMap : Target extends HTMLElement ? HTMLElementEventMap : Target extends SVGSVGElement ? SVGSVGElementEventMap : Target extends SVGElement ? SVGElementEventMap : Target extends MathMLElement ? MathMLElementEventMap : Target extends Element ? ElementEventMap : Target extends AbortSignal ? AbortSignalEventMap : Target extends AbstractWorker ? AbstractWorkerEventMap : Target extends Animation ? AnimationEventMap : Target extends BroadcastChannel ? BroadcastChannelEventMap : Target extends CSSAnimation ? AnimationEventMap : Target extends CSSTransition ? AnimationEventMap : Target extends FileReader ? FileReaderEventMap : Target extends IDBDatabase ? IDBDatabaseEventMap : Target extends IDBOpenDBRequest ? IDBOpenDBRequestEventMap : Target extends IDBRequest ? IDBRequestEventMap : Target extends IDBTransaction ? IDBTransactionEventMap : Target extends MediaDevices ? MediaDevicesEventMap : Target extends MediaKeySession ? MediaKeySessionEventMap : Target extends MediaQueryList ? MediaQueryListEventMap : Target extends MediaRecorder ? MediaRecorderEventMap : Target extends MediaSource ? MediaSourceEventMap : Target extends MediaStream ? MediaStreamEventMap : Target extends MediaStreamTrack ? MediaStreamTrackEventMap : Target extends MessagePort ? MessagePortEventMap : Target extends Notification ? NotificationEventMap : Target extends PaymentRequest ? PaymentRequestEventMap : Target extends Performance ? PerformanceEventMap : Target extends PermissionStatus ? PermissionStatusEventMap : Target extends PictureInPictureWindow ? PictureInPictureWindowEventMap : Target extends RemotePlayback ? RemotePlaybackEventMap : Target extends ScreenOrientation ? ScreenOrientationEventMap : Target extends ServiceWorker ? ServiceWorkerEventMap : Target extends ServiceWorkerContainer ? ServiceWorkerContainerEventMap : Target extends ServiceWorkerRegistration ? ServiceWorkerRegistrationEventMap : Target extends ShadowRoot ? ShadowRootEventMap : Target extends SharedWorker ? AbstractWorkerEventMap : Target extends SourceBuffer ? SourceBufferEventMap : Target extends SourceBufferList ? SourceBufferListEventMap : Target extends SpeechSynthesis ? SpeechSynthesisEventMap : Target extends SpeechSynthesisUtterance ? SpeechSynthesisUtteranceEventMap : Target extends VisualViewport ? VisualViewportEventMap : Target extends WebSocket ? WebSocketEventMap : Target extends Worker ? WorkerEventMap : Target extends XMLHttpRequest ? XMLHttpRequestEventMap : Target extends XMLHttpRequestEventTarget ? XMLHttpRequestEventTargetEventMap : Target extends XMLHttpRequestUpload ? XMLHttpRequestEventTargetEventMap : Target extends EventSource ? EventSourceEventMap : never;
-export type EventListenerDirectiveProps = [
-    type: string,
-    handler: (e: any) => void,
-    options?: EventListenerOptions
-];
-declare module "solid-js" {
-    namespace JSX {
-        interface Directives {
-            eventListener: EventListenerDirectiveProps;
-        }
-    }
-}
-export type E = JSX.Element;
+/* @ts-self-types="./types.d.ts" */
+//#region src/types.d.ts
+type EventListenerOptions = boolean | AddEventListenerOptions;
+type TargetWithEventMap = Window | Document | XMLDocument | HTMLBodyElement | HTMLMediaElement | HTMLVideoElement | HTMLElement | SVGSVGElement | SVGElement | MathMLElement | Element | AbortSignal | AbstractWorker | Animation | BroadcastChannel | CSSAnimation | CSSTransition | FileReader | IDBDatabase | IDBOpenDBRequest | IDBRequest | IDBTransaction | MediaDevices | MediaKeySession | MediaQueryList | MediaRecorder | MediaSource | MediaStream | MediaStreamTrack | MessagePort | Notification | PaymentRequest | Performance | PermissionStatus | PictureInPictureWindow | RemotePlayback | ScreenOrientation | ServiceWorker | ServiceWorkerContainer | ServiceWorkerRegistration | ShadowRoot | SharedWorker | SourceBuffer | SourceBufferList | SpeechSynthesis | SpeechSynthesisUtterance | VisualViewport | WebSocket | Worker | XMLHttpRequest | XMLHttpRequestEventTarget | XMLHttpRequestUpload | EventSource;
+type EventMapOf<Target> = Target extends Window ? WindowEventMap : Target extends Document | XMLDocument ? DocumentEventMap : Target extends HTMLBodyElement ? HTMLBodyElementEventMap : Target extends HTMLMediaElement ? HTMLMediaElementEventMap : Target extends HTMLVideoElement ? HTMLVideoElementEventMap : Target extends HTMLElement ? HTMLElementEventMap : Target extends SVGSVGElement ? SVGSVGElementEventMap : Target extends SVGElement ? SVGElementEventMap : Target extends MathMLElement ? MathMLElementEventMap : Target extends Element ? ElementEventMap : Target extends AbortSignal ? AbortSignalEventMap : Target extends AbstractWorker ? AbstractWorkerEventMap : Target extends Animation ? AnimationEventMap : Target extends BroadcastChannel ? BroadcastChannelEventMap : Target extends CSSAnimation ? AnimationEventMap : Target extends CSSTransition ? AnimationEventMap : Target extends FileReader ? FileReaderEventMap : Target extends IDBDatabase ? IDBDatabaseEventMap : Target extends IDBOpenDBRequest ? IDBOpenDBRequestEventMap : Target extends IDBRequest ? IDBRequestEventMap : Target extends IDBTransaction ? IDBTransactionEventMap : Target extends MediaDevices ? MediaDevicesEventMap : Target extends MediaKeySession ? MediaKeySessionEventMap : Target extends MediaQueryList ? MediaQueryListEventMap : Target extends MediaRecorder ? MediaRecorderEventMap : Target extends MediaSource ? MediaSourceEventMap : Target extends MediaStream ? MediaStreamEventMap : Target extends MediaStreamTrack ? MediaStreamTrackEventMap : Target extends MessagePort ? MessagePortEventMap : Target extends Notification ? NotificationEventMap : Target extends PaymentRequest ? PaymentRequestEventMap : Target extends Performance ? PerformanceEventMap : Target extends PermissionStatus ? PermissionStatusEventMap : Target extends PictureInPictureWindow ? PictureInPictureWindowEventMap : Target extends RemotePlayback ? RemotePlaybackEventMap : Target extends ScreenOrientation ? ScreenOrientationEventMap : Target extends ServiceWorker ? ServiceWorkerEventMap : Target extends ServiceWorkerContainer ? ServiceWorkerContainerEventMap : Target extends ServiceWorkerRegistration ? ServiceWorkerRegistrationEventMap : Target extends ShadowRoot ? ShadowRootEventMap : Target extends SharedWorker ? AbstractWorkerEventMap : Target extends SourceBuffer ? SourceBufferEventMap : Target extends SourceBufferList ? SourceBufferListEventMap : Target extends SpeechSynthesis ? SpeechSynthesisEventMap : Target extends SpeechSynthesisUtterance ? SpeechSynthesisUtteranceEventMap : Target extends VisualViewport ? VisualViewportEventMap : Target extends WebSocket ? WebSocketEventMap : Target extends Worker ? WorkerEventMap : Target extends XMLHttpRequest ? XMLHttpRequestEventMap : Target extends XMLHttpRequestEventTarget ? XMLHttpRequestEventTargetEventMap : Target extends XMLHttpRequestUpload ? XMLHttpRequestEventTargetEventMap : Target extends EventSource ? EventSourceEventMap : never;
+type EventListenerDirectiveProps = [type: string, handler: (e: any) => void, options?: EventListenerOptions];
+//#endregion
+export { EventListenerDirectiveProps, EventListenerOptions, EventMapOf, TargetWithEventMap };

dist/types.js

@@ -1,1 +0,1 @@
-export {};
+/* @ts-self-types="./types.d.ts" */

package.json

 {
   "name": "@solid-primitives/event-listener",
-  "version": "3.0.0-next.1",
+  "version": "3.0.0-next.2",
   "description": "SolidJS Primitives to manage creating event listeners.",
@@ -26,3 +26,3 @@ "author": "David Di Biase <[e-mail]>",
     "category": "Browser APIs",
-    "gzip": 890
+    "gzip": 896
   },
@@ -45,2 +45,6 @@ "private": false,
   },
+  "tsdown": {
+    "entry": "src/**/*.{ts,tsx}",
+    "outDir": "dist"
+  },
   "keywords": [
@@ -53,16 +57,16 @@ "event",
   "dependencies": {
-    "@solid-primitives/utils": "^7.0.0-next.1"
+    "@solid-primitives/utils": "^7.0.0-next.2"
   },
   "peerDependencies": {
-    "@solidjs/web": "^2.0.0-beta.15",
-    "solid-js": "^2.0.0-beta.15"
+    "@solidjs/web": "^2.0.0-beta.20",
+    "solid-js": "^2.0.0-beta.20"
   },
   "typesVersions": {},
   "devDependencies": {
-    "@solidjs/web": "2.0.0-beta.15",
-    "solid-js": "2.0.0-beta.15"
+    "@solidjs/web": "2.0.0-beta.20",
+    "solid-js": "2.0.0-beta.20"
   },
   "scripts": {
     "dev": "node --import=@nothing-but/node-resolve-ts --experimental-transform-types ../../scripts/dev.ts",
-    "build": "node --import=@nothing-but/node-resolve-ts --experimental-transform-types ../../scripts/build.ts",
+    "build": "pnpm -w build",
     "vitest": "vitest -c ../../configs/vitest.config.ts",
@@ -69,0 +73,0 @@ "test": "pnpm run vitest",

README.md

@@ -7,3 +7,3 @@ <p>
 
-[![size](https://img.shields.io/badge/size-890_B-blue?style=for-the-badge)](https://bundlephobia.com/package/@solid-primitives/event-listener)
+[![size](https://img.shields.io/badge/size-896_B-blue?style=for-the-badge)](https://bundlephobia.com/package/@solid-primitives/event-listener)
 [![size](https://img.shields.io/npm/v/@solid-primitives/event-listener?style=for-the-badge)](https://www.npmjs.com/package/@solid-primitives/event-listener)
@@ -10,0 +10,0 @@ [![stage](https://img.shields.io/endpoint?style=for-the-badge&url=https%3A%2F%2Fraw.githubusercontent.com%2Fsolidjs-community%2Fsolid-primitives%2Fmain%2Fassets%2Fbadges%2Fstage-3.json)](https://github.com/solidjs-community/solid-primitives#contribution-process)

No alert changes

Worsened metrics

Total package byte prevSize

35262

-1.33%

Lines of code

402

-12.23%

Dependency changes

• Updated

  @solid-primitives/utils@^7.0.0-next.2