native-document 1.0.15 → 1.0.16-8.2

package/src/data/Observable.js

@@ -1,55 +0,0 @@
-import ObservableItem from './ObservableItem';
-import Validator from "../utils/validator";
-import MemoryManager from "./MemoryManager";
-import NativeDocumentError from "../errors/NativeDocumentError";
-import {debounce} from "../utils/helpers.js";
-
-/**
- *
- * @param {*} value
- * @returns {ObservableItem}
- * @constructor
- */
-export function Observable(value) {
-    return new ObservableItem(value);
-}
-
-/**
- *
- * @param id
- * @returns {ObservableItem|null}
- */
-Observable.getById = function(id) {
-    const item = MemoryManager.getObservableById(parseInt(id));
-    if(!item) {
-        throw new NativeDocumentError('Observable.getById : No observable found with id ' + id);
-    }
-    return item;
-};
-
-/**
- *
- * @param {ObservableItem} observable
- */
-Observable.cleanup = function(observable) {
-    observable.cleanup();
-};
-
-/**
- * Enable auto cleanup of observables.
- * @param {Boolean} enable
- * @param {{interval:Boolean, threshold:number}} options
- */
-Observable.autoCleanup = function(enable = false, options = {}) {
-    if(!enable) {
-        return;
-    }
-    const { interval = 60000, threshold = 100 } = options;
-
-    window.addEventListener('beforeunload', () => {
-        MemoryManager.cleanup();
-    });
-
-    setInterval(() => MemoryManager.cleanObservables(threshold), interval);
-};
-

package/src/data/ObservableChecker.js

@@ -1,39 +0,0 @@
-/**
- *
- * @param {ObservableItem} $observable
- * @param {Function} $checker
- * @class ObservableChecker
- */
-export default function ObservableChecker($observable, $checker) {
-    this.observable = $observable;
-    this.checker = $checker;
-    this.unSubscriptions = [];
-}
-
-ObservableChecker.prototype.subscribe = function(callback) {
-    const unSubscribe = this.observable.subscribe((value) => {
-        callback && callback(this.checker(value));
-    });
-    this.unSubscriptions.push(unSubscribe);
-    return unSubscribe;
-};
-
-ObservableChecker.prototype.check = function(callback) {
-    return this.observable.check(() => callback(this.val()));
-}
-
-ObservableChecker.prototype.val = function() {
-    return this.checker && this.checker(this.observable.val());
-}
-
-ObservableChecker.prototype.set = function(value) {
-    return this.observable.set(value);
-};
-
-ObservableChecker.prototype.trigger = function() {
-    return this.observable.trigger();
-};
-
-ObservableChecker.prototype.cleanup = function() {
-    return this.observable.cleanup();
-};

package/src/data/ObservableItem.js

