@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/hooks/presentation/solid/network/useWebSocket.ts

@@ -0,0 +1,120 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseWebSocketOptions {
+	immediate?: boolean;
+	autoReconnect?: boolean;
+	reconnectInterval?: number;
+	maxReconnectAttempts?: number;
+	onConnected?: (event: Event) => void;
+	onDisconnected?: (event: CloseEvent) => void;
+	onError?: (event: Event) => void;
+	onMessage?: (event: MessageEvent) => void;
+}
+
+export interface UseWebSocketReturn {
+	data: () => string | null;
+	error: () => Event | null;
+	isOpen: () => boolean;
+	send: (data: string) => void;
+	connect: () => void;
+	disconnect: () => void;
+}
+
+export function useWebSocket(
+	url: string | (() => string),
+	options: UseWebSocketOptions = {},
+): UseWebSocketReturn {
+	const {
+		immediate = true,
+		autoReconnect = true,
+		reconnectInterval = 1000,
+		maxReconnectAttempts = 5,
+		onConnected,
+		onDisconnected,
+		onError,
+		onMessage,
+	} = options;
+
+	const [data, setData] = createSignal<string | null>(null);
+	const [error, setError] = createSignal<Event | null>(null);
+	const [isOpen, setIsOpen] = createSignal(false);
+
+	let ws: WebSocket | null = null;
+	let reconnectAttempts = 0;
+	let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+
+	const connect = () => {
+		const resolvedUrl = typeof url === "function" ? url() : url;
+
+		try {
+			ws = new WebSocket(resolvedUrl);
+
+			ws.onopen = (event) => {
+				setIsOpen(true);
+				setError(null);
+				reconnectAttempts = 0;
+				onConnected?.(event);
+			};
+
+			ws.onclose = (event) => {
+				setIsOpen(false);
+				onDisconnected?.(event);
+
+				if (autoReconnect && reconnectAttempts < maxReconnectAttempts) {
+					reconnectAttempts++;
+					reconnectTimer = setTimeout(connect, reconnectInterval);
+				}
+			};
+
+			ws.onerror = (event) => {
+				setError(event);
+				onError?.(event);
+			};
+
+			ws.onmessage = (event) => {
+				setData(event.data);
+				onMessage?.(event);
+			};
+		} catch (err) {
+			const errorObj =
+				err instanceof Error ? err : new Error("WebSocket error");
+			setError(errorObj as unknown as Event);
+			onError?.(errorObj as unknown as Event);
+		}
+	};
+
+	const disconnect = () => {
+		if (reconnectTimer) {
+			clearTimeout(reconnectTimer);
+			reconnectTimer = null;
+		}
+
+		if (ws) {
+			ws.close();
+			ws = null;
+		}
+
+		setIsOpen(false);
+	};
+
+	const send = (message: string) => {
+		if (ws && isOpen()) {
+			ws.send(message);
+		}
+	};
+
+	if (immediate) {
+		connect();
+	}
+
+	onCleanup(disconnect);
+
+	return {
+		data,
+		error,
+		isOpen,
+		send,
+		connect,
+		disconnect,
+	};
+}

package/src/hooks/presentation/solid/sensors/index.ts

@@ -0,0 +1,21 @@
+// Sensors composables
+export * from "./useAbsoluteOrientation";
+export * from "./useAccelerometer";
+export * from "./useAmbientLight";
+export * from "./useDeviceMotion";
+export * from "./useDeviceOrientation";
+export * from "./useGamepad";
+export * from "./useGamepadRumble";
+export * from "./useGravity";
+export * from "./useGyroscope";
+export * from "./useHID";
+export * from "./useLinearAcceleration";
+export * from "./useMagnetometer";
+export * from "./useMotion";
+export * from "./useNFC";
+export * from "./usePressure";
+export * from "./useProximity";
+export * from "./useRelativeOrientation";
+export * from "./useSerial";
+export * from "./useShake";
+export * from "./useTilt";

package/src/hooks/presentation/solid/sensors/useAbsoluteOrientation.ts

