@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/hooks/presentation/solid/array/useArrayMap.ts

@@ -0,0 +1,8 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export function useArrayMap<T, U>(
+	array: () => T[],
+	mapper: (item: T, index: number) => U,
+): Accessor<U[]> {
+	return createMemo(() => array().map(mapper));
+}

package/src/hooks/presentation/solid/array/useArrayPop.ts

@@ -0,0 +1,18 @@
+import { createSignal } from "solid-js";
+
+export function useArrayPop<T>(array: () => T[]): () => T | undefined {
+	const [_signal, setSignal] = createSignal<T | undefined>(undefined);
+
+	const pop = () => {
+		let removed: T | undefined;
+		setSignal(() => {
+			const arr = array();
+			if (arr.length === 0) return undefined;
+			removed = arr[arr.length - 1];
+			return removed;
+		});
+		return removed;
+	};
+
+	return pop;
+}

package/src/hooks/presentation/solid/array/useArrayPush.ts

@@ -0,0 +1,15 @@
+import { createSignal } from "solid-js";
+
+export function useArrayPush<T>(array: () => T[]): (item: T) => void {
+	const [_signal, setSignal] = createSignal<T | null>(null);
+
+	const push = (item: T) => {
+		setSignal(() => {
+			const arr = [...array()];
+			arr.push(item);
+			return item;
+		});
+	};
+
+	return push;
+}

package/src/hooks/presentation/solid/array/useArrayReduce.ts

@@ -0,0 +1,9 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export function useArrayReduce<T, U>(
+	array: () => T[],
+	reducer: (accumulator: U, currentValue: T, index: number) => U,
+	initialValue: U,
+): Accessor<U> {
+	return createMemo(() => array().reduce(reducer, initialValue));
+}

package/src/hooks/presentation/solid/array/useArrayShift.ts

@@ -0,0 +1,18 @@
+import { createSignal } from "solid-js";
+
+export function useArrayShift<T>(array: () => T[]): () => T | undefined {
+	const [_signal, setSignal] = createSignal<T | undefined>(undefined);
+
+	const shift = () => {
+		let removed: T | undefined;
+		setSignal(() => {
+			const arr = array();
+			if (arr.length === 0) return undefined;
+			removed = arr[0];
+			return removed;
+		});
+		return removed;
+	};
+
+	return shift;
+}

package/src/hooks/presentation/solid/array/useArraySome.ts

@@ -0,0 +1,8 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export function useArraySome<T>(
+	array: () => T[],
+	predicate: (item: T, index: number) => boolean,
+): Accessor<boolean> {
+	return createMemo(() => array().some(predicate));
+}

package/src/hooks/presentation/solid/array/useArraySort.ts

@@ -0,0 +1,12 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export function useArraySort<T>(
+	array: () => T[],
+	compareFn?: (a: T, b: T) => number,
+): Accessor<T[]> {
+	return createMemo(() => {
+		const arr = [...array()];
+		arr.sort(compareFn);
+		return arr;
+	});
+}

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

@@ -0,0 +1,35 @@
+// Browser composables
+export * from "./useBarcode";
+export * from "./useBattery";
+export * from "./useBeacon";
+export * from "./useBluetooth";
+export * from "./useClipboard";
+export * from "./useClipboardAdvanced";
+export * from "./useConnection";
+export * from "./useCredential";
+export * from "./useDisplayMedia";
+export * from "./useFaceDetection";
+export * from "./useFullscreen";
+export * from "./useGeolocation";
+export * from "./useLocalStorage";
+export * from "./useMediaDevices";
+export * from "./useMemory";
+export * from "./useNetwork";
+export * from "./useNotification";
+export * from "./usePayment";
+export * from "./usePerformance";
+export * from "./usePush";
+export * from "./useQrCode";
+export * from "./useScreenOrientation";
+export * from "./useServiceWorker";
+export * from "./useSessionStorage";
+export * from "./useShare";
+export * from "./useSpeechRecognition";
+export * from "./useSpeechSynthesis";
+export * from "./useStorage";
+export * from "./useTextDetection";
+export * from "./useUsb";
+export * from "./useUserMedia";
+export * from "./useVibration";
+export * from "./useWakeLock";
+export * from "./useWebAuthn";

package/src/hooks/presentation/solid/browser/useBarcode.ts

