@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/hooks/modules/toggle/domain/operations/query.ts

@@ -0,0 +1,9 @@
+/**
+ * Toggle Query Operations
+ */
+
+import type { ToggleEntity } from "#hooks/modules/toggle/types";
+
+export const isToggleOn = (entity: ToggleEntity): boolean => entity.value;
+
+export const isToggleOff = (entity: ToggleEntity): boolean => !entity.value;

package/src/hooks/modules/toggle/domain/validators/index.ts

@@ -0,0 +1,2 @@
+// Domain validation functions for toggle
+export * from "../operations";

package/src/hooks/modules/toggle/index.ts

@@ -0,0 +1,6 @@
+// Toggle module public API
+
+export * from "./application";
+export * from "./domain";
+export * from "./ports";
+export * from "./types";

package/src/hooks/modules/toggle/ports/index.ts

@@ -0,0 +1,5 @@
+// Ports for toggle module
+export interface ITogglePort {
+	persist(key: string, value: boolean): void;
+	restore(key: string): boolean | null;
+}

package/src/hooks/modules/toggle/types/index.ts

@@ -0,0 +1,9 @@
+// Domain type definitions for toggle module
+
+export type ToggleEntity = Readonly<{
+	value: boolean;
+}>;
+
+export type ToggleOptions = Readonly<{
+	initialValue?: boolean;
+}>;

package/src/hooks/presentation/index.ts

@@ -0,0 +1,2 @@
+// Presentation layer exports
+export * from "./solid";

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

@@ -0,0 +1,11 @@
+// Animation composables
+
+export * from "./useElapsedTime";
+export * from "./useInterval";
+export * from "./useIntervalFn";
+export * from "./useNow";
+export * from "./useRafFn";
+export * from "./useTimeout";
+export * from "./useTimeoutFn";
+export * from "./useTimestamp";
+export * from "./useTransition";

package/src/hooks/presentation/solid/animation/useElapsedTime.ts

@@ -0,0 +1,75 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseElapsedTimeOptions {
+	interval?: number;
+	immediate?: boolean;
+}
+
+export interface UseElapsedTimeReturn {
+	elapsedTime: () => number;
+	pause: () => void;
+	resume: () => void;
+	reset: () => void;
+}
+
+export function useElapsedTime(
+	options: UseElapsedTimeOptions = {},
+): UseElapsedTimeReturn {
+	const { interval = 1000, immediate = true } = options;
+
+	const [elapsedTime, setElapsedTime] = createSignal(0);
+	const [isActive, setIsActive] = createSignal(false);
+
+	let intervalId: ReturnType<typeof setInterval> | null = null;
+	let startTime: number | null = null;
+	let accumulatedTime = 0;
+
+	const update = (now2: number = Date.now()) => {
+		if (startTime !== null) {
+			const now = now2;
+			setElapsedTime(accumulatedTime + (now - startTime));
+		}
+	};
+
+	const resume = (now: number = Date.now()) => {
+		if (isActive()) return;
+
+		setIsActive(true);
+		startTime = now;
+		intervalId = setInterval(update, interval);
+	};
+
+	const pause = (now: number = Date.now()) => {
+		if (intervalId) {
+			clearInterval(intervalId);
+			intervalId = null;
+		}
+
+		if (startTime !== null) {
+			accumulatedTime += now - startTime;
+			startTime = null;
+		}
+
+		setIsActive(false);
+	};
+
+	const reset = () => {
+		pause();
+		setElapsedTime(0);
+		accumulatedTime = 0;
+		startTime = null;
+	};
+
+	if (immediate) {
+		resume();
+	}
+
+	onCleanup(pause);
+
+	return {
+		elapsedTime,
+		pause,
+		resume,
+		reset,
+	};
+}

package/src/hooks/presentation/solid/animation/useInterval.ts

