@wrikka/solid-framework 0.0.0-stage → 0.15.0

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

@@ -0,0 +1,34 @@
+/**
+ * Editor Domain Types
+ * Type definitions for editor module
+ */
+
+export type MonacoEditorOptions = {
+	container: string | HTMLElement;
+	value?: string;
+	language?: string;
+	theme?: string;
+	readOnly?: boolean;
+	minimap?: boolean;
+	lineNumbers?: boolean;
+	fontSize?: number;
+	fontFamily?: string;
+	tabSize?: number;
+	wordWrap?: boolean;
+	folding?: boolean;
+	autoIndent?: boolean;
+	highlightActiveLine?: boolean;
+	activeLineGutter?: boolean;
+};
+
+export type MonacoEventCallbacks = {
+	onChange?: (value: string) => void;
+	onFocus?: () => void;
+	onBlur?: () => void;
+	onCursorChange?: (position: { line: number; column: number }) => void;
+};
+
+export type CursorPosition = {
+	line: number;
+	column: number;
+};

package/src/hooks/modules/sensor/application/index.ts

@@ -0,0 +1,2 @@
+// Application layer exports
+export { useDeviceMotion, useDeviceOrientation, useGamepad } from "./usecases";

package/src/hooks/modules/sensor/application/usecases/index.ts

@@ -0,0 +1,25 @@
+// Use cases for sensor module
+import {
+	getGamepadButtonPressed,
+	hasMotionData,
+	hasOrientationData,
+	isGamepadConnected,
+} from "#hooks/modules/sensor/domain/operations";
+import type {
+	DeviceMotion,
+	DeviceOrientation,
+	GamepadState,
+} from "#hooks/modules/sensor/types";
+
+export const useDeviceOrientation = (orientation: DeviceOrientation) => ({
+	hasData: hasOrientationData(orientation),
+});
+
+export const useDeviceMotion = (motion: DeviceMotion) => ({
+	hasData: hasMotionData(motion),
+});
+
+export const useGamepad = (gamepad: GamepadState) => ({
+	isConnected: isGamepadConnected(gamepad),
+	isButtonPressed: (index: number) => getGamepadButtonPressed(gamepad, index),
+});

package/src/hooks/modules/sensor/domain/events/index.ts

@@ -0,0 +1,12 @@
+import type {
+	DeviceMotion,
+	DeviceOrientation,
+	GamepadState,
+} from "#hooks/modules/sensor/types";
+
+// Domain event types for sensor
+export type SensorEvent =
+	| { type: "orientationChange"; data: DeviceOrientation }
+	| { type: "motionChange"; data: DeviceMotion }
+	| { type: "gamepadConnected"; data: GamepadState }
+	| { type: "gamepadDisconnected"; index: number };

package/src/hooks/modules/sensor/domain/index.ts

@@ -0,0 +1,10 @@
+// Domain layer exports
+
+export * from "./events";
+export {
+	getGamepadButtonPressed,
+	hasMotionData,
+	hasOrientationData,
+	isGamepadConnected,
+} from "./operations";
+export * from "./validators";

package/src/hooks/modules/sensor/domain/models/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Sensor Domain Models
+ *
+ * Readonly data models for sensor domain
+ */
+
+export type * from "#hooks/modules/sensor/types";

package/src/hooks/modules/sensor/domain/operations/gamepad.ts

@@ -0,0 +1,16 @@
+/**
+ * Sensor Gamepad Operations
+ */
+
+import type { GamepadState } from "#hooks/modules/sensor/types";
+
+export const isGamepadConnected = (gamepad: GamepadState): boolean =>
+	gamepad.connected;
+
+export const getGamepadButtonPressed = (
+	gamepad: GamepadState,
+	buttonIndex: number,
+): boolean => {
+	if (buttonIndex >= gamepad.buttons.length) return false;
+	return gamepad.buttons[buttonIndex]?.pressed ?? false;
+};

package/src/hooks/modules/sensor/domain/operations/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Sensor Operations - Pure sensor operations with no side effects
+ */
+
+export type {
+	DeviceMotion,
+	DeviceOrientation,
+	GamepadState,
+} from "#hooks/modules/sensor/types";
+export { getGamepadButtonPressed, isGamepadConnected } from "./gamepad";
+export { hasMotionData } from "./motion";
+export { hasOrientationData } from "./orientation";

package/src/hooks/modules/sensor/domain/operations/motion.ts

@@ -0,0 +1,10 @@
+/**
+ * Sensor Motion Operations
+ */
+
+import type { DeviceMotion } from "#hooks/modules/sensor/types";
+
+export const hasMotionData = (motion: DeviceMotion): boolean =>
+	motion.acceleration.x !== null ||
+	motion.acceleration.y !== null ||
+	motion.acceleration.z !== null;

