fluxo-ui 0.0.1

package/store.cjs

@@ -0,0 +1,683 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./chunk-Do9eywBl.cjs");
+let react = require("react");
+//#region src/store/core/state.ts
+var getChangedPaths = (oldObj, newObj, prefix = "") => {
+	const paths = [];
+	const allKeys = new Set([...Object.keys(oldObj || {}), ...Object.keys(newObj || {})]);
+	for (const key of allKeys) {
+		const fullPath = prefix ? `${prefix}.${key}` : key;
+		const oldVal = oldObj?.[key];
+		const newVal = newObj?.[key];
+		if (oldVal !== newVal) {
+			paths.push(fullPath);
+			if (typeof oldVal === "object" && oldVal !== null && typeof newVal === "object" && newVal !== null) paths.push(...getChangedPaths(oldVal, newVal, fullPath));
+		}
+	}
+	return paths;
+};
+var matchesPropertyPath = (changePath, targetPath) => {
+	if (changePath === targetPath) return true;
+	if (changePath.startsWith(targetPath + ".")) return true;
+	if (targetPath.startsWith(changePath + ".")) return true;
+	return false;
+};
+function create(initializer, middlewares = []) {
+	let currentState = initializer();
+	let batchedCalls = [];
+	let isBatching = false;
+	let pendingState = null;
+	const initListeners = /* @__PURE__ */ new Set();
+	const changeListeners = /* @__PURE__ */ new Map();
+	const globalChangeListeners = /* @__PURE__ */ new Set();
+	const computedProperties = /* @__PURE__ */ new Map();
+	const setState = (stateOrUpdater, param2, param3) => {
+		let afterApply;
+		let replace = false;
+		if (typeof param2 === "function") {
+			afterApply = param2;
+			replace = param3 || false;
+		} else if (typeof param2 === "boolean") replace = param2;
+		batchedCalls.push({
+			stateOrUpdater,
+			afterApply,
+			replace
+		});
+		if (!isBatching) {
+			isBatching = true;
+			queueMicrotask(() => {
+				processBatch();
+			});
+		}
+	};
+	const processBatch = () => {
+		if (batchedCalls.length === 0) {
+			isBatching = false;
+			pendingState = null;
+			return;
+		}
+		const previousState = currentState;
+		let workingState = structuredClone(currentState);
+		const allChangedPaths = /* @__PURE__ */ new Set();
+		const afterCallbacks = [];
+		for (const call of batchedCalls) {
+			let newState;
+			if (typeof call.stateOrUpdater === "function") newState = call.stateOrUpdater(workingState);
+			else newState = call.stateOrUpdater;
+			if (call.replace) {
+				getChangedPaths(workingState, newState).forEach((path) => allChangedPaths.add(path));
+				workingState = newState;
+			} else {
+				getChangedPaths(workingState, {
+					...workingState,
+					...newState
+				}).forEach((path) => allChangedPaths.add(path));
+				Object.assign(workingState, newState);
+			}
+			if (call.afterApply) afterCallbacks.push(call.afterApply);
+		}
+		currentState = workingState;
+		batchedCalls = [];
+		isBatching = false;
+		pendingState = null;
+		markComputedStale(Array.from(allChangedPaths));
+		if (allChangedPaths.size > 0) notifyListeners("change", Array.from(allChangedPaths), previousState);
+		for (const callback of afterCallbacks) callback(currentState);
+	};
+	const triggerAsyncCompute = (propName) => {
+		const computed = computedProperties.get(propName);
+		if (!computed || !computed.isAsync) return;
+		computed.isLoading = true;
+		const promiseId = ++asyncPromiseCounter;
+		computed.activePromiseId = promiseId;
+		const result = computed.computeFn(currentState);
+		if (result instanceof Promise) result.then((value) => {
+			if (computed.activePromiseId !== promiseId) return;
+			computed.cachedValue = value;
+			computed.isStale = false;
+			computed.isLoading = false;
+			const previousState = structuredClone(currentState);
+			notifyListeners("change", [propName, `${propName}Loading`], previousState);
+		}).catch((error) => {
+			if (computed.activePromiseId !== promiseId) return;
+			computed.isLoading = false;
+			console.error(`Error computing async property '${propName}':`, error);
+			const previousState = structuredClone(currentState);
+			notifyListeners("change", [`${propName}Loading`], previousState);
+		});
+	};
+	const markComputedStale = (changedPaths) => {
+		for (const [propName, computed] of computedProperties) if (computed.dependencies.some((dep) => changedPaths.some((changed) => matchesPropertyPath(changed, dep)))) {
+			computed.isStale = true;
+			if (computed.isAsync) triggerAsyncCompute(propName);
+		}
+	};
+	const getState = (includeChanges = false) => {
+		let baseState = currentState;
+		if (includeChanges && batchedCalls.length > 0) {
+			if (!pendingState) {
+				pendingState = structuredClone(currentState);
+				for (const call of batchedCalls) {
+					let newState;
+					if (typeof call.stateOrUpdater === "function") newState = call.stateOrUpdater(pendingState);
+					else newState = call.stateOrUpdater;
+					if (call.replace) pendingState = newState;
+					else Object.assign(pendingState, newState);
+				}
+			}
+			baseState = pendingState;
+		}
+		const result = structuredClone(baseState);
+		for (const [propName, computed] of computedProperties) if (computed.isAsync) {
+			result[propName] = computed.cachedValue;
+			result[`${propName}Loading`] = computed.isLoading;
+		} else {
+			if (computed.isStale || computed.cachedValue === void 0) try {
+				computed.cachedValue = computed.computeFn(baseState);
+				computed.isStale = false;
+			} catch (error) {
+				console.error(`Error computing property '${propName}':`, error);
+				computed.cachedValue = void 0;
+			}
+			result[propName] = computed.cachedValue;
+		}
+		return result;
+	};
+	let cachedNotifyState = null;
+	const resolveNotifyState = () => {
+		if (!cachedNotifyState) cachedNotifyState = store.getState();
+		return cachedNotifyState;
+	};
+	const notifyListeners = async (event, changes, previous) => {
+		cachedNotifyState = null;
+		const context = {
+			setState,
+			previous
+		};
+		if (event === "init") for (const listener of initListeners) try {
+			await listener(resolveNotifyState(), context);
+		} catch (error) {
+			console.error("Error in init listener:", error);
+		}
+		else if (event === "change") {
+			for (const listener of globalChangeListeners) try {
+				cachedNotifyState = null;
+				await listener(resolveNotifyState(), context);
+			} catch (error) {
+				console.error("Error in change listener:", error);
+			}
+			if (changes) {
+				for (const [path, listeners] of changeListeners) if (path.split(",").map((p) => p.trim()).some((prop) => changes.some((change) => matchesPropertyPath(change, prop) || matchesPropertyPath(prop, change)))) for (const listener of listeners) try {
+					await listener(resolveNotifyState(), context);
+				} catch (error) {
+					console.error("Error in property change listener:", error);
+				}
+			}
+		}
+		cachedNotifyState = null;
+	};
+	const on = (event, ...args) => {
+		if (event === "init") {
+			const listener = args[0];
+			initListeners.add(listener);
+			return () => initListeners.delete(listener);
+		} else if (event === "change") if (args.length === 1) {
+			const listener = args[0];
+			globalChangeListeners.add(listener);
+			return () => globalChangeListeners.delete(listener);
+		} else {
+			const properties = args[0];
+			const listener = args[1];
+			if (!changeListeners.has(properties)) changeListeners.set(properties, /* @__PURE__ */ new Set());
+			changeListeners.get(properties).add(listener);
+			return () => {
+				const listeners = changeListeners.get(properties);
+				if (listeners) {
+					listeners.delete(listener);
+					if (listeners.size === 0) changeListeners.delete(properties);
+				}
+			};
+		}
+		return () => {};
+	};
+	const reset = () => {
+		const previousState = structuredClone(currentState);
+		currentState = initializer();
+		batchedCalls = [];
+		isBatching = false;
+		pendingState = null;
+		for (const [, computed] of computedProperties) {
+			computed.isStale = true;
+			computed.cachedValue = void 0;
+		}
+		const changedPaths = getChangedPaths(previousState, currentState);
+		notifyListeners("init");
+		notifyListeners("change", changedPaths, previousState);
+	};
+	let asyncPromiseCounter = 0;
+	const compute = (propName, computeFn, dependencies) => {
+		const testResult = computeFn(currentState);
+		const isAsync = testResult instanceof Promise;
+		if (isAsync) testResult.catch(() => {});
+		computedProperties.set(propName, {
+			name: propName,
+			computeFn,
+			dependencies,
+			isStale: true,
+			isAsync,
+			isLoading: false,
+			activePromiseId: 0
+		});
+		if (isAsync) triggerAsyncCompute(propName);
+	};
+	const clearComputed = (propName) => {
+		computedProperties.delete(propName);
+	};
+	const clearAllComputed = () => {
+		computedProperties.clear();
+	};
+	let store = {
+		getState,
+		setState,
+		on,
+		reset,
+		compute,
+		clearComputed,
+		clearAllComputed
+	};
+	for (const middleware of middlewares) store = middleware(store);
+	queueMicrotask(() => notifyListeners("init"));
+	return store;
+}
+//#endregion
+//#region src/store/core/model.ts
+function createModel(config) {
+	const stores = /* @__PURE__ */ new Map();
+	const loadingPromises = /* @__PURE__ */ new Map();
+	let listState = {
+		isLoading: false,
+		items: [],
+		page: 1,
+		itemsPerPage: 10,
+		totalCount: 0,
+		sortBy: []
+	};
+	let listLoading = false;
+	const getItemId = (item) => {
+		if (config.selectId) return config.selectId(item);
+		return item.id || config.nextId?.();
+	};
+	const loadFromPersist = () => {
+		if (config.loadFromPersist) return config.loadFromPersist();
+		if (config.persist === "local" || config.persist === true) try {
+			const stored = localStorage.getItem("model-store");
+			return stored ? JSON.parse(stored) : void 0;
+		} catch {
+			return;
+		}
+		if (config.persist === "session") try {
+			const stored = sessionStorage.getItem("model-store");
+			return stored ? JSON.parse(stored) : void 0;
+		} catch {
+			return;
+		}
+	};
+	const persistData = (data) => {
+		if (typeof config.persist === "function") config.persist(data);
+		else if (config.persist === "local" || config.persist === true) try {
+			localStorage.setItem("model-store", JSON.stringify(data));
+		} catch (error) {
+			console.error("Failed to persist to localStorage:", error);
+		}
+		else if (config.persist === "session") try {
+			sessionStorage.setItem("model-store", JSON.stringify(data));
+		} catch (error) {
+			console.error("Failed to persist to sessionStorage:", error);
+		}
+	};
+	const createStore = (initialState, id) => {
+		const storeId = id || getItemId(initialState) || config.nextId?.();
+		let errors = {};
+		const defaultState = config.createWithDefaults?.(storeId) || {};
+		const persistedState = loadFromPersist() || void 0;
+		const fullInitialState = {
+			...defaultState,
+			...persistedState,
+			...initialState
+		};
+		const store = create(() => fullInitialState);
+		if (config.computedProperties) for (const [propName, propConfig] of Object.entries(config.computedProperties)) store.compute(propName, propConfig.compute, propConfig.dependencies);
+		const setError = (newErrors) => {
+			if (!newErrors) errors = void 0;
+			else errors = { ...newErrors };
+		};
+		const validate = () => {
+			if (!config.validate) return true;
+			const validationResult = config.validate(store.getState());
+			if (validationResult) {
+				errors = validationResult;
+				return false;
+			}
+			errors = {};
+			return true;
+		};
+		const applyTransform = (state) => {
+			if (!config.transform) return state;
+			return {
+				...state,
+				...config.transform(state)
+			};
+		};
+		const save = async () => {
+			const modelStore = stores.get(storeId);
+			if (!modelStore || modelStore.isSaving) return;
+			modelStore._isSaving = true;
+			try {
+				let currentState = store.getState();
+				if (config.transformBehavior === "before_validate") {
+					currentState = applyTransform(currentState);
+					store.setState(currentState, true);
+				}
+				if (config.validateBehavior === "save" && !validate()) throw new Error("Validation failed: " + JSON.stringify(errors));
+				if (config.transformBehavior === "after_validate") {
+					currentState = applyTransform(currentState);
+					store.setState(currentState, true);
+				}
+				if (config.transformBehavior === "save") {
+					currentState = applyTransform(currentState);
+					store.setState(currentState, true);
+				}
+				const finalState = store.getState();
+				const changeOptions = {
+					changes: Object.keys(finalState),
+					setState: store.setState,
+					setError
+				};
+				if (getItemId(finalState) && config.onUpdate) await config.onUpdate(finalState, changeOptions);
+				else if (config.onCreate) await config.onCreate(finalState, changeOptions);
+				modelStore._isStale = false;
+				if (config.persist) persistData(finalState);
+			} finally {
+				modelStore._isSaving = false;
+			}
+		};
+		const deleteItem = async () => {
+			const modelStore = stores.get(storeId);
+			if (!modelStore || modelStore.isDeleting || !config.onDelete) throw new Error("Delete operation not supported");
+			modelStore._isDeleting = true;
+			try {
+				await config.onDelete(store.getState());
+				destroy();
+			} finally {
+				modelStore._isDeleting = false;
+			}
+		};
+		const destroy = () => {
+			stores.delete(storeId);
+		};
+		const refresh = async () => {
+			if (!config.loadItem) return;
+			const modelStore = stores.get(storeId);
+			if (!modelStore) return;
+			modelStore._isLoading = true;
+			try {
+				const freshData = await config.loadItem(storeId);
+				store.setState(freshData, true);
+				modelStore._isStale = false;
+			} finally {
+				modelStore._isLoading = false;
+			}
+		};
+		if (config.saveOnChange) {
+			let saveTimeout;
+			store.on("change", () => {
+				clearTimeout(saveTimeout);
+				saveTimeout = setTimeout(() => {
+					save().catch(console.error);
+				}, 500);
+			});
+		}
+		if (config.validateBehavior === "change") store.on("change", () => {
+			validate();
+		});
+		if (config.transformBehavior === "change") store.on("change", (state) => {
+			const transformed = applyTransform(state);
+			if (JSON.stringify(transformed) !== JSON.stringify(state)) store.setState(transformed, true);
+		});
+		const modelStore = {
+			...store,
+			id: storeId,
+			get isStale() {
+				return this._isStale !== void 0 ? this._isStale : true;
+			},
+			get isLoading() {
+				return this._isLoading || false;
+			},
+			get isSaving() {
+				return this._isSaving || false;
+			},
+			get isDeleting() {
+				return this._isDeleting || false;
+			},
+			save,
+			delete: deleteItem,
+			destroy,
+			refresh
+		};
+		modelStore._isStale = true;
+		modelStore._isLoading = false;
+		modelStore._isSaving = false;
+		modelStore._isDeleting = false;
+		return modelStore;
+	};
+	const shouldFetchFromServer = (behavior) => {
+		if (!behavior || behavior === "stale") return false;
+		if (behavior === "new") return true;
+		if (behavior === "swr") return true;
+		if (typeof behavior === "number") return true;
+		if (Array.isArray(behavior)) return true;
+		return false;
+	};
+	return {
+		create(initialState) {
+			const store = createStore(initialState);
+			stores.set(store.id, store);
+			return store;
+		},
+		get(id) {
+			let store = stores.get(id);
+			if (!store && config.loadItem) {
+				store = createStore({}, id);
+				stores.set(id, store);
+				if (shouldFetchFromServer(config.itemLoadBehavior)) {
+					if (!loadingPromises.has(id)) {
+						store._isLoading = true;
+						const timeoutMs = config.loadTimeout || 5e3;
+						const handleLoad = Promise.race([config.loadItem(id), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Load timeout")), timeoutMs))]).then((data) => {
+							if (stores.has(id)) {
+								const existingStore = stores.get(id);
+								existingStore.setState(data, true);
+								existingStore._isStale = false;
+								existingStore._isLoading = false;
+							}
+							loadingPromises.delete(id);
+							return data;
+						}).catch((error) => {
+							if (stores.has(id)) stores.get(id)._isLoading = false;
+							loadingPromises.delete(id);
+							console.error("Failed to load item:", error);
+							throw error;
+						});
+						loadingPromises.set(id, handleLoad);
+					}
+				}
+			} else if (!store) {
+				store = createStore({}, id);
+				stores.set(id, store);
+			}
+			return store;
+		},
+		list(options = {}) {
+			const { itemsPerPage = 10, page = 1, sortBy } = options;
+			if (config.loadItems) if (config.paginationHandledBy === "server" || config.sortHandledBy === "server") {
+				if (!listLoading) {
+					listLoading = true;
+					listState.isLoading = true;
+					const sortArray = typeof sortBy === "function" ? [] : Array.isArray(sortBy) ? sortBy : sortBy ? [sortBy] : [];
+					const pageOptions = {
+						page,
+						count: itemsPerPage,
+						sortBy: sortArray,
+						setTotalCount: (count) => {
+							listState.totalCount = count;
+						}
+					};
+					config.loadItems(pageOptions).then((items) => {
+						listState = {
+							...listState,
+							items,
+							page,
+							itemsPerPage,
+							sortBy: sortArray,
+							isLoading: false
+						};
+						listLoading = false;
+					}).catch((error) => {
+						listState.isLoading = false;
+						listLoading = false;
+						console.error("Failed to load items:", error);
+					});
+				}
+			} else {
+				let items = Array.from(stores.values()).map((store) => store.getState());
+				if (typeof sortBy === "function") items.sort(sortBy);
+				else if (sortBy) {
+					const sortFields = Array.isArray(sortBy) ? sortBy : [sortBy];
+					items.sort((a, b) => {
+						for (const field of sortFields) {
+							const aVal = a[field];
+							const bVal = b[field];
+							if (aVal < bVal) return -1;
+							if (aVal > bVal) return 1;
+						}
+						return 0;
+					});
+				}
+				const startIndex = (page - 1) * itemsPerPage;
+				const endIndex = startIndex + itemsPerPage;
+				listState = {
+					isLoading: false,
+					items: items.slice(startIndex, endIndex),
+					page,
+					itemsPerPage,
+					totalCount: items.length,
+					sortBy: Array.isArray(sortBy) ? sortBy : typeof sortBy === "string" ? [sortBy] : []
+				};
+			}
+			return { ...listState };
+		}
+	};
+}
+//#endregion
+//#region src/store/factory/react-hooks.ts
+var shallowEqual = (a, b) => {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) return false;
+	return true;
+};
+var strictEqual = (a, b) => Object.is(a, b);
+function useStore(store, selector, equalityFn) {
+	const [state, setState] = (0, react.useState)(() => {
+		const currentState = store.getState();
+		return selector ? selector(currentState) : currentState;
+	});
+	const selectorRef = (0, react.useRef)(selector);
+	const equalityRef = (0, react.useRef)(strictEqual);
+	const stateRef = (0, react.useRef)(state);
+	selectorRef.current = selector;
+	equalityRef.current = equalityFn === true ? shallowEqual : equalityFn || strictEqual;
+	(0, react.useEffect)(() => {
+		return store.on("change", (newState) => {
+			const newSelectedState = selectorRef.current ? selectorRef.current(newState) : newState;
+			if (!equalityRef.current(stateRef.current, newSelectedState)) {
+				stateRef.current = newSelectedState;
+				setState(newSelectedState);
+			}
+		});
+	}, [store]);
+	return state;
+}
+function createHook(store) {
+	function hook(selector, equalityFn) {
+		return useStore(store, selector, equalityFn);
+	}
+	return hook;
+}
+function useModelStore(modelStore, selector, shallowCompare) {
+	const getExtendedState = (0, react.useCallback)(() => ({
+		...modelStore.getState(),
+		id: modelStore.id,
+		isStale: modelStore.isStale,
+		isLoading: modelStore.isLoading,
+		isSaving: modelStore.isSaving,
+		isDeleting: modelStore.isDeleting
+	}), [modelStore]);
+	const [state, setState] = (0, react.useState)(() => {
+		const extendedState = getExtendedState();
+		return selector ? selector(extendedState) : extendedState;
+	});
+	const selectorRef = (0, react.useRef)(selector);
+	const equalityRef = (0, react.useRef)(shallowCompare ? shallowEqual : strictEqual);
+	const stateRef = (0, react.useRef)(state);
+	const forceUpdateRef = (0, react.useRef)(0);
+	selectorRef.current = selector;
+	(0, react.useEffect)(() => {
+		const updateState = () => {
+			const extendedState = getExtendedState();
+			const newSelectedState = selectorRef.current ? selectorRef.current(extendedState) : extendedState;
+			if (!equalityRef.current(stateRef.current, newSelectedState)) {
+				stateRef.current = newSelectedState;
+				setState(newSelectedState);
+			}
+		};
+		const unsubscribe = modelStore.on("change", updateState);
+		const interval = setInterval(() => {
+			forceUpdateRef.current += 1;
+			updateState();
+		}, 100);
+		return () => {
+			unsubscribe();
+			clearInterval(interval);
+		};
+	}, [modelStore, getExtendedState]);
+	return state;
+}
+function createItemHook(modelStore) {
+	return function(selector, shallowCompare) {
+		return useModelStore(modelStore, selector, shallowCompare);
+	};
+}
+function useListStore(factory, selector, shallowCompare) {
+	const [state, setState] = (0, react.useState)(() => {
+		const listState = factory.list();
+		return selector ? selector(listState) : listState;
+	});
+	const selectorRef = (0, react.useRef)(selector);
+	const equalityRef = (0, react.useRef)(shallowCompare ? shallowEqual : strictEqual);
+	const stateRef = (0, react.useRef)(state);
+	const forceUpdateRef = (0, react.useRef)(0);
+	selectorRef.current = selector;
+	(0, react.useEffect)(() => {
+		const updateState = () => {
+			const listState = factory.list();
+			const newSelectedState = selectorRef.current ? selectorRef.current(listState) : listState;
+			if (!equalityRef.current(stateRef.current, newSelectedState)) {
+				stateRef.current = newSelectedState;
+				setState(newSelectedState);
+			}
+		};
+		const interval = setInterval(() => {
+			forceUpdateRef.current += 1;
+			updateState();
+		}, 100);
+		updateState();
+		return () => clearInterval(interval);
+	}, [factory]);
+	return state;
+}
+function createListHook(factory) {
+	return function(selector, shallowCompare) {
+		return useListStore(factory, selector, shallowCompare);
+	};
+}
+function createModelHook(factory) {
+	return function(id, selector, shallowCompare) {
+		const store = factory.get(id);
+		if (!store) throw new Error(`Store with id ${id} not found`);
+		return useModelStore(store, selector, shallowCompare);
+	};
+}
+function useDebounce(value, delay) {
+	const [debouncedValue, setDebouncedValue] = (0, react.useState)(value);
+	(0, react.useEffect)(() => {
+		const handler = setTimeout(() => {
+			setDebouncedValue(value);
+		}, delay);
+		return () => {
+			clearTimeout(handler);
+		};
+	}, [value, delay]);
+	return debouncedValue;
+}
+//#endregion
+exports.create = create;
+exports.createHook = createHook;
+exports.createItemHook = createItemHook;
+exports.createListHook = createListHook;
+exports.createModel = createModel;
+exports.createModelHook = createModelHook;
+exports.useDebounce = useDebounce;

package/store.d.ts

@@ -0,0 +1 @@
+export {}