ccstate 2.2.0 → 4.0.0

package/README.md

@@ -7,7 +7,6 @@
 ![NPM Version](https://img.shields.io/npm/v/ccstate)
 ![npm package minimized gzipped size](https://img.shields.io/bundlejs/size/ccstate)
 [![CI](https://github.com/e7h4n/ccstate/actions/workflows/ci.yaml/badge.svg)](https://github.com/e7h4n/ccstate/actions/workflows/ci.yaml)
-[![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/e7h4n/ccstate)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 CCState is a semantic, strict, and flexible state management library suitable for medium to large single-page applications with complex state management needs.
@@ -19,7 +18,7 @@ The name of CCState comes from three basic data types: computed, command, and st
 - 💯 Simple & Intuitive: Crystal-clear API design with just 3 data types and 2 operations
 - ✅ Rock-solid Reliability: Comprehensive test coverage reaching 100% branch coverage
 - 🪶 Ultra-lightweight: Zero dependencies, only 500 lines of core code
-- 💡 Framework Agnostic: Seamlessly works with [React](docs/react.md), [Vue](docs/vue.md), or any UI framework
+- 💡 Framework Agnostic: Seamlessly works with [React](docs/react.md), [Vue](docs/vue.md), [Solid.js](docs/solid.md), [Vanilla](docs/vanilla.md), or any UI framework
 - 🚀 Blazing Fast: Optimized performance from day one, 2x-7x faster than Jotai across scenarios
 
 ## Getting Started
@@ -62,7 +61,7 @@ Use `useGet` and `useSet` hooks in React to get/set data, and use `useResolved`
 
 ```jsx
 // App.js
-import { useGet, useSet, useResolved } from 'ccstate';
+import { useGet, useSet, useResolved } from 'ccstate-react';
 import { userId$, user$ } from './data';
 
 export default function App() {
@@ -85,29 +84,15 @@ export default function App() {
     </div>
   );
 }
-```
-
-Use `createStore` and `StoreProvider` to provide a CCState store to React, all states and computations will only affect this isolated store.
 
-```tsx
 // main.jsx
-import { createStore, StoreProvider } from 'ccstate';
-import { StrictMode } from 'react';
 import { createRoot } from 'react-dom/client';
-
 import App from './App';
 
 const rootElement = document.getElementById('root');
 const root = createRoot(rootElement);
 
-const store = createStore();
-root.render(
-  <StrictMode>
-    <StoreProvider value={store}>
-      <App />
-    </StoreProvider>
-  </StrictMode>,
-);
+root.render(<App />);
 ```
 
 That's it! [Click here to see the full example](https://codesandbox.io/p/sandbox/cr3xg6).
@@ -290,6 +275,14 @@ That's it! Next, you can learn how to use CCState in React.
 
 [Using in Vue](docs/vue.md)
 
+## Using in Solid.js
+
+[Using in Solid.js](docs/solid.md)
+
+## Using in Vanilla
+
+[Using in Vanilla](docs/vanilla.md)
+
 ### Testing & Debugging
 
 Testing Value/Computed should be as simple as testing a Map.
@@ -314,12 +307,12 @@ Here are some tips to help you better debug during testing.
 Use `ConsoleInterceptor` to log most store behaviors to the console during testing:
 
 ```typescript
-import { createConsoleDebugStore, state, computed, command } from 'ccstate';
+import { createDebugStore, state, computed, command } from 'ccstate';
 
 const base$ = state(1, { debugLabel: 'base$' });
 const derived$ = computed((get) => get(base$) * 2);
 
-const store = createConsoleDebugStore([base$, 'derived'], ['set', 'sub']); // log sub & set actions
+const store = createDebugStore([base$, 'derived'], ['set', 'sub']); // log sub & set actions
 store.set(base$, 1); // console: SET [V0:base$] 1
 store.sub(
   derived$,
@@ -728,7 +721,7 @@ Click show to make double enter the display state, and you can see the `set` `sh
     ret: – 14
 ```
 
-The abbreviation `CPT` represents `Computed` evaluation, not just a simple read operation. You can also try modifying the parameters of `createConsoleDebugStore` in the code to include `get` in the logs, and you'll find that not every `get` triggers a `Computed` evaluation.
+The abbreviation `CPT` represents `Computed` evaluation, not just a simple read operation. You can also try modifying the parameters of `createDebugStore` in the code to include `get` in the logs, and you'll find that not every `get` triggers a `Computed` evaluation.
 
 Click increment to see the `set` trigger the `Computed` evaluation.
 
@@ -823,10 +816,9 @@ So, I think the only way to implement `Computed`'s effect-less is to separate th
 
 Here are some new ideas:
 
-- Integration with svelte / solid.js
-- Enhance devtools
+- Integration with svelte
+- Enhance debug ability
   - Support viewing current subscription graph and related atom values
-  - Enable logging and breakpoints for specific atoms in devtools
 - Performance improvements
   - Mount atomState directly on atoms when there's only one store in the application to reduce WeakMap lookup overhead
   - Support static declaration of upstream dependencies for Computed to improve performance by disabling runtime dependency analysis

package/core/index.cjs

@@ -1015,8 +1015,16 @@ function createStore() {
   var listenerManager = new ListenerManager();
   return new StoreImpl(atomManager, listenerManager);
 }
+var defaultStore = undefined;
+function getDefaultStore() {
+  if (!defaultStore) {
+    defaultStore = createStore();
+  }
+  return defaultStore;
+}
 
 exports.command = command;
 exports.computed = computed;
 exports.createStore = createStore;
+exports.getDefaultStore = getDefaultStore;
 exports.state = state;

package/core/index.d.cts

@@ -48,5 +48,6 @@ type CallbackFunc<T> = Command<T, []>;
 type Subscribe = (atoms$: ReadableAtom<unknown>[] | ReadableAtom<unknown>, callback: CallbackFunc<unknown>, options?: SubscribeOptions) => () => void;
 
 declare function createStore(): Store;
+declare function getDefaultStore(): Store;
 
-export { type Command, type Computed, type Getter, type Read, type Setter, type State, type Store, type Subscribe, type Updater, type Write, command, computed, createStore, state };
+export { type Command, type Computed, type Getter, type Read, type Setter, type State, type Store, type Subscribe, type Updater, type Write, command, computed, createStore, getDefaultStore, state };

package/core/index.d.ts

@@ -48,5 +48,6 @@ type CallbackFunc<T> = Command<T, []>;
 type Subscribe = (atoms$: ReadableAtom<unknown>[] | ReadableAtom<unknown>, callback: CallbackFunc<unknown>, options?: SubscribeOptions) => () => void;
 
 declare function createStore(): Store;
+declare function getDefaultStore(): Store;
 
-export { type Command, type Computed, type Getter, type Read, type Setter, type State, type Store, type Subscribe, type Updater, type Write, command, computed, createStore, state };
+export { type Command, type Computed, type Getter, type Read, type Setter, type State, type Store, type Subscribe, type Updater, type Write, command, computed, createStore, getDefaultStore, state };

package/core/index.js

@@ -1013,5 +1013,12 @@ function createStore() {
   var listenerManager = new ListenerManager();
   return new StoreImpl(atomManager, listenerManager);
 }
+var defaultStore = undefined;
+function getDefaultStore() {
+  if (!defaultStore) {
+    defaultStore = createStore();
+  }
+  return defaultStore;
+}
 
-export { command, computed, createStore, state };
+export { command, computed, createStore, getDefaultStore, state };

package/debug/index.cjs

@@ -1,15 +1,5 @@
 'use strict';
 
-function nestedAtomToString(atoms) {
-  return atoms.map(function (atom) {
-    var _atom$debugLabel;
-    if (Array.isArray(atom)) {
-      return nestedAtomToString(atom);
-    }
-    return (_atom$debugLabel = atom.debugLabel) !== null && _atom$debugLabel !== void 0 ? _atom$debugLabel : 'anonymous';
-  });
-}
-
 function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
   for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
@@ -31,13 +21,6 @@ function _callSuper(t, o, e) {
 function _classCallCheck(a, n) {
   if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
 }
-function _construct(t, e, r) {
-  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
-  var o = [null];
-  o.push.apply(o, e);
-  var p = new (t.bind.apply(t, o))();
-  return r && _setPrototypeOf(p, r.prototype), p;
-}
 function _defineProperties(e, r) {
   for (var t = 0; t < r.length; t++) {
     var o = r[t];
@@ -131,13 +114,6 @@ function _inherits(t, e) {
     writable: !1
   }), e && _setPrototypeOf(t, e);
 }
-function _isNativeFunction(t) {
-  try {
-    return -1 !== Function.toString.call(t).indexOf("[native code]");
-  } catch (n) {
-    return "function" == typeof t;
-  }
-}
 function _isNativeReflectConstruct() {
   try {
     var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
@@ -523,15 +499,6 @@ function _toPropertyKey(t) {
   var i = _toPrimitive(t, "string");
   return "symbol" == typeof i ? i : i + "";
 }
-function _typeof(o) {
-  "@babel/helpers - typeof";
-
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-    return typeof o;
-  } : function (o) {
-    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-  }, _typeof(o);
-}
 function _unsupportedIterableToArray(r, a) {
   if (r) {
     if ("string" == typeof r) return _arrayLikeToArray(r, a);
@@ -539,28 +506,6 @@ function _unsupportedIterableToArray(r, a) {
     return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
   }
 }
-function _wrapNativeSuper(t) {
-  var r = "function" == typeof Map ? new Map() : void 0;
-  return _wrapNativeSuper = function (t) {
-    if (null === t || !_isNativeFunction(t)) return t;
-    if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
-    if (void 0 !== r) {
-      if (r.has(t)) return r.get(t);
-      r.set(t, Wrapper);
-    }
-    function Wrapper() {
-      return _construct(t, arguments, _getPrototypeOf(this).constructor);
-    }
-    return Wrapper.prototype = Object.create(t.prototype, {
-      constructor: {
-        value: Wrapper,
-        enumerable: !1,
-        writable: !0,
-        configurable: !0
-      }
-    }), _setPrototypeOf(Wrapper, t);
-  }, _wrapNativeSuper(t);
-}
 
 function canReadAsCompute(atom) {
   return 'read' in atom;
@@ -1160,7 +1105,7 @@ var DebugStoreImpl = /*#__PURE__*/function (_StoreImpl) {
   _inherits(DebugStoreImpl, _StoreImpl);
   return _createClass(DebugStoreImpl);
 }(StoreImpl);
-function createDebugStore(interceptor) {
+function createDebugStoreInternal(interceptor) {
   var atomManager = new AtomManager({
     interceptor: interceptor
   });
@@ -1261,12 +1206,15 @@ var ConsoleInterceptor = /*#__PURE__*/_createClass(function ConsoleInterceptor(w
   });
   this.watches = watches;
 });
-function createConsoleDebugStore(watches, defaultActions) {
+function createDebugStore() {
+  var watches = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var defaultActions = arguments.length > 1 ? arguments[1] : undefined;
+  var parsedDefaultActions = defaultActions ? new Set(defaultActions) : undefined;
   var parsedWatches = watches.map(function (watch) {
     if (typeof watch === 'string' || watch instanceof RegExp) {
       return {
         target: watch,
-        actions: defaultActions ? new Set(defaultActions) : undefined
+        actions: parsedDefaultActions
       };
     }
     if ('target' in watch) {
@@ -1274,179 +1222,11 @@ function createConsoleDebugStore(watches, defaultActions) {
     }
     return {
       target: watch,
-      actions: defaultActions ? new Set(defaultActions) : undefined
+      actions: parsedDefaultActions
     };
   });
   var interceptor = new ConsoleInterceptor(parsedWatches);
-  return createDebugStore(interceptor);
-}
-
-var StoreEvent = /*#__PURE__*/function (_Event) {
-  function StoreEvent(type, eventId, targetAtom, state, time, args, result) {
-    var _this;
-    _classCallCheck(this, StoreEvent);
-    _this = _callSuper(this, StoreEvent, [type]);
-    _this.eventId = eventId;
-    _this.targetAtom = targetAtom;
-    _this.state = state;
-    _this.time = time;
-    _this.args = args;
-    _this.result = result;
-    return _this;
-  }
-  _inherits(StoreEvent, _Event);
-  return _createClass(StoreEvent);
-}(/*#__PURE__*/_wrapNativeSuper(Event));
-
-var EventInterceptor = /*#__PURE__*/function () {
-  function EventInterceptor() {
-    var _this = this;
-    _classCallCheck(this, EventInterceptor);
-    _defineProperty(this, "traceId", 0);
-    _defineProperty(this, "events", new EventTarget());
-    _defineProperty(this, "get", function (atom$, fn) {
-      return _this.wrapWithTrace(fn, function (eventId, time) {
-        _this.createEvent('get', eventId, atom$.toString(), time, 'begin', [], undefined);
-      }, function (eventId, time, result) {
-        _this.createEvent('get', eventId, atom$.toString(), time, 'success', [], result);
-      }, function (eventId, time, error) {
-        _this.createEvent('get', eventId, atom$.toString(), time, 'error', [], error);
-      });
-    });
-    _defineProperty(this, "computed", function (atom$, fn) {
-      return _this.wrapWithTrace(fn, function (eventId, time) {
-        _this.createEvent('computed', eventId, atom$.toString(), time, 'begin', [], undefined);
-      }, function (eventId, time, result) {
-        _this.createEvent('computed', eventId, atom$.toString(), time, 'success', [], result);
-      }, function (eventId, time, error) {
-        _this.createEvent('computed', eventId, atom$.toString(), time, 'error', [], error);
-      });
-    });
-    _defineProperty(this, "set", function (atom$, fn) {
-      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-        args[_key - 2] = arguments[_key];
-      }
-      return _this.wrapWithTrace(fn, function (eventId, time) {
-        _this.createEvent('set', eventId, atom$.toString(), time, 'begin', args, undefined);
-      }, function (eventId, time, result) {
-        _this.createEvent('set', eventId, atom$.toString(), time, 'success', args, result);
-      }, function (eventId, time, error) {
-        _this.createEvent('set', eventId, atom$.toString(), time, 'error', args, error);
-      });
-    });
-    _defineProperty(this, "sub", function (atom$, callback$, fn) {
-      var eventId = _this.traceId++;
-      _this.createEvent('sub', eventId, atom$.toString(), performance.now(), 'begin', [callback$.toString()], undefined);
-      fn();
-      _this.createEvent('sub', eventId, atom$.toString(), performance.now(), 'success', [callback$.toString()], undefined);
-    });
-    _defineProperty(this, "unsub", function (atom$, callback$, fn) {
-      var eventId = _this.traceId++;
-      _this.createEvent('unsub', eventId, atom$.toString(), performance.now(), 'begin', [callback$.toString()], undefined);
-      fn();
-      _this.createEvent('unsub', eventId, atom$.toString(), performance.now(), 'success', [callback$.toString()], undefined);
-    });
-    _defineProperty(this, "mount", function (atom$) {
-      var eventId = _this.traceId++;
-      _this.createEvent('mount', eventId, atom$.toString(), performance.now(), 'begin', [], undefined);
-    });
-    _defineProperty(this, "unmount", function (atom$) {
-      var eventId = _this.traceId++;
-      _this.createEvent('unmount', eventId, atom$.toString(), performance.now(), 'begin', [], undefined);
-    });
-    _defineProperty(this, "notify", function (callback$, fn) {
-      var eventId = _this.traceId++;
-      _this.createEvent('notify', eventId, callback$.toString(), performance.now(), 'begin', [], undefined);
-      var ret = fn();
-      _this.createEvent('notify', eventId, callback$.toString(), performance.now(), 'success', [], ret);
-    });
-  }
-  return _createClass(EventInterceptor, [{
-    key: "createEvent",
-    value: function createEvent(type, eventId, atom, time, state, args, result) {
-      var event = new StoreEvent(type, eventId, atom, state, time, args, result);
-      this.events.dispatchEvent(event);
-      return event;
-    }
-  }, {
-    key: "wrapWithTrace",
-    value: function wrapWithTrace(fn, createBeginEvent, createSuccessEvent, createErrorEvent) {
-      var eventId = this.traceId++;
-      createBeginEvent(eventId, performance.now());
-      try {
-        var result = fn();
-        createSuccessEvent(eventId, performance.now(), result);
-        return result;
-      } catch (e) {
-        createErrorEvent(eventId, performance.now(), e);
-        throw e;
-      }
-    }
-  }, {
-    key: "addEventListener",
-    value: function addEventListener(type, listener, options) {
-      this.events.addEventListener(type, listener, options);
-    }
-  }, {
-    key: "removeEventListener",
-    value: function removeEventListener(type, listener, options) {
-      this.events.removeEventListener(type, listener, options);
-    }
-  }]);
-}();
-
-var GLOBAL_CCSTATE_INTERCEPED_KEY = '__CCSTATE_INTERCEPED__';
-function setupDevtoolsInterceptor(targetWindow, signal) {
-  var interceptor = new EventInterceptor();
-  var watchedAtoms = new Set();
-  targetWindow.addEventListener('message', function (_ref) {
-    var data = _ref.data;
-    if (!data || _typeof(data) !== 'object' || !('source' in data) || data.source !== 'ccstate-devtools') {
-      return;
-    }
-    var payload = data.payload;
-    watchedAtoms.add(payload.args[0]);
-  }, {
-    signal: signal
-  });
-  function handleStoreEvent(event) {
-    var debugLabel = event.targetAtom.substring(event.targetAtom.indexOf(':') + 1);
-    if (watchedAtoms.has(debugLabel)) {
-      console.group("[CCState] ".concat(event.type, " ").concat(event.targetAtom, " ").concat(event.state));
-      console.log('args', event.args);
-      console.log('result', event.result);
-      console.groupEnd();
-    }
-    var message = {
-      source: 'ccstate-store',
-      payload: {
-        type: event.type,
-        eventId: event.eventId,
-        targetAtom: event.targetAtom,
-        time: event.time,
-        state: event.state
-      }
-    };
-    targetWindow.postMessage(message);
-  }
-  interceptor.addEventListener('get', handleStoreEvent);
-  interceptor.addEventListener('computed', handleStoreEvent);
-  interceptor.addEventListener('set', handleStoreEvent);
-  interceptor.addEventListener('sub', handleStoreEvent);
-  interceptor.addEventListener('unsub', handleStoreEvent);
-  interceptor.addEventListener('mount', handleStoreEvent);
-  interceptor.addEventListener('unmount', handleStoreEvent);
-  interceptor.addEventListener('notify', handleStoreEvent);
-  targetWindow[GLOBAL_CCSTATE_INTERCEPED_KEY] = true;
-  console.warn('[CCSTATE] Interceptor injected, DO NOT USE THIS IN PRODUCTION');
-  return interceptor;
+  return createDebugStoreInternal(interceptor);
 }
 
-exports.ConsoleInterceptor = ConsoleInterceptor;
-exports.EventInterceptor = EventInterceptor;
-exports.GLOBAL_CCSTATE_INTERCEPED_KEY = GLOBAL_CCSTATE_INTERCEPED_KEY;
-exports.StoreEvent = StoreEvent;
-exports.createConsoleDebugStore = createConsoleDebugStore;
 exports.createDebugStore = createDebugStore;
-exports.nestedAtomToString = nestedAtomToString;
-exports.setupDevtoolsInterceptor = setupDevtoolsInterceptor;

package/debug/index.d.cts

@@ -29,11 +29,6 @@ interface Command<T, Args extends unknown[]> {
 }
 type ReadableAtom<T> = State<T> | Computed<T>;
 
-type NestedAtom = (State<unknown> | Computed<unknown> | Command<unknown, unknown[]> | NestedAtom)[];
-type NestedString = (string | NestedString)[];
-
-declare function nestedAtomToString(atoms: NestedAtom): NestedString;
-
 interface Store {
     get: Getter;
     set: Setter;
@@ -44,28 +39,9 @@ interface SubscribeOptions {
 }
 type CallbackFunc<T> = Command<T, []>;
 type Subscribe = (atoms$: ReadableAtom<unknown>[] | ReadableAtom<unknown>, callback: CallbackFunc<unknown>, options?: SubscribeOptions) => () => void;
-type InterceptorGet = <T>(atom$: State<T> | Computed<T>, fn: () => T) => void;
-interface InterceptorSet {
-    <T, Args extends unknown[]>(func$: Command<T, Args>, fn: () => T, ...args: Args): void;
-    <T>(value$: State<T>, fn: () => void, val: T | Updater<T>): void;
-}
-type InterceptorSub = <T>(atom$: ReadableAtom<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-type InterceptorUnsub = <T>(atom$: ReadableAtom<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-type InterceptorMount = <T>(atom$: ReadableAtom<T>) => void;
-type InterceptorUnmount = <T>(atom$: ReadableAtom<T>) => void;
-type InterceptorNotify = <T>(callback$: CallbackFunc<T>, fn: () => T) => void;
-type InterceptorComputed = <T>(atom$: Computed<T>, fn: () => T) => void;
-interface StoreInterceptor {
-    get?: InterceptorGet;
-    set?: InterceptorSet;
-    sub?: InterceptorSub;
-    unsub?: InterceptorUnsub;
-    mount?: InterceptorMount;
-    unmount?: InterceptorUnmount;
-    notify?: InterceptorNotify;
-    computed?: InterceptorComputed;
-}
+type StoreEventType = 'set' | 'get' | 'sub' | 'unsub' | 'mount' | 'unmount' | 'notify' | 'computed';
 
+type NestedAtom = (State<unknown> | Computed<unknown> | Command<unknown, unknown[]> | NestedAtom)[];
 interface DebugStore extends Store {
     getReadDependencies: (atom: Computed<unknown>) => NestedAtom;
     getReadDependents: (atom: State<unknown> | Computed<unknown>) => NestedAtom;
@@ -73,62 +49,10 @@ interface DebugStore extends Store {
     getSubscribeGraph: () => NestedAtom;
 }
 
-declare function createDebugStore(interceptor?: StoreInterceptor): DebugStore;
-
-type StoreEventType = 'set' | 'get' | 'sub' | 'unsub' | 'mount' | 'unmount' | 'notify' | 'computed';
-
 interface AtomWatch {
     target: State<unknown> | Computed<unknown> | Command<unknown, unknown[]> | string | RegExp;
     actions?: Set<StoreEventType>;
 }
-declare class ConsoleInterceptor implements StoreInterceptor {
-    private readonly watches;
-    constructor(watches: AtomWatch[]);
-    private shouldLog;
-    get: <T>(atom$: State<T> | Computed<T>, fn: () => T) => void;
-    computed: <T>(atom$: Computed<T>, fn: () => T) => void;
-    set: <T, Args extends unknown[]>(atom$: State<T> | Command<T, Args>, fn: () => T, ...args: Args | [T | Updater<T>]) => void;
-    sub: <T>(atom$: State<T> | Computed<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-    unsub: <T>(atom$: State<T> | Computed<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-    mount: <T>(atom$: State<T> | Computed<T>) => void;
-    unmount: <T>(atom$: State<T> | Computed<T>) => void;
-    notify: <T>(callback$: CallbackFunc<T>, fn: () => T) => void;
-}
-declare function createConsoleDebugStore(watches: (AtomWatch | string | RegExp | State<unknown> | Computed<unknown> | Command<unknown, unknown[]>)[], defaultActions?: StoreEventType[]): DebugStore;
-
-declare class StoreEvent extends Event {
-    readonly eventId: number;
-    readonly targetAtom: string;
-    readonly state: 'begin' | 'success' | 'error';
-    readonly time: DOMHighResTimeStamp;
-    readonly args: unknown[];
-    readonly result: unknown;
-    constructor(type: StoreEventType, eventId: number, targetAtom: string, state: 'begin' | 'success' | 'error', time: DOMHighResTimeStamp, args: unknown[], result: unknown);
-}
-
-declare class EventInterceptor implements StoreInterceptor {
-    private traceId;
-    private events;
-    private createEvent;
-    private wrapWithTrace;
-    addEventListener(type: StoreEventType, listener: (event: StoreEvent) => void, options?: AddEventListenerOptions | boolean): void;
-    removeEventListener(type: StoreEventType, listener: (event: StoreEvent) => void, options?: EventListenerOptions | boolean): void;
-    get: <T>(atom$: State<T> | Computed<T>, fn: () => T) => T;
-    computed: <T>(atom$: Computed<T>, fn: () => T) => T;
-    set: <T, Args extends unknown[]>(atom$: State<T> | Command<T, Args>, fn: () => T, ...args: Args | [T | Updater<T>]) => T;
-    sub: <T>(atom$: State<T> | Computed<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-    unsub: <T>(atom$: State<T> | Computed<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-    mount: <T>(atom$: State<T> | Computed<T>) => void;
-    unmount: <T>(atom$: State<T> | Computed<T>) => void;
-    notify: <T>(callback$: CallbackFunc<T>, fn: () => T) => void;
-}
-
-type PackedEventMessage = Pick<StoreEvent, 'type' | 'eventId' | 'targetAtom' | 'time' | 'state'>;
-interface DevToolsHookMessage {
-    source: 'ccstate-store';
-    payload: PackedEventMessage;
-}
-declare const GLOBAL_CCSTATE_INTERCEPED_KEY = "__CCSTATE_INTERCEPED__";
-declare function setupDevtoolsInterceptor(targetWindow: Window, signal?: AbortSignal): EventInterceptor;
+declare function createDebugStore(watches?: (AtomWatch | string | RegExp | State<unknown> | Computed<unknown> | Command<unknown, unknown[]>)[], defaultActions?: StoreEventType[]): DebugStore;
 
-export { ConsoleInterceptor, type DebugStore, type DevToolsHookMessage, EventInterceptor, GLOBAL_CCSTATE_INTERCEPED_KEY, type PackedEventMessage, StoreEvent, type StoreEventType, type StoreInterceptor, createConsoleDebugStore, createDebugStore, nestedAtomToString, setupDevtoolsInterceptor };
+export { type DebugStore, createDebugStore };

package/debug/index.d.ts

@@ -29,11 +29,6 @@ interface Command<T, Args extends unknown[]> {
 }
 type ReadableAtom<T> = State<T> | Computed<T>;
 
-type NestedAtom = (State<unknown> | Computed<unknown> | Command<unknown, unknown[]> | NestedAtom)[];
-type NestedString = (string | NestedString)[];
-
-declare function nestedAtomToString(atoms: NestedAtom): NestedString;
-
 interface Store {
     get: Getter;
     set: Setter;
@@ -44,28 +39,9 @@ interface SubscribeOptions {
 }
 type CallbackFunc<T> = Command<T, []>;
 type Subscribe = (atoms$: ReadableAtom<unknown>[] | ReadableAtom<unknown>, callback: CallbackFunc<unknown>, options?: SubscribeOptions) => () => void;
-type InterceptorGet = <T>(atom$: State<T> | Computed<T>, fn: () => T) => void;
-interface InterceptorSet {
-    <T, Args extends unknown[]>(func$: Command<T, Args>, fn: () => T, ...args: Args): void;
-    <T>(value$: State<T>, fn: () => void, val: T | Updater<T>): void;
-}
-type InterceptorSub = <T>(atom$: ReadableAtom<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-type InterceptorUnsub = <T>(atom$: ReadableAtom<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-type InterceptorMount = <T>(atom$: ReadableAtom<T>) => void;
-type InterceptorUnmount = <T>(atom$: ReadableAtom<T>) => void;
-type InterceptorNotify = <T>(callback$: CallbackFunc<T>, fn: () => T) => void;
-type InterceptorComputed = <T>(atom$: Computed<T>, fn: () => T) => void;
-interface StoreInterceptor {
-    get?: InterceptorGet;
-    set?: InterceptorSet;
-    sub?: InterceptorSub;
-    unsub?: InterceptorUnsub;
-    mount?: InterceptorMount;
-    unmount?: InterceptorUnmount;
-    notify?: InterceptorNotify;
-    computed?: InterceptorComputed;
-}
+type StoreEventType = 'set' | 'get' | 'sub' | 'unsub' | 'mount' | 'unmount' | 'notify' | 'computed';
 
+type NestedAtom = (State<unknown> | Computed<unknown> | Command<unknown, unknown[]> | NestedAtom)[];
 interface DebugStore extends Store {
     getReadDependencies: (atom: Computed<unknown>) => NestedAtom;
     getReadDependents: (atom: State<unknown> | Computed<unknown>) => NestedAtom;
@@ -73,62 +49,10 @@ interface DebugStore extends Store {
     getSubscribeGraph: () => NestedAtom;
 }
 
-declare function createDebugStore(interceptor?: StoreInterceptor): DebugStore;
-
-type StoreEventType = 'set' | 'get' | 'sub' | 'unsub' | 'mount' | 'unmount' | 'notify' | 'computed';
-
 interface AtomWatch {
     target: State<unknown> | Computed<unknown> | Command<unknown, unknown[]> | string | RegExp;
     actions?: Set<StoreEventType>;
 }
-declare class ConsoleInterceptor implements StoreInterceptor {
-    private readonly watches;
-    constructor(watches: AtomWatch[]);
-    private shouldLog;
-    get: <T>(atom$: State<T> | Computed<T>, fn: () => T) => void;
-    computed: <T>(atom$: Computed<T>, fn: () => T) => void;
-    set: <T, Args extends unknown[]>(atom$: State<T> | Command<T, Args>, fn: () => T, ...args: Args | [T | Updater<T>]) => void;
-    sub: <T>(atom$: State<T> | Computed<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-    unsub: <T>(atom$: State<T> | Computed<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-    mount: <T>(atom$: State<T> | Computed<T>) => void;
-    unmount: <T>(atom$: State<T> | Computed<T>) => void;
-    notify: <T>(callback$: CallbackFunc<T>, fn: () => T) => void;
-}
-declare function createConsoleDebugStore(watches: (AtomWatch | string | RegExp | State<unknown> | Computed<unknown> | Command<unknown, unknown[]>)[], defaultActions?: StoreEventType[]): DebugStore;
-
-declare class StoreEvent extends Event {
-    readonly eventId: number;
-    readonly targetAtom: string;
-    readonly state: 'begin' | 'success' | 'error';
-    readonly time: DOMHighResTimeStamp;
-    readonly args: unknown[];
-    readonly result: unknown;
-    constructor(type: StoreEventType, eventId: number, targetAtom: string, state: 'begin' | 'success' | 'error', time: DOMHighResTimeStamp, args: unknown[], result: unknown);
-}
-
-declare class EventInterceptor implements StoreInterceptor {
-    private traceId;
-    private events;
-    private createEvent;
-    private wrapWithTrace;
-    addEventListener(type: StoreEventType, listener: (event: StoreEvent) => void, options?: AddEventListenerOptions | boolean): void;
-    removeEventListener(type: StoreEventType, listener: (event: StoreEvent) => void, options?: EventListenerOptions | boolean): void;
-    get: <T>(atom$: State<T> | Computed<T>, fn: () => T) => T;
-    computed: <T>(atom$: Computed<T>, fn: () => T) => T;
-    set: <T, Args extends unknown[]>(atom$: State<T> | Command<T, Args>, fn: () => T, ...args: Args | [T | Updater<T>]) => T;
-    sub: <T>(atom$: State<T> | Computed<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-    unsub: <T>(atom$: State<T> | Computed<T>, callback$: CallbackFunc<T>, fn: () => void) => void;
-    mount: <T>(atom$: State<T> | Computed<T>) => void;
-    unmount: <T>(atom$: State<T> | Computed<T>) => void;
-    notify: <T>(callback$: CallbackFunc<T>, fn: () => T) => void;
-}
-
-type PackedEventMessage = Pick<StoreEvent, 'type' | 'eventId' | 'targetAtom' | 'time' | 'state'>;
-interface DevToolsHookMessage {
-    source: 'ccstate-store';
-    payload: PackedEventMessage;
-}
-declare const GLOBAL_CCSTATE_INTERCEPED_KEY = "__CCSTATE_INTERCEPED__";
-declare function setupDevtoolsInterceptor(targetWindow: Window, signal?: AbortSignal): EventInterceptor;
+declare function createDebugStore(watches?: (AtomWatch | string | RegExp | State<unknown> | Computed<unknown> | Command<unknown, unknown[]>)[], defaultActions?: StoreEventType[]): DebugStore;
 
-export { ConsoleInterceptor, type DebugStore, type DevToolsHookMessage, EventInterceptor, GLOBAL_CCSTATE_INTERCEPED_KEY, type PackedEventMessage, StoreEvent, type StoreEventType, type StoreInterceptor, createConsoleDebugStore, createDebugStore, nestedAtomToString, setupDevtoolsInterceptor };
+export { type DebugStore, createDebugStore };