@oxog/state 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1292 @@
+'use strict';
+
+var react = require('react');
+
+// src/utils/deep-clone.ts
+function deepClone(value, seen) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (!seen) {
+    seen = /* @__PURE__ */ new WeakMap();
+  }
+  if (seen.has(value)) {
+    return seen.get(value);
+  }
+  seen.set(value, value);
+  if (Array.isArray(value)) {
+    const cloned = [];
+    seen.set(value, cloned);
+    value.forEach((item, index) => {
+      cloned[index] = deepClone(item, seen);
+    });
+    return cloned;
+  }
+  if (value.constructor === Object) {
+    const cloned = {};
+    seen.set(value, cloned);
+    for (const key in value) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        cloned[key] = deepClone(value[key], seen);
+      }
+    }
+    return cloned;
+  }
+  return value;
+}
+
+// src/utils/deep-equal.ts
+function deepEqual(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  if (Array.isArray(a)) {
+    const arrB = b;
+    if (a.length !== arrB.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], arrB[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  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) || !deepEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/utils/shallow-equal.ts
+function 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 (!keysB.includes(key) || !Object.is(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/utils/deep-merge.ts
+function deepMerge(target, source) {
+  if (source === null) {
+    return target;
+  }
+  if (typeof source !== "object") {
+    return source;
+  }
+  const output = deepClone(target);
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = output[key];
+      if (sourceValue instanceof Date) {
+        output[key] = new Date(sourceValue.getTime());
+        continue;
+      }
+      if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && !(sourceValue instanceof Date) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue) && !(targetValue instanceof Date)) {
+        output[key] = deepMerge(targetValue, sourceValue);
+      } else {
+        output[key] = cloneValue(sourceValue);
+      }
+    }
+  }
+  return output;
+}
+function cloneValue(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => cloneValue(v));
+  }
+  if (value.constructor === Object) {
+    const cloned = {};
+    for (const key in value) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        cloned[key] = cloneValue(value[key]);
+      }
+    }
+    return cloned;
+  }
+  return value;
+}
+
+// src/utils/is-function.ts
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// src/utils/pick.ts
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+
+// src/utils/omit.ts
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+
+// src/utils/identity.ts
+function identity(value) {
+  return value;
+}
+
+// src/kernel.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe to an event.
+   *
+   * @param event - Event name
+   * @param handler - Event handler
+   * @returns Unsubscribe function
+   */
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+    return () => {
+      this.listeners.get(event)?.delete(handler);
+    };
+  }
+  /**
+   * Emit an event to all subscribers.
+   *
+   * @param event - Event name
+   * @param data - Event data
+   */
+  emit(event, data) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`Error in ${event} handler:`, error);
+        }
+      }
+    }
+  }
+  /** Clear all listeners. */
+  destroy() {
+    this.listeners.clear();
+  }
+};
+var Kernel = class {
+  plugins = /* @__PURE__ */ new Map();
+  eventBus = new EventBus();
+  config;
+  errorHandlers = /* @__PURE__ */ new Set();
+  initializing = false;
+  constructor(config) {
+    this.config = config || {};
+  }
+  /**
+   * Register a plugin.
+   *
+   * @param plugin - The plugin to register
+   * @param options - Plugin options
+   * @param store - The store instance
+   * @throws {Error} If plugin already registered or dependencies missing
+   */
+  register(plugin, options, store) {
+    if (!plugin.name || !plugin.version || typeof plugin.install !== "function") {
+      throw new Error("Invalid plugin: must have name, version, and install function");
+    }
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin '${plugin.name}' is already registered`);
+    }
+    if (plugin.dependencies) {
+      for (const dep of plugin.dependencies) {
+        if (!this.plugins.has(dep)) {
+          throw new Error(
+            `Plugin '${plugin.name}' requires '${dep}' to be registered first`
+          );
+        }
+      }
+    }
+    const instance = {
+      plugin,
+      options
+    };
+    try {
+      plugin.install(store, options);
+    } catch (error) {
+      throw new Error(`Failed to install plugin '${plugin.name}': ${error}`);
+    }
+    this.plugins.set(plugin.name, instance);
+    if (!this.initializing && plugin.onInit) {
+      this.runOnInit(plugin, store);
+    }
+  }
+  /**
+   * Initialize all plugins.
+   *
+   * @param store - The store instance
+   */
+  async initializeAll(store) {
+    this.initializing = true;
+    const plugins = Array.from(this.plugins.values());
+    for (const { plugin } of plugins) {
+      if (plugin.onInit) {
+        await this.runOnInit(plugin, store);
+      }
+    }
+    this.initializing = false;
+  }
+  /**
+   * Run plugin's onInit safely.
+   */
+  async runOnInit(plugin, store) {
+    try {
+      await plugin.onInit(store);
+    } catch (error) {
+      console.error(`Error in ${plugin.name} onInit:`, error);
+    }
+  }
+  /**
+   * Unregister a plugin.
+   *
+   * @param name - Plugin name
+   */
+  async unregister(name) {
+    const instance = this.plugins.get(name);
+    if (!instance) {
+      return;
+    }
+    if (instance.plugin.onDestroy) {
+      try {
+        await instance.plugin.onDestroy();
+      } catch (error) {
+        console.error(`Error in ${name} onDestroy:`, error);
+      }
+    }
+    this.plugins.delete(name);
+  }
+  /**
+   * Emit a state change event.
+   *
+   * @param state - New state
+   * @param prevState - Previous state
+   */
+  emitStateChange(state, prevState) {
+    this.eventBus.emit("stateChange", { state, prevState });
+    for (const { plugin } of this.plugins.values()) {
+      if (plugin.onStateChange) {
+        try {
+          plugin.onStateChange(state, prevState);
+        } catch (error) {
+          console.error(`Error in ${plugin.name} onStateChange:`, error);
+        }
+      }
+    }
+  }
+  /**
+   * Emit an error event.
+   *
+   * @param error - The error
+   */
+  emitError(error) {
+    this.eventBus.emit("error", error);
+    for (const { plugin } of this.plugins.values()) {
+      if (plugin.onError) {
+        try {
+          plugin.onError(error);
+        } catch (err) {
+          console.error(`Error in ${plugin.name} onError:`, err);
+        }
+      }
+    }
+    for (const handler of this.errorHandlers) {
+      try {
+        handler(error);
+      } catch (err) {
+        console.error("Error in error handler:", err);
+      }
+    }
+  }
+  /**
+   * Add an error handler.
+   *
+   * @param handler - Error handler function
+   * @returns Unsubscribe function
+   */
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => {
+      this.errorHandlers.delete(handler);
+    };
+  }
+  /**
+   * Subscribe to an event.
+   *
+   * @param event - Event name
+   * @param handler - Event handler
+   * @returns Unsubscribe function
+   */
+  on(event, handler) {
+    return this.eventBus.on(event, handler);
+  }
+  /** Destroy the kernel and cleanup. */
+  async destroy() {
+    const pluginNames = Array.from(this.plugins.keys());
+    for (const name of pluginNames) {
+      await this.unregister(name);
+    }
+    this.eventBus.destroy();
+    this.errorHandlers.clear();
+  }
+};
+function createKernel(config) {
+  return new Kernel(config);
+}
+
+// src/batch-context.ts
+var batchDepth = 0;
+var batchStores = /* @__PURE__ */ new Set();
+var batchManagedStores = /* @__PURE__ */ new Set();
+function isBatching() {
+  return batchDepth > 0;
+}
+function getBatchDepth() {
+  return batchDepth;
+}
+function incrementBatchDepth() {
+  return ++batchDepth;
+}
+function decrementBatchDepth() {
+  return --batchDepth;
+}
+function getBatchManagedStores() {
+  return batchManagedStores;
+}
+function clearBatchStores() {
+  batchStores.clear();
+  batchManagedStores.clear();
+}
+function addBatchStore(store) {
+  batchStores.add(store);
+}
+function addManagedStore(store) {
+  batchManagedStores.add(store);
+}
+function isStoreManaged(store) {
+  return batchManagedStores.has(store);
+}
+var sharedBatchContext = {
+  get depth() {
+    return batchDepth;
+  },
+  get stores() {
+    return batchStores;
+  },
+  get managedStores() {
+    return batchManagedStores;
+  },
+  isBatching,
+  batch(store, fn) {
+    const wasAlreadyBatching = isStoreManaged(store);
+    incrementBatchDepth();
+    addBatchStore(store);
+    if (!wasAlreadyBatching && "beginBatch" in store) {
+      store.beginBatch();
+      addManagedStore(store);
+    }
+    try {
+      const result = fn();
+      decrementBatchDepth();
+      if (getBatchDepth() === 0) {
+        for (const s of getBatchManagedStores()) {
+          if ("flushNotifications" in s) {
+            s.flushNotifications();
+          }
+          if ("endBatch" in s) {
+            s.endBatch();
+          }
+        }
+        clearBatchStores();
+      }
+      return result;
+    } catch (error) {
+      decrementBatchDepth();
+      if (getBatchDepth() === 0) {
+        for (const s of getBatchManagedStores()) {
+          if ("endBatch" in s) {
+            s.endBatch();
+          }
+        }
+        clearBatchStores();
+      }
+      throw error;
+    }
+  }
+};
+
+// src/types.ts
+var StoreErrorCode = /* @__PURE__ */ ((StoreErrorCode2) => {
+  StoreErrorCode2["STORE_DESTROYED"] = "STORE_DESTROYED";
+  StoreErrorCode2["PLUGIN_EXISTS"] = "PLUGIN_EXISTS";
+  StoreErrorCode2["PLUGIN_DEPENDENCY_MISSING"] = "PLUGIN_DEPENDENCY_MISSING";
+  StoreErrorCode2["INVALID_STATE_UPDATE"] = "INVALID_STATE_UPDATE";
+  StoreErrorCode2["ACTION_ERROR"] = "ACTION_ERROR";
+  return StoreErrorCode2;
+})(StoreErrorCode || {});
+var StoreError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "StoreError";
+  }
+};
+
+// src/store.ts
+var StoreImpl = class {
+  state;
+  initialState;
+  listeners = /* @__PURE__ */ new Set();
+  selectorSubscriptions = /* @__PURE__ */ new Map();
+  kernel;
+  destroyed = false;
+  batchDepth = 0;
+  pendingNotify = false;
+  queuedState = null;
+  queuedPrevState = null;
+  actions = {};
+  constructor(initialState, kernel) {
+    this.state = deepClone(initialState);
+    this.initialState = deepClone(initialState);
+    this.kernel = kernel;
+    this.kernel.onError((error) => {
+      console.error("Store error:", error);
+    });
+  }
+  /** Get current state snapshot. */
+  getState() {
+    this.checkNotDestroyed();
+    return this.state;
+  }
+  /** Update state with partial object or function. */
+  setState(partial) {
+    this.checkNotDestroyed();
+    const prevState = this.state;
+    const update = typeof partial === "function" ? partial(this.state) : partial;
+    this.state = { ...this.state, ...update };
+    this.notifyOrQueue(this.state, prevState);
+  }
+  /** Deep merge state. */
+  merge(partial) {
+    this.checkNotDestroyed();
+    const prevState = this.state;
+    this.state = deepMerge(this.state, partial);
+    this.notifyOrQueue(this.state, prevState);
+  }
+  /** Reset to initial state. */
+  reset() {
+    this.checkNotDestroyed();
+    const prevState = this.state;
+    this.state = deepClone(this.initialState);
+    this.notifyOrQueue(this.state, prevState);
+  }
+  subscribe(arg1, arg2, arg3) {
+    this.checkNotDestroyed();
+    if (arg2 === void 0 && typeof arg1 === "function") {
+      const listener2 = arg1;
+      this.listeners.add(listener2);
+      return () => {
+        this.listeners.delete(listener2);
+      };
+    }
+    const selector2 = arg1;
+    const listener = arg2;
+    const equalityFn = arg3 || shallowEqual;
+    let subscription = this.selectorSubscriptions.get(selector2);
+    if (!subscription) {
+      const initialValue = selector2(this.state);
+      subscription = {
+        value: initialValue,
+        listeners: /* @__PURE__ */ new Set(),
+        selector: selector2,
+        equalityFn
+      };
+      this.selectorSubscriptions.set(selector2, subscription);
+    }
+    subscription.listeners.add(listener);
+    return () => {
+      const sub = this.selectorSubscriptions.get(selector2);
+      if (sub) {
+        sub.listeners.delete(listener);
+        if (sub.listeners.size === 0) {
+          this.selectorSubscriptions.delete(selector2);
+        }
+      }
+    };
+  }
+  /** Register a plugin. */
+  use(plugin, options) {
+    this.checkNotDestroyed();
+    this.kernel.register(plugin, options, this);
+    return this;
+  }
+  /** Destroy store and cleanup. */
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.kernel.destroy();
+    this.listeners.clear();
+    this.selectorSubscriptions.clear();
+    this.actions = {};
+  }
+  /** Add an action (for fluent builder pattern). */
+  addAction(name, fn) {
+    this.actions[name] = fn;
+    return this;
+  }
+  /** Get all actions. */
+  getActions() {
+    return this.actions;
+  }
+  /** Check if store is destroyed. */
+  checkNotDestroyed() {
+    if (this.destroyed) {
+      throw new Error("Cannot use destroyed store");
+    }
+  }
+  /** Notify listeners or queue if batching. */
+  notifyOrQueue(state, prevState) {
+    const inGlobalBatch = sharedBatchContext.isBatching();
+    if (inGlobalBatch) {
+      const managedStores = sharedBatchContext.managedStores;
+      if (!managedStores.has(this)) {
+        managedStores.add(this);
+      }
+    }
+    if (this.batchDepth > 0 || inGlobalBatch) {
+      this.queuedState = state;
+      if (!this.pendingNotify) {
+        this.queuedPrevState = prevState;
+      }
+      this.pendingNotify = true;
+    } else {
+      this.notify(state, prevState);
+    }
+  }
+  /** Notify all listeners. */
+  notify(state, prevState) {
+    this.kernel.emitStateChange(state, prevState);
+    for (const listener of this.listeners) {
+      try {
+        listener(state, prevState);
+      } catch (error) {
+        this.kernel.emitError(error);
+      }
+    }
+    for (const subscription of this.selectorSubscriptions.values()) {
+      const newValue = subscription.selector(state);
+      if (!subscription.equalityFn(newValue, subscription.value)) {
+        const prevValue = subscription.value;
+        subscription.value = newValue;
+        for (const listener of subscription.listeners) {
+          try {
+            listener(newValue, prevValue);
+          } catch (error) {
+            this.kernel.emitError(error);
+          }
+        }
+      }
+    }
+  }
+  /** Flush pending notifications (end of batch). */
+  flushNotifications() {
+    if (this.pendingNotify) {
+      this.notify(this.queuedState, this.queuedPrevState);
+      this.pendingNotify = false;
+      this.queuedState = null;
+      this.queuedPrevState = null;
+    }
+  }
+  /** Start batching. */
+  beginBatch() {
+    this.batchDepth++;
+  }
+  /** End batching. */
+  endBatch() {
+    this.batchDepth--;
+    if (this.batchDepth === 0) {
+      this.flushNotifications();
+    }
+  }
+};
+var StoreBuilderImpl = class {
+  store;
+  constructor(initialState, kernel) {
+    this.store = new StoreImpl(initialState, kernel);
+  }
+  getState() {
+    return this.store.getState();
+  }
+  setState(partial) {
+    this.store.setState(partial);
+  }
+  merge(partial) {
+    this.store.merge(partial);
+  }
+  reset() {
+    this.store.reset();
+  }
+  subscribe(arg1, arg2, arg3) {
+    if (arg2 === void 0) {
+      return this.store.subscribe(arg1);
+    } else {
+      return this.store.subscribe(arg1, arg2, arg3);
+    }
+  }
+  use(plugin, options) {
+    this.store.use(plugin, options);
+    return this;
+  }
+  destroy() {
+    this.store.destroy();
+  }
+  action(name, fn) {
+    this.store.addAction(name, fn);
+    this[name] = (...args) => {
+      const currentState = this.getState();
+      const result = fn(currentState, ...args);
+      if (result instanceof Promise) {
+        return result.then((partial) => {
+          this.setState(partial);
+          return partial;
+        });
+      }
+      this.setState(result);
+      return result;
+    };
+    return this;
+  }
+  /** Add action (internal use). */
+  addAction(name, fn) {
+    this.store.addAction(name, fn);
+    return this;
+  }
+  /** Get actions (internal use). */
+  getActions() {
+    return this.store.getActions();
+  }
+  /** Start batching. */
+  beginBatch() {
+    this.store.beginBatch();
+  }
+  /** End batching. */
+  endBatch() {
+    this.store.endBatch();
+  }
+  /** Flush pending notifications. */
+  flushNotifications() {
+    this.store.flushNotifications();
+  }
+};
+function createStore(initialState, actions) {
+  const kernel = createKernel({ name: "store" });
+  const state = { ...initialState };
+  const extractedActions = {};
+  for (const key in state) {
+    if (isFunction(state[key]) && key.startsWith("$")) {
+      extractedActions[key.substring(1)] = state[key];
+      delete state[key];
+    }
+  }
+  const allActions = { ...extractedActions, ...actions };
+  const builder = new StoreBuilderImpl(state, kernel);
+  if (allActions) {
+    for (const [name, fn] of Object.entries(allActions)) {
+      builder.addAction(name, fn);
+    }
+  }
+  const actionList = builder.getActions();
+  for (const [name, fn] of Object.entries(actionList)) {
+    builder[name] = (...args) => {
+      const currentState = builder.getState();
+      const result = fn(currentState, ...args);
+      if (result instanceof Promise) {
+        return result.then((partial) => {
+          builder.setState(partial);
+          return partial;
+        });
+      }
+      builder.setState(result);
+      return result;
+    };
+  }
+  kernel.initializeAll(builder).catch((error) => {
+    console.error("Error initializing plugins:", error);
+  });
+  return new Proxy(builder, {
+    get(target, prop) {
+      if (prop in target) {
+        return target[prop];
+      }
+      const store = target.store;
+      if (store && typeof store[prop] === "function") {
+        return store[prop].bind(store);
+      }
+      if (store && prop in store) {
+        return store[prop];
+      }
+      return void 0;
+    },
+    set(target, prop, value) {
+      if (prop in target || typeof value === "function") {
+        target[prop] = value;
+        return true;
+      }
+      const store = target.store;
+      if (store) {
+        store[prop] = value;
+        return true;
+      }
+      return false;
+    }
+  });
+}
+function batch(fn) {
+  return fn();
+}
+function useStore(store, selector2 = identity, equalityFn = shallowEqual) {
+  const selectorRef = react.useRef(selector2);
+  const equalityFnRef = react.useRef(equalityFn);
+  const storeRef = react.useRef(store);
+  if (selectorRef.current !== selector2) {
+    selectorRef.current = selector2;
+  }
+  if (equalityFnRef.current !== equalityFn) {
+    equalityFnRef.current = equalityFn;
+  }
+  if (storeRef.current !== store) {
+    storeRef.current = store;
+  }
+  const getSnapshot = () => {
+    const state = storeRef.current.getState();
+    return selectorRef.current(state);
+  };
+  const getServerSnapshot = getSnapshot;
+  const subscribe = (callback) => {
+    const unsubscribe = storeRef.current.subscribe(
+      (state) => selectorRef.current(state),
+      (value, prevValue) => {
+        if (!equalityFnRef.current(value, prevValue)) {
+          callback();
+        }
+      },
+      equalityFnRef.current
+    );
+    return unsubscribe;
+  };
+  const selectedState = react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  react.useDebugValue(selectedState);
+  return selectedState;
+}
+function useCreateStore(initialState) {
+  const storeRef = react.useRef();
+  if (storeRef.current === void 0) {
+    storeRef.current = createStore(initialState);
+  }
+  react.useEffect(() => {
+    return () => {
+      if (storeRef.current) {
+        storeRef.current.destroy();
+        storeRef.current = void 0;
+      }
+    };
+  }, []);
+  return storeRef.current;
+}
+function useAction(store, actionName) {
+  const storeRef = react.useRef(store);
+  if (storeRef.current !== store) {
+    storeRef.current = store;
+  }
+  const action = storeRef.current[actionName];
+  const actionRef = react.useRef(action);
+  if (actionRef.current !== action) {
+    actionRef.current = action;
+  }
+  return actionRef.current;
+}
+
+// src/plugins/persist.ts
+var defaultStorage = {
+  getItem: (key) => {
+    if (typeof window === "undefined") return null;
+    try {
+      return window.localStorage.getItem(key);
+    } catch {
+      return null;
+    }
+  },
+  setItem: (key, value) => {
+    if (typeof window === "undefined") return;
+    try {
+      window.localStorage.setItem(key, value);
+    } catch {
+    }
+  },
+  /* c8 ignore next 3 */
+  removeItem: () => {
+  }
+};
+var sessionStorage = {
+  getItem: (key) => {
+    if (typeof window === "undefined") return null;
+    try {
+      return window.sessionStorage.getItem(key);
+    } catch {
+      return null;
+    }
+  },
+  setItem: (key, value) => {
+    if (typeof window === "undefined") return;
+    try {
+      window.sessionStorage.setItem(key, value);
+    } catch {
+    }
+  },
+  removeItem: (key) => {
+    if (typeof window === "undefined") return;
+    try {
+      window.sessionStorage.removeItem(key);
+    } catch {
+    }
+  }
+};
+function persist(options) {
+  const { key, storage = defaultStorage, whitelist, blacklist } = options;
+  return {
+    name: "persist",
+    version: "1.0.0",
+    install(store) {
+      try {
+        const saved = storage.getItem(key);
+        if (saved) {
+          const parsed = JSON.parse(saved);
+          store.merge(parsed);
+        }
+      } catch (error) {
+        console.error(`Failed to hydrate state from '${key}':`, error);
+      }
+      store.subscribe((state) => {
+        try {
+          let toSave = state;
+          if (whitelist) {
+            toSave = pick(state, whitelist);
+          } else if (blacklist) {
+            toSave = omit(state, blacklist);
+          }
+          storage.setItem(key, JSON.stringify(toSave));
+        } catch (error) {
+          console.error(`Failed to persist state to '${key}':`, error);
+        }
+      });
+    },
+    onDestroy() {
+    }
+  };
+}
+function createStorage(storage) {
+  return storage;
+}
+
+// src/plugins/devtools.ts
+function hasDevtools() {
+  return typeof window !== "undefined" && !!window.__REDUX_DEVTOOLS_EXTENSION__;
+}
+function getDevtools() {
+  if (typeof window === "undefined") return null;
+  return window.__REDUX_DEVTOOLS_EXTENSION__ || null;
+}
+function devtools(options = {}) {
+  const { name = "OxogState Store", enabled = true, maxAge = 50 } = options;
+  let connection = null;
+  let history2 = [];
+  return {
+    name: "devtools",
+    version: "1.0.0",
+    install(store) {
+      if (!enabled || !hasDevtools()) {
+        return;
+      }
+      const extension = getDevtools();
+      if (!extension) return;
+      connection = extension.connect({ name });
+      connection.init(store.getState());
+      store.subscribe((state, prevState) => {
+        if (!connection) return;
+        history2.push({ state, action: "UPDATE" });
+        if (history2.length > maxAge) {
+          history2.shift();
+        }
+        connection.send({ type: "UPDATE", prev: prevState }, state);
+      });
+      connection.subscribe((message) => {
+        if (message.type === "DISPATCH" && message.payload) {
+          switch (message.payload.type) {
+            case "JUMP_TO_STATE":
+            case "JUMP_TO_ACTION": {
+              const index = message.payload.type === "JUMP_TO_ACTION" ? history2.findIndex((h) => h.action === message.payload.action) : message.payload.index;
+              if (index >= 0 && index < history2.length) {
+                const entry = history2[index];
+                if (entry) {
+                  store.setState(entry.state);
+                }
+              }
+              break;
+            }
+            case "COMMIT": {
+              connection.init(store.getState());
+              history2 = [];
+              break;
+            }
+            case "ROLLBACK": {
+              if (history2.length > 1) {
+                const previous = history2[history2.length - 2];
+                if (previous) {
+                  store.setState(previous.state);
+                }
+              }
+              break;
+            }
+            case "RESET": {
+              store.reset();
+              break;
+            }
+          }
+        }
+      });
+    },
+    onDestroy() {
+      connection = null;
+      history2 = [];
+    }
+  };
+}
+
+// src/plugins/history.ts
+function history(options = {}) {
+  const { limit = 50, keys } = options;
+  let historyState = null;
+  let isInternalUpdate = false;
+  return {
+    name: "history",
+    version: "1.0.0",
+    install(store) {
+      historyState = {
+        past: [],
+        present: store.getState(),
+        future: []
+      };
+      store.subscribe((state) => {
+        if (!historyState || isInternalUpdate) return;
+        const previousPresent = historyState.present;
+        const newPresent = state;
+        let hasChanged = true;
+        if (keys && keys.length > 0) {
+          hasChanged = keys.some((key) => {
+            return previousPresent[key] !== newPresent[key];
+          });
+        } else {
+          hasChanged = previousPresent !== newPresent;
+        }
+        if (!hasChanged) return;
+        historyState.past.push(previousPresent);
+        if (historyState.past.length > limit) {
+          historyState.past.shift();
+        }
+        historyState.present = newPresent;
+        historyState.future = [];
+      });
+      store.undo = () => {
+        if (!historyState || historyState.past.length === 0) return;
+        const previous = historyState.past.pop();
+        historyState.future.push(historyState.present);
+        historyState.present = previous;
+        isInternalUpdate = true;
+        store.setState(previous);
+        isInternalUpdate = false;
+      };
+      store.redo = () => {
+        if (!historyState || historyState.future.length === 0) return;
+        const next = historyState.future.pop();
+        historyState.past.push(historyState.present);
+        historyState.present = next;
+        isInternalUpdate = true;
+        store.setState(next);
+        isInternalUpdate = false;
+      };
+      store.clearHistory = () => {
+        if (!historyState) return;
+        historyState.past = [];
+        historyState.future = [];
+      };
+      store.canUndo = () => {
+        return historyState !== null && historyState.past.length > 0;
+      };
+      store.canRedo = () => {
+        return historyState !== null && historyState.future.length > 0;
+      };
+    },
+    onDestroy() {
+      historyState = null;
+    }
+  };
+}
+function hasHistory(store) {
+  return typeof store.undo === "function" && typeof store.redo === "function";
+}
+
+// src/plugins/sync.ts
+function sync(options = {}) {
+  const { channel = "oxog-state" } = options;
+  let broadcastChannel = null;
+  let currentStore = null;
+  let isLocalUpdate = false;
+  return {
+    name: "sync",
+    version: "1.0.0",
+    install(store) {
+      currentStore = store;
+      if (typeof BroadcastChannel === "undefined") {
+        console.warn("BroadcastChannel is not supported in this environment");
+        return;
+      }
+      broadcastChannel = new BroadcastChannel(channel);
+      broadcastChannel.onmessage = (event) => {
+        if (!isLocalUpdate) {
+          try {
+            store.setState(event.data);
+          } catch (error) {
+            console.error("Error applying sync state:", error);
+          }
+        }
+      };
+    },
+    onInit() {
+      if (broadcastChannel && currentStore) {
+        isLocalUpdate = true;
+        try {
+          broadcastChannel.postMessage(currentStore.getState());
+        } catch (error) {
+          console.error("Error broadcasting initial state:", error);
+        }
+        isLocalUpdate = false;
+      }
+    },
+    onDestroy() {
+      if (broadcastChannel) {
+        broadcastChannel.close();
+        broadcastChannel = null;
+      }
+      currentStore = null;
+    }
+  };
+}
+function triggerSync(store, channel = "oxog-state") {
+  if (typeof BroadcastChannel === "undefined") {
+    console.warn("BroadcastChannel is not supported in this environment");
+    return;
+  }
+  const broadcastChannel = new BroadcastChannel(channel);
+  broadcastChannel.postMessage(store.getState());
+  broadcastChannel.close();
+}
+
+// src/plugins/immer.ts
+function createProxy(base, copies) {
+  return new Proxy(base || {}, {
+    get(target, key) {
+      const value = target[key];
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        if (copies.has(value)) {
+          return createProxy(copies.get(value), copies);
+        }
+        return createProxy(value, copies);
+      }
+      return value;
+    },
+    set(target, key, value) {
+      if (!copies.has(target)) {
+        copies.set(target, { ...target });
+      }
+      const copy = copies.get(target);
+      copy[key] = value;
+      return true;
+    },
+    deleteProperty(target, key) {
+      if (!copies.has(target)) {
+        copies.set(target, { ...target });
+      }
+      const copy = copies.get(target);
+      delete copy[key];
+      return true;
+    }
+  });
+}
+function finalize(base, copies) {
+  if (!copies.has(base)) {
+    return deepClone2(base);
+  }
+  const copy = copies.get(base);
+  for (const key in copy) {
+    if (Object.prototype.hasOwnProperty.call(copy, key)) {
+      const value = copy[key];
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        copy[key] = finalize(value, copies);
+      }
+    }
+  }
+  return copy;
+}
+function deepClone2(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => deepClone2(v));
+  }
+  const cloned = {};
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      cloned[key] = deepClone2(value[key]);
+    }
+  }
+  return cloned;
+}
+function produce(base, recipe) {
+  const copies = /* @__PURE__ */ new Map();
+  const draft = createProxy(base, copies);
+  recipe(draft);
+  return finalize(base, copies);
+}
+function immer() {
+  return {
+    name: "immer",
+    version: "1.0.0",
+    install(store) {
+      const originalSetState = store.setState.bind(store);
+      store.setState = (update) => {
+        if (typeof update === "function") {
+          const newState = produce(store.getState(), update);
+          originalSetState(newState);
+        } else {
+          originalSetState(update);
+        }
+      };
+    }
+  };
+}
+
+// src/plugins/selector.ts
+function selector(options) {
+  const { selectors } = options;
+  return {
+    name: "selector",
+    version: "1.0.0",
+    install(store) {
+      const originalGetState = store.getState.bind(store);
+      const cache = /* @__PURE__ */ new Map();
+      const computedState = new Proxy({}, {
+        get(_, prop) {
+          const selectorFn = selectors[prop];
+          if (selectorFn) {
+            const currentState = originalGetState();
+            const cacheKey = prop;
+            const cached = cache.get(cacheKey);
+            if (cached && cached.state === currentState) {
+              return cached.value;
+            }
+            const value = selectorFn(currentState);
+            cache.set(cacheKey, { value, state: currentState });
+            return value;
+          }
+          return originalGetState()[prop];
+        }
+      });
+      store.getState = () => computedState;
+      store.subscribe(() => {
+        cache.clear();
+      });
+    }
+  };
+}
+
+exports.StoreError = StoreError;
+exports.StoreErrorCode = StoreErrorCode;
+exports.batch = batch;
+exports.createStorage = createStorage;
+exports.createStore = createStore;
+exports.deepClone = deepClone;
+exports.deepEqual = deepEqual;
+exports.deepMerge = deepMerge;
+exports.devtools = devtools;
+exports.hasHistory = hasHistory;
+exports.history = history;
+exports.identity = identity;
+exports.immer = immer;
+exports.isFunction = isFunction;
+exports.omit = omit;
+exports.persist = persist;
+exports.pick = pick;
+exports.produce = produce;
+exports.selector = selector;
+exports.sessionStorage = sessionStorage;
+exports.shallowEqual = shallowEqual;
+exports.sync = sync;
+exports.triggerSync = triggerSync;
+exports.useAction = useAction;
+exports.useCreateStore = useCreateStore;
+exports.useStore = useStore;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map