@@ -0,0 +1,41 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+
+export function useAbsoluteOrientation(): {
+	alpha: Accessor<number>;
+	beta: Accessor<number>;
+	gamma: Accessor<number>;
+	isSupported: Accessor<boolean>;
+} {
+	const [alpha, setAlpha] = createSignal(0);
+	const [beta, setBeta] = createSignal(0);
+	const [gamma, setGamma] = createSignal(0);
+	const [isSupported, setIsSupported] = createSignal(
+		"AbsoluteOrientationSensor" in window,
+	);
+	let sensor: any = null;
+
+	onMount(() => {
+		if (isSupported()) {
+			try {
+				sensor = new (window as any).AbsoluteOrientationSensor();
+				sensor.onreading = (): void => {
+					setAlpha(sensor.quaternion[3] || 0);
+					setBeta(sensor.quaternion[2] || 0);
+					setGamma(sensor.quaternion[1] || 0);
+				};
+				sensor.onerror = (_event: any): void => {};
+				sensor.start();
+			} catch (_err) {
+				setIsSupported(false);
+			}
+		}
+	});
+
+	onCleanup(() => {
+		if (sensor) {
+			sensor.stop();
+		}
+	});
+
+	return { alpha, beta, gamma, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useAccelerometer.ts

@@ -0,0 +1,39 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+
+export function useAccelerometer(): {
+	x: Accessor<number>;
+	y: Accessor<number>;
+	z: Accessor<number>;
+	isSupported: Accessor<boolean>;
+} {
+	const [x, setX] = createSignal(0);
+	const [y, setY] = createSignal(0);
+	const [z, setZ] = createSignal(0);
+	const [isSupported, setIsSupported] = createSignal("Accelerometer" in window);
+	let sensor: any = null;
+
+	onMount(() => {
+		if (isSupported()) {
+			try {
+				sensor = new (window as any).Accelerometer();
+				sensor.onreading = (): void => {
+					setX(sensor.x);
+					setY(sensor.y);
+					setZ(sensor.z);
+				};
+				sensor.onerror = (_event: any): void => {};
+				sensor.start();
+			} catch (_err) {
+				setIsSupported(false);
+			}
+		}
+	});
+
+	onCleanup(() => {
+		if (sensor) {
+			sensor.stop();
+		}
+	});
+
+	return { x, y, z, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useAmbientLight.ts

@@ -0,0 +1,35 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+
+export function useAmbientLight(): {
+	illuminance: Accessor<number>;
+	isSupported: Accessor<boolean>;
+} {
+	const [illuminance, setIlluminance] = createSignal(0);
+	const [isSupported, setIsSupported] = createSignal(
+		"AmbientLightSensor" in window,
+	);
+	let sensor: any = null;
+
+	onMount(() => {
+		if (isSupported()) {
+			try {
+				sensor = new (window as any).AmbientLightSensor();
+				sensor.onreading = (): void => {
+					setIlluminance(sensor.illuminance);
+				};
+				sensor.onerror = (_event: any): void => {};
+				sensor.start();
+			} catch (_err) {
+				setIsSupported(false);
+			}
+		}
+	});
+
+	onCleanup(() => {
+		if (sensor) {
+			sensor.stop();
+		}
+	});
+
+	return { illuminance, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useDeviceMotion.ts

@@ -0,0 +1,50 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+import type { DeviceMotion } from "#hooks/shared/types";
+
+export function useDeviceMotion(): {
+	motion: Accessor<DeviceMotion>;
+	isSupported: Accessor<boolean>;
+} {
+	const [motion, setMotion] = createSignal<DeviceMotion>({
+		acceleration: { x: null, y: null, z: null },
+		accelerationIncludingGravity: { x: null, y: null, z: null },
+		rotationRate: { alpha: null, beta: null, gamma: null },
+		interval: null,
+	});
+	const [isSupported] = createSignal("DeviceMotionEvent" in window);
+
+	const handleMotion = (event: DeviceMotionEvent): void => {
+		setMotion({
+			acceleration: {
+				x: event.acceleration?.x ?? null,
+				y: event.acceleration?.y ?? null,
+				z: event.acceleration?.z ?? null,
+			},
+			accelerationIncludingGravity: {
+				x: event.accelerationIncludingGravity?.x ?? null,
+				y: event.accelerationIncludingGravity?.y ?? null,
+				z: event.accelerationIncludingGravity?.z ?? null,
+			},
+			rotationRate: {
+				alpha: event.rotationRate?.alpha ?? null,
+				beta: event.rotationRate?.beta ?? null,
+				gamma: event.rotationRate?.gamma ?? null,
+			},
+			interval: event.interval ?? null,
+		});
+	};
+
+	onMount(() => {
+		if (isSupported()) {
+			window.addEventListener("devicemotion", handleMotion);
+		}
+	});
+
+	onCleanup(() => {
+		if (isSupported()) {
+			window.removeEventListener("devicemotion", handleMotion);
+		}
+	});
+
+	return { motion, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useDeviceOrientation.ts

@@ -0,0 +1,38 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+import type { DeviceOrientation } from "#hooks/shared/types";
+
+export function useDeviceOrientation(): {
+	orientation: Accessor<DeviceOrientation>;
+	isSupported: Accessor<boolean>;
+} {
+	const [orientation, setOrientation] = createSignal<DeviceOrientation>({
+		alpha: null,
+		beta: null,
+		gamma: null,
+		absolute: false,
+	});
+	const [isSupported] = createSignal("DeviceOrientationEvent" in window);
+
+	const handleOrientation = (event: DeviceOrientationEvent): void => {
+		setOrientation({
+			alpha: event.alpha,
+			beta: event.beta,
+			gamma: event.gamma,
+			absolute: event.absolute ?? false,
+		});
+	};
+
+	onMount(() => {
+		if (isSupported()) {
+			window.addEventListener("deviceorientation", handleOrientation);
+		}
+	});
+
+	onCleanup(() => {
+		if (isSupported()) {
+			window.removeEventListener("deviceorientation", handleOrientation);
+		}
+	});
+
+	return { orientation, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useGamepad.ts

@@ -0,0 +1,52 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+import type { GamepadState } from "#hooks/shared/types";
+
+export function useGamepad(): {
+	gamepads: Accessor<GamepadState[]>;
+	isSupported: Accessor<boolean>;
+} {
+	const [gamepads, setGamepads] = createSignal<GamepadState[]>([]);
+	const [isSupported] = createSignal("getGamepads" in navigator);
+
+	const updateGamepads = (): void => {
+		const pads = navigator.getGamepads();
+		setGamepads(
+			Array.from(pads)
+				.filter((pad): pad is Gamepad => pad !== null)
+				.map((pad) => ({
+					id: pad.id,
+					index: pad.index,
+					connected: pad.connected,
+					timestamp: pad.timestamp,
+					buttons: Array.from(pad.buttons).map((b) => b.pressed),
+					axes: Array.from(pad.axes),
+				})),
+		);
+	};
+
+	const handleGamepadConnected = (_event: GamepadEvent): void => {
+		updateGamepads();
+	};
+
+	const handleGamepadDisconnected = (_event: GamepadEvent): void => {
+		updateGamepads();
+	};
+
+	onMount(() => {
+		if (isSupported()) {
+			window.addEventListener("gamepadconnected", handleGamepadConnected);
+			window.addEventListener("gamepaddisconnected", handleGamepadDisconnected);
+			updateGamepads();
+		}
+	});
+
+	onCleanup(() => {
+		window.removeEventListener("gamepadconnected", handleGamepadConnected);
+		window.removeEventListener(
+			"gamepaddisconnected",
+			handleGamepadDisconnected,
+		);
+	});
+
+	return { gamepads, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useGamepadRumble.ts

@@ -0,0 +1,28 @@
+export function useGamepadRumble(): {
+	rumble: (
+		gamepadIndex: number,
+		duration: number,
+		strongMagnitude: number,
+		weakMagnitude: number,
+	) => Promise<void>;
+} {
+	const rumble = async (
+		gamepadIndex: number,
+		duration: number,
+		strongMagnitude: number,
+		weakMagnitude: number,
+	): Promise<void> => {
+		const gamepad = navigator.getGamepads()[gamepadIndex];
+		if (!gamepad?.vibrationActuator) {
+			throw new Error("Gamepad not found or does not support vibration");
+		}
+
+		await gamepad.vibrationActuator.playEffect("dual-rumble", {
+			duration,
+			strongMagnitude,
+			weakMagnitude,
+		});
+	};
+
+	return { rumble };
+}

package/src/hooks/presentation/solid/sensors/useGravity.ts

@@ -0,0 +1,39 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+
+export function useGravity(): {
+	x: Accessor<number>;
+	y: Accessor<number>;
+	z: Accessor<number>;
+	isSupported: Accessor<boolean>;
+} {
+	const [x, setX] = createSignal(0);
+	const [y, setY] = createSignal(0);
+	const [z, setZ] = createSignal(0);
+	const [isSupported, setIsSupported] = createSignal("GravitySensor" in window);
+	let sensor: any = null;
+
+	onMount(() => {
+		if (isSupported()) {
+			try {
+				sensor = new (window as any).GravitySensor();
+				sensor.onreading = (): void => {
+					setX(sensor.x);
+					setY(sensor.y);
+					setZ(sensor.z);
+				};
+				sensor.onerror = (_event: any): void => {};
+				sensor.start();
+			} catch (_err) {
+				setIsSupported(false);
+			}
+		}
+	});
+
+	onCleanup(() => {
+		if (sensor) {
+			sensor.stop();
+		}
+	});
+
+	return { x, y, z, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useGyroscope.ts

@@ -0,0 +1,39 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+
+export function useGyroscope(): {
+	x: Accessor<number>;
+	y: Accessor<number>;
+	z: Accessor<number>;
+	isSupported: Accessor<boolean>;
+} {
+	const [x, setX] = createSignal(0);
+	const [y, setY] = createSignal(0);
+	const [z, setZ] = createSignal(0);
+	const [isSupported, setIsSupported] = createSignal("Gyroscope" in window);
+	let sensor: any = null;
+
+	onMount(() => {
+		if (isSupported()) {
+			try {
+				sensor = new (window as any).Gyroscope();
+				sensor.onreading = (): void => {
+					setX(sensor.x);
+					setY(sensor.y);
+					setZ(sensor.z);
+				};
+				sensor.onerror = (_event: any): void => {};
+				sensor.start();
+			} catch (_err) {
+				setIsSupported(false);
+			}
+		}
+	});
+
+	onCleanup(() => {
+		if (sensor) {
+			sensor.stop();
+		}
+	});
+
+	return { x, y, z, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useHID.ts

@@ -0,0 +1,19 @@
+import { type Accessor, createSignal } from "solid-js";
+
+export function useHID(): {
+	isSupported: Accessor<boolean>;
+	requestDevice: (filters?: any[]) => Promise<any>;
+} {
+	const [isSupported] = createSignal("hid" in navigator);
+
+	const requestDevice = async (filters: any[] = []): Promise<any> => {
+		if (!isSupported()) {
+			throw new Error("HID API is not supported");
+		}
+
+		const device = await (navigator as any).hid.requestDevice({ filters });
+		return device;
+	};
+
+	return { isSupported, requestDevice };
+}

package/src/hooks/presentation/solid/sensors/useLinearAcceleration.ts

@@ -0,0 +1,41 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+
+export function useLinearAcceleration(): {
+	x: Accessor<number>;
+	y: Accessor<number>;
+	z: Accessor<number>;
+	isSupported: Accessor<boolean>;
+} {
+	const [x, setX] = createSignal(0);
+	const [y, setY] = createSignal(0);
+	const [z, setZ] = createSignal(0);
+	const [isSupported, setIsSupported] = createSignal(
+		"LinearAccelerationSensor" in window,
+	);
+	let sensor: any = null;
+
+	onMount(() => {
+		if (isSupported()) {
+			try {
+				sensor = new (window as any).LinearAccelerationSensor();
+				sensor.onreading = (): void => {
+					setX(sensor.x);
+					setY(sensor.y);
+					setZ(sensor.z);
+				};
+				sensor.onerror = (_event: any): void => {};
+				sensor.start();
+			} catch (_err) {
+				setIsSupported(false);
+			}
+		}
+	});
+
+	onCleanup(() => {
+		if (sensor) {
+			sensor.stop();
+		}
+	});
+
+	return { x, y, z, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useMagnetometer.ts

@@ -0,0 +1,39 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+
+export function useMagnetometer(): {
+	x: Accessor<number>;
+	y: Accessor<number>;
+	z: Accessor<number>;
+	isSupported: Accessor<boolean>;
+} {
+	const [x, setX] = createSignal(0);
+	const [y, setY] = createSignal(0);
+	const [z, setZ] = createSignal(0);
+	const [isSupported, setIsSupported] = createSignal("Magnetometer" in window);
+	let sensor: any = null;
+
+	onMount(() => {
+		if (isSupported()) {
+			try {
+				sensor = new (window as any).Magnetometer();
+				sensor.onreading = (): void => {
+					setX(sensor.x);
+					setY(sensor.y);
+					setZ(sensor.z);
+				};
+				sensor.onerror = (_event: any): void => {};
+				sensor.start();
+			} catch (_err) {
+				setIsSupported(false);
+			}
+		}
+	});
+
+	onCleanup(() => {
+		if (sensor) {
+			sensor.stop();
+		}
+	});
+
+	return { x, y, z, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useMotion.ts

@@ -0,0 +1,31 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+
+export function useMotion(): {
+	motion: Accessor<{ x: number; y: number; z: number }>;
+	isSupported: Accessor<boolean>;
+} {
+	const [motion, setMotion] = createSignal({ x: 0, y: 0, z: 0 });
+	const [isSupported] = createSignal("DeviceMotionEvent" in window);
+
+	const handleMotion = (event: DeviceMotionEvent): void => {
+		setMotion({
+			x: event.accelerationIncludingGravity?.x ?? 0,
+			y: event.accelerationIncludingGravity?.y ?? 0,
+			z: event.accelerationIncludingGravity?.z ?? 0,
+		});
+	};
+
+	onMount(() => {
+		if (isSupported()) {
+			window.addEventListener("devicemotion", handleMotion);
+		}
+	});
+
+	onCleanup(() => {
+		if (isSupported()) {
+			window.removeEventListener("devicemotion", handleMotion);
+		}
+	});
+
+	return { motion, isSupported };
+}

package/src/hooks/presentation/solid/sensors/useNFC.ts

@@ -0,0 +1,19 @@
+import { type Accessor, createSignal } from "solid-js";
+
+export function useNFC(): {
+	isSupported: Accessor<boolean>;
+	scan: () => Promise<any>;
+} {
+	const [isSupported, _setIsSupported] = createSignal("NDEFReader" in window);
+
+	const scan = async (): Promise<any> => {
+		if (!isSupported()) {
+			throw new Error("NFC API is not supported");
+		}
+
+		const ndef = new (window as any).NDEFReader();
+		return await ndef.scan();
+	};
+
+	return { isSupported, scan };
+}

package/src/hooks/presentation/solid/sensors/usePressure.ts

@@ -0,0 +1,35 @@
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+
+export function usePressure(): {
+	pressure: Accessor<number>;
+	isSupported: Accessor<boolean>;
+} {
+	const [pressure, setPressure] = createSignal(0);
+	const [isSupported, setIsSupported] = createSignal(
+		"PressureSensor" in window,
+	);
+	let sensor: any = null;
+
+	onMount(() => {
+		if (isSupported()) {
+			try {
+				sensor = new (window as any).PressureSensor();
+				sensor.onreading = (): void => {
+					setPressure(sensor.pressure);
+				};
+				sensor.onerror = (_event: any): void => {};
+				sensor.start();
+			} catch (_err) {
+				setIsSupported(false);
+			}
+		}
+	});
+
+	onCleanup(() => {
+		if (sensor) {
+			sensor.stop();
+		}
+	});
+
+	return { pressure, isSupported };
+}