@coherent.js/state 1.0.0-beta.2

package/dist/index.js

@@ -0,0 +1,1696 @@
+// src/reactive-state.js
+import { globalErrorHandler, StateError } from "@coherent.js/core/src/utils/_error-handler.js";
+var Observable = class _Observable {
+  constructor(value, options = {}) {
+    this._value = value;
+    this._observers = /* @__PURE__ */ new Set();
+    this._computedDependents = /* @__PURE__ */ new Set();
+    this._options = {
+      deep: options.deep !== false,
+      immediate: options.immediate !== false,
+      ...options
+    };
+  }
+  get value() {
+    if (_Observable._currentComputed) {
+      this._computedDependents.add(_Observable._currentComputed);
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    if (this._value === newValue && !this._options.deep) {
+      return;
+    }
+    const oldValue = this._value;
+    this._value = newValue;
+    this._observers.forEach((observer) => {
+      try {
+        observer(newValue, oldValue);
+      } catch (_error) {
+        globalErrorHandler.handle(_error, {
+          type: "watcher-_error",
+          context: { newValue, oldValue }
+        });
+      }
+    });
+    this._computedDependents.forEach((computed2) => {
+      computed2._invalidate();
+    });
+  }
+  watch(callback, options = {}) {
+    if (typeof callback !== "function") {
+      throw new StateError("Watch callback must be a function");
+    }
+    const observer = (newValue, oldValue) => {
+      callback(newValue, oldValue, () => this.unwatch(observer));
+    };
+    this._observers.add(observer);
+    if (options.immediate !== false) {
+      observer(this._value, void 0);
+    }
+    return () => this.unwatch(observer);
+  }
+  unwatch(observer) {
+    this._observers.delete(observer);
+  }
+  unwatchAll() {
+    this._observers.clear();
+    this._computedDependents.clear();
+  }
+};
+var Computed = class extends Observable {
+  constructor(getter, options = {}) {
+    super(void 0, options);
+    this._getter = getter;
+    this._cached = false;
+    this._dirty = true;
+    if (typeof getter !== "function") {
+      throw new StateError("Computed getter must be a function");
+    }
+  }
+  get value() {
+    if (this._dirty || !this._cached) {
+      this._compute();
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    throw new StateError("Cannot set value on computed property");
+  }
+  _compute() {
+    const prevComputed = Observable._currentComputed;
+    Observable._currentComputed = this;
+    try {
+      const newValue = this._getter();
+      if (newValue !== this._value) {
+        const oldValue = this._value;
+        this._value = newValue;
+        this._observers.forEach((observer) => {
+          observer(newValue, oldValue);
+        });
+      }
+      this._cached = true;
+      this._dirty = false;
+    } catch (_error) {
+      globalErrorHandler.handle(_error, {
+        type: "computed-_error",
+        context: { getter: this._getter.toString() }
+      });
+    } finally {
+      Observable._currentComputed = prevComputed;
+    }
+  }
+  _invalidate() {
+    this._dirty = true;
+    this._computedDependents.forEach((computed2) => {
+      computed2._invalidate();
+    });
+  }
+};
+Observable._currentComputed = null;
+var ReactiveState = class {
+  constructor(initialState = {}, options = {}) {
+    this._state = /* @__PURE__ */ new Map();
+    this._computed = /* @__PURE__ */ new Map();
+    this._watchers = /* @__PURE__ */ new Map();
+    this._middleware = [];
+    this._history = [];
+    this._options = {
+      enableHistory: options.enableHistory !== false,
+      maxHistorySize: options.maxHistorySize || 50,
+      enableMiddleware: options.enableMiddleware !== false,
+      deep: options.deep !== false,
+      ...options
+    };
+    Object.entries(initialState).forEach(([key, value]) => {
+      this.set(key, value);
+    });
+  }
+  /**
+   * Get reactive state value
+   */
+  get(key) {
+    const observable2 = this._state.get(key);
+    return observable2 ? observable2.value : void 0;
+  }
+  /**
+   * Set reactive state value
+   */
+  set(key, value, options = {}) {
+    const config = { ...this._options, ...options };
+    if (config.enableMiddleware) {
+      const middlewareResult = this._runMiddleware("set", { key, value, oldValue: this.get(key) });
+      if (middlewareResult.cancelled) {
+        return false;
+      }
+      value = middlewareResult.value !== void 0 ? middlewareResult.value : value;
+    }
+    let observable2 = this._state.get(key);
+    if (!observable2) {
+      observable2 = new Observable(value, config);
+      this._state.set(key, observable2);
+    } else {
+      if (config.enableHistory) {
+        this._addToHistory("set", key, observable2.value, value);
+      }
+      observable2.value = value;
+    }
+    return true;
+  }
+  /**
+   * Check if state has a key
+   */
+  has(key) {
+    return this._state.has(key);
+  }
+  /**
+   * Delete state key
+   */
+  delete(key) {
+    const observable2 = this._state.get(key);
+    if (observable2) {
+      if (this._options.enableHistory) {
+        this._addToHistory("delete", key, observable2.value, void 0);
+      }
+      observable2.unwatchAll();
+      this._state.delete(key);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Clear all state
+   */
+  clear() {
+    if (this._options.enableHistory) {
+      this._addToHistory("clear", null, this.toObject(), {});
+    }
+    for (const observable2 of this._state.values()) {
+      observable2.unwatchAll();
+    }
+    this._state.clear();
+    this._computed.clear();
+    this._watchers.clear();
+  }
+  /**
+   * Create computed property
+   */
+  computed(key, getter, options = {}) {
+    if (typeof getter !== "function") {
+      throw new StateError(`Computed property '${key}' getter must be a function`);
+    }
+    const computed2 = new Computed(getter, { ...this._options, ...options });
+    this._computed.set(key, computed2);
+    return computed2;
+  }
+  /**
+   * Get computed property value
+   */
+  getComputed(key) {
+    const computed2 = this._computed.get(key);
+    return computed2 ? computed2.value : void 0;
+  }
+  /**
+   * Watch state changes
+   */
+  watch(key, callback, options = {}) {
+    if (typeof key === "function") {
+      return this._watchComputed(key, callback, options);
+    }
+    const observable2 = this._state.get(key);
+    if (!observable2) {
+      throw new StateError(`Cannot watch undefined state key: ${key}`);
+    }
+    const unwatch = observable2.watch(callback, options);
+    if (!this._watchers.has(key)) {
+      this._watchers.set(key, /* @__PURE__ */ new Set());
+    }
+    this._watchers.get(key).add(unwatch);
+    return unwatch;
+  }
+  /**
+   * Watch computed expression
+   */
+  _watchComputed(expression, callback, options = {}) {
+    const computed2 = new Computed(expression, options);
+    const unwatch = computed2.watch(callback, options);
+    return unwatch;
+  }
+  /**
+   * Batch state updates
+   */
+  batch(updates) {
+    if (typeof updates === "function") {
+      const oldEnableHistory = this._options.enableHistory;
+      this._options.enableHistory = false;
+      try {
+        const result = updates(this);
+        if (oldEnableHistory) {
+          this._addToHistory("batch", null, null, this.toObject());
+        }
+        return result;
+      } finally {
+        this._options.enableHistory = oldEnableHistory;
+      }
+    } else if (typeof updates === "object") {
+      return this.batch(() => {
+        Object.entries(updates).forEach(([key, value]) => {
+          this.set(key, value);
+        });
+      });
+    }
+  }
+  /**
+   * Subscribe to multiple state changes
+   */
+  subscribe(keys, callback, options = {}) {
+    if (!Array.isArray(keys)) {
+      keys = [keys];
+    }
+    const unwatchers = keys.map((key) => {
+      return this.watch(key, (newValue, oldValue) => {
+        callback({
+          key,
+          newValue,
+          oldValue,
+          state: this.toObject()
+        });
+      }, options);
+    });
+    return () => {
+      unwatchers.forEach((unwatch) => unwatch());
+    };
+  }
+  /**
+   * Add middleware for state changes
+   */
+  use(middleware) {
+    if (typeof middleware !== "function") {
+      throw new StateError("Middleware must be a function");
+    }
+    this._middleware.push(middleware);
+  }
+  /**
+   * Run middleware chain
+   */
+  _runMiddleware(action, context) {
+    let result = { ...context, cancelled: false };
+    for (const middleware of this._middleware) {
+      try {
+        const middlewareResult = middleware(action, result);
+        if (middlewareResult) {
+          result = { ...result, ...middlewareResult };
+          if (result.cancelled) {
+            break;
+          }
+        }
+      } catch (_error) {
+        globalErrorHandler.handle(_error, {
+          type: "middleware-_error",
+          context: { action, middleware: middleware.toString() }
+        });
+      }
+    }
+    return result;
+  }
+  /**
+   * Add action to history
+   */
+  _addToHistory(action, key, oldValue, newValue) {
+    if (!this._options.enableHistory) return;
+    this._history.unshift({
+      action,
+      key,
+      oldValue,
+      newValue,
+      timestamp: Date.now()
+    });
+    if (this._history.length > this._options.maxHistorySize) {
+      this._history = this._history.slice(0, this._options.maxHistorySize);
+    }
+  }
+  /**
+   * Get state history
+   */
+  getHistory(limit = 10) {
+    return this._history.slice(0, limit);
+  }
+  /**
+   * Undo last action
+   */
+  undo() {
+    const lastAction = this._history.shift();
+    if (!lastAction) return false;
+    const { action, key, oldValue } = lastAction;
+    const oldEnableHistory = this._options.enableHistory;
+    this._options.enableHistory = false;
+    try {
+      switch (action) {
+        case "set":
+          if (oldValue === void 0) {
+            this.delete(key);
+          } else {
+            this.set(key, oldValue);
+          }
+          break;
+        case "delete":
+          this.set(key, oldValue);
+          break;
+        case "clear":
+          this.clear();
+          Object.entries(oldValue || {}).forEach(([k, v]) => {
+            this.set(k, v);
+          });
+          break;
+      }
+      return true;
+    } finally {
+      this._options.enableHistory = oldEnableHistory;
+    }
+  }
+  /**
+   * Convert state to plain object
+   */
+  toObject() {
+    const result = {};
+    for (const [key, observable2] of this._state.entries()) {
+      result[key] = observable2.value;
+    }
+    return result;
+  }
+  /**
+   * Convert computed properties to object
+   */
+  getComputedValues() {
+    const result = {};
+    for (const [key, computed2] of this._computed.entries()) {
+      result[key] = computed2.value;
+    }
+    return result;
+  }
+  /**
+   * Get state statistics
+   */
+  getStats() {
+    return {
+      stateKeys: this._state.size,
+      computedKeys: this._computed.size,
+      watcherKeys: this._watchers.size,
+      historyLength: this._history.length,
+      middlewareCount: this._middleware.length
+    };
+  }
+  /**
+   * Cleanup and destroy
+   */
+  destroy() {
+    for (const observable2 of this._state.values()) {
+      observable2.unwatchAll();
+    }
+    for (const computed2 of this._computed.values()) {
+      computed2.unwatchAll();
+    }
+    this._state.clear();
+    this._computed.clear();
+    this._watchers.clear();
+    this._middleware.length = 0;
+    this._history.length = 0;
+  }
+};
+function createReactiveState(initialState, options = {}) {
+  return new ReactiveState(initialState, options);
+}
+function observable(value, options = {}) {
+  return new Observable(value, options);
+}
+function computed(getter, options = {}) {
+  return new Computed(getter, options);
+}
+var stateUtils = {
+  /**
+   * Create a toggle state
+   */
+  toggle(initialValue = false) {
+    const obs = observable(initialValue);
+    obs.toggle = () => {
+      obs.value = !obs.value;
+    };
+    return obs;
+  },
+  /**
+   * Create a counter state
+   */
+  counter(initialValue = 0) {
+    const obs = observable(initialValue);
+    obs.increment = (by = 1) => {
+      obs.value += by;
+    };
+    obs.decrement = (by = 1) => {
+      obs.value -= by;
+    };
+    obs.reset = () => {
+      obs.value = initialValue;
+    };
+    return obs;
+  },
+  /**
+   * Create an array state with utilities
+   */
+  array(initialArray = []) {
+    const obs = observable([...initialArray]);
+    obs.push = (...items) => {
+      obs.value = [...obs.value, ...items];
+    };
+    obs.pop = () => {
+      const newArray = [...obs.value];
+      const result = newArray.pop();
+      obs.value = newArray;
+      return result;
+    };
+    obs.filter = (predicate) => {
+      obs.value = obs.value.filter(predicate);
+    };
+    obs.clear = () => {
+      obs.value = [];
+    };
+    return obs;
+  },
+  /**
+   * Create object state with deep reactivity
+   */
+  object(initialObject = {}) {
+    const state = createReactiveState(initialObject, { deep: true });
+    return state;
+  }
+};
+
+// src/state-manager.js
+var globalState = /* @__PURE__ */ new Map();
+function createState(initialState = {}) {
+  const state = new Map(Object.entries(initialState));
+  return {
+    get(key) {
+      return state.get(key);
+    },
+    set(key, value) {
+      state.set(key, value);
+      return this;
+    },
+    has(key) {
+      return state.has(key);
+    },
+    delete(key) {
+      return state.delete(key);
+    },
+    clear() {
+      state.clear();
+      return this;
+    },
+    toObject() {
+      return Object.fromEntries(state);
+    },
+    // For debugging
+    _internal: state
+  };
+}
+var globalStateManager = {
+  set(key, value) {
+    globalState.set(key, value);
+  },
+  get(key) {
+    return globalState.get(key);
+  },
+  has(key) {
+    return globalState.has(key);
+  },
+  clear() {
+    globalState.clear();
+  },
+  // Create isolated state for each request
+  createRequestState() {
+    return createState();
+  }
+};
+var contextStacks = /* @__PURE__ */ new Map();
+function provideContext(key, value) {
+  if (!contextStacks.has(key)) {
+    contextStacks.set(key, []);
+  }
+  const stack = contextStacks.get(key);
+  const previousValue = globalState.get(key);
+  stack.push(previousValue);
+  globalState.set(key, value);
+}
+function createContextProvider(key, value, children) {
+  return (renderFunction) => {
+    try {
+      provideContext(key, value);
+      if (renderFunction && typeof renderFunction === "function") {
+        return renderFunction(children);
+      } else {
+        return children;
+      }
+    } finally {
+      restoreContext(key);
+    }
+  };
+}
+function restoreContext(key) {
+  if (!contextStacks.has(key)) return;
+  const stack = contextStacks.get(key);
+  const previousValue = stack.pop();
+  if (stack.length === 0) {
+    if (previousValue === void 0) {
+      globalState.delete(key);
+    } else {
+      globalState.set(key, previousValue);
+    }
+    contextStacks.delete(key);
+  } else {
+    globalState.set(key, previousValue);
+  }
+}
+function clearAllContexts() {
+  contextStacks.clear();
+}
+function useContext(key) {
+  return globalState.get(key);
+}
+
+// src/state-persistence.js
+var LocalStorageAdapter = class {
+  constructor() {
+    this.available = typeof localStorage !== "undefined";
+  }
+  async get(key) {
+    if (!this.available) return null;
+    try {
+      return localStorage.getItem(key);
+    } catch (error) {
+      console.error("LocalStorage get error:", error);
+      return null;
+    }
+  }
+  async set(key, value) {
+    if (!this.available) return false;
+    try {
+      localStorage.setItem(key, value);
+      return true;
+    } catch (error) {
+      console.error("LocalStorage set error:", error);
+      return false;
+    }
+  }
+  async remove(key) {
+    if (!this.available) return false;
+    try {
+      localStorage.removeItem(key);
+      return true;
+    } catch (error) {
+      console.error("LocalStorage remove error:", error);
+      return false;
+    }
+  }
+  async clear() {
+    if (!this.available) return false;
+    try {
+      localStorage.clear();
+      return true;
+    } catch (error) {
+      console.error("LocalStorage clear error:", error);
+      return false;
+    }
+  }
+};
+var SessionStorageAdapter = class {
+  constructor() {
+    this.available = typeof sessionStorage !== "undefined";
+  }
+  async get(key) {
+    if (!this.available) return null;
+    try {
+      return sessionStorage.getItem(key);
+    } catch (error) {
+      console.error("SessionStorage get error:", error);
+      return null;
+    }
+  }
+  async set(key, value) {
+    if (!this.available) return false;
+    try {
+      sessionStorage.setItem(key, value);
+      return true;
+    } catch (error) {
+      console.error("SessionStorage set error:", error);
+      return false;
+    }
+  }
+  async remove(key) {
+    if (!this.available) return false;
+    try {
+      sessionStorage.removeItem(key);
+      return true;
+    } catch (error) {
+      console.error("SessionStorage remove error:", error);
+      return false;
+    }
+  }
+  async clear() {
+    if (!this.available) return false;
+    try {
+      sessionStorage.clear();
+      return true;
+    } catch (error) {
+      console.error("SessionStorage clear error:", error);
+      return false;
+    }
+  }
+};
+var IndexedDBAdapter = class {
+  constructor(dbName = "coherent-db", storeName = "state") {
+    this.dbName = dbName;
+    this.storeName = storeName;
+    this.available = typeof indexedDB !== "undefined";
+    this.db = null;
+  }
+  async init() {
+    if (!this.available) return false;
+    if (this.db) return true;
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
+      request.onerror = () => {
+        console.error("IndexedDB open error:", request.error);
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve(true);
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
+        }
+      };
+    });
+  }
+  async get(key) {
+    if (!this.available) return null;
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.get(key);
+      request.onerror = () => {
+        console.error("IndexedDB get error:", request.error);
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        resolve(request.result || null);
+      };
+    });
+  }
+  async set(key, value) {
+    if (!this.available) return false;
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.put(value, key);
+      request.onerror = () => {
+        console.error("IndexedDB set error:", request.error);
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        resolve(true);
+      };
+    });
+  }
+  async remove(key) {
+    if (!this.available) return false;
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.delete(key);
+      request.onerror = () => {
+        console.error("IndexedDB remove error:", request.error);
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        resolve(true);
+      };
+    });
+  }
+  async clear() {
+    if (!this.available) return false;
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.clear();
+      request.onerror = () => {
+        console.error("IndexedDB clear error:", request.error);
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        resolve(true);
+      };
+    });
+  }
+};
+var MemoryAdapter = class {
+  constructor() {
+    this.storage = /* @__PURE__ */ new Map();
+    this.available = true;
+  }
+  async get(key) {
+    return this.storage.get(key) || null;
+  }
+  async set(key, value) {
+    this.storage.set(key, value);
+    return true;
+  }
+  async remove(key) {
+    return this.storage.delete(key);
+  }
+  async clear() {
+    this.storage.clear();
+    return true;
+  }
+};
+var SimpleEncryption = class {
+  constructor(key) {
+    this.key = key || "default-key";
+  }
+  encrypt(text) {
+    let result = "";
+    for (let i = 0; i < text.length; i++) {
+      result += String.fromCharCode(
+        text.charCodeAt(i) ^ this.key.charCodeAt(i % this.key.length)
+      );
+    }
+    return btoa(result);
+  }
+  decrypt(encrypted) {
+    const text = atob(encrypted);
+    let result = "";
+    for (let i = 0; i < text.length; i++) {
+      result += String.fromCharCode(
+        text.charCodeAt(i) ^ this.key.charCodeAt(i % this.key.length)
+      );
+    }
+    return result;
+  }
+};
+function createStorageAdapter(type) {
+  switch (type) {
+    case "localStorage":
+      return new LocalStorageAdapter();
+    case "sessionStorage":
+      return new SessionStorageAdapter();
+    case "indexedDB":
+      return new IndexedDBAdapter();
+    case "memory":
+      return new MemoryAdapter();
+    default:
+      return new LocalStorageAdapter();
+  }
+}
+function createPersistentState(initialState = {}, options = {}) {
+  const opts = {
+    storage: "localStorage",
+    key: "coherent-state",
+    debounce: true,
+    debounceDelay: 300,
+    serialize: JSON.stringify,
+    deserialize: JSON.parse,
+    include: null,
+    exclude: null,
+    encrypt: false,
+    encryptionKey: null,
+    onSave: null,
+    onLoad: null,
+    onError: null,
+    versioning: false,
+    version: "1.0.0",
+    migrate: null,
+    ttl: null,
+    crossTab: false,
+    ...options
+  };
+  const adapter = createStorageAdapter(opts.storage);
+  const encryption = opts.encrypt ? new SimpleEncryption(opts.encryptionKey) : null;
+  let state = { ...initialState };
+  let saveTimeout = null;
+  const listeners = /* @__PURE__ */ new Set();
+  function filterKeys(obj) {
+    if (!obj || typeof obj !== "object") return obj;
+    if (opts.include && Array.isArray(opts.include)) {
+      const filtered = {};
+      opts.include.forEach((key) => {
+        if (key in obj) {
+          filtered[key] = obj[key];
+        }
+      });
+      return filtered;
+    }
+    if (opts.exclude && Array.isArray(opts.exclude)) {
+      const filtered = { ...obj };
+      opts.exclude.forEach((key) => {
+        delete filtered[key];
+      });
+      return filtered;
+    }
+    return obj;
+  }
+  async function save(immediate = false) {
+    if (opts.debounce && !immediate) {
+      clearTimeout(saveTimeout);
+      saveTimeout = setTimeout(() => save(true), opts.debounceDelay);
+      return;
+    }
+    try {
+      const filteredState = filterKeys(state);
+      const serialized = opts.serialize(filteredState);
+      const data = {
+        state: serialized,
+        version: opts.version,
+        timestamp: Date.now(),
+        ttl: opts.ttl
+      };
+      let dataString = JSON.stringify(data);
+      if (encryption) {
+        dataString = encryption.encrypt(dataString);
+      }
+      await adapter.set(opts.key, dataString);
+      if (opts.onSave) {
+        opts.onSave(filteredState);
+      }
+      if (opts.crossTab && typeof BroadcastChannel !== "undefined") {
+        const channel = new BroadcastChannel("coherent-state-sync");
+        channel.postMessage({ type: "state-update", state: filteredState });
+        channel.close();
+      }
+    } catch (error) {
+      console.error("State save error:", error);
+      if (opts.onError) {
+        opts.onError(error);
+      }
+    }
+  }
+  async function load() {
+    try {
+      let dataString = await adapter.get(opts.key);
+      if (!dataString) return null;
+      if (encryption) {
+        dataString = encryption.decrypt(dataString);
+      }
+      const data = JSON.parse(dataString);
+      if (data.ttl && data.timestamp) {
+        const age = Date.now() - data.timestamp;
+        if (age > data.ttl) {
+          await adapter.remove(opts.key);
+          return null;
+        }
+      }
+      if (opts.versioning && data.version !== opts.version) {
+        if (opts.migrate) {
+          const migrated = opts.migrate(data.state, data.version, opts.version);
+          return opts.deserialize(migrated);
+        }
+        return null;
+      }
+      const loadedState = opts.deserialize(data.state);
+      if (opts.onLoad) {
+        opts.onLoad(loadedState);
+      }
+      return loadedState;
+    } catch (error) {
+      console.error("State load error:", error);
+      if (opts.onError) {
+        opts.onError(error);
+      }
+      return null;
+    }
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+  function notifyListeners(oldState, newState) {
+    listeners.forEach((listener) => {
+      try {
+        listener(newState, oldState);
+      } catch (error) {
+        console.error("Listener error:", error);
+      }
+    });
+  }
+  function getState(key) {
+    return key ? state[key] : { ...state };
+  }
+  function setState(updates, persist2 = true) {
+    const oldState = { ...state };
+    if (typeof updates === "function") {
+      updates = updates(oldState);
+    }
+    state = { ...state, ...updates };
+    notifyListeners(oldState, state);
+    if (persist2) {
+      save();
+    }
+  }
+  function resetState(persist2 = true) {
+    const oldState = { ...state };
+    state = { ...initialState };
+    notifyListeners(oldState, state);
+    if (persist2) {
+      save(true);
+    }
+  }
+  async function clearStorage() {
+    await adapter.remove(opts.key);
+  }
+  async function persist() {
+    await save(true);
+  }
+  async function restore() {
+    const loaded = await load();
+    if (loaded) {
+      const oldState = { ...state };
+      state = { ...state, ...loaded };
+      notifyListeners(oldState, state);
+      return true;
+    }
+    return false;
+  }
+  if (opts.crossTab && typeof BroadcastChannel !== "undefined") {
+    const channel = new BroadcastChannel("coherent-state-sync");
+    channel.onmessage = (event) => {
+      if (event.data.type === "state-update") {
+        const oldState = { ...state };
+        state = { ...state, ...event.data.state };
+        notifyListeners(oldState, state);
+      }
+    };
+  }
+  if (opts.storage !== "memory") {
+    restore();
+  }
+  return {
+    getState,
+    setState,
+    resetState,
+    subscribe,
+    persist,
+    restore,
+    clearStorage,
+    load,
+    save: () => save(true),
+    get adapter() {
+      return adapter;
+    }
+  };
+}
+function withLocalStorage(initialState = {}, key = "coherent-state", options = {}) {
+  return createPersistentState(initialState, {
+    ...options,
+    storage: "localStorage",
+    key
+  });
+}
+function withSessionStorage(initialState = {}, key = "coherent-state", options = {}) {
+  return createPersistentState(initialState, {
+    ...options,
+    storage: "sessionStorage",
+    key
+  });
+}
+function withIndexedDB(initialState = {}, key = "coherent-state", options = {}) {
+  return createPersistentState(initialState, {
+    ...options,
+    storage: "indexedDB",
+    key
+  });
+}
+
+// src/state-validation.js
+var SchemaValidator = class {
+  constructor(schema, options = {}) {
+    this.schema = schema;
+    this.options = {
+      coerce: false,
+      allowUnknown: true,
+      ...options
+    };
+  }
+  /**
+   * Validate value against schema
+   * @param {*} value - Value to validate
+   * @param {Object} schema - Schema to validate against
+   * @param {string} path - Current path in object
+   * @returns {ValidationResult} Validation result
+   */
+  validate(value, schema = this.schema, path = "") {
+    const errors = [];
+    let coercedValue = value;
+    if (schema.type) {
+      const typeResult = this.validateType(value, schema.type, path);
+      if (!typeResult.valid) {
+        errors.push(...typeResult.errors);
+        if (!this.options.coerce) {
+          return { valid: false, errors, value };
+        }
+      }
+      coercedValue = typeResult.value;
+    }
+    if (schema.enum) {
+      const enumResult = this.validateEnum(coercedValue, schema.enum, path);
+      if (!enumResult.valid) {
+        errors.push(...enumResult.errors);
+      }
+    }
+    if (schema.type === "string") {
+      const stringResult = this.validateString(coercedValue, schema, path);
+      if (!stringResult.valid) {
+        errors.push(...stringResult.errors);
+      }
+    }
+    if (schema.type === "number" || schema.type === "integer") {
+      const numberResult = this.validateNumber(coercedValue, schema, path);
+      if (!numberResult.valid) {
+        errors.push(...numberResult.errors);
+      }
+    }
+    if (schema.type === "array") {
+      const arrayResult = this.validateArray(coercedValue, schema, path);
+      if (!arrayResult.valid) {
+        errors.push(...arrayResult.errors);
+      }
+      coercedValue = arrayResult.value;
+    }
+    if (schema.type === "object") {
+      const objectResult = this.validateObject(coercedValue, schema, path);
+      if (!objectResult.valid) {
+        errors.push(...objectResult.errors);
+      }
+      coercedValue = objectResult.value;
+    }
+    if (schema.validate && typeof schema.validate === "function") {
+      const customResult = schema.validate(coercedValue);
+      if (customResult !== true) {
+        errors.push({
+          path,
+          message: typeof customResult === "string" ? customResult : "Custom validation failed",
+          type: "custom",
+          value: coercedValue
+        });
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      value: coercedValue
+    };
+  }
+  validateType(value, type, path) {
+    const actualType = Array.isArray(value) ? "array" : typeof value;
+    const errors = [];
+    let coercedValue = value;
+    const types = Array.isArray(type) ? type : [type];
+    const isValid = types.some((t) => {
+      if (t === "array") return Array.isArray(value);
+      if (t === "null") return value === null;
+      if (t === "integer") return typeof value === "number" && Number.isInteger(value);
+      return typeof value === t;
+    });
+    if (!isValid) {
+      if (this.options.coerce) {
+        const primaryType = types[0];
+        try {
+          if (primaryType === "string") {
+            coercedValue = String(value);
+          } else if (primaryType === "number") {
+            coercedValue = Number(value);
+            if (isNaN(coercedValue)) {
+              errors.push({
+                path,
+                message: `Cannot coerce "${value}" to number`,
+                type: "type",
+                value,
+                expected: primaryType
+              });
+            }
+          } else if (primaryType === "boolean") {
+            coercedValue = Boolean(value);
+          } else if (primaryType === "integer") {
+            coercedValue = parseInt(value, 10);
+            if (isNaN(coercedValue)) {
+              errors.push({
+                path,
+                message: `Cannot coerce "${value}" to integer`,
+                type: "type",
+                value,
+                expected: primaryType
+              });
+            }
+          }
+        } catch {
+          errors.push({
+            path,
+            message: `Cannot coerce value to ${primaryType}`,
+            type: "type",
+            value,
+            expected: primaryType
+          });
+        }
+      } else {
+        errors.push({
+          path,
+          message: `Expected type ${types.join(" or ")}, got ${actualType}`,
+          type: "type",
+          value,
+          expected: type
+        });
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      value: coercedValue
+    };
+  }
+  validateEnum(value, enumValues, path) {
+    const errors = [];
+    if (!enumValues.includes(value)) {
+      errors.push({
+        path,
+        message: `Value must be one of: ${enumValues.join(", ")}`,
+        type: "enum",
+        value,
+        expected: enumValues
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  validateString(value, schema, path) {
+    const errors = [];
+    if (schema.minLength !== void 0 && value.length < schema.minLength) {
+      errors.push({
+        path,
+        message: `String length must be >= ${schema.minLength}`,
+        type: "minLength",
+        value
+      });
+    }
+    if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+      errors.push({
+        path,
+        message: `String length must be <= ${schema.maxLength}`,
+        type: "maxLength",
+        value
+      });
+    }
+    if (schema.pattern) {
+      const regex = new RegExp(schema.pattern);
+      if (!regex.test(value)) {
+        errors.push({
+          path,
+          message: `String does not match pattern: ${schema.pattern}`,
+          type: "pattern",
+          value
+        });
+      }
+    }
+    if (schema.format) {
+      const formatResult = this.validateFormat(value, schema.format, path);
+      if (!formatResult.valid) {
+        errors.push(...formatResult.errors);
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  validateFormat(value, format, path) {
+    const errors = [];
+    const formats = {
+      email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+      url: /^https?:\/\/.+/,
+      uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+      date: /^\d{4}-\d{2}-\d{2}$/,
+      "date-time": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
+    };
+    if (formats[format] && !formats[format].test(value)) {
+      errors.push({
+        path,
+        message: `String does not match format: ${format}`,
+        type: "format",
+        value,
+        expected: format
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  validateNumber(value, schema, path) {
+    const errors = [];
+    if (schema.minimum !== void 0 && value < schema.minimum) {
+      errors.push({
+        path,
+        message: `Number must be >= ${schema.minimum}`,
+        type: "minimum",
+        value
+      });
+    }
+    if (schema.maximum !== void 0 && value > schema.maximum) {
+      errors.push({
+        path,
+        message: `Number must be <= ${schema.maximum}`,
+        type: "maximum",
+        value
+      });
+    }
+    if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
+      errors.push({
+        path,
+        message: `Number must be > ${schema.exclusiveMinimum}`,
+        type: "exclusiveMinimum",
+        value
+      });
+    }
+    if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
+      errors.push({
+        path,
+        message: `Number must be < ${schema.exclusiveMaximum}`,
+        type: "exclusiveMaximum",
+        value
+      });
+    }
+    if (schema.multipleOf !== void 0 && value % schema.multipleOf !== 0) {
+      errors.push({
+        path,
+        message: `Number must be multiple of ${schema.multipleOf}`,
+        type: "multipleOf",
+        value
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  validateArray(value, schema, path) {
+    const errors = [];
+    const coercedValue = [...value];
+    if (schema.minItems !== void 0 && value.length < schema.minItems) {
+      errors.push({
+        path,
+        message: `Array must have at least ${schema.minItems} items`,
+        type: "minItems",
+        value
+      });
+    }
+    if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
+      errors.push({
+        path,
+        message: `Array must have at most ${schema.maxItems} items`,
+        type: "maxItems",
+        value
+      });
+    }
+    if (schema.uniqueItems) {
+      const seen = /* @__PURE__ */ new Set();
+      const duplicates = [];
+      value.forEach((item, index) => {
+        const key = JSON.stringify(item);
+        if (seen.has(key)) {
+          duplicates.push(index);
+        }
+        seen.add(key);
+      });
+      if (duplicates.length > 0) {
+        errors.push({
+          path,
+          message: "Array items must be unique",
+          type: "uniqueItems",
+          value
+        });
+      }
+    }
+    if (schema.items) {
+      value.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        const itemResult = this.validate(item, schema.items, itemPath);
+        if (!itemResult.valid) {
+          errors.push(...itemResult.errors);
+        }
+        if (this.options.coerce) {
+          coercedValue[index] = itemResult.value;
+        }
+      });
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      value: coercedValue
+    };
+  }
+  validateObject(value, schema, path) {
+    const errors = [];
+    const coercedValue = { ...value };
+    if (schema.required) {
+      schema.required.forEach((prop) => {
+        if (!(prop in value)) {
+          errors.push({
+            path: path ? `${path}.${prop}` : prop,
+            message: `Required property "${prop}" is missing`,
+            type: "required",
+            value: void 0
+          });
+        }
+      });
+    }
+    if (schema.properties) {
+      Object.entries(schema.properties).forEach(([prop, propSchema]) => {
+        if (prop in value) {
+          const propPath = path ? `${path}.${prop}` : prop;
+          const propResult = this.validate(value[prop], propSchema, propPath);
+          if (!propResult.valid) {
+            errors.push(...propResult.errors);
+          }
+          if (this.options.coerce) {
+            coercedValue[prop] = propResult.value;
+          }
+        }
+      });
+    }
+    if (schema.additionalProperties === false && !this.options.allowUnknown) {
+      const allowedProps = new Set(Object.keys(schema.properties || {}));
+      Object.keys(value).forEach((prop) => {
+        if (!allowedProps.has(prop)) {
+          errors.push({
+            path: path ? `${path}.${prop}` : prop,
+            message: `Unknown property "${prop}"`,
+            type: "additionalProperties",
+            value: value[prop]
+          });
+        }
+      });
+    }
+    const propCount = Object.keys(value).length;
+    if (schema.minProperties !== void 0 && propCount < schema.minProperties) {
+      errors.push({
+        path,
+        message: `Object must have at least ${schema.minProperties} properties`,
+        type: "minProperties",
+        value
+      });
+    }
+    if (schema.maxProperties !== void 0 && propCount > schema.maxProperties) {
+      errors.push({
+        path,
+        message: `Object must have at most ${schema.maxProperties} properties`,
+        type: "maxProperties",
+        value
+      });
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      value: coercedValue
+    };
+  }
+};
+function createValidatedState(initialState = {}, options = {}) {
+  const opts = {
+    schema: null,
+    validators: {},
+    strict: false,
+    coerce: false,
+    onError: null,
+    validateOnSet: true,
+    validateOnGet: false,
+    required: [],
+    allowUnknown: true,
+    ...options
+  };
+  const schemaValidator = opts.schema ? new SchemaValidator(opts.schema, {
+    coerce: opts.coerce,
+    allowUnknown: opts.allowUnknown
+  }) : null;
+  let state = { ...initialState };
+  const listeners = /* @__PURE__ */ new Set();
+  const validationErrors = /* @__PURE__ */ new Map();
+  function validateState(value, key = null) {
+    const errors = [];
+    let validatedValue = value;
+    if (schemaValidator) {
+      const schema = key && opts.schema.properties ? opts.schema.properties[key] : opts.schema;
+      const result = schemaValidator.validate(value, schema, key || "");
+      if (!result.valid) {
+        errors.push(...result.errors);
+      }
+      validatedValue = result.value;
+    }
+    if (key && opts.validators[key]) {
+      const validator = opts.validators[key];
+      const result = validator(value);
+      if (result !== true) {
+        errors.push({
+          path: key,
+          message: typeof result === "string" ? result : "Validation failed",
+          type: "custom",
+          value
+        });
+      }
+    } else if (!key) {
+      Object.entries(opts.validators).forEach(([fieldKey, validator]) => {
+        if (fieldKey in value) {
+          const result = validator(value[fieldKey]);
+          if (result !== true) {
+            errors.push({
+              path: fieldKey,
+              message: typeof result === "string" ? result : "Validation failed",
+              type: "custom",
+              value: value[fieldKey]
+            });
+          }
+        }
+      });
+    }
+    if (opts.required.length > 0 && !key) {
+      opts.required.forEach((field) => {
+        if (!(field in value)) {
+          errors.push({
+            path: field,
+            message: `Required field "${field}" is missing`,
+            type: "required",
+            value: void 0
+          });
+        }
+      });
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      value: validatedValue
+    };
+  }
+  function getState(key) {
+    const value = key ? state[key] : { ...state };
+    if (opts.validateOnGet) {
+      const result = validateState(value, key);
+      if (!result.valid) {
+        validationErrors.set(key || "__root__", result.errors);
+        if (opts.onError) {
+          opts.onError(result.errors);
+        }
+      }
+    }
+    return value;
+  }
+  function setState(updates) {
+    const oldState = { ...state };
+    if (typeof updates === "function") {
+      updates = updates(oldState);
+    }
+    const newState = { ...state, ...updates };
+    if (opts.validateOnSet) {
+      const result = validateState(newState);
+      if (!result.valid) {
+        validationErrors.set("__root__", result.errors);
+        if (opts.onError) {
+          opts.onError(result.errors);
+        }
+        if (opts.strict) {
+          const error = new Error("Validation failed");
+          error.validationErrors = result.errors;
+          throw error;
+        }
+        return;
+      }
+      if (opts.coerce) {
+        const updatedKeys = Object.keys(updates);
+        const newUpdates = {};
+        updatedKeys.forEach((key) => {
+          if (result.value[key] !== state[key]) {
+            newUpdates[key] = result.value[key];
+          }
+        });
+        updates = newUpdates;
+      }
+      validationErrors.clear();
+    }
+    state = { ...state, ...updates };
+    listeners.forEach((listener) => {
+      try {
+        listener(state, oldState);
+      } catch (error) {
+        console.error("Listener error:", error);
+      }
+    });
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+  function getErrors(key = "__root__") {
+    return validationErrors.get(key) || [];
+  }
+  function isValid() {
+    const result = validateState(state);
+    if (!result.valid) {
+      validationErrors.set("__root__", result.errors);
+    }
+    return result.valid;
+  }
+  function validateField(key, value) {
+    return validateState(value, key);
+  }
+  return {
+    getState,
+    setState,
+    subscribe,
+    getErrors,
+    isValid,
+    validateField,
+    validate: () => validateState(state)
+  };
+}
+var validators = {
+  /**
+   * Email validator
+   * @param {string} value - Email to validate
+   * @returns {boolean|string} True if valid, error message otherwise
+   */
+  email: (value) => {
+    if (typeof value !== "string") return "Email must be a string";
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return "Invalid email format";
+    return true;
+  },
+  /**
+   * URL validator
+   * @param {string} value - URL to validate
+   * @returns {boolean|string} True if valid, error message otherwise
+   */
+  url: (value) => {
+    if (typeof value !== "string") return "URL must be a string";
+    try {
+      new URL(value);
+      return true;
+    } catch {
+      return "Invalid URL format";
+    }
+  },
+  /**
+   * Range validator
+   * @param {number} min - Minimum value
+   * @param {number} max - Maximum value
+   * @returns {Function} Validator function
+   */
+  range: (min, max) => (value) => {
+    if (typeof value !== "number") return "Value must be a number";
+    if (value < min || value > max) return `Value must be between ${min} and ${max}`;
+    return true;
+  },
+  /**
+   * Length validator
+   * @param {number} min - Minimum length
+   * @param {number} max - Maximum length
+   * @returns {Function} Validator function
+   */
+  length: (min, max) => (value) => {
+    if (typeof value !== "string") return "Value must be a string";
+    if (value.length < min || value.length > max) {
+      return `Length must be between ${min} and ${max}`;
+    }
+    return true;
+  },
+  /**
+   * Pattern validator
+   * @param {RegExp|string} pattern - Pattern to match
+   * @returns {Function} Validator function
+   */
+  pattern: (pattern) => (value) => {
+    if (typeof value !== "string") return "Value must be a string";
+    const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+    if (!regex.test(value)) return `Value does not match pattern: ${pattern}`;
+    return true;
+  },
+  /**
+   * Required validator
+   * @param {*} value - Value to validate
+   * @returns {boolean|string} True if valid, error message otherwise
+   */
+  required: (value) => {
+    if (value === void 0 || value === null || value === "") {
+      return "Value is required";
+    }
+    return true;
+  }
+};
+
+// src/index.js
+var index_default = {
+  // Reactive state utilities
+  createReactiveState,
+  observable,
+  computed,
+  // SSR-compatible state management
+  createState,
+  globalStateManager,
+  provideContext,
+  createContextProvider,
+  restoreContext,
+  clearAllContexts,
+  useContext,
+  // Persistence utilities
+  createPersistentState,
+  withLocalStorage,
+  withSessionStorage,
+  withIndexedDB,
+  // Validation utilities
+  createValidatedState,
+  validators,
+  // State utilities
+  stateUtils
+};
+export {
+  Observable,
+  ReactiveState,
+  clearAllContexts,
+  computed,
+  createContextProvider,
+  createPersistentState,
+  createReactiveState,
+  createState,
+  createValidatedState,
+  index_default as default,
+  globalStateManager,
+  observable,
+  provideContext,
+  restoreContext,
+  stateUtils,
+  useContext,
+  validators,
+  withIndexedDB,
+  withLocalStorage,
+  withSessionStorage
+};
+//# sourceMappingURL=index.js.map