@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/stores/modules/store/domain/operations/actions.ts

@@ -0,0 +1,120 @@
+// Store Module - Action Operations
+// Clean Architecture: Redux-like action pattern with type safety
+
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// ACTION TYPES
+// ============================================
+
+export interface Action<T = unknown> {
+	type: string;
+	payload?: T;
+	meta?: Record<string, unknown>;
+}
+
+export type ActionCreator<T = unknown> = (payload?: T) => Action<T>;
+
+export type Reducer<T> = (state: T, action: Action) => T;
+
+// ============================================
+// CREATE ACTION
+// ============================================
+
+export const createAction = <T = unknown>(type: string): ActionCreator<T> => {
+	return (payload?: T): Action<T> => ({
+		type,
+		payload,
+	});
+};
+
+// ============================================
+// CREATE REDUCER
+// ============================================
+
+export const createReducer = <T>(
+	initialState: T,
+	handlers: Record<string, (state: T, action: Action) => T>,
+): Reducer<T> => {
+	return (state: T = initialState, action: Action): T => {
+		const handler = handlers[action.type];
+		if (handler) {
+			return handler(state, action);
+		}
+		return state;
+	};
+};
+
+// ============================================
+// DISPATCHER
+// ============================================
+
+export interface Dispatcher<T> {
+	dispatch: (action: Action) => void;
+	getState: () => T;
+	subscribe: (listener: (state: T) => void) => () => void;
+}
+
+export const createDispatcher = <T>(store: Store<T>): Dispatcher<T> => {
+	return {
+		dispatch: (action: Action): void => {
+			// Note: This is a simple dispatcher. For full Redux-like behavior,
+			// you would integrate with a reducer system
+			console.log("Dispatching action:", action.type, action.payload);
+		},
+		getState: () => store.getState(),
+		subscribe: (listener: (state: T) => void) => {
+			return store.subscribe(listener);
+		},
+	};
+};
+
+// ============================================
+// ACTION BUILDER
+// ============================================
+
+export class ActionBuilder<T = unknown> {
+	private type: string;
+	private payload?: T;
+	private meta?: Record<string, unknown>;
+
+	constructor(type: string) {
+		this.type = type;
+	}
+
+	withPayload(payload: T): ActionBuilder<T> {
+		this.payload = payload;
+		return this;
+	}
+
+	withMeta(meta: Record<string, unknown>): ActionBuilder<T> {
+		this.meta = meta;
+		return this;
+	}
+
+	build(): Action<T> {
+		return {
+			type: this.type,
+			payload: this.payload,
+			meta: this.meta,
+		};
+	}
+}
+
+export const createActionBuilder = <T = unknown>(
+	type: string,
+): ActionBuilder<T> => {
+	return new ActionBuilder<T>(type);
+};
+
+// ============================================
+// ACTION TYPE INFERENCE
+// ============================================
+
+export type ActionType<T extends ActionCreator> = ReturnType<T>;
+
+export type ActionTypeFromActionCreators<
+	T extends Record<string, ActionCreator>,
+> = {
+	[K in keyof T]: ActionType<T[K]>;
+}[keyof T];

package/src/stores/modules/store/domain/operations/composition.ts

