@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/hooks/presentation/solid/time/whenever.ts

@@ -0,0 +1,13 @@
+import { type Accessor, createEffect } from "solid-js";
+
+export function whenever<T>(
+	source: Accessor<T>,
+	callback: (value: T) => void,
+): void {
+	createEffect(() => {
+		const value = source();
+		if (value) {
+			callback(value);
+		}
+	});
+}

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

@@ -0,0 +1,8 @@
+// Utilities composables
+export * from "./useDebounce";
+export * from "./useEventBus";
+export * from "./useMemoize";
+export * from "./useSorted";
+export * from "./useThrottle";
+export * from "./useToNumber";
+export * from "./useToString";

package/src/hooks/presentation/solid/utilities/useArrayEvery.ts

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

package/src/hooks/presentation/solid/utilities/useArrayFilter.ts

@@ -0,0 +1,11 @@
+import { type Accessor, createMemo } from "solid-js";
+import type { ArrayFilterOptions } from "#hooks/shared/types";
+
+export function useArrayFilter<T>(
+	list: Accessor<T[]>,
+	options: ArrayFilterOptions<T>,
+): Accessor<T[]> {
+	const { filter } = options;
+
+	return createMemo(() => list().filter(filter));
+}

package/src/hooks/presentation/solid/utilities/useArrayFind.ts

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

package/src/hooks/presentation/solid/utilities/useArrayIncludes.ts

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

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

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

package/src/hooks/presentation/solid/utilities/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/utilities/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/utilities/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/utilities/useClamp.ts

@@ -0,0 +1,24 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export interface UseClampOptions {
+	min?: number;
+	max?: number;
+}
+
+export function useClamp(
+	value: number | (() => number),
+	options: UseClampOptions = {},
+): Accessor<number> {
+	const { min = -Infinity, max = Infinity } = options;
+
+	const resolvedValue = createMemo(() =>
+		typeof value === "function" ? (value as () => number)() : value,
+	);
+
+	const clamped = createMemo(() => {
+		const v = resolvedValue();
+		return Math.min(Math.max(v, min), max);
+	});
+
+	return clamped;
+}

package/src/hooks/presentation/solid/utilities/useDebounce.ts

@@ -0,0 +1,32 @@
+import { onCleanup } from "solid-js";
+
+export interface UseDebounceOptions {
+	delay?: number;
+}
+
+export function useDebounce<T>(
+	fn: (value: T) => void,
+	options: UseDebounceOptions = {},
+): (value: T) => void {
+	const { delay = 300 } = options;
+
+	let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+	const debounced = (value: T) => {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+		}
+
+		timeoutId = setTimeout(() => {
+			fn(value);
+		}, delay);
+	};
+
+	onCleanup(() => {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+		}
+	});
+
+	return debounced;
+}

package/src/hooks/presentation/solid/utilities/useEventBus.ts

@@ -0,0 +1,57 @@
+import { createSignal } from "solid-js";
+
+type EventCallback<T = unknown> = (data: T) => void;
+
+export function useEventBus() {
+	const [events, setEvents] = createSignal(
+		new Map<string, Set<EventCallback>>(),
+	);
+
+	const on = <T = unknown>(
+		event: string,
+		callback: EventCallback<T>,
+	): (() => void) => {
+		let cleanup: (() => void) | undefined;
+
+		setEvents((currentEvents) => {
+			const newEvents = new Map(currentEvents);
+			if (!newEvents.has(event)) {
+				newEvents.set(event, new Set());
+			}
+			const callbacks = newEvents.get(event);
+			if (callbacks) {
+				callbacks.add(callback as EventCallback);
+
+				cleanup = () => {
+					callbacks.delete(callback as EventCallback);
+					if (callbacks.size === 0) {
+						newEvents.delete(event);
+					}
+				};
+			}
+
+			return newEvents;
+		});
+
+		return cleanup ?? (() => {});
+	};
+
+	const emit = <T = unknown>(event: string, data: T): void => {
+		const callbacks = events().get(event);
+		if (callbacks) {
+			for (const callback of callbacks) {
+				callback(data);
+			}
+		}
+	};
+
+	const off = (event: string): void => {
+		setEvents((currentEvents) => {
+			const newEvents = new Map(currentEvents);
+			newEvents.delete(event);
+			return newEvents;
+		});
+	};
+
+	return { on, emit, off };
+}