@@ -0,0 +1,68 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseIntervalOptions {
+	immediate?: boolean;
+	callback?: () => void;
+}
+
+export interface UseIntervalReturn {
+	counter: () => number;
+	isActive: () => boolean;
+	start: () => void;
+	stop: () => void;
+	reset: () => void;
+}
+
+export function useInterval(
+	interval: number | (() => number),
+	options: UseIntervalOptions = {},
+): UseIntervalReturn {
+	const { immediate = false, callback } = options;
+
+	const [counter, setCounter] = createSignal(0);
+	const [isActive, setIsActive] = createSignal(false);
+
+	let intervalId: ReturnType<typeof setInterval> | null = null;
+
+	const start = () => {
+		if (isActive()) return;
+
+		setIsActive(true);
+
+		const resolvedInterval =
+			typeof interval === "function" ? interval() : interval;
+
+		intervalId = setInterval(() => {
+			setCounter((prev) => prev + 1);
+			callback?.();
+		}, resolvedInterval);
+	};
+
+	const stop = () => {
+		if (intervalId) {
+			clearInterval(intervalId);
+			intervalId = null;
+		}
+
+		setIsActive(false);
+	};
+
+	const reset = () => {
+		stop();
+		setCounter(0);
+	};
+
+	if (immediate) {
+		start();
+	}
+
+	onCleanup(stop);
+
+	return {
+		counter,
+		isActive,
+		start,
+		stop,
+		reset,
+	};
+}

package/src/hooks/presentation/solid/animation/useIntervalFn.ts

@@ -0,0 +1,54 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseIntervalFnOptions {
+	immediate?: boolean;
+}
+
+export interface UseIntervalFnReturn {
+	isActive: () => boolean;
+	start: () => void;
+	stop: () => void;
+}
+
+export function useIntervalFn(
+	fn: () => void,
+	interval: number | (() => number),
+	options: UseIntervalFnOptions = {},
+): UseIntervalFnReturn {
+	const { immediate = false } = options;
+
+	const [isActive, setIsActive] = createSignal(false);
+
+	let intervalId: ReturnType<typeof setInterval> | null = null;
+
+	const start = () => {
+		if (isActive()) return;
+
+		const resolvedInterval =
+			typeof interval === "function" ? interval() : interval;
+
+		setIsActive(true);
+		intervalId = setInterval(fn, resolvedInterval);
+	};
+
+	const stop = () => {
+		if (intervalId) {
+			clearInterval(intervalId);
+			intervalId = null;
+		}
+
+		setIsActive(false);
+	};
+
+	if (immediate) {
+		start();
+	}
+
+	onCleanup(stop);
+
+	return {
+		isActive,
+		start,
+		stop,
+	};
+}

package/src/hooks/presentation/solid/animation/useNow.ts

@@ -0,0 +1,57 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseNowOptions {
+	interval?: number;
+	immediate?: boolean;
+}
+
+export interface UseNowReturn {
+	now: () => Date;
+	pause: () => void;
+	resume: () => void;
+}
+
+export function useNow(
+	options: UseNowOptions = {},
+	now2: number = Date.now(),
+): UseNowReturn {
+	const { interval = 1000, immediate = true } = options;
+
+	const [now, setNow] = createSignal(new Date(now2));
+	const [isActive, setIsActive] = createSignal(false);
+
+	let intervalId: ReturnType<typeof setInterval> | null = null;
+
+	const update = (now: number = Date.now()) => {
+		setNow(new Date(now));
+	};
+
+	const resume = () => {
+		if (isActive()) return;
+
+		setIsActive(true);
+		update();
+		intervalId = setInterval(update, interval);
+	};
+
+	const pause = () => {
+		if (intervalId) {
+			clearInterval(intervalId);
+			intervalId = null;
+		}
+
+		setIsActive(false);
+	};
+
+	if (immediate) {
+		resume();
+	}
+
+	onCleanup(pause);
+
+	return {
+		now,
+		pause,
+		resume,
+	};
+}

package/src/hooks/presentation/solid/animation/useRafFn.ts