@@ -0,0 +1,205 @@
+// Store Module - Composition Operations
+// Clean Architecture: Store composition and combination utilities
+
+import type { Store } from "#stores/modules/store/types";
+
+// ============================================
+// COMBINED STATE TYPE
+// ============================================
+
+export type CombinedState<T extends readonly Store<any>[]> = {
+	[K in keyof T]: T[K] extends Store<infer S> ? S : never;
+};
+
+// ============================================
+// REDUCERS
+// ============================================
+
+export type ReducerFunction<T, U> = (state: T, action: U) => T;
+
+export type CombinedReducers<
+	T extends Record<string, ReducerFunction<any, any>>,
+> = {
+	[K in keyof T]: T[K];
+};
+
+// ============================================
+// COMBINE REDUCERS
+// ============================================
+
+export const combineReducers = <
+	T extends Record<string, ReducerFunction<any, any>>,
+>(
+	reducers: T,
+): ReducerFunction<{ [K in keyof T]: ReturnType<T[K]> }, any> => {
+	return (state, action) => {
+		const nextState = { ...state };
+		let hasChanged = false;
+
+		for (const key in reducers) {
+			const reducer = reducers[key];
+			const previousState = state[key];
+			const nextStateForKey = reducer(previousState, action);
+
+			if (nextStateForKey !== previousState) {
+				nextState[key] = nextStateForKey;
+				hasChanged = true;
+			}
+		}
+
+		return hasChanged ? nextState : state;
+	};
+};
+
+// ============================================
+// COMBINE STORES
+// ============================================
+
+export const combineStores = <T extends readonly Store<any>[]>(
+	...stores: T
+): Store<CombinedState<T>> => {
+	const getState = (): CombinedState<T> => {
+		return stores.map((store) => store.getState()) as CombinedState<T>;
+	};
+
+	const listeners = new Set<(state: CombinedState<T>) => void>();
+
+	const subscribe = (
+		listener: (state: CombinedState<T>) => void,
+	): (() => void) => {
+		listeners.add(listener);
+
+		const unsubscribes = stores.map((store) =>
+			store.subscribe(() => {
+				listener(getState());
+			}),
+		);
+
+		return () => {
+			listeners.delete(listener);
+			for (const unsubscribe of unsubscribes) {
+				unsubscribe();
+			}
+		};
+	};
+
+	return {
+		getState,
+		setState: () => {
+			throw new Error("Combined stores are read-only");
+		},
+		subscribe,
+	};
+};
+
+// ============================================
+// SELECTOR FROM STORES
+// ============================================
+
+export const createSelectorFromCombinedStores = <
+	T extends readonly Store<any>[],
+	U,
+>(
+	stores: T,
+	selector: (states: CombinedState<T>) => U,
+): (() => U) => {
+	let lastStates: unknown[] = [];
+	let lastResult: U;
+
+	return (): U => {
+		const currentStates = stores.map((store) => store.getState());
+
+		if (
+			lastStates.length === currentStates.length &&
+			lastStates.every((state, i) => state === currentStates[i])
+		) {
+			return lastResult;
+		}
+
+		lastStates = currentStates;
+		lastResult = selector(currentStates as CombinedState<T>);
+		return lastResult;
+	};
+};
+
+// ============================================
+// STORE MAP
+// ============================================
+
+export type StoreMap<T> = {
+	[K in keyof T]: Store<T[K]>;
+};
+
+export const createStoreMap = <T extends Record<string, any>>(
+	stores: StoreMap<T>,
+): Store<T> => {
+	const keys = Object.keys(stores) as Array<keyof T>;
+
+	const getState = (): T => {
+		const result = {} as T;
+		for (const key of keys) {
+			result[key] = stores[key].getState();
+		}
+		return result;
+	};
+
+	const listeners = new Set<(state: T) => void>();
+
+	const subscribe = (listener: (state: T) => void): (() => void) => {
+		listeners.add(listener);
+
+		const unsubscribes = keys.map((key) =>
+			stores[key].subscribe(() => {
+				listener(getState());
+			}),
+		);
+
+		return () => {
+			listeners.delete(listener);
+			for (const unsubscribe of unsubscribes) {
+				unsubscribe();
+			}
+		};
+	};
+
+	return {
+		getState,
+		setState: () => {
+			throw new Error("Store map is read-only");
+		},
+		subscribe,
+	};
+};
+
+// ============================================
+// STORE SLICE
+// ============================================
+
+export const createStoreSlice = <T, K extends keyof T>(
+	store: Store<T>,
+	key: K,
+): Store<T[K]> => {
+	const getState = (): T[K] => store.getState()[key];
+
+	const subscribe = (listener: (state: T[K]) => void): (() => void) => {
+		return store.subscribe((state) => {
+			listener(state[key]);
+		});
+	};
+
+	return {
+		getState,
+		setState: (newState: T[K] | ((prev: T[K]) => T[K])) => {
+			const currentState = store.getState();
+			const updatedValue =
+				typeof newState === "function"
+					? (newState as (prev: T[K]) => T[K])(currentState[key])
+					: newState;
+			store.setState({
+				...currentState,
+				[key]: updatedValue,
+			} as Partial<T> as T);
+		},
+		subscribe,
+	};
+};