@@ -0,0 +1,15 @@
+import { createSignal } from "solid-js";
+
+export function useBarcode() {
+	const [isSupported, _setIsSupported] = createSignal(
+		"BarcodeDetector" in window,
+	);
+	const detect = async (image: any) => {
+		if (!isSupported()) {
+			throw new Error("Barcode Detection API is not supported");
+		}
+		const detector = new (window as any).BarcodeDetector();
+		return await detector.detect(image);
+	};
+	return { isSupported, detect };
+}

package/src/hooks/presentation/solid/browser/useBattery.ts

@@ -0,0 +1,37 @@
+import { createSignal, onMount } from "solid-js";
+
+export function useBattery() {
+	const [battery, setBattery] = createSignal<any>(null);
+	const [isSupported, setIsSupported] = createSignal(false);
+	onMount(() => {
+		if ("getBattery" in navigator) {
+			setIsSupported(true);
+			(navigator as any).getBattery().then((bat: any) => {
+				setBattery({
+					level: bat.level,
+					charging: bat.charging,
+					chargingTime: bat.chargingTime,
+					dischargingTime: bat.dischargingTime,
+				});
+				bat.addEventListener("levelchange", () => {
+					const current = battery();
+					if (current) {
+						setBattery({ ...current, level: bat.level });
+					}
+				});
+				bat.addEventListener("chargingchange", () => {
+					const current = battery();
+					if (current) {
+						setBattery({
+							...current,
+							charging: bat.charging,
+							chargingTime: bat.chargingTime,
+							dischargingTime: bat.dischargingTime,
+						});
+					}
+				});
+			});
+		}
+	});
+	return { battery, isSupported };
+}

package/src/hooks/presentation/solid/browser/useBeacon.ts

@@ -0,0 +1,4 @@
+export function useBeacon() {
+	const send = (url: string, data: any) => navigator.sendBeacon(url, data);
+	return { send };
+}

package/src/hooks/presentation/solid/browser/useBluetooth.ts

@@ -0,0 +1,15 @@
+import { createSignal } from "solid-js";
+
+export function useBluetooth() {
+	const [isSupported] = createSignal("bluetooth" in navigator);
+	const [devices, setDevices] = createSignal<any[]>([]);
+	const requestDevice = async (options: any = {}) => {
+		if (!isSupported()) {
+			throw new Error("Bluetooth is not supported");
+		}
+		const device = await (navigator as any).bluetooth.requestDevice(options);
+		setDevices([...devices(), device]);
+		return device;
+	};
+	return { isSupported, devices, requestDevice };
+}

package/src/hooks/presentation/solid/browser/useClipboard.ts

@@ -0,0 +1,17 @@
+import { type Accessor, createSignal } from "solid-js";
+
+export function useClipboard(): {
+	text: Accessor<string>;
+	copy: (text: string) => Promise<void>;
+} {
+	const [text, setText] = createSignal("");
+
+	const copy = async (value: string): Promise<void> => {
+		try {
+			await navigator.clipboard.writeText(value);
+			setText(value);
+		} catch (_error) {}
+	};
+
+	return { text, copy };
+}

package/src/hooks/presentation/solid/browser/useClipboardAdvanced.ts

@@ -0,0 +1,54 @@
+import { type Accessor, createSignal } from "solid-js";
+
+export function useClipboardAdvanced(): {
+	text: Accessor<string>;
+	image: Accessor<Blob | null>;
+	copyText: (text: string) => Promise<void>;
+	copyImage: (blob: Blob) => Promise<void>;
+	readText: () => Promise<string>;
+	readImage: () => Promise<Blob>;
+} {
+	const [text, setText] = createSignal("");
+	const [image, setImage] = createSignal<Blob | null>(null);
+
+	const copyText = async (value: string): Promise<void> => {
+		try {
+			await navigator.clipboard.writeText(value);
+			setText(value);
+		} catch (_err) {}
+	};
+
+	const copyImage = async (blob: Blob): Promise<void> => {
+		try {
+			await navigator.clipboard.write([
+				new ClipboardItem({ [blob.type]: blob }),
+			]);
+			setImage(blob);
+		} catch (_err) {}
+	};
+
+	const readText = async (): Promise<string> => {
+		try {
+			const value = await navigator.clipboard.readText();
+			setText(value);
+			return value;
+		} catch (_err) {
+			return "";
+		}
+	};
+
+	const readImage = async (): Promise<Blob> => {
+		const items = await navigator.clipboard.read();
+		for (const item of items) {
+			const imageItem = item.types.find((type) => type.startsWith("image/"));
+			if (imageItem) {
+				const blob = await item.getType(imageItem);
+				setImage(blob);
+				return blob;
+			}
+		}
+		throw new Error("No image found in clipboard");
+	};
+
+	return { text, image, copyText, copyImage, readText, readImage };
+}