@@ -0,0 +1,57 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseRafFnOptions {
+	immediate?: boolean;
+}
+
+export interface UseRafFnReturn {
+	isActive: () => boolean;
+	pause: () => void;
+	resume: () => void;
+}
+
+export function useRafFn(
+	fn: (timestamp: number) => void,
+	options: UseRafFnOptions = {},
+): UseRafFnReturn {
+	const { immediate = true } = options;
+
+	const [isActive, setIsActive] = createSignal(false);
+
+	let rafId: number | null = null;
+
+	const loop = (timestamp: number) => {
+		if (!isActive()) return;
+
+		fn(timestamp);
+		rafId = requestAnimationFrame(loop);
+	};
+
+	const resume = () => {
+		if (isActive()) return;
+
+		setIsActive(true);
+		rafId = requestAnimationFrame(loop);
+	};
+
+	const pause = () => {
+		if (rafId) {
+			cancelAnimationFrame(rafId);
+			rafId = null;
+		}
+
+		setIsActive(false);
+	};
+
+	if (immediate) {
+		resume();
+	}
+
+	onCleanup(pause);
+
+	return {
+		isActive,
+		pause,
+		resume,
+	};
+}

package/src/hooks/presentation/solid/animation/useTimeout.ts

@@ -0,0 +1,55 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseTimeoutOptions {
+	immediate?: boolean;
+	callback?: () => void;
+}
+
+export interface UseTimeoutReturn {
+	ready: () => boolean;
+	start: () => void;
+	stop: () => void;
+}
+
+export function useTimeout(
+	delay: number | (() => number),
+	options: UseTimeoutOptions = {},
+): UseTimeoutReturn {
+	const { immediate = false, callback } = options;
+
+	const [ready, setReady] = createSignal(false);
+
+	let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+	const start = () => {
+		if (ready()) return;
+
+		const resolvedDelay = typeof delay === "function" ? delay() : delay;
+
+		timeoutId = setTimeout(() => {
+			setReady(true);
+			callback?.();
+		}, resolvedDelay);
+	};
+
+	const stop = () => {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+
+		setReady(false);
+	};
+
+	if (immediate) {
+		start();
+	}
+
+	onCleanup(stop);
+
+	return {
+		ready,
+		start,
+		stop,
+	};
+}

package/src/hooks/presentation/solid/animation/useTimeoutFn.ts

@@ -0,0 +1,55 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseTimeoutFnOptions {
+	immediate?: boolean;
+}
+
+export interface UseTimeoutFnReturn {
+	isReady: () => boolean;
+	start: () => void;
+	stop: () => void;
+}
+
+export function useTimeoutFn(
+	fn: () => void,
+	delay: number | (() => number),
+	options: UseTimeoutFnOptions = {},
+): UseTimeoutFnReturn {
+	const { immediate = false } = options;
+
+	const [isReady, setIsReady] = createSignal(false);
+
+	let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+	const start = () => {
+		if (isReady()) return;
+
+		const resolvedDelay = typeof delay === "function" ? delay() : delay;
+
+		timeoutId = setTimeout(() => {
+			fn();
+			setIsReady(true);
+		}, resolvedDelay);
+	};
+
+	const stop = () => {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+
+		setIsReady(false);
+	};
+
+	if (immediate) {
+		start();
+	}
+
+	onCleanup(stop);
+
+	return {
+		isReady,
+		start,
+		stop,
+	};
+}

package/src/hooks/presentation/solid/animation/useTimestamp.ts