package/src/stores/modules/store/domain/operations/derived-operations.ts

@@ -0,0 +1,21 @@
+// Store Module - Domain Operations
+// Clean Architecture: Derived store and deep observation operations
+
+export const createProjection = <T, U>(
+	source: T,
+	selector: (state: T) => U,
+): U => {
+	return selector(source);
+};
+
+export const deepProxy = <T extends object>(target: T): T => {
+	return new Proxy(target, {
+		get(obj, prop) {
+			const value = Reflect.get(obj, prop);
+			if (value && typeof value === "object" && !Array.isArray(value)) {
+				return deepProxy(value);
+			}
+			return value;
+		},
+	});
+};

package/src/stores/modules/store/domain/operations/diffing.ts

@@ -0,0 +1,272 @@
+// Store Module - Diffing and Patching
+// Clean Architecture: State diffing and incremental updates
+
+// ============================================
+// DIFF TYPES
+// ============================================
+
+export interface Diff<T> {
+	path: string;
+	op: "add" | "remove" | "replace" | "move" | "copy";
+	value?: T;
+	oldValue?: T;
+	from?: string;
+}
+
+export interface Patch<T> {
+	diffs: Diff<T>[];
+	version: number;
+}
+
+// ============================================
+// DIFF FUNCTION
+// ============================================
+
+export const diff = <T extends Record<string, any>>(
+	oldState: T,
+	newState: T,
+): Diff<T>[] => {
+	const diffs: Diff<T>[] = [];
+
+	if (typeof oldState !== "object" || oldState === null) {
+		if (oldState !== newState) {
+			diffs.push({
+				path: "",
+				op: "replace",
+				value: newState,
+				oldValue: oldState,
+			});
+		}
+		return diffs;
+	}
+
+	const oldKeys = Object.keys(oldState) as Array<keyof T>;
+	const newKeys = Object.keys(newState) as Array<keyof T>;
+
+	// Check for removed keys
+	for (const key of oldKeys) {
+		if (!(key in newState)) {
+			diffs.push({
+				path: key as string,
+				op: "remove",
+				oldValue: oldState[key] as any,
+			});
+		}
+	}
+
+	// Check for added or modified keys
+	for (const key of newKeys) {
+		const oldValue = oldState[key] as any;
+		const newValue = newState[key] as any;
+
+		if (!(key in oldState)) {
+			diffs.push({
+				path: key as string,
+				op: "add",
+				value: newValue,
+			});
+		} else if (oldValue !== newValue) {
+			if (typeof newValue === "object" && newValue !== null) {
+				// Recursively diff nested objects
+				const nestedDiffs = diff(oldValue, newValue);
+				for (const nestedDiff of nestedDiffs) {
+					diffs.push({
+						...nestedDiff,
+						path: `${key as string}.${nestedDiff.path}`,
+					});
+				}
+			} else {
+				diffs.push({
+					path: key as string,
+					op: "replace",
+					value: newValue,
+					oldValue,
+				});
+			}
+		}
+	}
+
+	return diffs;
+};
+
+// ============================================
+// PATCH FUNCTION
+// ============================================
+
+export const patch = <T extends Record<string, any>>(
+	state: T,
+	patchData: Patch<T>,
+): T => {
+	const result = { ...state };
+
+	for (const diffItem of patchData.diffs) {
+		const pathParts = diffItem.path.split(".");
+		let current: any = result;
+
+		// Navigate to the parent object
+		for (let i = 0; i < pathParts.length - 1; i++) {
+			const part = pathParts[i];
+			if (!(part in current)) {
+				current[part] = {};
+			}
+			current = current[part];
+		}
+
+		const lastPart = pathParts[pathParts.length - 1];
+
+		switch (diffItem.op) {
+			case "add":
+			case "replace":
+				current[lastPart] = diffItem.value;
+				break;
+			case "remove":
+				delete current[lastPart];
+				break;
+			case "move":
+				if (diffItem.from) {
+					const fromParts = diffItem.from.split(".");
+					let fromCurrent: any = result;
+					for (const part of fromParts.slice(0, -1)) {
+						fromCurrent = fromCurrent[part];
+					}
+					const fromLastPart = fromParts[fromParts.length - 1];
+					current[lastPart] = fromCurrent[fromLastPart];
+					delete fromCurrent[fromLastPart];
+				}
+				break;
+			case "copy":
+				if (diffItem.from) {
+					const fromParts = diffItem.from.split(".");
+					let fromCurrent: any = result;
+					for (const part of fromParts.slice(0, -1)) {
+						fromCurrent = fromCurrent[part];
+					}
+					const fromLastPart = fromParts[fromParts.length - 1];
+					current[lastPart] = fromCurrent[fromLastPart];
+				}
+				break;
+		}
+	}
+
+	return result;
+};
+
+// ============================================
+// JSON PATCH SUPPORT
+// ============================================
+
+export interface JsonPatchOperation {
+	op: "add" | "remove" | "replace" | "move" | "copy" | "test";
+	path: string;
+	value?: unknown;
+	from?: string;
+}
+
+export const toJsonPatch = <T>(diffs: Diff<T>[]): JsonPatchOperation[] => {
+	return diffs.map((diff) => ({
+		op: diff.op,
+		path: `/${diff.path.replace(/\./g, "/")}`,
+		value: diff.value,
+		from: diff.from ? `/${diff.from.replace(/\./g, "/")}` : undefined,
+	}));
+};
+
+export const fromJsonPatch = <T>(
+	state: T,
+	operations: JsonPatchOperation[],
+): T => {
+	const result = JSON.parse(JSON.stringify(state));
+
+	for (const op of operations) {
+		const pathParts = op.path.split("/").filter(Boolean);
+		let current: any = result;
+
+		// Navigate to parent
+		for (let i = 0; i < pathParts.length - 1; i++) {
+			const part = pathParts[i];
+			const index = !Number.isNaN(Number(part)) ? Number(part) : part;
+			current = current[index];
+		}
+
+		const lastPart = pathParts[pathParts.length - 1];
+		const lastIndex = !Number.isNaN(Number(lastPart))
+			? Number(lastPart)
+			: lastPart;
+
+		switch (op.op) {
+			case "add":
+			case "replace":
+				current[lastIndex] = op.value;
+				break;
+			case "remove":
+				if (Array.isArray(current)) {
+					current.splice(lastIndex as number, 1);
+				} else {
+					delete current[lastIndex];
+				}
+				break;
+			case "move":
+			case "copy":
+				if (op.from) {
+					const fromParts = op.from.split("/").filter(Boolean);
+					let fromCurrent: any = result;
+					for (const part of fromParts.slice(0, -1)) {
+						const index = !Number.isNaN(Number(part)) ? Number(part) : part;
+						fromCurrent = fromCurrent[index];
+					}
+					const fromLastPart = fromParts[fromParts.length - 1];
+					const fromLastIndex = !Number.isNaN(Number(fromLastPart))
+						? Number(fromLastPart)
+						: fromLastPart;
+					current[lastIndex] = fromCurrent[fromLastIndex];
+					if (op.op === "move") {
+						if (Array.isArray(fromCurrent)) {
+							fromCurrent.splice(fromLastIndex as number, 1);
+						} else {
+							delete fromCurrent[fromLastIndex];
+						}
+					}
+				}
+				break;
+		}
+	}
+
+	return result;
+};
+
+// ============================================
+// PATCH HISTORY
+// ============================================
+
+export interface PatchHistory<T> {
+	patches: Patch<T>[];
+	currentVersion: number;
+}
+
+export const createPatchHistory = <T>(): PatchHistory<T> => {
+	return {
+		patches: [],
+		currentVersion: 0,
+	};
+};
+
+export const applyPatch = <T>(
+	history: PatchHistory<T>,
+	patchData: Patch<T>,
+): PatchHistory<T> => {
+	return {
+		patches: [...history.patches, patchData],
+		currentVersion: history.currentVersion + 1,
+	};
+};
+
+export const undoPatch = <T>(history: PatchHistory<T>): PatchHistory<T> => {
+	if (history.currentVersion === 0) return history;
+
+	const newPatches = history.patches.slice(0, -1);
+
+	return {
+		patches: newPatches,
+		currentVersion: history.currentVersion - 1,
+	};
+};