package/src/hooks/presentation/solid/utilities/useMemoize.ts

@@ -0,0 +1,15 @@
+export function useMemoize<T extends (...args: any[]) => any>(fn: T): T {
+	const cache = new Map<string, ReturnType<T>>();
+
+	return ((...args: Parameters<T>) => {
+		const key = JSON.stringify(args);
+
+		if (cache.has(key)) {
+			return cache.get(key);
+		}
+
+		const result = fn(...args);
+		cache.set(key, result);
+		return result;
+	}) as T;
+}

package/src/hooks/presentation/solid/utilities/useOffset.ts

@@ -0,0 +1,20 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export interface UseOffsetOptions {
+	offset?: number;
+}
+
+export function useOffset(
+	value: number | (() => number),
+	options: UseOffsetOptions = {},
+): Accessor<number> {
+	const { offset = 0 } = options;
+
+	const resolvedValue = createMemo(() =>
+		typeof value === "function" ? (value as () => number)() : value,
+	);
+
+	const offsetValue = createMemo(() => resolvedValue() + offset);
+
+	return offsetValue;
+}

package/src/hooks/presentation/solid/utilities/useRound.ts

@@ -0,0 +1,24 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export interface UseRoundOptions {
+	precision?: number;
+}
+
+export function useRound(
+	value: number | (() => number),
+	options: UseRoundOptions = {},
+): Accessor<number> {
+	const { precision = 0 } = options;
+
+	const resolvedValue = createMemo(() =>
+		typeof value === "function" ? (value as () => number)() : value,
+	);
+
+	const rounded = createMemo(() => {
+		const v = resolvedValue();
+		const factor = 10 ** precision;
+		return Math.round(v * factor) / factor;
+	});
+
+	return rounded;
+}

package/src/hooks/presentation/solid/utilities/useSorted.ts

@@ -0,0 +1,12 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export function useSorted<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/utilities/useThrottle.ts

@@ -0,0 +1,44 @@
+import { onCleanup } from "solid-js";
+
+export interface UseThrottleOptions {
+	delay?: number;
+}
+
+export function useThrottle<T>(
+	fn: (value: T) => void,
+	options: UseThrottleOptions = {},
+): (value: T) => void {
+	const { delay = 300 } = options;
+
+	let lastCall = 0;
+	let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+	const throttled = (value: T, now2: number = Date.now()) => {
+		const now = now2;
+
+		if (now - lastCall >= delay) {
+			lastCall = now;
+			fn(value);
+		} else {
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+			}
+
+			timeoutId = setTimeout(
+				() => {
+					lastCall = Date.now();
+					fn(value);
+				},
+				delay - (now - lastCall),
+			);
+		}
+	};
+
+	onCleanup(() => {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+		}
+	});
+
+	return throttled;
+}

package/src/hooks/presentation/solid/utilities/useToNumber.ts

@@ -0,0 +1,11 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export function useToNumber(
+	value: string | number | (() => string | number),
+): Accessor<number> {
+	return createMemo(() => {
+		const v =
+			typeof value === "function" ? (value as () => string | number)() : value;
+		return Number(v);
+	});
+}

package/src/hooks/presentation/solid/utilities/useToString.ts

@@ -0,0 +1,10 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export function useToString(
+	value: unknown | (() => unknown),
+): Accessor<string> {
+	return createMemo(() => {
+		const v = typeof value === "function" ? (value as () => unknown)() : value;
+		return String(v);
+	});
+}

package/src/hooks/realtime/use-sse.ts