@@ -1,195 +0,0 @@
-import DebugManager from "../utils/debug-manager";
-import MemoryManager from "./MemoryManager";
-import NativeDocumentError from "../errors/NativeDocumentError";
-import ObservableChecker from "./ObservableChecker";
-
-/**
- *
- * @param {*} value
- * @class ObservableItem
- */
-export default function ObservableItem(value) {
-    if (value === undefined) {
-        throw new NativeDocumentError('ObservableItem requires an initial value');
-    }
-    if(value instanceof ObservableItem) {
-        throw new NativeDocumentError('ObservableItem cannot be an Observable');
-    }
-
-    this.$previousValue = value;
-    this.$currentValue = value;
-    this.$isCleanedUp = false;
-
-    this.$listeners = null;
-    this.$watchers = null;
-
-    this.$memoryId = MemoryManager.register(this);
-}
-
-Object.defineProperty(ObservableItem.prototype, '$value', {
-    get() {
-        return this.$currentValue;
-    },
-    set(value) {
-        this.set(value);
-    },
-    configurable: true,
-});
-
-ObservableItem.prototype.triggerListeners = function(operations) {
-    const $listeners = this.$listeners;
-    const $previousValue = this.$previousValue;
-    const $currentValue = this.$currentValue;
-
-    operations = operations || {};
-    if($listeners?.length) {
-        for(let i = 0, length = $listeners.length; i < length; i++) {
-            $listeners[i]($currentValue, $previousValue, operations);
-        }
-    }
-};
-
-ObservableItem.prototype.triggerWatchers = function() {
-    if(!this.$watchers) {
-        return;
-    }
-
-    const $watchers = this.$watchers;
-    const $previousValue = this.$previousValue;
-    const $currentValue = this.$currentValue;
-
-    if($watchers.has($currentValue)) {
-        const watchValueList = $watchers.get($currentValue);
-        watchValueList.forEach(itemValue => {
-            if(itemValue.ifTrue.called) {
-                return;
-            }
-            itemValue.ifTrue.callback();
-            itemValue.else.called = false;
-        })
-    }
-    if($watchers.has($previousValue)) {
-        const watchValueList = $watchers.get($previousValue);
-        watchValueList.forEach(itemValue => {
-            if(itemValue.else.called) {
-                return;
-            }
-            itemValue.else.callback();
-            itemValue.ifTrue.called = false;
-        });
-    }
-};
-
-ObservableItem.prototype.trigger = function(operations) {
-    this.triggerListeners(operations);
-    this.triggerWatchers();
-}
-
-/**
- * @param {*} data
- */
-ObservableItem.prototype.set = function(data) {
-    const newValue = (typeof data === 'function') ? data(this.$currentValue) : data;
-    if(this.$currentValue === newValue) {
-        return;
-    }
-    this.$previousValue = this.$currentValue;
-    this.$currentValue = newValue;
-    this.trigger();
-};
-
-ObservableItem.prototype.val = function() {
-    return this.$currentValue;
-};
-
-ObservableItem.prototype.disconnectAll = function() {
-    this.$listeners?.splice(0);
-    this.$previousValue = null;
-    this.$currentValue = null;
-    if(this.$watchers) {
-        for (const [_, watchValueList] of this.$watchers) {
-            for (const itemValue of watchValueList) {
-                itemValue.ifTrue.callback = null;
-                itemValue.else.callback = null;
-            }
-            watchValueList.clear();
-        }
-    }
-    this.$watchers?.clear();
-    this.$listeners = null;
-    this.$watchers = null;
-}
-ObservableItem.prototype.cleanup = function() {
-    MemoryManager.unregister(this.$memoryId);
-    this.disconnectAll();
-    this.$isCleanedUp = true;
-    delete this.$value;
-}
-
-/**
- *
- * @param {Function} callback
- * @returns {(function(): void)}
- */
-ObservableItem.prototype.subscribe = function(callback) {
-    this.$listeners = this.$listeners ?? [];
-    if (this.$isCleanedUp) {
-        DebugManager.warn('Observable subscription', '⚠️ Attempted to subscribe to a cleaned up observable.');
-        return () => {};
-    }
-    if (typeof callback !== 'function') {
-        throw new NativeDocumentError('Callback must be a function');
-    }
-
-    this.$listeners.push(callback);
-    return () => this.unsubscribe(callback);
-};
-
-ObservableItem.prototype.on = function(value, callback, elseCallback) {
-    this.$watchers = this.$watchers ?? new Map();
-
-    let watchValueList = this.$watchers.get(value);
-    if(!watchValueList) {
-        watchValueList = new Set();
-        this.$watchers.set(value, watchValueList);
-    }
-
-    let itemValue = {
-        ifTrue: { callback, called: false },
-        else: { callback: elseCallback, called: false }
-    };
-    watchValueList.add(itemValue);
-    return () => {
-        watchValueList?.delete(itemValue);
-        if(watchValueList.size === 0) {
-            this.$watchers?.delete(value);
-        }
-        watchValueList = null;
-        itemValue = null;
-    };
-};
-
-/**
- * Unsubscribe from an observable.
- * @param {Function} callback
- */
-ObservableItem.prototype.unsubscribe = function(callback) {
-    const index = this.$listeners.indexOf(callback);
-    if (index > -1) {
-        this.$listeners.splice(index, 1);
-    }
-};
-
-/**
- * Create an Observable checker instance
- * @param callback
- * @returns {ObservableChecker}
- */
-ObservableItem.prototype.check = function(callback) {
-    return new ObservableChecker(this, callback)
-};
-ObservableItem.prototype.get = ObservableItem.prototype.check;
-
-    ObservableItem.prototype.toString = function() {
-    return '{{#ObItem::(' +this.$memoryId+ ')}}';
-}

package/src/data/Store.js

