@esportsplus/reactivity 0.0.18 → 0.0.19

package/build/{reactive.js → index.browser.js}

@@ -1,4 +1,17 @@
-import { CLEAN, CHECK, DIRTY } from './symbols';
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+
+// UNUSED EXPORTS: default, effect, reactive, scheduler
+
+;// CONCATENATED MODULE: ./src/symbols.ts
+const CLEAN = 0;
+const CHECK = 1;
+const DIRTY = 2;
+
+
+;// CONCATENATED MODULE: ./src/reactive.ts
+
 let index = 0, reaction = null, queue = [], scheduled = false, schedulers = new Set, stack = null;
 function mark(instances, state) {
     if (!instances) {
@@ -186,5 +199,79 @@ const scheduler = {
         schedulers.delete(scheduler);
     }
 };
-export default Reactive;
-export { scheduler };
+/* harmony default export */ const reactive = (Reactive);
+
+
+;// CONCATENATED MODULE: ./src/methods/effect.ts
+
+/* harmony default export */ const effect = ((fn) => {
+    new reactive(fn, true);
+});
+
+;// CONCATENATED MODULE: ./src/methods/reactive.ts
+
+function factory(value) {
+    if (typeof value === 'object' && value !== null && (value.constructor === Object)) {
+        return obj(value);
+    }
+    return new reactive(value);
+}
+function fn(value) {
+    let fn = new reactive(value);
+    return (...args) => {
+        let value = fn.get();
+        if (args.length && typeof value === 'function') {
+            value = value(...args);
+        }
+        return value;
+    };
+}
+function obj(values) {
+    let lazy = {}, properties = {};
+    for (let key in values) {
+        properties[key] = {
+            get() {
+                if (!lazy[key]) {
+                    lazy[key] = factory(values[key]);
+                }
+                if (lazy[key] instanceof reactive) {
+                    return lazy[key].get();
+                }
+                return lazy[key];
+            },
+            set(value) {
+                if (!lazy[key]) {
+                    lazy[key] = factory(values[key]);
+                }
+                if (lazy[key] instanceof reactive) {
+                    lazy[key].set(value);
+                }
+                else {
+                    lazy[key] = factory(value);
+                }
+            }
+        };
+    }
+    return Object.defineProperties({}, properties);
+}
+;
+/* harmony default export */ const methods_reactive = ((value) => {
+    if (typeof value === 'function') {
+        return fn(value);
+    }
+    return factory(value);
+});
+
+;// CONCATENATED MODULE: ./src/methods/index.ts
+
+
+
+
+;// CONCATENATED MODULE: ./src/index.ts
+
+
+/* harmony default export */ const src = ({ effect: effect, reactive: methods_reactive, scheduler: scheduler });
+
+
+/******/ })()
+;

package/build/index.js

