watch-state 3.4.1 → 3.4.2

package/Cache/Cache.d.ts

@@ -1,4 +1,28 @@
-import { Watch, Watcher } from '../Watch';
+import { Watch } from '../Watch';
+import { Watcher } from '../types';
+/**
+ * You can cache computed state.
+ * The watcher will not be triggered while new result is the same.
+ * ```javascript
+ * const name = new State('Foo')
+ * const surname = new State('Bar')
+ *
+ * const fullName = new Cache(() => (
+ *   `${name.value} ${surname.value[0]}`
+ * ))
+ *
+ * new Watch(() => {
+ *   console.log(fullName.value)
+ * })
+ * // console.log('Foo B')
+ *
+ * surname.value = 'Baz'
+ * // nothing happens
+ *
+ * surname.value = 'Quux'
+ * // console.log('Foo Q')
+ * ```
+ * */
 export declare class Cache<V = any> extends Watch {
     protected updated: boolean;
     private _state;

package/Cache/Cache.es6.js

@@ -1,6 +1,29 @@
 import { Watch } from '../Watch/Watch.es6.js';
 import { State } from '../State/State.es6.js';
 
+/**
+ * You can cache computed state.
+ * The watcher will not be triggered while new result is the same.
+ * ```javascript
+ * const name = new State('Foo')
+ * const surname = new State('Bar')
+ *
+ * const fullName = new Cache(() => (
+ *   `${name.value} ${surname.value[0]}`
+ * ))
+ *
+ * new Watch(() => {
+ *   console.log(fullName.value)
+ * })
+ * // console.log('Foo B')
+ *
+ * surname.value = 'Baz'
+ * // nothing happens
+ *
+ * surname.value = 'Quux'
+ * // console.log('Foo Q')
+ * ```
+ * */
 class Cache extends Watch {
     constructor(watcher, freeParent, fireImmediately) {
         super(watcher, freeParent, !fireImmediately);

package/Cache/Cache.js

@@ -5,6 +5,29 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var Watch = require('../Watch/Watch.js');
 var State = require('../State/State.js');
 
+/**
+ * You can cache computed state.
+ * The watcher will not be triggered while new result is the same.
+ * ```javascript
+ * const name = new State('Foo')
+ * const surname = new State('Bar')
+ *
+ * const fullName = new Cache(() => (
+ *   `${name.value} ${surname.value[0]}`
+ * ))
+ *
+ * new Watch(() => {
+ *   console.log(fullName.value)
+ * })
+ * // console.log('Foo B')
+ *
+ * surname.value = 'Baz'
+ * // nothing happens
+ *
+ * surname.value = 'Quux'
+ * // console.log('Foo Q')
+ * ```
+ * */
 class Cache extends Watch.Watch {
     constructor(watcher, freeParent, fireImmediately) {
         super(watcher, freeParent, !fireImmediately);

package/Event/Event.d.ts

@@ -7,6 +7,19 @@ export declare class Event {
     start(): void;
     end(): void;
     private forceUpdate;
+    /**
+     * You can run watchers of a state with `update` method.
+     * ```typescript
+     * const count = new State(0)
+     *
+     * new Watch(() => {
+     *   console.log(count.value)
+     * })
+     * // console.log(0)
+     *
+     * count.update()
+     * // console.log(0)
+     * ```
+     * */
     update(): void;
 }
-export declare const globalEvent: Event;

package/Event/Event.es6.js

@@ -1,4 +1,4 @@
-import { scope } from '../scope/scope.es6.js';
+import { scope, globalEvent } from '../constants.es6.js';
 
 class Event {
     add(target) {
@@ -12,7 +12,7 @@ class Event {
         else {
             watchers = this.watchers = new Set([target]);
         }
-        target.onDestroy(() => watchers.delete(target));
+        target.onClear(() => watchers.delete(target));
     }
     start() {
         if (!scope.activeEvent) {
@@ -36,6 +36,20 @@ class Event {
             watcher.update();
         }
     }
+    /**
+     * You can run watchers of a state with `update` method.
+     * ```typescript
+     * const count = new State(0)
+     *
+     * new Watch(() => {
+     *   console.log(count.value)
+     * })
+     * // console.log(0)
+     *
+     * count.update()
+     * // console.log(0)
+     * ```
+     * */
     update() {
         var _a;
         if ((_a = this.watchers) === null || _a === void 0 ? void 0 : _a.size) {
@@ -49,7 +63,6 @@ class Event {
             }
         }
     }
-}
-const globalEvent = new Event();
+}
 
-export { Event, globalEvent };
+export { Event };

package/Event/Event.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var scope = require('../scope/scope.js');
+var constants = require('../constants.js');
 
 class Event {
     add(target) {
@@ -16,21 +16,21 @@ class Event {
         else {
             watchers = this.watchers = new Set([target]);
         }
-        target.onDestroy(() => watchers.delete(target));
+        target.onClear(() => watchers.delete(target));
     }
     start() {
-        if (!scope.scope.activeEvent) {
-            this.activeWatcher = scope.scope.activeWatcher;
-            scope.scope.activeWatcher = undefined;
-            scope.scope.activeEvent = this;
+        if (!constants.scope.activeEvent) {
+            this.activeWatcher = constants.scope.activeWatcher;
+            constants.scope.activeWatcher = undefined;
+            constants.scope.activeEvent = this;
         }
-        scope.scope.activeEventDeep++;
+        constants.scope.activeEventDeep++;
     }
     end() {
-        if (!--scope.scope.activeEventDeep && scope.scope.activeEvent === this) {
-            scope.scope.activeEvent = undefined;
+        if (!--constants.scope.activeEventDeep && constants.scope.activeEvent === this) {
+            constants.scope.activeEvent = undefined;
             this.update();
-            scope.scope.activeWatcher = this.activeWatcher;
+            constants.scope.activeWatcher = this.activeWatcher;
         }
     }
     forceUpdate() {
@@ -40,21 +40,33 @@ class Event {
             watcher.update();
         }
     }
+    /**
+     * You can run watchers of a state with `update` method.
+     * ```typescript
+     * const count = new State(0)
+     *
+     * new Watch(() => {
+     *   console.log(count.value)
+     * })
+     * // console.log(0)
+     *
+     * count.update()
+     * // console.log(0)
+     * ```
+     * */
     update() {
         var _a;
         if ((_a = this.watchers) === null || _a === void 0 ? void 0 : _a.size) {
-            if (this === globalEvent) {
+            if (this === constants.globalEvent) {
                 this.forceUpdate();
             }
             else {
-                globalEvent.start();
+                constants.globalEvent.start();
                 this.forceUpdate();
-                globalEvent.end();
+                constants.globalEvent.end();
             }
         }
     }
-}
-const globalEvent = new Event();
+}
 
 exports.Event = Event;
-exports.globalEvent = globalEvent;

package/Event/index.es6.js

@@ -1 +1 @@
-export { Event, globalEvent } from './Event.es6.js';
+export { Event } from './Event.es6.js';

package/Event/index.js

@@ -7,4 +7,3 @@ var Event = require('./Event.js');
 
 
 exports.Event = Event.Event;
-exports.globalEvent = Event.globalEvent;

package/README.md

@@ -63,10 +63,10 @@
     <img src="https://img.shields.io/npm/l/watch-state" alt="watch-state license">
   </a>
   <a href="https://changelogs.xyz/watch-state" target="_blank">
-    <img src="https://img.shields.io/badge/Changelog-⋮-brightgreen" alt="watch-state minzipped size">
+    <img src="https://img.shields.io/badge/Changelog-⋮-brightgreen" alt="watch-state changelog">
   </a>
   <a href="https://d8corp.github.io/watch-state/coverage/lcov-report" target="_blank">
-    <img src="https://github.com/d8corp/watch-state/workflows/tests/badge.svg" alt="watch-state minzipped size">
+    <img src="https://github.com/d8corp/watch-state/workflows/tests/badge.svg" alt="watch-state tests">
   </a>
 </div>
 <br>
@@ -131,7 +131,7 @@ const {
 ### Simple example:
 You can create an instance of `State` and **watch** it's **value**.
 ```javascript
-import {Watch, State} from 'watch-state'
+import { Watch, State } from 'watch-state'
 
 const count = new State(0)
 
@@ -216,7 +216,7 @@ watcher.update()
 // console.log(0)
 ```
 
-### Destroy
+### destroy
 You can stop watching by `destroy` method of `Watch`.
 ```javascript
 const count = new State(0)
@@ -235,25 +235,27 @@ count.value++
 // nothing happens
 ```
 
-### Watch.onDestroy()
-You can react on destruction of `Watch` by `onDestroy` method.
+### onDestroy()
+You can subscribe on destroy or update of watcher
 ```javascript
-const watcher = new Watch(() => {})
-
-watcher.onDestroy(() => {
-  console.log('destructor')
+const count = new State(0)
+const watcher = new Watch(() => {
+  console.log('count', count.value)
+  // the order does not matter
+  onDestroy(() => console.log('destructor'))
 })
+// console.log('count', 0)
 
-watcher.destroy()
+count.value++
 // console.log('destructor')
-```
-`onDestructor` returns `this` so you can use **fluent interface**.
-```javascript
-const watcher = new Watch(() => {})
-  .onDestroy(() => console.log('destructor'))
+// console.log('count', 1)
 
 watcher.destroy()
 // console.log('destructor')
+
+watcher.destroy()
+count.value++
+// nothing happens
 ```
 
 ### Deep watch:
@@ -377,7 +379,7 @@ new Watch(() => {
 
 You can use `globalEvent` every time if you do not want to extend the Event functionality.
 ```typescript
-import {State, globalEvent} from 'watch-state'
+import { State, globalEvent } from 'watch-state'
 const count = new State(0)
 
 new Watch(() => {
@@ -387,6 +389,19 @@ new Watch(() => {
 })
 ```
 
+### createEvent
+You can create event function with createEvent
+```typescript
+import { State, createEvent } from 'watch-state'
+
+const count = new State(0)
+const increase = createEvent(() => {
+  console.log(count.value++)
+})
+
+new Watch(increase)
+```
+
 ### Typescript:
 Generic of `State`
 ```typescript

package/State/State.es6.js

@@ -1,5 +1,5 @@
 import { Event } from '../Event/Event.es6.js';
-import { scope } from '../scope/scope.es6.js';
+import { scope } from '../constants.es6.js';
 
 class State extends Event {
     constructor(state) {

package/State/State.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var Event = require('../Event/Event.js');
-var scope = require('../scope/scope.js');
+var constants = require('../constants.js');
 
 class State extends Event.Event {
     constructor(state) {
@@ -18,8 +18,8 @@ class State extends Event.Event {
      * ```
      * */
     get value() {
-        if (scope.scope.activeWatcher) {
-            this.add(scope.scope.activeWatcher);
+        if (constants.scope.activeWatcher) {
+            this.add(constants.scope.activeWatcher);
         }
         return this.state;
     }

package/Watch/Watch.d.ts

@@ -1,9 +1,4 @@
-export interface Watcher<R = any> {
-    (update?: boolean): R;
-}
-export interface Destructor<R = any> {
-    (): R;
-}
+import { Destructor, Watcher } from '../types';
 export declare class Watch {
     private readonly watcher;
     destructors: Destructor[];
@@ -12,7 +7,42 @@ export declare class Watch {
     protected run(): any;
     protected watchRun(): void;
     protected forceUpdate(): void;
+    /**
+     * You can run a watcher even when it's states are not updated.
+     * ```typescript
+     * const count = new State(0)
+     *
+     * const watcher = new Watch(() => {
+     *   console.log(count.value)
+     * })
+     * // console.log(0)
+     *
+     * watcher.update()
+     * // console.log(0)
+     * ```
+     * */
     update(): void;
+    /**
+     * You can stop watching by `destroy` method of `Watch`.
+     * ```javascript
+     * const count = new State(0)
+     *
+     * const watcher = new Watch(() => {
+     *   console.log(count.value)
+     * })
+     * // console.log(0)
+     *
+     * count.value++
+     * // console.log(1)
+     *
+     * watcher.destroy()
+     *
+     * count.value++
+     * // nothing happens
+     * ```
+     * */
     destroy(): void;
+    onClear(callback: Destructor): this;
+    /** @deprecated use onClear */
     onDestroy(callback: Destructor): this;
 }

package/Watch/Watch.es6.js

@@ -1,11 +1,12 @@
-import { scope } from '../scope/scope.es6.js';
+import { scope } from '../constants.es6.js';
+import { onDestroy } from '../utils/onDestroy/onDestroy.es6.js';
 
 class Watch {
     constructor(watcher, freeParent, freeUpdate) {
         this.watcher = watcher;
         this.ran = false;
-        if (!freeParent && scope.activeWatcher) {
-            scope.activeWatcher.onDestroy(() => this.destroy());
+        if (!freeParent) {
+            onDestroy(() => this.destroy());
         }
         if (!freeUpdate) {
             this.watchRun();
@@ -26,6 +27,20 @@ class Watch {
         this.destroy();
         this.watchRun();
     }
+    /**
+     * You can run a watcher even when it's states are not updated.
+     * ```typescript
+     * const count = new State(0)
+     *
+     * const watcher = new Watch(() => {
+     *   console.log(count.value)
+     * })
+     * // console.log(0)
+     *
+     * watcher.update()
+     * // console.log(0)
+     * ```
+     * */
     update() {
         this.destroy();
         if (scope.activeEvent) {
@@ -35,6 +50,25 @@ class Watch {
             this.watchRun();
         }
     }
+    /**
+     * You can stop watching by `destroy` method of `Watch`.
+     * ```javascript
+     * const count = new State(0)
+     *
+     * const watcher = new Watch(() => {
+     *   console.log(count.value)
+     * })
+     * // console.log(0)
+     *
+     * count.value++
+     * // console.log(1)
+     *
+     * watcher.destroy()
+     *
+     * count.value++
+     * // nothing happens
+     * ```
+     * */
     destroy() {
         const { destructors } = this;
         if (destructors) {
@@ -42,7 +76,7 @@ class Watch {
             destructors.forEach(e => e());
         }
     }
-    onDestroy(callback) {
+    onClear(callback) {
         if (this.destructors) {
             this.destructors.push(callback);
         }
@@ -51,6 +85,10 @@ class Watch {
         }
         return this;
     }
+    /** @deprecated use onClear */
+    onDestroy(callback) {
+        return this.onClear(callback);
+    }
 }
 
 export { Watch };

package/Watch/Watch.js

@@ -2,14 +2,15 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var scope = require('../scope/scope.js');
+var constants = require('../constants.js');
+var onDestroy = require('../utils/onDestroy/onDestroy.js');
 
 class Watch {
     constructor(watcher, freeParent, freeUpdate) {
         this.watcher = watcher;
         this.ran = false;
-        if (!freeParent && scope.scope.activeWatcher) {
-            scope.scope.activeWatcher.onDestroy(() => this.destroy());
+        if (!freeParent) {
+            onDestroy.onDestroy(() => this.destroy());
         }
         if (!freeUpdate) {
             this.watchRun();
@@ -21,24 +22,57 @@ class Watch {
         return this.watcher(ran);
     }
     watchRun() {
-        const prevWatcher = scope.scope.activeWatcher;
-        scope.scope.activeWatcher = this;
+        const prevWatcher = constants.scope.activeWatcher;
+        constants.scope.activeWatcher = this;
         this.run();
-        scope.scope.activeWatcher = prevWatcher;
+        constants.scope.activeWatcher = prevWatcher;
     }
     forceUpdate() {
         this.destroy();
         this.watchRun();
     }
+    /**
+     * You can run a watcher even when it's states are not updated.
+     * ```typescript
+     * const count = new State(0)
+     *
+     * const watcher = new Watch(() => {
+     *   console.log(count.value)
+     * })
+     * // console.log(0)
+     *
+     * watcher.update()
+     * // console.log(0)
+     * ```
+     * */
     update() {
         this.destroy();
-        if (scope.scope.activeEvent) {
-            scope.scope.activeEvent.add(this);
+        if (constants.scope.activeEvent) {
+            constants.scope.activeEvent.add(this);
         }
         else {
             this.watchRun();
         }
     }
+    /**
+     * You can stop watching by `destroy` method of `Watch`.
+     * ```javascript
+     * const count = new State(0)
+     *
+     * const watcher = new Watch(() => {
+     *   console.log(count.value)
+     * })
+     * // console.log(0)
+     *
+     * count.value++
+     * // console.log(1)
+     *
+     * watcher.destroy()
+     *
+     * count.value++
+     * // nothing happens
+     * ```
+     * */
     destroy() {
         const { destructors } = this;
         if (destructors) {
@@ -46,7 +80,7 @@ class Watch {
             destructors.forEach(e => e());
         }
     }
-    onDestroy(callback) {
+    onClear(callback) {
         if (this.destructors) {
             this.destructors.push(callback);
         }
@@ -55,6 +89,10 @@ class Watch {
         }
         return this;
     }
+    /** @deprecated use onClear */
+    onDestroy(callback) {
+        return this.onClear(callback);
+    }
 }
 
 exports.Watch = Watch;

package/constants.d.ts

@@ -0,0 +1,4 @@
+import { Event } from './Event';
+import { Scope } from './types';
+export declare const globalEvent: Event;
+export declare const scope: Scope;

package/constants.es6.js

@@ -0,0 +1,10 @@
+import { Event } from './Event/Event.es6.js';
+
+const globalEvent = new Event();
+const scope = {
+    activeWatcher: undefined,
+    activeEvent: undefined,
+    activeEventDeep: 0,
+};
+
+export { globalEvent, scope };

package/{scope/scope.js → constants.js}

@@ -2,10 +2,14 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var Event = require('./Event/Event.js');
+
+const globalEvent = new Event.Event();
 const scope = {
     activeWatcher: undefined,
     activeEvent: undefined,
     activeEventDeep: 0,
 };
 
+exports.globalEvent = globalEvent;
 exports.scope = scope;

package/index.d.ts

@@ -2,4 +2,6 @@ export * from './Watch';
 export * from './State';
 export * from './Cache';
 export * from './Event';
-export * from './scope';
+export * from './utils';
+export * from './types';
+export * from './constants';

package/index.es6.js

@@ -1,5 +1,7 @@
 export { Watch } from './Watch/Watch.es6.js';
 export { State } from './State/State.es6.js';
 export { Cache } from './Cache/Cache.es6.js';
-export { Event, globalEvent } from './Event/Event.es6.js';
-export { scope } from './scope/scope.es6.js';
+export { Event } from './Event/Event.es6.js';
+export { onDestroy } from './utils/onDestroy/onDestroy.es6.js';
+export { createEvent } from './utils/createEvent/createEvent.es6.js';
+export { globalEvent, scope } from './constants.es6.js';

package/index.js

@@ -6,7 +6,9 @@ var Watch = require('./Watch/Watch.js');
 var State = require('./State/State.js');
 var Cache = require('./Cache/Cache.js');
 var Event = require('./Event/Event.js');
-var scope = require('./scope/scope.js');
+var onDestroy = require('./utils/onDestroy/onDestroy.js');
+var createEvent = require('./utils/createEvent/createEvent.js');
+var constants = require('./constants.js');
 
 
 
@@ -14,5 +16,7 @@ exports.Watch = Watch.Watch;
 exports.State = State.State;
 exports.Cache = Cache.Cache;
 exports.Event = Event.Event;
-exports.globalEvent = Event.globalEvent;
-exports.scope = scope.scope;
+exports.onDestroy = onDestroy.onDestroy;
+exports.createEvent = createEvent.createEvent;
+exports.globalEvent = constants.globalEvent;
+exports.scope = constants.scope;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watch-state",
-  "version": "3.4.1",
+  "version": "3.4.2",
   "description": "CANT inc. state management system.",
   "author": "Mikhail Lysikov <d8corp@mail.ru>",
   "license": "MIT",

package/types.d.ts

@@ -0,0 +1,13 @@
+import { Watch } from './Watch';
+import { Event } from './Event';
+export interface Watcher<R = any> {
+    (update?: boolean): R;
+}
+export interface Destructor<R = any> {
+    (): R;
+}
+export interface Scope {
+    activeWatcher?: Watch;
+    activeEvent?: Event;
+    activeEventDeep: number;
+}

package/utils/createEvent/createEvent.d.ts

@@ -0,0 +1,14 @@
+/**
+ * You can create event function with createEvent
+ * ```typescript
+ * import { State, createEvent } from 'watch-state'
+ *
+ * const count = new State(0)
+ * const increase = createEvent(() => {
+ *   console.log(count.value++)
+ * })
+ *
+ * new Watch(increase)
+ * ```
+ * */
+export declare function createEvent<F extends Function>(fn: F): F;

package/utils/createEvent/createEvent.es6.js

@@ -0,0 +1,25 @@
+import { globalEvent } from '../../constants.es6.js';
+
+/**
+ * You can create event function with createEvent
+ * ```typescript
+ * import { State, createEvent } from 'watch-state'
+ *
+ * const count = new State(0)
+ * const increase = createEvent(() => {
+ *   console.log(count.value++)
+ * })
+ *
+ * new Watch(increase)
+ * ```
+ * */
+function createEvent(fn) {
+    return function () {
+        globalEvent.start();
+        const result = fn.apply(this, arguments);
+        globalEvent.end();
+        return result;
+    };
+}
+
+export { createEvent };

package/utils/createEvent/createEvent.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../../constants.js');
+
+/**
+ * You can create event function with createEvent
+ * ```typescript
+ * import { State, createEvent } from 'watch-state'
+ *
+ * const count = new State(0)
+ * const increase = createEvent(() => {
+ *   console.log(count.value++)
+ * })
+ *
+ * new Watch(increase)
+ * ```
+ * */
+function createEvent(fn) {
+    return function () {
+        constants.globalEvent.start();
+        const result = fn.apply(this, arguments);
+        constants.globalEvent.end();
+        return result;
+    };
+}
+
+exports.createEvent = createEvent;

package/utils/createEvent/index.d.ts

@@ -0,0 +1 @@
+export * from './createEvent';

package/utils/createEvent/index.es6.js

@@ -0,0 +1 @@
+export { createEvent } from './createEvent.es6.js';

package/utils/createEvent/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createEvent = require('./createEvent.js');
+
+
+
+exports.createEvent = createEvent.createEvent;

package/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './onDestroy';
+export * from './createEvent';

package/utils/index.es6.js

@@ -0,0 +1,2 @@
+export { onDestroy } from './onDestroy/onDestroy.es6.js';
+export { createEvent } from './createEvent/createEvent.es6.js';

package/utils/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var onDestroy = require('./onDestroy/onDestroy.js');
+var createEvent = require('./createEvent/createEvent.js');
+
+
+
+exports.onDestroy = onDestroy.onDestroy;
+exports.createEvent = createEvent.createEvent;

package/utils/onDestroy/index.d.ts

@@ -0,0 +1 @@
+export * from './onDestroy';

package/utils/onDestroy/index.es6.js

@@ -0,0 +1 @@
+export { onDestroy } from './onDestroy.es6.js';

package/utils/onDestroy/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var onDestroy = require('./onDestroy.js');
+
+
+
+exports.onDestroy = onDestroy.onDestroy;

package/utils/onDestroy/onDestroy.d.ts

@@ -0,0 +1,25 @@
+import { Destructor } from '../../types';
+/**
+ * You can subscribe on destroy or update of watcher
+ * ```javascript
+ * const count = new State(0)
+ * const watcher = new Watch(() => {
+ *   console.log('count', count.value)
+ *   // the order does not matter
+ *   onDestroy(() => console.log('destructor'))
+ * })
+ * // console.log('count', 0)
+ *
+ * count.value++
+ * // console.log('destructor')
+ * // console.log('count', 1)
+ *
+ * watcher.destroy()
+ * // console.log('destructor')
+ *
+ * watcher.destroy()
+ * count.value++
+ * // nothing happens
+ * ```
+ * */
+export declare function onDestroy(destructor: Destructor): void;

package/utils/onDestroy/onDestroy.es6.js

@@ -0,0 +1,32 @@
+import { scope } from '../../constants.es6.js';
+
+/**
+ * You can subscribe on destroy or update of watcher
+ * ```javascript
+ * const count = new State(0)
+ * const watcher = new Watch(() => {
+ *   console.log('count', count.value)
+ *   // the order does not matter
+ *   onDestroy(() => console.log('destructor'))
+ * })
+ * // console.log('count', 0)
+ *
+ * count.value++
+ * // console.log('destructor')
+ * // console.log('count', 1)
+ *
+ * watcher.destroy()
+ * // console.log('destructor')
+ *
+ * watcher.destroy()
+ * count.value++
+ * // nothing happens
+ * ```
+ * */
+function onDestroy(destructor) {
+    if (scope.activeWatcher) {
+        scope.activeWatcher.onClear(destructor);
+    }
+}
+
+export { onDestroy };

package/utils/onDestroy/onDestroy.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../../constants.js');
+
+/**
+ * You can subscribe on destroy or update of watcher
+ * ```javascript
+ * const count = new State(0)
+ * const watcher = new Watch(() => {
+ *   console.log('count', count.value)
+ *   // the order does not matter
+ *   onDestroy(() => console.log('destructor'))
+ * })
+ * // console.log('count', 0)
+ *
+ * count.value++
+ * // console.log('destructor')
+ * // console.log('count', 1)
+ *
+ * watcher.destroy()
+ * // console.log('destructor')
+ *
+ * watcher.destroy()
+ * count.value++
+ * // nothing happens
+ * ```
+ * */
+function onDestroy(destructor) {
+    if (constants.scope.activeWatcher) {
+        constants.scope.activeWatcher.onClear(destructor);
+    }
+}
+
+exports.onDestroy = onDestroy;

package/watch-state.min.js

@@ -1 +1 @@
-var watchState=function(t){"use strict";const e={activeWatcher:void 0,activeEvent:void 0,activeEventDeep:0};class s{constructor(t,s,a){this.watcher=t,this.ran=!1,!s&&e.activeWatcher&&e.activeWatcher.onDestroy((()=>this.destroy())),a||this.watchRun()}run(){const{ran:t}=this;return this.ran=!0,this.watcher(t)}watchRun(){const t=e.activeWatcher;e.activeWatcher=this,this.run(),e.activeWatcher=t}forceUpdate(){this.destroy(),this.watchRun()}update(){this.destroy(),e.activeEvent?e.activeEvent.add(this):this.watchRun()}destroy(){const{destructors:t}=this;t&&(this.destructors=void 0,t.forEach((t=>t())))}onDestroy(t){return this.destructors?this.destructors.push(t):this.destructors=[t],this}}class a{add(t){let{watchers:e}=this;if(e){if(e.has(t))return;e.add(t)}else e=this.watchers=new Set([t]);t.onDestroy((()=>e.delete(t)))}start(){e.activeEvent||(this.activeWatcher=e.activeWatcher,e.activeWatcher=void 0,e.activeEvent=this),e.activeEventDeep++}end(){--e.activeEventDeep||e.activeEvent!==this||(e.activeEvent=void 0,this.update(),e.activeWatcher=this.activeWatcher)}forceUpdate(){const{watchers:t}=this;this.watchers=void 0;for(const e of t)e.update()}update(){var t;(null===(t=this.watchers)||void 0===t?void 0:t.size)&&(this===i?this.forceUpdate():(i.start(),this.forceUpdate(),i.end()))}}const i=new a;class r extends a{constructor(t){super(),this.state=t}get value(){return e.activeWatcher&&this.add(e.activeWatcher),this.state}set value(t){t!==this.state&&(this.state=t,this.update())}}class h extends s{constructor(t,e,s){super(t,e,!s)}destroy(){return super.destroy()}run(){this.updated=!0,this.value=super.run()}get hasWatcher(){if(this.updated&&this.size)for(const t of this._state.watchers)if(!(t instanceof h)||t.hasWatcher)return!0}get size(){var t,e;return null===(e=null===(t=this._state)||void 0===t?void 0:t.watchers)||void 0===e?void 0:e.size}deepUpdate(){if(this.updated=!1,this.destroy(),this.size)for(const t of this._state.watchers)t.deepUpdate()}update(){this.updated&&(this.hasWatcher?this.forceUpdate():this.deepUpdate())}get state(){return this._state||(this._state=new r)}get value(){return this.updated||this.forceUpdate(),this.state.value}set value(t){this.state.value=t}}return t.Cache=h,t.Event=a,t.State=r,t.Watch=s,t.globalEvent=i,t.scope=e,Object.defineProperty(t,"__esModule",{value:!0}),t}({});
+var watchState=function(t){"use strict";class e{add(t){let{watchers:e}=this;if(e){if(e.has(t))return;e.add(t)}else e=this.watchers=new Set([t]);t.onClear((()=>e.delete(t)))}start(){a.activeEvent||(this.activeWatcher=a.activeWatcher,a.activeWatcher=void 0,a.activeEvent=this),a.activeEventDeep++}end(){--a.activeEventDeep||a.activeEvent!==this||(a.activeEvent=void 0,this.update(),a.activeWatcher=this.activeWatcher)}forceUpdate(){const{watchers:t}=this;this.watchers=void 0;for(const e of t)e.update()}update(){var t;(null===(t=this.watchers)||void 0===t?void 0:t.size)&&(this===s?this.forceUpdate():(s.start(),this.forceUpdate(),s.end()))}}const s=new e,a={activeWatcher:void 0,activeEvent:void 0,activeEventDeep:0};function i(t){a.activeWatcher&&a.activeWatcher.onClear(t)}class r{constructor(t,e,s){this.watcher=t,this.ran=!1,e||i((()=>this.destroy())),s||this.watchRun()}run(){const{ran:t}=this;return this.ran=!0,this.watcher(t)}watchRun(){const t=a.activeWatcher;a.activeWatcher=this,this.run(),a.activeWatcher=t}forceUpdate(){this.destroy(),this.watchRun()}update(){this.destroy(),a.activeEvent?a.activeEvent.add(this):this.watchRun()}destroy(){const{destructors:t}=this;t&&(this.destructors=void 0,t.forEach((t=>t())))}onClear(t){return this.destructors?this.destructors.push(t):this.destructors=[t],this}onDestroy(t){return this.onClear(t)}}class h extends e{constructor(t){super(),this.state=t}get value(){return a.activeWatcher&&this.add(a.activeWatcher),this.state}set value(t){t!==this.state&&(this.state=t,this.update())}}class c extends r{constructor(t,e,s){super(t,e,!s)}destroy(){return super.destroy()}run(){this.updated=!0,this.value=super.run()}get hasWatcher(){if(this.updated&&this.size)for(const t of this._state.watchers)if(!(t instanceof c)||t.hasWatcher)return!0}get size(){var t,e;return null===(e=null===(t=this._state)||void 0===t?void 0:t.watchers)||void 0===e?void 0:e.size}deepUpdate(){if(this.updated=!1,this.destroy(),this.size)for(const t of this._state.watchers)t.deepUpdate()}update(){this.updated&&(this.hasWatcher?this.forceUpdate():this.deepUpdate())}get state(){return this._state||(this._state=new h)}get value(){return this.updated||this.forceUpdate(),this.state.value}set value(t){this.state.value=t}}return t.Cache=c,t.Event=e,t.State=h,t.Watch=r,t.createEvent=function(t){return function(){s.start();const e=t.apply(this,arguments);return s.end(),e}},t.globalEvent=s,t.onDestroy=i,t.scope=a,Object.defineProperty(t,"__esModule",{value:!0}),t}({});

package/scope/index.d.ts

@@ -1 +0,0 @@
-export * from './scope';

package/scope/index.es6.js

@@ -1 +0,0 @@
-export { scope } from './scope.es6.js';

package/scope/index.js

@@ -1,9 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var scope = require('./scope.js');
-
-
-
-exports.scope = scope.scope;

package/scope/scope.d.ts

@@ -1,7 +0,0 @@
-import { Watch, Event } from '..';
-export interface Scope {
-    activeWatcher?: Watch;
-    activeEvent?: Event;
-    activeEventDeep: number;
-}
-export declare const scope: Scope;

package/scope/scope.es6.js

@@ -1,7 +0,0 @@
-const scope = {
-    activeWatcher: undefined,
-    activeEvent: undefined,
-    activeEventDeep: 0,
-};
-
-export { scope };