@@ -0,0 +1,61 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseTimestampOptions {
+	immediate?: boolean;
+	callback?: (timestamp: number) => void;
+}
+
+export interface UseTimestampReturn {
+	timestamp: () => number;
+	pause: () => void;
+	resume: () => void;
+}
+
+export function useTimestamp(
+	options: UseTimestampOptions = {},
+	now: number = Date.now(),
+): UseTimestampReturn {
+	const { immediate = true, callback } = options;
+
+	const [timestamp, setTimestamp] = createSignal(now);
+	const [isActive, setIsActive] = createSignal(false);
+
+	let rafId: number | null = null;
+
+	const loop = (now2: number = Date.now()) => {
+		if (!isActive()) return;
+
+		const now = now2;
+		setTimestamp(now);
+		callback?.(now);
+		rafId = requestAnimationFrame(loop);
+	};
+
+	const resume = () => {
+		if (isActive()) return;
+
+		setIsActive(true);
+		rafId = requestAnimationFrame(loop);
+	};
+
+	const pause = () => {
+		if (rafId) {
+			cancelAnimationFrame(rafId);
+			rafId = null;
+		}
+
+		setIsActive(false);
+	};
+
+	if (immediate) {
+		resume();
+	}
+
+	onCleanup(pause);
+
+	return {
+		timestamp,
+		pause,
+		resume,
+	};
+}

package/src/hooks/presentation/solid/animation/useTransition.ts

@@ -0,0 +1,87 @@
+import { createSignal, onCleanup } from "solid-js";
+
+export interface UseTransitionOptions {
+	duration?: number;
+	easing?: (t: number) => number;
+	delay?: number;
+}
+
+export interface UseTransitionReturn {
+	progress: () => number;
+	isRunning: () => boolean;
+	start: () => void;
+	stop: () => void;
+	reset: () => void;
+}
+
+export function useTransition(
+	options: UseTransitionOptions = {},
+): UseTransitionReturn {
+	const { duration = 300, easing = (t) => t, delay = 0 } = options;
+
+	const [progress, setProgress] = createSignal(0);
+	const [isRunning, setIsRunning] = createSignal(false);
+
+	let startTime: number | null = null;
+	let animationFrame: number | null = null;
+	let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+	const animate = (timestamp: number) => {
+		if (startTime === null) {
+			startTime = timestamp;
+		}
+
+		const elapsed = timestamp - startTime;
+		const easedProgress = easing(Math.min(elapsed / duration, 1));
+
+		setProgress(easedProgress);
+
+		if (elapsed < duration) {
+			animationFrame = requestAnimationFrame(animate);
+		} else {
+			setIsRunning(false);
+		}
+	};
+
+	const start = () => {
+		if (isRunning()) return;
+
+		setIsRunning(true);
+		setProgress(0);
+		startTime = null;
+
+		timeoutId = setTimeout(() => {
+			animationFrame = requestAnimationFrame(animate);
+		}, delay);
+	};
+
+	const stop = () => {
+		if (animationFrame) {
+			cancelAnimationFrame(animationFrame);
+			animationFrame = null;
+		}
+
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+
+		setIsRunning(false);
+	};
+
+	const reset = () => {
+		stop();
+		setProgress(0);
+		startTime = null;
+	};
+
+	onCleanup(stop);
+
+	return {
+		progress,
+		isRunning,
+		start,
+		stop,
+		reset,
+	};
+}

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

@@ -0,0 +1,14 @@
+// Array composables
+
+export * from "./useArrayConcat";
+export * from "./useArrayEvery";
+export * from "./useArrayFilter";
+export * from "./useArrayFind";
+export * from "./useArrayIncludes";
+export * from "./useArrayMap";
+export * from "./useArrayPop";
+export * from "./useArrayPush";
+export * from "./useArrayReduce";
+export * from "./useArrayShift";
+export * from "./useArraySome";
+export * from "./useArraySort";

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

@@ -0,0 +1,18 @@
+import { type Accessor, createMemo } from "solid-js";
+
+export function useArrayConcat<T>(
+	array: () => T[],
+	...items: (T | T[])[]
+): Accessor<T[]> {
+	return createMemo(() => {
+		const arr = [...array()];
+		items.forEach((item) => {
+			if (Array.isArray(item)) {
+				arr.push(...item);
+			} else {
+				arr.push(item);
+			}
+		});
+		return arr;
+	});
+}

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

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

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

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

package/src/hooks/presentation/solid/array/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));
+}