@@ -0,0 +1,70 @@
+/**
+ * useSse — EventSource as a reactive signal
+ * Returns the latest parsed event; reconnects automatically (native
+ * EventSource behavior) and closes on cleanup
+ */
+
+import { type Accessor, createSignal, onCleanup, onMount } from "solid-js";
+import { isServer } from "solid-js/web";
+
+export interface UseSseOptions<T> {
+	/** Parse event.data — default JSON.parse with string fallback */
+	parse?: (raw: string) => T;
+	/** Named event to listen for — default "message" */
+	event?: string;
+	/** Start closed — call the returned open() to connect */
+	immediate?: boolean;
+}
+
+export interface SseChannel<T> {
+	data: Accessor<T | undefined>;
+	error: Accessor<Event | undefined>;
+	ready: Accessor<boolean>;
+	open(): void;
+	close(): void;
+}
+
+export const useSse = <T = unknown>(
+	url: string,
+	options: UseSseOptions<T> = {},
+): SseChannel<T> => {
+	const [data, setData] = createSignal<T>();
+	const [error, setError] = createSignal<Event>();
+	const [ready, setReady] = createSignal(false);
+	let source: EventSource | undefined;
+
+	const parse =
+		options.parse ??
+		((raw: string) => {
+			try {
+				return JSON.parse(raw) as T;
+			} catch {
+				return raw as T;
+			}
+		});
+
+	const open = () => {
+		if (isServer || source) return;
+		source = new EventSource(url);
+		source.onopen = () => setReady(true);
+		source.onerror = (e) => {
+			setReady(false);
+			setError(e);
+		};
+		source.addEventListener(options.event ?? "message", (e) => {
+			setData(() => parse((e as MessageEvent).data as string));
+		});
+	};
+	const close = () => {
+		source?.close();
+		source = undefined;
+		setReady(false);
+	};
+
+	onMount(() => {
+		if (options.immediate !== false) open();
+	});
+	onCleanup(close);
+
+	return { data, error, ready, open, close };
+};

package/src/hooks/shared/constants/index.ts

@@ -0,0 +1,4 @@
+// Common constants
+export const DEFAULT_MIN_VALUE = 0;
+export const DEFAULT_MAX_VALUE = Number.POSITIVE_INFINITY;
+export const DEFAULT_INITIAL_VALUE = 0;

package/src/hooks/shared/errors/index.ts

@@ -0,0 +1 @@
+export * from "./validation-error";

package/src/hooks/shared/errors/validation-error.ts

@@ -0,0 +1,28 @@
+// Validation error type
+export class ValidationError extends Error {
+	field: string;
+	value: unknown;
+	context?: Record<string, unknown>;
+
+	constructor(
+		message: string,
+		field: string,
+		value: unknown,
+		context?: Record<string, unknown>,
+	) {
+		super(message);
+		this.name = "ValidationError";
+		this.field = field;
+		this.value = value;
+		Object.assign(this, context !== undefined ? { context } : {});
+	}
+}
+
+export function createValidationError(
+	message: string,
+	field: string,
+	value: unknown,
+	context?: Record<string, unknown>,
+): ValidationError {
+	return new ValidationError(message, field, value, context);
+}

package/src/hooks/shared/index.ts

@@ -0,0 +1,8 @@
+export {
+	DEFAULT_INITIAL_VALUE,
+	DEFAULT_MAX_VALUE,
+	DEFAULT_MIN_VALUE,
+} from "./constants";
+export * from "./errors";
+export * from "./types";
+export { chain, err, ok } from "./utils";

package/src/hooks/shared/types/index.ts

@@ -0,0 +1,17 @@
+export {
+	isNone,
+	isSome,
+	map as optionMap,
+	none,
+	some,
+	unwrap,
+} from "./option";
+// Re-export with renamed function to avoid conflicts
+export {
+	chain,
+	failure,
+	resultMap,
+	resultMap as map,
+	success,
+} from "./result";
+export * from "./utilities";

package/src/hooks/shared/types/option.ts

@@ -0,0 +1,17 @@
+// Option type for nullable values
+export type Option<T> = T | null | undefined;
+
+export const some = <T>(value: T): Option<T> => value;
+export const none = (): Option<never> => null;
+
+export const isSome = <T>(option: Option<T>): option is T =>
+	option !== null && option !== undefined;
+
+export const isNone = <T>(option: Option<T>): option is null | undefined =>
+	option === null || option === undefined;
+
+export const map = <T, U>(option: Option<T>, fn: (value: T) => U): Option<U> =>
+	isSome(option) ? fn(option) : none();
+
+export const unwrap = <T>(option: Option<T>, defaultValue: T): T =>
+	isSome(option) ? option : defaultValue;