@@ -1,4 +1,277 @@
-import { scheduler } from './reactive';
-import { effect, reactive } from './methods';
-export default { effect, reactive, scheduler };
-export { effect, reactive, scheduler };
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+
+// UNUSED EXPORTS: default, effect, reactive, scheduler
+
+;// CONCATENATED MODULE: ./src/symbols.ts
+const CLEAN = 0;
+const CHECK = 1;
+const DIRTY = 2;
+
+
+;// CONCATENATED MODULE: ./src/reactive.ts
+
+let index = 0, reaction = null, queue = [], scheduled = false, schedulers = new Set, stack = null;
+function mark(instances, state) {
+    if (!instances) {
+        return;
+    }
+    for (let i = 0, n = instances.length; i < n; i++) {
+        let instance = instances[i];
+        if (instance.state < state) {
+            if (instance.effect && instance.state === CLEAN) {
+                queue.push(instance);
+                if (!scheduled) {
+                    schedule();
+                }
+            }
+            instance.state = state;
+            if (instance.observers) {
+                mark(instance.observers, CHECK);
+            }
+        }
+    }
+}
+function schedule() {
+    if (scheduled) {
+        return;
+    }
+    for (let scheduler of schedulers) {
+        scheduler.schedule();
+    }
+    scheduled = true;
+}
+async function task() {
+    let n = queue.length;
+    for (let i = 0; i < n; i++) {
+        await queue[i].get();
+    }
+    queue.splice(0, n);
+    scheduled = false;
+    if (queue.length) {
+        schedule();
+    }
+}
+class Reactive {
+    fn;
+    value;
+    effect;
+    cleanup = null;
+    observers = null;
+    sources = null;
+    state;
+    constructor(data, effect = false) {
+        this.effect = effect;
+        if (typeof data === 'function') {
+            this.fn = data;
+            this.state = DIRTY;
+            this.value = undefined;
+            if (effect) {
+                this.update();
+            }
+        }
+        else {
+            this.state = CLEAN;
+            this.value = data;
+        }
+    }
+    get() {
+        if (reaction) {
+            if (!stack && reaction.sources && reaction.sources[index] == this) {
+                index++;
+            }
+            else {
+                if (!stack) {
+                    stack = [this];
+                }
+                else {
+                    stack.push(this);
+                }
+            }
+        }
+        if (this.fn) {
+            this.sync();
+        }
+        return this.value;
+    }
+    set(value) {
+        if (this.value !== value) {
+            mark(this.observers, DIRTY);
+        }
+        this.value = value;
+    }
+    removeParentObservers() {
+        if (!this.sources) {
+            return;
+        }
+        for (let i = index; i < this.sources.length; i++) {
+            let source = this.sources[i];
+            source.observers[source.observers.findIndex((v) => v === this)] = source.observers[source.observers.length - 1];
+            source.observers.pop();
+        }
+    }
+    sync() {
+        if (this.state === CHECK && this.sources) {
+            for (let i = 0, n = this.sources.length; i < n; i++) {
+                this.sources[i].sync();
+                if (this.state === DIRTY) {
+                    break;
+                }
+            }
+        }
+        if (this.state === DIRTY) {
+            this.update();
+        }
+        this.state = CLEAN;
+    }
+    update() {
+        let previous = {
+            index: index,
+            reaction: reaction,
+            stack: stack,
+            value: this.value
+        };
+        index = 0;
+        reaction = this;
+        stack = [];
+        try {
+            if (this.cleanup) {
+                for (let i = 0, n = this.cleanup.length; i < n; i++) {
+                    this.cleanup[i](this.value);
+                }
+                this.cleanup.length = 0;
+            }
+            this.value = this.fn((fn) => {
+                if (!this.cleanup) {
+                    this.cleanup = [fn];
+                }
+                else {
+                    this.cleanup.push(fn);
+                }
+            });
+            if (stack.length) {
+                this.removeParentObservers();
+                if (this.sources && index > 0) {
+                    this.sources.length = index + stack.length;
+                    for (let i = 0; i < stack.length; i++) {
+                        this.sources[index + i] = stack[i];
+                    }
+                }
+                else {
+                    this.sources = stack;
+                }
+                for (let i = index; i < this.sources.length; i++) {
+                    let source = this.sources[i];
+                    if (!source.observers) {
+                        source.observers = [this];
+                    }
+                    else {
+                        source.observers.push(this);
+                    }
+                }
+            }
+            else if (this.sources && index < this.sources.length) {
+                this.removeParentObservers();
+                this.sources.length = index;
+            }
+        }
+        finally {
+            index = previous.index;
+            reaction = previous.reaction;
+            stack = previous.stack;
+        }
+        if (this.observers && previous.value !== this.value) {
+            for (let i = 0; i < this.observers.length; i++) {
+                this.observers[i].state = DIRTY;
+            }
+        }
+        this.state = CLEAN;
+    }
+}
+const scheduler = {
+    add: (scheduler) => {
+        scheduler.tasks.add(task);
+        schedulers.add(scheduler);
+    },
+    delete: (scheduler) => {
+        scheduler.tasks.delete(task);
+        schedulers.delete(scheduler);
+    }
+};
+/* harmony default export */ const reactive = (Reactive);
+
+
+;// CONCATENATED MODULE: ./src/methods/effect.ts
+
+/* harmony default export */ const effect = ((fn) => {
+    new reactive(fn, true);
+});
+
+;// CONCATENATED MODULE: ./src/methods/reactive.ts
+
+function factory(value) {
+    if (typeof value === 'object' && value !== null && (value.constructor === Object)) {
+        return obj(value);
+    }
+    return new reactive(value);
+}
+function fn(value) {
+    let fn = new reactive(value);
+    return (...args) => {
+        let value = fn.get();
+        if (args.length && typeof value === 'function') {
+            value = value(...args);
+        }
+        return value;
+    };
+}
+function obj(values) {
+    let lazy = {}, properties = {};
+    for (let key in values) {
+        properties[key] = {
+            get() {
+                if (!lazy[key]) {
+                    lazy[key] = factory(values[key]);
+                }
+                if (lazy[key] instanceof reactive) {
+                    return lazy[key].get();
+                }
+                return lazy[key];
+            },
+            set(value) {
+                if (!lazy[key]) {
+                    lazy[key] = factory(values[key]);
+                }
+                if (lazy[key] instanceof reactive) {
+                    lazy[key].set(value);
+                }
+                else {
+                    lazy[key] = factory(value);
+                }
+            }
+        };
+    }
+    return Object.defineProperties({}, properties);
+}
+;
+/* harmony default export */ const methods_reactive = ((value) => {
+    if (typeof value === 'function') {
+        return fn(value);
+    }
+    return factory(value);
+});
+
+;// CONCATENATED MODULE: ./src/methods/index.ts
+
+
+
+
+;// CONCATENATED MODULE: ./src/index.ts
+
+
+/* harmony default export */ const src = ({ effect: effect, reactive: methods_reactive, scheduler: scheduler });
+
+
+/******/ })()
+;