package/src/hooks/presentation/solid/browser/useConnection.ts

@@ -0,0 +1,22 @@
+import { createSignal, onCleanup, onMount } from "solid-js";
+
+export function useConnection() {
+	const [connection, setConnection] = createSignal<any>(null);
+	onMount(() => {
+		const conn =
+			(navigator as any).connection ||
+			(navigator as any).mozConnection ||
+			(navigator as any).webkitConnection;
+		if (conn) {
+			setConnection(conn);
+			const handleChange = () => {
+				setConnection(conn);
+			};
+			conn.addEventListener("change", handleChange);
+			onCleanup(() => {
+				conn.removeEventListener("change", handleChange);
+			});
+		}
+	});
+	return { connection };
+}

package/src/hooks/presentation/solid/browser/useCredential.ts

@@ -0,0 +1,18 @@
+import { createSignal } from "solid-js";
+
+export function useCredential() {
+	const [isSupported] = createSignal("credentials" in navigator);
+	const store = async (credential: any) => {
+		if (!isSupported()) {
+			throw new Error("Credential Management API is not supported");
+		}
+		await (navigator as any).credentials.store(credential);
+	};
+	const get = async (options: any) => {
+		if (!isSupported()) {
+			throw new Error("Credential Management API is not supported");
+		}
+		return await (navigator as any).credentials.get(options);
+	};
+	return { isSupported, store, get };
+}

package/src/hooks/presentation/solid/browser/useDisplayMedia.ts

@@ -0,0 +1,24 @@
+import { type Accessor, createSignal } from "solid-js";
+
+export function useDisplayMedia(constraints: any = {}): {
+	stream: Accessor<MediaStream | null>;
+	start: () => Promise<void>;
+	stop: () => void;
+} {
+	const [stream, setStream] = createSignal<MediaStream | null>(null);
+
+	const start = async (): Promise<void> => {
+		const result = await navigator.mediaDevices.getDisplayMedia(constraints);
+		setStream(result);
+	};
+
+	const stop = (): void => {
+		const currentStream = stream();
+		if (currentStream) {
+			currentStream.getTracks().forEach((track) => void track.stop());
+			setStream(null);
+		}
+	};
+
+	return { stream, start, stop };
+}

package/src/hooks/presentation/solid/browser/useFaceDetection.ts

@@ -0,0 +1,20 @@
+import { type Accessor, createSignal } from "solid-js";
+
+export function useFaceDetection(): {
+	isSupported: Accessor<boolean>;
+	detect: (image: ImageBitmapSource) => Promise<any[]>;
+} {
+	const [isSupported] = createSignal("FaceDetector" in window);
+
+	const detect = async (image: ImageBitmapSource): Promise<any[]> => {
+		if (!isSupported()) {
+			throw new Error("Face Detection API is not supported");
+		}
+
+		const detector = new (window as any).FaceDetector();
+		const faces = await detector.detect(image);
+		return faces;
+	};
+
+	return { isSupported, detect };
+}

package/src/hooks/presentation/solid/browser/useFullscreen.ts

@@ -0,0 +1,33 @@
+import { createSignal, onCleanup, onMount } from "solid-js";
+
+export function useFullscreen(target?: any) {
+	const [isFullscreen, setIsFullscreen] = createSignal(false);
+	const enter = async () => {
+		const el = target ? target() : document.documentElement;
+		try {
+			await el.requestFullscreen();
+		} catch (_err) {}
+	};
+	const exit = async () => {
+		try {
+			await document.exitFullscreen();
+		} catch (_err) {}
+	};
+	const toggle = async () => {
+		if (isFullscreen()) {
+			await exit();
+		} else {
+			await enter();
+		}
+	};
+	const handleChange = () => {
+		setIsFullscreen(!!document.fullscreenElement);
+	};
+	onMount(() => {
+		document.addEventListener("fullscreenchange", handleChange);
+	});
+	onCleanup(() => {
+		document.removeEventListener("fullscreenchange", handleChange);
+	});
+	return { isFullscreen, enter, exit, toggle };
+}