@@ -1,74 +0,0 @@
-import {Observable} from "./Observable";
-
-export const Store = (function() {
-
-    const $stores = new Map();
-
-    return {
-        /**
-         * Create a new state follower and return it.
-         * @param {string} name
-         * @returns {ObservableItem}
-         */
-        use(name) {
-            const {observer: originalObserver, subscribers } = $stores.get(name);
-            const observerFollower = Observable(originalObserver.val());
-            const unSubscriber = originalObserver.subscribe(value => observerFollower.set(value));
-            const updaterUnsubscriber = observerFollower.subscribe(value => originalObserver.set(value));
-            observerFollower.destroy = () => {
-                unSubscriber();
-                updaterUnsubscriber();
-                observerFollower.cleanup();
-            };
-            subscribers.add(observerFollower);
-
-            return observerFollower;
-        },
-        /**
-         * @param {string} name
-         * @returns {ObservableItem}
-         */
-        follow(name) {
-            return this.use(name);
-        },
-        /**
-         * Create a new state and return the observer.
-         * @param {string} name
-         * @param {*} value
-         * @returns {ObservableItem}
-         */
-        create(name, value) {
-            const observer = Observable(value);
-            $stores.set(name, { observer, subscribers: new Set()});
-            return observer;
-        },
-        /**
-         * Get the observer for a state.
-         * @param {string} name
-         * @returns {null|ObservableItem}
-         */
-        get(name) {
-            const item = $stores.get(name);
-            return item ? item.observer : null;
-        },
-        /**
-         *
-         * @param {string} name
-         * @returns {{observer: ObservableItem, subscribers: Set}}
-         */
-        getWithSubscribers(name) {
-            return $stores.get(name);
-        },
-        /**
-         * Delete a state.
-         * @param {string} name
-         */
-        delete(name) {
-            const item = $stores.get(name);
-            if(!item) return;
-            item.observer.cleanup();
-            item.subscribers.forEach(follower => follower.destroy());
-            item.observer.clear();
-        }
-    };
-}());

package/src/data/observable-helpers/array.js

@@ -1,74 +0,0 @@
-import NativeDocumentError from "../../errors/NativeDocumentError";
-import {Observable} from "../Observable";
-import ObservableItem from "../ObservableItem";
-
-
-const methods = ['push', 'pop', 'shift', 'unshift', 'reverse', 'sort', 'splice'];
-
-/**
- *
- * @param {Array} target
- * @returns {ObservableItem}
- */
-Observable.array = function(target) {
-    if(!Array.isArray(target)) {
-        throw new NativeDocumentError('Observable.array : target must be an array');
-    }
-    const observer = Observable(target);
-
-    methods.forEach((method) => {
-        observer[method] = function(...values) {
-            const result = observer.val()[method](...values);
-            observer.trigger({ action: method, args: values, result });
-            return result;
-        };
-    });
-
-    observer.clear = function() {
-        observer.$value.length = 0;
-        observer.trigger({ action: 'clear' });
-        return true;
-    };
-
-    observer.remove = function(index) {
-        const deleted = observer.$value.splice(index, 1);
-        if(deleted.length === 0) {
-            return [];
-        }
-        observer.trigger({ action: 'remove', args: [index], result: deleted[0] });
-        return deleted;
-    };
-
-    observer.swap = function(indexA, indexB) {
-        const value = observer.$value;
-        const length = value.length;
-        if(length < indexA || length < indexB) {
-            return false;
-        }
-        if(indexB < indexA) {
-            const temp = indexA;
-            indexA = indexB;
-            indexB = temp;
-        }
-        const elementA = value[indexA];
-        const elementB = value[indexB]
-
-        value[indexA] = elementB;
-        value[indexB] = elementA;
-        observer.trigger({ action: 'swap', args: [indexA, indexB], result: [elementA, elementB] });
-        return true;
-    };
-
-    observer.length = function() {
-        return observer.$value.length;
-    }
-
-    const overrideMethods = ['map', 'filter', 'reduce', 'some', 'every', 'find', 'findIndex', 'concat'];
-    overrideMethods.forEach((method) => {
-        observer[method] = function(...args) {
-            return observer.val()[method](...args);
-        };
-    })
-
-    return observer;
-};

package/src/data/observable-helpers/batch.js