package/src/hooks/modules/sensor/domain/operations/orientation.ts

@@ -0,0 +1,10 @@
+/**
+ * Sensor Orientation Operations
+ */
+
+import type { DeviceOrientation } from "#hooks/modules/sensor/types";
+
+export const hasOrientationData = (orientation: DeviceOrientation): boolean =>
+	orientation.alpha !== null ||
+	orientation.beta !== null ||
+	orientation.gamma !== null;

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

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

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

@@ -0,0 +1,10 @@
+// Sensor module public API
+
+export * from "./application";
+export * from "./domain";
+export * from "./ports";
+export type {
+	DeviceMotion,
+	DeviceOrientation,
+	GamepadState,
+} from "./types";

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

@@ -0,0 +1,8 @@
+import type { GamepadState } from "../types";
+
+// Ports for sensor module
+export interface ISensorPort {
+	requestOrientationPermission(): Promise<boolean>;
+	requestMotionPermission(): Promise<boolean>;
+	getGamepad(index: number): GamepadState | null;
+}

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

@@ -0,0 +1,29 @@
+// Domain type definitions for sensor module
+
+export type DeviceOrientation = Readonly<{
+	alpha: number | null;
+	beta: number | null;
+	gamma: number | null;
+}>;
+
+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;
+	};
+}>;
+
+export type GamepadState = Readonly<{
+	axes: readonly number[];
+	buttons: readonly GamepadButton[];
+	connected: boolean;
+	id: string;
+	index: number;
+}>;

package/src/hooks/modules/storage/application/index.ts

@@ -0,0 +1,2 @@
+// Application layer exports
+export { useStorage } from "./usecases";

package/src/hooks/modules/storage/application/usecases/index.ts

@@ -0,0 +1,18 @@
+// Use cases for storage module
+import {
+	deserialize,
+	serialize,
+	validateStorageKey,
+} from "#hooks/modules/storage/domain/operations";
+import type { StorageOptions } from "#hooks/modules/storage/types";
+
+export const useStorage = <T>(key: string, options: StorageOptions<T> = {}) => {
+	if (!validateStorageKey(key)) {
+		throw new Error("Invalid storage key");
+	}
+
+	return {
+		set: (value: T): string => serialize(value, options),
+		get: (value: string): T => deserialize(value, options),
+	};
+};

package/src/hooks/modules/storage/domain/events/index.ts

@@ -0,0 +1,5 @@
+// Domain event types for storage
+export type StorageEvent<T> =
+	| { type: "set"; key: string; value: T }
+	| { type: "remove"; key: string }
+	| { type: "clear" };

package/src/hooks/modules/storage/domain/index.ts

@@ -0,0 +1,6 @@
+// Domain layer exports
+
+export * from "./events";
+export * from "./models";
+export { deserialize, serialize, validateStorageKey } from "./operations";
+export * from "./validators";

package/src/hooks/modules/storage/domain/models/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Storage Domain Models
+ * Readonly data models for storage domain
+ */
+
+export * from "./storage";

package/src/hooks/modules/storage/domain/models/storage.ts

@@ -0,0 +1,11 @@
+/**
+ * Storage Domain Model
+ * Readonly data model for storage state
+ */
+
+import type { StorageOptions as StorageOptionsType } from "#hooks/modules/storage/types";
+
+export type StorageState<T> = Readonly<{
+	value: T | null;
+	options: StorageOptionsType<T>;
+}>;

package/src/hooks/modules/storage/domain/operations/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Storage Operations - Pure storage operations with no side effects
+ */
+
+export type { StorageOptions } from "#hooks/modules/storage/types";
+
+export { deserialize, serialize } from "./serialize";
+export { validateStorageKey } from "./validate";

package/src/hooks/modules/storage/domain/operations/serialize.ts

@@ -0,0 +1,22 @@
+/**
+ * Storage Serialization Operations
+ */
+
+import type { StorageOptions } from "#hooks/modules/storage/types";
+
+export const serialize = <T>(value: T, options: StorageOptions<T>): string => {
+	if (options.serializer) {
+		return options.serializer(value);
+	}
+	return JSON.stringify(value);
+};
+
+export const deserialize = <T>(
+	value: string,
+	options: StorageOptions<T>,
+): T => {
+	if (options.deserializer) {
+		return options.deserializer(value);
+	}
+	return JSON.parse(value) as T;
+};

package/src/hooks/modules/storage/domain/operations/validate.ts

@@ -0,0 +1,7 @@
+/**
+ * Storage Validation Operations
+ */
+
+export const validateStorageKey = (key: string): boolean => {
+	return key.length > 0 && key.length < 1000;
+};

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

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

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

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

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

@@ -0,0 +1,7 @@
+// Ports for storage module
+export interface IStoragePort<T> {
+	get(key: string): T | null;
+	set(key: string, value: T): void;
+	remove(key: string): void;
+	clear(): void;
+}

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

