@coherent.js/state 1.0.0-beta.5 → 1.0.0-beta.7

package/dist/reactive-state.js

@@ -0,0 +1,512 @@
+// src/reactive-state.js
+var StateError = class extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "StateError";
+    this.type = options.type || "state";
+    this.component = options.component;
+    this.context = options.context;
+    this.timestamp = Date.now();
+  }
+};
+var globalErrorHandler = {
+  handle(error, context = {}) {
+    console.error("State Error:", error.message, context);
+  }
+};
+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;
+  }
+};
+var reactive_state_default = ReactiveState;
+export {
+  Observable,
+  ReactiveState,
+  StateError,
+  computed,
+  createReactiveState,
+  reactive_state_default as default,
+  globalErrorHandler,
+  observable,
+  stateUtils
+};
+//# sourceMappingURL=reactive-state.js.map

package/dist/reactive-state.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/reactive-state.js"],
+  "sourcesContent": ["/**\n * Reactive State Management System for Coherent.js\n * Provides computed properties, watchers, and reactive updates\n */\n\n// Simple error handling for this module\nexport class StateError extends Error {\n    constructor(message, options = {}) {\n        super(message);\n        this.name = 'StateError';\n        this.type = options.type || 'state';\n        this.component = options.component;\n        this.context = options.context;\n        this.timestamp = Date.now();\n    }\n}\n\nexport const globalErrorHandler = {\n    handle(error, context = {}) {\n        console.error('State Error:', error.message, context);\n    }\n};\n\n/**\n * Observable wrapper for tracking state changes\n */\nexport class Observable {\n    constructor(value, options = {}) {\n        this._value = value;\n        this._observers = new Set();\n        this._computedDependents = new Set();\n        this._options = {\n            deep: options.deep !== false,\n            immediate: options.immediate !== false,\n            ...options\n        };\n    }\n\n    get value() {\n        // Track dependency for computed properties\n        if (Observable._currentComputed) {\n            this._computedDependents.add(Observable._currentComputed);\n        }\n        return this._value;\n    }\n\n    set value(newValue) {\n        if (this._value === newValue && !this._options.deep) {\n            return;\n        }\n\n        const oldValue = this._value;\n        this._value = newValue;\n\n        // Notify observers\n        this._observers.forEach(observer => {\n            try {\n                observer(newValue, oldValue);\n            } catch (_error) {\n                globalErrorHandler.handle(_error, {\n                    type: 'watcher-_error',\n                    context: { newValue, oldValue }\n                });\n            }\n        });\n\n        // Update computed dependents\n        this._computedDependents.forEach(computed => {\n            computed._invalidate();\n        });\n    }\n\n    watch(callback, options = {}) {\n        if (typeof callback !== 'function') {\n            throw new StateError('Watch callback must be a function');\n        }\n\n        const observer = (newValue, oldValue) => {\n            callback(newValue, oldValue, () => this.unwatch(observer));\n        };\n\n        this._observers.add(observer);\n\n        // Call immediately if requested\n        if (options.immediate !== false) {\n            observer(this._value, undefined);\n        }\n\n        // Return unwatch function\n        return () => this.unwatch(observer);\n    }\n\n    unwatch(observer) {\n        this._observers.delete(observer);\n    }\n\n    unwatchAll() {\n        this._observers.clear();\n        this._computedDependents.clear();\n    }\n}\n\n/**\n * Computed property implementation\n */\nclass Computed extends Observable {\n    constructor(getter, options = {}) {\n        super(undefined, options);\n        this._getter = getter;\n        this._cached = false;\n        this._dirty = true;\n\n        if (typeof getter !== 'function') {\n            throw new StateError('Computed getter must be a function');\n        }\n    }\n\n    get value() {\n        if (this._dirty || !this._cached) {\n            this._compute();\n        }\n        return this._value;\n    }\n\n    set value(newValue) {\n        throw new StateError('Cannot set value on computed property');\n    }\n\n    _compute() {\n        const prevComputed = Observable._currentComputed;\n        Observable._currentComputed = this;\n\n        try {\n            const newValue = this._getter();\n\n            if (newValue !== this._value) {\n                const oldValue = this._value;\n                this._value = newValue;\n\n                // Notify observers\n                this._observers.forEach(observer => {\n                    observer(newValue, oldValue);\n                });\n            }\n\n            this._cached = true;\n            this._dirty = false;\n        } catch (_error) {\n            globalErrorHandler.handle(_error, {\n                type: 'computed-_error',\n                context: { getter: this._getter.toString() }\n            });\n        } finally {\n            Observable._currentComputed = prevComputed;\n        }\n    }\n\n    _invalidate() {\n        this._dirty = true;\n        this._computedDependents.forEach(computed => {\n            computed._invalidate();\n        });\n    }\n}\n\n// Static property for tracking current computed\nObservable._currentComputed = null;\n\n/**\n * Reactive state container with advanced features\n */\nexport class ReactiveState {\n    constructor(initialState = {}, options = {}) {\n        this._state = new Map();\n        this._computed = new Map();\n        this._watchers = new Map();\n        this._middleware = [];\n        this._history = [];\n        this._options = {\n            enableHistory: options.enableHistory !== false,\n            maxHistorySize: options.maxHistorySize || 50,\n            enableMiddleware: options.enableMiddleware !== false,\n            deep: options.deep !== false,\n            ...options\n        };\n\n        // Initialize state\n        Object.entries(initialState).forEach(([key, value]) => {\n            this.set(key, value);\n        });\n    }\n\n    /**\n     * Get reactive state value\n     */\n    get(key) {\n        const observable = this._state.get(key);\n        return observable ? observable.value : undefined;\n    }\n\n    /**\n     * Set reactive state value\n     */\n    set(key, value, options = {}) {\n        const config = { ...this._options, ...options };\n\n        // Run middleware\n        if (config.enableMiddleware) {\n            const middlewareResult = this._runMiddleware('set', { key, value, oldValue: this.get(key) });\n            if (middlewareResult.cancelled) {\n                return false;\n            }\n            value = middlewareResult.value !== undefined ? middlewareResult.value : value;\n        }\n\n        // Get or create observable\n        let observable = this._state.get(key);\n        if (!observable) {\n            observable = new Observable(value, config);\n            this._state.set(key, observable);\n        } else {\n            // Record history\n            if (config.enableHistory) {\n                this._addToHistory('set', key, observable.value, value);\n            }\n\n            observable.value = value;\n        }\n\n        return true;\n    }\n\n    /**\n     * Check if state has a key\n     */\n    has(key) {\n        return this._state.has(key);\n    }\n\n    /**\n     * Delete state key\n     */\n    delete(key) {\n        const observable = this._state.get(key);\n        if (observable) {\n            // Record history\n            if (this._options.enableHistory) {\n                this._addToHistory('delete', key, observable.value, undefined);\n            }\n\n            observable.unwatchAll();\n            this._state.delete(key);\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * Clear all state\n     */\n    clear() {\n        // Record history\n        if (this._options.enableHistory) {\n            this._addToHistory('clear', null, this.toObject(), {});\n        }\n\n        // Cleanup observables\n        for (const observable of this._state.values()) {\n            observable.unwatchAll();\n        }\n\n        this._state.clear();\n        this._computed.clear();\n        this._watchers.clear();\n    }\n\n    /**\n     * Create computed property\n     */\n    computed(key, getter, options = {}) {\n        if (typeof getter !== 'function') {\n            throw new StateError(`Computed property '${key}' getter must be a function`);\n        }\n\n        const computed = new Computed(getter, { ...this._options, ...options });\n        this._computed.set(key, computed);\n\n        return computed;\n    }\n\n    /**\n     * Get computed property value\n     */\n    getComputed(key) {\n        const computed = this._computed.get(key);\n        return computed ? computed.value : undefined;\n    }\n\n    /**\n     * Watch state changes\n     */\n    watch(key, callback, options = {}) {\n        if (typeof key === 'function') {\n            // Watch computed expression\n            return this._watchComputed(key, callback, options);\n        }\n\n        const observable = this._state.get(key);\n        if (!observable) {\n            throw new StateError(`Cannot watch undefined state key: ${key}`);\n        }\n\n        const unwatch = observable.watch(callback, options);\n\n        // Store watcher for cleanup\n        if (!this._watchers.has(key)) {\n            this._watchers.set(key, new Set());\n        }\n        this._watchers.get(key).add(unwatch);\n\n        return unwatch;\n    }\n\n    /**\n     * Watch computed expression\n     */\n    _watchComputed(expression, callback, options = {}) {\n        const computed = new Computed(expression, options);\n        const unwatch = computed.watch(callback, options);\n\n        return unwatch;\n    }\n\n    /**\n     * Batch state updates\n     */\n    batch(updates) {\n        if (typeof updates === 'function') {\n            // Batch function updates\n            const oldEnableHistory = this._options.enableHistory;\n            this._options.enableHistory = false;\n\n            try {\n                const result = updates(this);\n\n                // Record batch in history\n                if (oldEnableHistory) {\n                    this._addToHistory('batch', null, null, this.toObject());\n                }\n\n                return result;\n            } finally {\n                this._options.enableHistory = oldEnableHistory;\n            }\n        } else if (typeof updates === 'object') {\n            // Batch object updates\n            return this.batch(() => {\n                Object.entries(updates).forEach(([key, value]) => {\n                    this.set(key, value);\n                });\n            });\n        }\n    }\n\n    /**\n     * Subscribe to multiple state changes\n     */\n    subscribe(keys, callback, options = {}) {\n        if (!Array.isArray(keys)) {\n            keys = [keys];\n        }\n\n        const unwatchers = keys.map(key => {\n            return this.watch(key, (newValue, oldValue) => {\n                callback({\n                    key,\n                    newValue,\n                    oldValue,\n                    state: this.toObject()\n                });\n            }, options);\n        });\n\n        // Return unsubscribe function\n        return () => {\n            unwatchers.forEach(unwatch => unwatch());\n        };\n    }\n\n    /**\n     * Add middleware for state changes\n     */\n    use(middleware) {\n        if (typeof middleware !== 'function') {\n            throw new StateError('Middleware must be a function');\n        }\n        this._middleware.push(middleware);\n    }\n\n    /**\n     * Run middleware chain\n     */\n    _runMiddleware(action, context) {\n        let result = { ...context, cancelled: false };\n\n        for (const middleware of this._middleware) {\n            try {\n                const middlewareResult = middleware(action, result);\n                if (middlewareResult) {\n                    result = { ...result, ...middlewareResult };\n                    if (result.cancelled) {\n                        break;\n                    }\n                }\n            } catch (_error) {\n                globalErrorHandler.handle(_error, {\n                    type: 'middleware-_error',\n                    context: { action, middleware: middleware.toString() }\n                });\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * Add action to history\n     */\n    _addToHistory(action, key, oldValue, newValue) {\n        if (!this._options.enableHistory) return;\n\n        this._history.unshift({\n            action,\n            key,\n            oldValue,\n            newValue,\n            timestamp: Date.now()\n        });\n\n        // Limit history size\n        if (this._history.length > this._options.maxHistorySize) {\n            this._history = this._history.slice(0, this._options.maxHistorySize);\n        }\n    }\n\n    /**\n     * Get state history\n     */\n    getHistory(limit = 10) {\n        return this._history.slice(0, limit);\n    }\n\n    /**\n     * Undo last action\n     */\n    undo() {\n        const lastAction = this._history.shift();\n        if (!lastAction) return false;\n\n        const { action, key, oldValue } = lastAction;\n\n        // Temporarily disable history\n        const oldEnableHistory = this._options.enableHistory;\n        this._options.enableHistory = false;\n\n        try {\n            switch (action) {\n                case 'set':\n                    if (oldValue === undefined) {\n                        this.delete(key);\n                    } else {\n                        this.set(key, oldValue);\n                    }\n                    break;\n                case 'delete':\n                    this.set(key, oldValue);\n                    break;\n                case 'clear':\n                    this.clear();\n                    Object.entries(oldValue || {}).forEach(([k, v]) => {\n                        this.set(k, v);\n                    });\n                    break;\n            }\n            return true;\n        } finally {\n            this._options.enableHistory = oldEnableHistory;\n        }\n    }\n\n    /**\n     * Convert state to plain object\n     */\n    toObject() {\n        const result = {};\n        for (const [key, observable] of this._state.entries()) {\n            result[key] = observable.value;\n        }\n        return result;\n    }\n\n    /**\n     * Convert computed properties to object\n     */\n    getComputedValues() {\n        const result = {};\n        for (const [key, computed] of this._computed.entries()) {\n            result[key] = computed.value;\n        }\n        return result;\n    }\n\n    /**\n     * Get state statistics\n     */\n    getStats() {\n        return {\n            stateKeys: this._state.size,\n            computedKeys: this._computed.size,\n            watcherKeys: this._watchers.size,\n            historyLength: this._history.length,\n            middlewareCount: this._middleware.length\n        };\n    }\n\n    /**\n     * Cleanup and destroy\n     */\n    destroy() {\n        // Clear all watchers\n        for (const observable of this._state.values()) {\n            observable.unwatchAll();\n        }\n        for (const computed of this._computed.values()) {\n            computed.unwatchAll();\n        }\n\n        // Clear collections\n        this._state.clear();\n        this._computed.clear();\n        this._watchers.clear();\n        this._middleware.length = 0;\n        this._history.length = 0;\n    }\n}\n\n/**\n * Create reactive state store\n */\nexport function createReactiveState(initialState, options = {}) {\n    return new ReactiveState(initialState, options);\n}\n\n/**\n * Create observable value\n */\nexport function observable(value, options = {}) {\n    return new Observable(value, options);\n}\n\n/**\n * Create computed property\n */\nexport function computed(getter, options = {}) {\n    return new Computed(getter, options);\n}\n\n/**\n * Utility functions for common state patterns\n */\nexport const stateUtils = {\n    /**\n     * Create a toggle state\n     */\n    toggle(initialValue = false) {\n        const obs = observable(initialValue);\n        obs.toggle = () => {\n            obs.value = !obs.value;\n        };\n        return obs;\n    },\n\n    /**\n     * Create a counter state\n     */\n    counter(initialValue = 0) {\n        const obs = observable(initialValue);\n        obs.increment = (by = 1) => {\n            obs.value += by;\n        };\n        obs.decrement = (by = 1) => {\n            obs.value -= by;\n        };\n        obs.reset = () => {\n            obs.value = initialValue;\n        };\n        return obs;\n    },\n\n    /**\n     * Create an array state with utilities\n     */\n    array(initialArray = []) {\n        const obs = observable([...initialArray]);\n        obs.push = (...items) => {\n            obs.value = [...obs.value, ...items];\n        };\n        obs.pop = () => {\n            const newArray = [...obs.value];\n            const result = newArray.pop();\n            obs.value = newArray;\n            return result;\n        };\n        obs.filter = (predicate) => {\n            obs.value = obs.value.filter(predicate);\n        };\n        obs.clear = () => {\n            obs.value = [];\n        };\n        return obs;\n    },\n\n    /**\n     * Create object state with deep reactivity\n     */\n    object(initialObject = {}) {\n        const state = createReactiveState(initialObject, { deep: true });\n        return state;\n    }\n};\n\nexport default ReactiveState;\n"],
+  "mappings": "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",
+  "names": ["computed", "observable"]
+}