@@ -1,22 +0,0 @@
-import Validator from "../../utils/validator";
-import {Observable} from "../Observable";
-
-/**
- *
- * @param {Function} callback
- * @returns {Function}
- */
-Observable.batch = function(callback) {
-    const $observer = Observable(0);
-    const batch = function() {
-        if(Validator.isAsyncFunction(callback)) {
-            return (callback(...arguments)).then(() => {
-                $observer.trigger();
-            }).catch(error => { throw error; });
-        }
-        callback(...arguments);
-        $observer.trigger();
-    };
-    batch.$observer = $observer;
-    return batch;
-};

package/src/data/observable-helpers/computed.js

@@ -1,28 +0,0 @@
-import ObservableItem from "../ObservableItem";
-import Validator from "../../utils/validator";
-import NativeDocumentError from "../../errors/NativeDocumentError";
-import {Observable} from "../Observable";
-
-/**
- *
- * @param {Function} callback
- * @param {Array|Function} dependencies
- * @returns {ObservableItem}
- */
-Observable.computed = function(callback, dependencies = []) {
-    const initialValue = callback();
-    const observable = new ObservableItem(initialValue);
-    const updatedValue = () => observable.set(callback());
-
-    if(Validator.isFunction(dependencies)) {
-        if(!Validator.isObservable(dependencies.$observer)) {
-            throw new NativeDocumentError('Observable.computed : dependencies must be valid batch function');
-        }
-        dependencies.$observer.subscribe(updatedValue);
-        return observable;
-    }
-
-    dependencies.forEach(dependency => dependency.subscribe(updatedValue));
-
-    return observable;
-};

package/src/data/observable-helpers/object.js

@@ -1,111 +0,0 @@
-import Validator from "../../utils/validator";
-import {Observable} from "../Observable";
-
-/**
- *
- * @param {Object} value
- * @returns {Proxy}
- */
-Observable.init = function(value) {
-    const data = {};
-    for(const key in value) {
-        const itemValue = value[key];
-        if(Validator.isJson(itemValue)) {
-            data[key] = Observable.init(itemValue);
-            continue;
-        }
-        else if(Validator.isArray(itemValue)) {
-            data[key] = Observable.array(itemValue);
-            continue;
-        }
-        data[key] = Observable(itemValue);
-    }
-
-    const $val = function() {
-        const result = {};
-        for(const key in data) {
-            const dataItem = data[key];
-            if(Validator.isObservable(dataItem)) {
-                result[key] = dataItem.val();
-            } else if(Validator.isProxy(dataItem)) {
-                result[key] = dataItem.$value;
-            } else {
-                result[key] = dataItem;
-            }
-        }
-        return result;
-    };
-    const $clone = function() {
-
-    };
-
-    return new Proxy(data, {
-        get(target, property) {
-            if(property === '__isProxy__') {
-                return true;
-            }
-            if(property === '$value') {
-                return $val();
-            }
-            if(property === '$clone') {
-                return $clone;
-            }
-            if(target[property] !== undefined) {
-                return target[property];
-            }
-            return undefined;
-        },
-        set(target, prop, newValue) {
-            if(target[prop] !== undefined) {
-                target[prop].set(newValue);
-            }
-        }
-    })
-};
-
-/**
- * Get the value of an observable or an object of observables.
- * @param {ObservableItem|Object<ObservableItem>} data
- * @returns {{}|*|null}
- */
-Observable.value = function(data) {
-    if(Validator.isObservable(data)) {
-        return data.val();
-    }
-    if(Validator.isProxy(data)) {
-        return data.$value;
-    }
-    if(Validator.isArray(data)) {
-        const result = [];
-        data.forEach(item => {
-            result.push(Observable.value(item));
-        });
-        return result;
-    }
-    return data;
-};
-
-
-Observable.update = function($target, data) {
-    for(const key in data) {
-        const targetItem = $target[key];
-        const newValue = data[key];
-
-        if(Validator.isObservable(targetItem)) {
-            if(Validator.isArray(newValue)) {
-                Observable.update(targetItem, newValue);
-                continue;
-            }
-            targetItem.set(newValue);
-            continue;
-        }
-        if(Validator.isProxy(targetItem)) {
-            Observable.update(targetItem, newValue);
-            continue;
-        }
-        $target[key] = newValue;
-    }
-};
-
-Observable.object = Observable.init;
-Observable.json = Observable.init;