@@ -0,0 +1,6 @@
+// Domain type definitions for storage module
+
+export type StorageOptions<T> = Readonly<{
+	deserializer?: (value: string) => T;
+	serializer?: (value: T) => string;
+}>;

package/src/hooks/modules/time/application/index.ts

@@ -0,0 +1,2 @@
+// Application layer exports
+export { useDebounce, useInterval, useThrottle, useTimeout } from "./usecases";

package/src/hooks/modules/time/application/usecases/index.ts

@@ -0,0 +1,5 @@
+// Time Module Use Cases - Public API
+export { useDebounce } from "./use-debounce";
+export { useInterval } from "./use-interval";
+export { useThrottle } from "./use-throttle";
+export { useTimeout } from "./use-timeout";

package/src/hooks/modules/time/application/usecases/use-debounce.ts

@@ -0,0 +1,10 @@
+// Debounce Use Case
+import { validateDebounceDelay } from "#hooks/modules/time/domain/operations";
+import type { DebounceFnOptions } from "#hooks/modules/time/types";
+
+export const useDebounce = (options: DebounceFnOptions) => {
+	if (!validateDebounceDelay(options.debounce)) {
+		throw new Error("Invalid debounce delay");
+	}
+	return { delay: options.debounce };
+};

package/src/hooks/modules/time/application/usecases/use-interval.ts

@@ -0,0 +1,10 @@
+// Interval Use Case
+import { validateInterval } from "#hooks/modules/time/domain/operations";
+import type { IntervalOptions } from "#hooks/modules/time/types";
+
+export const useInterval = (options: IntervalOptions) => {
+	if (!validateInterval(options.interval)) {
+		throw new Error("Invalid interval");
+	}
+	return { interval: options.interval, immediate: options.immediate ?? false };
+};

package/src/hooks/modules/time/application/usecases/use-throttle.ts

@@ -0,0 +1,10 @@
+// Throttle Use Case
+import { validateThrottleDelay } from "#hooks/modules/time/domain/operations";
+import type { ThrottleFnOptions } from "#hooks/modules/time/types";
+
+export const useThrottle = (options: ThrottleFnOptions) => {
+	if (!validateThrottleDelay(options.throttle)) {
+		throw new Error("Invalid throttle delay");
+	}
+	return { delay: options.throttle };
+};

package/src/hooks/modules/time/application/usecases/use-timeout.ts

@@ -0,0 +1,10 @@
+// Timeout Use Case
+import { validateTimeout } from "#hooks/modules/time/domain/operations";
+import type { TimeoutOptions } from "#hooks/modules/time/types";
+
+export const useTimeout = (options: TimeoutOptions) => {
+	if (!validateTimeout(options.timeout)) {
+		throw new Error("Invalid timeout");
+	}
+	return { timeout: options.timeout };
+};

package/src/hooks/modules/time/domain/events/index.ts

@@ -0,0 +1,6 @@
+// Domain event types for time
+export type TimeEvent =
+	| { type: "debounced"; timestamp: number }
+	| { type: "throttled"; timestamp: number }
+	| { type: "interval"; timestamp: number }
+	| { type: "timeout"; timestamp: number };

package/src/hooks/modules/time/domain/index.ts

@@ -0,0 +1,12 @@
+// Domain layer exports
+
+export * from "./events";
+export * from "./models";
+export {
+	calculateNextExecution,
+	validateDebounceDelay,
+	validateInterval,
+	validateThrottleDelay,
+	validateTimeout,
+} from "./operations";
+export * from "./validators";

package/src/hooks/modules/time/domain/models/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Time Domain Models
+ * Readonly data models for time domain
+ */
+
+export * from "./time";

package/src/hooks/modules/time/domain/models/time.ts

@@ -0,0 +1,16 @@
+/**
+ * Time Domain Model
+ * Readonly data models for time-related operations
+ */
+
+import type {
+	DebounceFnOptions as DebounceFnOptionsType,
+	IntervalOptions as IntervalOptionsType,
+	ThrottleFnOptions as ThrottleFnOptionsType,
+	TimeoutOptions as TimeoutOptionsType,
+} from "#hooks/modules/time/types";
+
+export type DebounceFnOptions = DebounceFnOptionsType;
+export type ThrottleFnOptions = ThrottleFnOptionsType;
+export type IntervalOptions = IntervalOptionsType;
+export type TimeoutOptions = TimeoutOptionsType;

package/src/hooks/modules/time/domain/operations/calculate.ts

@@ -0,0 +1,8 @@
+/**
+ * Time Calculation Operations
+ */
+
+export const calculateNextExecution = (
+	lastExecution: number,
+	delay: number,
+): number => lastExecution + delay;