package/dist/state-manager.js

@@ -0,0 +1,102 @@
+// 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);
+}
+export {
+  clearAllContexts,
+  createContextProvider,
+  createState,
+  globalStateManager,
+  provideContext,
+  restoreContext,
+  useContext
+};
+//# sourceMappingURL=state-manager.js.map

package/dist/state-manager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/state-manager.js"],
+  "sourcesContent": ["/**\n * Simple state management for server-side rendering\n * This is mainly for component state during rendering\n */\n\nconst globalState = new Map();\n\n/**\n * Creates a state container for a request/render cycle\n * @param {Object} initialState - Initial state object\n * @returns {Object} State container\n */\nexport function createState(initialState = {}) {\n    const state = new Map(Object.entries(initialState));\n\n    return {\n        get(key) {\n            return state.get(key);\n        },\n\n        set(key, value) {\n            state.set(key, value);\n            return this;\n        },\n\n        has(key) {\n            return state.has(key);\n        },\n\n        delete(key) {\n            return state.delete(key);\n        },\n\n        clear() {\n            state.clear();\n            return this;\n        },\n\n        toObject() {\n            return Object.fromEntries(state);\n        },\n\n        // For debugging\n        _internal: state\n    };\n}\n\n/**\n * Global state for sharing data across components during SSR\n */\nexport const globalStateManager = {\n    set(key, value) {\n        globalState.set(key, value);\n    },\n\n    get(key) {\n        return globalState.get(key);\n    },\n\n    has(key) {\n        return globalState.has(key);\n    },\n\n    clear() {\n        globalState.clear();\n    },\n\n    // Create isolated state for each request\n    createRequestState() {\n        return createState();\n    }\n};\n\n/**\n * Context stack for managing nested context providers\n */\nconst contextStacks = new Map();\n\n/**\n * Context provider for passing data down the component tree\n * @param {string} key - Context key\n * @param {*} value - Context value\n * @param {Object} children - Children to render with context\n * @returns {Object} Children with context available\n */\nexport function provideContext(key, value) {\n    // Initialize context stack if it doesn't exist\n    if (!contextStacks.has(key)) {\n        contextStacks.set(key, []);\n    }\n    \n    const stack = contextStacks.get(key);\n    \n    // Store previous value\n    const previousValue = globalState.get(key);\n    \n    // Push previous value to stack and set new value\n    stack.push(previousValue);\n    globalState.set(key, value);\n}\n\n/**\n * Create a context provider component that works with the rendering system\n * @param {string} key - Context key\n * @param {*} value - Context value\n * @param {Object} children - Children to render with context\n * @returns {Function} Component function that provides context\n */\nexport function createContextProvider(key, value, children) {\n    // Return a function that will render the children within the context\n    return (renderFunction) => {\n        try {\n            // Provide context\n            provideContext(key, value);\n            \n            // If a render function is provided, use it to render children\n            // Otherwise return children to be rendered by the caller\n            if (renderFunction && typeof renderFunction === 'function') {\n                return renderFunction(children);\n            } else {\n                return children;\n            }\n        } finally {\n            // Always restore context when done\n            restoreContext(key);\n        }\n    };\n}\n\n/**\n * Restore context to previous value\n * @param {string} key - Context key\n */\nexport function restoreContext(key) {\n    if (!contextStacks.has(key)) return;\n    \n    const stack = contextStacks.get(key);\n    \n    // Restore previous value from stack\n    const previousValue = stack.pop();\n    \n    if (stack.length === 0) {\n        // No more providers, delete the key if it was undefined before\n        if (previousValue === undefined) {\n            globalState.delete(key);\n        } else {\n            globalState.set(key, previousValue);\n        }\n        \n        // Clean up empty stack\n        contextStacks.delete(key);\n    } else {\n        // Restore previous value\n        globalState.set(key, previousValue);\n    }\n}\n\n/**\n * Clear all context stacks (useful for cleanup after rendering)\n */\nexport function clearAllContexts() {\n    contextStacks.clear();\n    // Note: This doesn't clear globalState as it might contain other data\n}\n\n/**\n * Context consumer to access provided context\n * @param {string} key - Context key\n * @returns {*} Context value\n */\nexport function useContext(key) {\n    return globalState.get(key);\n}\n"],
+  "mappings": ";AAKA,IAAM,cAAc,oBAAI,IAAI;AAOrB,SAAS,YAAY,eAAe,CAAC,GAAG;AAC3C,QAAM,QAAQ,IAAI,IAAI,OAAO,QAAQ,YAAY,CAAC;AAElD,SAAO;AAAA,IACH,IAAI,KAAK;AACL,aAAO,MAAM,IAAI,GAAG;AAAA,IACxB;AAAA,IAEA,IAAI,KAAK,OAAO;AACZ,YAAM,IAAI,KAAK,KAAK;AACpB,aAAO;AAAA,IACX;AAAA,IAEA,IAAI,KAAK;AACL,aAAO,MAAM,IAAI,GAAG;AAAA,IACxB;AAAA,IAEA,OAAO,KAAK;AACR,aAAO,MAAM,OAAO,GAAG;AAAA,IAC3B;AAAA,IAEA,QAAQ;AACJ,YAAM,MAAM;AACZ,aAAO;AAAA,IACX;AAAA,IAEA,WAAW;AACP,aAAO,OAAO,YAAY,KAAK;AAAA,IACnC;AAAA;AAAA,IAGA,WAAW;AAAA,EACf;AACJ;AAKO,IAAM,qBAAqB;AAAA,EAC9B,IAAI,KAAK,OAAO;AACZ,gBAAY,IAAI,KAAK,KAAK;AAAA,EAC9B;AAAA,EAEA,IAAI,KAAK;AACL,WAAO,YAAY,IAAI,GAAG;AAAA,EAC9B;AAAA,EAEA,IAAI,KAAK;AACL,WAAO,YAAY,IAAI,GAAG;AAAA,EAC9B;AAAA,EAEA,QAAQ;AACJ,gBAAY,MAAM;AAAA,EACtB;AAAA;AAAA,EAGA,qBAAqB;AACjB,WAAO,YAAY;AAAA,EACvB;AACJ;AAKA,IAAM,gBAAgB,oBAAI,IAAI;AASvB,SAAS,eAAe,KAAK,OAAO;AAEvC,MAAI,CAAC,cAAc,IAAI,GAAG,GAAG;AACzB,kBAAc,IAAI,KAAK,CAAC,CAAC;AAAA,EAC7B;AAEA,QAAM,QAAQ,cAAc,IAAI,GAAG;AAGnC,QAAM,gBAAgB,YAAY,IAAI,GAAG;AAGzC,QAAM,KAAK,aAAa;AACxB,cAAY,IAAI,KAAK,KAAK;AAC9B;AASO,SAAS,sBAAsB,KAAK,OAAO,UAAU;AAExD,SAAO,CAAC,mBAAmB;AACvB,QAAI;AAEA,qBAAe,KAAK,KAAK;AAIzB,UAAI,kBAAkB,OAAO,mBAAmB,YAAY;AACxD,eAAO,eAAe,QAAQ;AAAA,MAClC,OAAO;AACH,eAAO;AAAA,MACX;AAAA,IACJ,UAAE;AAEE,qBAAe,GAAG;AAAA,IACtB;AAAA,EACJ;AACJ;AAMO,SAAS,eAAe,KAAK;AAChC,MAAI,CAAC,cAAc,IAAI,GAAG,EAAG;AAE7B,QAAM,QAAQ,cAAc,IAAI,GAAG;AAGnC,QAAM,gBAAgB,MAAM,IAAI;AAEhC,MAAI,MAAM,WAAW,GAAG;AAEpB,QAAI,kBAAkB,QAAW;AAC7B,kBAAY,OAAO,GAAG;AAAA,IAC1B,OAAO;AACH,kBAAY,IAAI,KAAK,aAAa;AAAA,IACtC;AAGA,kBAAc,OAAO,GAAG;AAAA,EAC5B,OAAO;AAEH,gBAAY,IAAI,KAAK,aAAa;AAAA,EACtC;AACJ;AAKO,SAAS,mBAAmB;AAC/B,gBAAc,MAAM;AAExB;AAOO,SAAS,WAAW,KAAK;AAC5B,SAAO,YAAY,IAAI,GAAG;AAC9B;",
+  "names": []
+}