package/build/methods/reactive.d.ts

@@ -1,3 +1,3 @@
-import { Infer } from '../types';
+import { Infer } from '~/types';
 declare const _default: <T>(value: T) => Infer<T>;
 export default _default;

package/package.json

@@ -1,19 +1,19 @@
 {
     "author": "ICJR",
+    "browser": "build/index.browser.js",
     "description": "Reactivity",
     "devDependencies": {
-        "tsc-alias": "^1.8.2",
-        "typescript": "^4.9.4"
+        "@esportsplus/webpack": "^0.0.78"
     },
-    "main": "./build/index.js",
+    "main": "build/index.js",
     "name": "@esportsplus/reactivity",
     "private": false,
     "scripts": {
-        "build": "tsc && tsc-alias",
+        "build": "webpack",
         "-": "-",
         "prepare": "npm run build",
         "prepublishOnly": "npm run build"
     },
-    "types": "./build/index.d.ts",
-    "version": "0.0.18"
+    "types": "build/index.d.ts",
+    "version": "0.0.19"
 }

package/tsconfig.json

@@ -1,24 +1,10 @@
 {
     "compilerOptions": {
-        "allowJs": true,
-        "alwaysStrict": true,
-        "baseUrl": "src",
-        "declaration": true,
-        "declarationDir": "./build",
-        "lib": ["dom", "esnext"],
-        "module": "esnext",
-        "moduleResolution": "nodenext",
-        "noUnusedLocals": true,
-        "noUnusedParameters": true,
-        "outDir": "./build",
-        "paths": {
-            "~/*": ["*"]
-        },
-        "removeComments": true,
-        "resolveJsonModule": true,
-        "strict": true,
-        "target": "esnext"
+        "baseUrl": ".",
+        "declarationDir": "build",
+        "outDir": "build",
     },
     "exclude": ["node_modules"],
+    "extends": "@esportsplus/webpack/tsconfig.base.json",
     "include": ["src"]
-}
+}

package/webpack.config.ts

@@ -0,0 +1,6 @@
+import { config, entry } from '@esportsplus/webpack';
+
+
+export default config.library({
+    entry: entry.js('src/index.ts')
+});

package/build/methods/effect.js

@@ -1,4 +0,0 @@
-import Reactive from '../reactive';
-export default (fn) => {
-    new Reactive(fn, true);
-};

package/build/methods/index.js

@@ -1,3 +0,0 @@
-import effect from './effect';
-import reactive from './reactive';
-export { effect, reactive };

package/build/methods/reactive.js

@@ -1,52 +0,0 @@
-import Reactive from '../reactive';
-function factory(value) {
-    if (typeof value === 'object' && value !== null && (value.constructor === Object)) {
-        return obj(value);
-    }
-    return new Reactive(value);
-}
-function fn(value) {
-    let fn = new Reactive(value);
-    return (...args) => {
-        let value = fn.get();
-        if (args.length && typeof value === 'function') {
-            value = value(...args);
-        }
-        return value;
-    };
-}
-function obj(values) {
-    let lazy = {}, properties = {};
-    for (let key in values) {
-        properties[key] = {
-            get() {
-                if (!lazy[key]) {
-                    lazy[key] = factory(values[key]);
-                }
-                if (lazy[key] instanceof Reactive) {
-                    return lazy[key].get();
-                }
-                return lazy[key];
-            },
-            set(value) {
-                if (!lazy[key]) {
-                    lazy[key] = factory(values[key]);
-                }
-                if (lazy[key] instanceof Reactive) {
-                    lazy[key].set(value);
-                }
-                else {
-                    lazy[key] = factory(value);
-                }
-            }
-        };
-    }
-    return Object.defineProperties({}, properties);
-}
-;
-export default (value) => {
-    if (typeof value === 'function') {
-        return fn(value);
-    }
-    return factory(value);
-};

package/build/symbols.js

@@ -1,4 +0,0 @@
-const CLEAN = 0;
-const CHECK = 1;
-const DIRTY = 2;
-export { CLEAN, CHECK, DIRTY };

package/build/types.js

@@ -1 +0,0 @@
-export {};