package/src/hooks/modules/time/domain/operations/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Time Operations - Pure time operations with no side effects
+ */
+
+export { calculateNextExecution } from "./calculate";
+export {
+	validateDebounceDelay,
+	validateInterval,
+	validateThrottleDelay,
+	validateTimeout,
+} from "./validate";

package/src/hooks/modules/time/domain/operations/validate.ts

@@ -0,0 +1,11 @@
+/**
+ * Time Validation Operations
+ */
+
+export const validateDebounceDelay = (delay: number): boolean => delay >= 0;
+
+export const validateThrottleDelay = (delay: number): boolean => delay >= 0;
+
+export const validateInterval = (interval: number): boolean => interval > 0;
+
+export const validateTimeout = (timeout: number): boolean => timeout >= 0;

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

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

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

@@ -0,0 +1,5 @@
+// Time module public API
+
+export * from "./application";
+export * from "./ports";
+export * from "./types";

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

@@ -0,0 +1,9 @@
+// Ports for time module
+export interface ITimerPort {
+	setTimeout(callback: () => void, delay: number): number;
+	clearTimeout(id: number): void;
+	setInterval(callback: () => void, delay: number): number;
+	clearInterval(id: number): void;
+	requestAnimationFrame(callback: () => void): number;
+	cancelAnimationFrame(id: number): void;
+}

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

@@ -0,0 +1,18 @@
+// Domain type definitions for time module
+
+export type DebounceFnOptions = Readonly<{
+	debounce: number;
+}>;
+
+export type ThrottleFnOptions = Readonly<{
+	throttle: number;
+}>;
+
+export type IntervalOptions = Readonly<{
+	immediate?: boolean;
+	interval: number;
+}>;
+
+export type TimeoutOptions = Readonly<{
+	timeout: number;
+}>;

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

@@ -0,0 +1,2 @@
+// Application layer exports
+export { useToggle } from "./usecases";

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

@@ -0,0 +1,48 @@
+// Use cases for toggle module
+import { createSignal } from "solid-js";
+import {
+	createToggleEntity,
+	isToggleOff,
+	isToggleOn,
+	setToggleValue,
+	toggle,
+} from "#hooks/modules/toggle/domain/operations";
+import type { ToggleOptions } from "#hooks/modules/toggle/types";
+
+export const useToggle = (options: ToggleOptions = {}) => {
+	const entity = createToggleEntity(options);
+
+	return {
+		entity,
+		toggle: () => toggle(entity),
+		set: (value: boolean) => setToggleValue(entity, value),
+		isOn: () => isToggleOn(entity),
+		isOff: () => isToggleOff(entity),
+	};
+};
+
+// Reactive adapter - this is the bridge to SolidJS reactivity
+export const createReactiveToggle = (options: ToggleOptions = {}) => {
+	const [entity, setEntity] = createSignal(createToggleEntity(options));
+	const [value, setValue] = createSignal(entity().value);
+
+	const toggle = (): void => {
+		const newEntity = setToggleValue(entity(), !entity().value);
+		setEntity(() => newEntity);
+		setValue(() => newEntity.value);
+	};
+
+	const set = (newValue: boolean): void => {
+		const newEntity = setToggleValue(entity(), newValue);
+		setEntity(() => newEntity);
+		setValue(() => newEntity.value);
+	};
+
+	return {
+		value,
+		toggle,
+		set,
+		isOn: () => isToggleOn(entity()),
+		isOff: () => isToggleOff(entity()),
+	};
+};

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

@@ -0,0 +1,4 @@
+// Domain event types for toggle
+export type ToggleEvent =
+	| { type: "toggled"; previousValue: boolean; newValue: boolean }
+	| { type: "set"; value: boolean };

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

@@ -0,0 +1,11 @@
+// Domain layer exports
+
+export * from "./events";
+export {
+	createToggleEntity,
+	isToggleOff,
+	isToggleOn,
+	setToggleValue,
+	toggle,
+} from "./operations";
+export * from "./validators";

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

@@ -0,0 +1,7 @@
+/**
+ * Toggle Domain Models
+ *
+ * Readonly data models for toggle domain
+ */
+
+export type * from "#hooks/modules/toggle/types";

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

@@ -0,0 +1,11 @@
+/**
+ * Toggle Creation Operations
+ */
+
+import type { ToggleEntity, ToggleOptions } from "#hooks/modules/toggle/types";
+
+export const createToggleEntity = (
+	options: ToggleOptions = {},
+): ToggleEntity => ({
+	value: options.initialValue ?? false,
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Toggle Operations - Pure toggle operations with no side effects
+ */
+
+export type {
+	ToggleEntity,
+	ToggleOptions,
+} from "#hooks/modules/toggle/types";
+
+export { createToggleEntity } from "./create";
+export { setToggleValue, toggle } from "./modify";
+export { isToggleOff, isToggleOn } from "./query";

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

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