package/src/hooks/presentation/solid/browser/useGeolocation.ts

@@ -0,0 +1,64 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export function useGeolocation(options: any = {}) {
+	const { enableHighAccuracy = true, timeout = 5000, maximumAge = 0 } = options;
+	const [position, setPosition] = createSignal<any>(null);
+	const [error, setError] = createSignal<any>(null);
+	let watchId: any = null;
+	const getCurrentPosition = () => {
+		if (!navigator.geolocation) {
+			return;
+		}
+		navigator.geolocation.getCurrentPosition(
+			(pos: any) => {
+				setPosition({
+					latitude: pos.coords.latitude,
+					longitude: pos.coords.longitude,
+					accuracy: pos.coords.accuracy,
+					altitude: pos.coords.altitude,
+					altitudeAccuracy: pos.coords.altitudeAccuracy,
+					heading: pos.coords.heading,
+					speed: pos.coords.speed,
+				});
+				setError(null);
+			},
+			(err: any) => {
+				setError(err);
+			},
+			{ enableHighAccuracy, timeout, maximumAge },
+		);
+	};
+	const watchPosition = () => {
+		if (!navigator.geolocation) {
+			return;
+		}
+		watchId = navigator.geolocation.watchPosition(
+			(pos: any) => {
+				setPosition({
+					latitude: pos.coords.latitude,
+					longitude: pos.coords.longitude,
+					accuracy: pos.coords.accuracy,
+					altitude: pos.coords.altitude,
+					altitudeAccuracy: pos.coords.altitudeAccuracy,
+					heading: pos.coords.heading,
+					speed: pos.coords.speed,
+				});
+				setError(null);
+			},
+			(err: any) => {
+				setError(err);
+			},
+			{ enableHighAccuracy, timeout, maximumAge },
+		);
+	};
+	const clearWatch = () => {
+		if (watchId !== null) {
+			navigator.geolocation.clearWatch(watchId);
+			watchId = null;
+		}
+	};
+	onCleanup(() => {
+		clearWatch();
+	});
+	return { position, error, getCurrentPosition, watchPosition, clearWatch };
+}

package/src/hooks/presentation/solid/browser/useLocalStorage.ts

@@ -0,0 +1,11 @@
+import type { Accessor } from "solid-js";
+import type { StorageOptions } from "#hooks/shared/types";
+import { useStorage } from "./useStorage";
+
+export function useLocalStorage<T>(
+	key: string,
+	initialValue: T,
+	options: StorageOptions<T> = {},
+): Accessor<T> {
+	return useStorage(key, initialValue, localStorage, options);
+}

package/src/hooks/presentation/solid/browser/useMediaDevices.ts

@@ -0,0 +1,24 @@
+import { type Accessor, createSignal } from "solid-js";
+
+export function useMediaDevices(): {
+	isSupported: Accessor<boolean>;
+	devices: Accessor<MediaDeviceInfo[]>;
+	enumerate: () => Promise<MediaDeviceInfo[]>;
+} {
+	const [isSupported, _setIsSupported] = createSignal(
+		"mediaDevices" in navigator,
+	);
+	const [devices, setDevices] = createSignal<MediaDeviceInfo[]>([]);
+
+	const enumerate = async (): Promise<MediaDeviceInfo[]> => {
+		if (!isSupported()) {
+			throw new Error("Media Devices API is not supported");
+		}
+
+		const result = await navigator.mediaDevices.enumerateDevices();
+		setDevices(() => result);
+		return result;
+	};
+
+	return { isSupported, devices, enumerate };
+}

package/src/hooks/presentation/solid/browser/useMemory.ts

@@ -0,0 +1,9 @@
+import { createSignal } from "solid-js";
+
+export function useMemory() {
+	const [memory, setMemory] = createSignal<any>(null);
+	if ("memory" in performance) {
+		setMemory((performance as any).memory);
+	}
+	return { memory };
+}

package/src/hooks/presentation/solid/browser/useNetwork.ts