package/src/hooks/shared/types/result.ts

@@ -0,0 +1,34 @@
+// Result type for error handling
+export type Result<T, E = Error> =
+	| { success: true; data: T }
+	| { success: false; error: E };
+
+export const success = <T>(data: T): Result<T> => ({
+	success: true,
+	data,
+});
+
+export const failure = <E = Error>(error: E): Result<never, E> => ({
+	success: false,
+	error,
+});
+
+export const resultMap = <T, U>(
+	result: Result<T>,
+	fn: (data: T) => U,
+): Result<U> => {
+	if (result.success) {
+		return success(fn(result.data));
+	}
+	return result as unknown as Result<U>;
+};
+
+export const chain = <T, U, E>(
+	result: Result<T, E>,
+	fn: (data: T) => Result<U, E>,
+): Result<U, E> => {
+	if (result.success) {
+		return fn(result.data);
+	}
+	return result;
+};

package/src/hooks/shared/types/utilities.ts

@@ -0,0 +1,102 @@
+// Utility types for composables
+
+export type ArrayFilterOptions<T> = Readonly<{
+	filter: (item: T) => boolean;
+}>;
+
+export type ArrayFindOptions<T> = Readonly<{
+	predicate: (item: T) => boolean;
+}>;
+
+export type ArrayMapOptions<T, U> = Readonly<{
+	map: (item: T) => U;
+}>;
+
+export type RefDebouncedOptions = Readonly<{
+	debounce?: number;
+}>;
+
+export type RefThrottledOptions = Readonly<{
+	throttle?: number;
+}>;
+
+export type SyncRefOptions = Readonly<{
+	direction?: "ltr" | "rtl" | "both";
+}>;
+
+export type Breakpoint = Readonly<{
+	name: string;
+	minWidth: number;
+}>;
+
+export type ScrollToOptions = Readonly<{
+	behavior?: ScrollBehavior;
+	offset?: number;
+}>;
+
+export type ScrollDirection = "up" | "down" | "left" | "right";
+
+export type ScrollDirectionState = {
+	x: ScrollDirection | null;
+	y: ScrollDirection | null;
+};
+
+// Storage options
+export type StorageOptions<T> = Readonly<{
+	serializer?: (value: T) => string;
+	deserializer?: (value: string) => T;
+	onError?: (error: Error) => void;
+}>;
+
+// Time utilities
+export type DebounceFnOptions = Readonly<{
+	debounce?: number;
+}>;
+
+export type ThrottleFnOptions = Readonly<{
+	throttle?: number;
+}>;
+
+export type TimeoutOptions = Readonly<{
+	timeout?: number;
+}>;
+
+export type IntervalOptions = Readonly<{
+	interval?: number;
+}>;
+
+// Sensor types
+export type GamepadState = Readonly<{
+	id: string;
+	index: number;
+	connected: boolean;
+	timestamp: number;
+	buttons: readonly boolean[];
+	axes: readonly number[];
+}>;
+
+export type DeviceOrientation = Readonly<{
+	alpha: number | null;
+	beta: number | null;
+	gamma: number | null;
+	absolute: boolean;
+}>;
+
+export type DeviceMotion = Readonly<{
+	acceleration: {
+		x: number | null;
+		y: number | null;
+		z: number | null;
+	};
+	accelerationIncludingGravity: {
+		x: number | null;
+		y: number | null;
+		z: number | null;
+	};
+	rotationRate: {
+		alpha: number | null;
+		beta: number | null;
+		gamma: number | null;
+	};
+	interval: number | null;
+}>;

package/src/hooks/shared/utils/identity.ts

@@ -0,0 +1,2 @@
+// Identity utility function
+export const identity = <T>(x: T): T => x;

package/src/hooks/shared/utils/index.ts

@@ -0,0 +1,4 @@
+export { identity } from "./identity";
+export * from "./logger";
+export { pipe } from "./pipe";
+export * from "./result";