@@ -0,0 +1,43 @@
+import { createSignal, onCleanup, onMount } from "solid-js";
+
+export function useNetwork() {
+	const [status, setStatus] = createSignal({
+		online: navigator.onLine,
+		type: "unknown",
+		effectiveType: "unknown",
+		rtt: 0,
+		downlink: 0,
+		saveData: false,
+	});
+	const updateStatus = () => {
+		const connection =
+			(navigator as any).connection ||
+			(navigator as any).mozConnection ||
+			(navigator as any).webkitConnection;
+		setStatus({
+			online: navigator.onLine,
+			type: connection?.type || "unknown",
+			effectiveType: connection?.effectiveType || "unknown",
+			rtt: connection?.rtt || 0,
+			downlink: connection?.downlink || 0,
+			saveData: connection?.saveData,
+		});
+	};
+	const handleOnline = () => {
+		setStatus((prev) => ({ ...prev, online: true }));
+		updateStatus();
+	};
+	const handleOffline = () => {
+		setStatus((prev) => ({ ...prev, online: false }));
+	};
+	onMount(() => {
+		window.addEventListener("online", handleOnline);
+		window.addEventListener("offline", handleOffline);
+		updateStatus();
+	});
+	onCleanup(() => {
+		window.removeEventListener("online", handleOnline);
+		window.removeEventListener("offline", handleOffline);
+	});
+	return { status };
+}

package/src/hooks/presentation/solid/browser/useNotification.ts

@@ -0,0 +1,21 @@
+import { createSignal } from "solid-js";
+
+export function useNotification() {
+	const [isSupported] = createSignal("Notification" in window);
+	const [permission, setPermission] = createSignal("default");
+	const requestPermission = async () => {
+		if (!isSupported()) {
+			throw new Error("Notifications are not supported");
+		}
+		const result = await Notification.requestPermission();
+		setPermission(result);
+		return result;
+	};
+	const show = (title: string, options: any = {}) => {
+		if (!isSupported() || permission() !== "granted") {
+			throw new Error("Notification permission not granted");
+		}
+		return new Notification(title, options);
+	};
+	return { isSupported, permission, requestPermission, show };
+}

package/src/hooks/presentation/solid/browser/usePayment.ts

@@ -0,0 +1,17 @@
+import { createSignal } from "solid-js";
+
+export function usePayment() {
+	const [isSupported] = createSignal("PaymentRequest" in window);
+	const request = async (details: any, options: any = {}) => {
+		if (!isSupported()) {
+			throw new Error("Payment Request API is not supported");
+		}
+		const paymentRequest = new (window as any).PaymentRequest(
+			details.methodData,
+			details.total,
+			options,
+		);
+		return await paymentRequest.show();
+	};
+	return { isSupported, request };
+}

package/src/hooks/presentation/solid/browser/usePerformance.ts

@@ -0,0 +1,13 @@
+import { createSignal, onMount } from "solid-js";
+
+export function usePerformance() {
+	const [timing, setTiming] = createSignal<any>(null);
+	const [navigation, setNavigation] = createSignal<any>(null);
+	const [entries, setEntries] = createSignal<any[]>([]);
+	onMount(() => {
+		setTiming((performance as any).timing);
+		setNavigation(performance.getEntriesByType("navigation")[0]);
+		setEntries(performance.getEntries());
+	});
+	return { timing, navigation, entries };
+}

package/src/hooks/presentation/solid/browser/usePush.ts

@@ -0,0 +1,12 @@
+import { createSignal } from "solid-js";
+
+export function usePush() {
+	const [isSupported] = createSignal("PushManager" in window);
+	const subscribe = async (registration: any, options: any = {}) => {
+		if (!(isSupported() && registration.pushManager)) {
+			throw new Error("Push API is not supported");
+		}
+		return await registration.pushManager.subscribe(options);
+	};
+	return { isSupported, subscribe };
+}

package/src/hooks/presentation/solid/browser/useQrCode.ts

@@ -0,0 +1,11 @@
+import { qrAdapter } from "#hooks/adapters/qr";
+
+export function useQRCode(): {
+	generate: (text: string) => Promise<string>;
+	scan: (image: ImageBitmapSource) => Promise<string | null>;
+} {
+	return {
+		generate: qrAdapter.generate,
+		scan: qrAdapter.scan,
+	};
+}