native-document 1.0.152 → 1.0.154

package/src/core/data/ObservableObject.js

@@ -1,7 +1,7 @@
 import ObservableItem from "./ObservableItem";
 import Validator from "../utils/validator";
 import {nextTick} from "../utils/helpers";
-import {Observable} from "./Observable";
+import ObservableArray from "./ObservableArray";
 
 export const ObservableObject = function(target, configs) {
     ObservableItem.call(this, target);
@@ -43,24 +43,24 @@ ObservableObject.prototype.$load = function(initialValue) {
             if(configs?.deep !== false) {
                 const mappedItemValue = itemValue.map(item => {
                     if(Validator.isJson(item)) {
-                        return Observable.json(item, configs);
+                        return new ObservableObject(item, configs);
                     }
                     if(Validator.isArray(item)) {
-                        return Observable.array(item, configs);
+                        return new ObservableArray(item, configs);
                     }
-                    return Observable(item, configs);
+                    return new ObservableItem(item, configs);
                 });
-                this.$observables[key] = Observable.array(mappedItemValue, configs);
+                this.$observables[key] = new ObservableArray(mappedItemValue, configs);
                 continue;
             }
-            this.$observables[key] = Observable.array(itemValue, configs);
+            this.$observables[key] = new ObservableArray(itemValue, configs);
             continue;
         }
         if(Validator.isObservable(itemValue) || Validator.isProxy(itemValue)) {
             this.$observables[key] = itemValue;
             continue;
         }
-        this.$observables[key] = (typeof itemValue === 'object') ? Observable.object(itemValue, configs) : Observable(itemValue, configs);
+        this.$observables[key] = (typeof itemValue === 'object') ? new ObservableObject(itemValue, configs) : new ObservableItem(itemValue, configs);
     }
 };
 
@@ -122,9 +122,9 @@ ObservableObject.prototype.set = function(newData) {
             if(Validator.isObservable(firstElementFromOriginalValue) || Validator.isProxy(firstElementFromOriginalValue)) {
                 const newValues = newValue.map(item => {
                     if(Validator.isProxy(firstElementFromOriginalValue)) {
-                        return Observable.init(item, configs);
+                        return new ObservableObject(item, configs);
                     }
-                    return Observable(item, configs);
+                    return ObservableItem(item, configs);
                 });
                 targetItem.set(newValues);
                 continue;
@@ -152,7 +152,7 @@ ObservableObject.prototype.keys = function() {
 };
 ObservableObject.prototype.$keys = ObservableObject.prototype.keys;
 ObservableObject.prototype.clone = function() {
-    return Observable.init(this.val(), this.configs);
+    return new ObservableObject(this.val(), this.configs);
 };
 ObservableObject.prototype.$clone = ObservableObject.prototype.clone;
 ObservableObject.prototype.reset = function() {

package/src/core/data/observable-helpers/observable.is-to.js

@@ -1,7 +1,6 @@
 import ObservableItem from "../ObservableItem";
-import { Observable } from "../Observable";
 
-const $computed = (fn, dependencies) => Observable.computed(fn, dependencies);
+const $computed = (fn, dependencies) => ObservableItem.computed(fn, dependencies);
 const $checker = (obs, fn) => obs.transform(fn);
 
 //

package/src/core/data/observable-helpers/observable.prototypes.js

@@ -15,7 +15,6 @@ import ObservableItem from "../ObservableItem";
 import ObservableChecker from "../ObservableChecker";
 import {Formatters} from "../../utils/formatters";
 import NativeDocumentError from "../../errors/NativeDocumentError";
-import {Observable} from "../Observable";
 
 ObservableItem.prototype.when = function(value) {
     return new ObservableWhen(this, value);
@@ -113,7 +112,7 @@ ObservableItem.prototype.format = function(type, options = {}) {
     const formatter = Formatters[type];
     const localeObservable = Formatters.locale;
 
-    return Observable.computed(() => formatter(self.val(), localeObservable.val(), options),
+    return ObservableItem.computed(() => formatter(self.val(), localeObservable.val(), options),
         [self, localeObservable]
     );
 };

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

@@ -1,22 +0,0 @@
-import {Observable} from "../Observable";
-import ObservableArray from "../ObservableArray";
-
-
-/**
- * Creates an observable array with reactive array methods.
- * All mutations trigger updates automatically.
- *
- * @param {Array} [target=[]] - Initial array value
- * @param {Object|null} [configs=null] - Configuration options
- * // @param {boolean} [configs.propagation=true] - Whether to propagate changes to parent observables
- * // @param {boolean} [configs.deep=false] - Whether to make nested objects observable
- * @param {boolean} [configs.reset=false] - Whether to store initial value for reset()
- * @returns {ObservableArray} An observable array with reactive methods
- * @example
- * const items = Observable.array([1, 2, 3]);
- * items.push(4); // Triggers update
- * items.subscribe((arr) => console.log(arr));
- */
-Observable.array = function(target = [], configs = null) {
-    return new ObservableArray(target, configs);
-};

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

@@ -1,22 +0,0 @@
-import Validator from "../../../core/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/core/data/observable-helpers/computed.js

@@ -1,55 +0,0 @@
-import ObservableItem from "../ObservableItem";
-import Validator from "../../utils/validator";
-import NativeDocumentError from "../..//errors/NativeDocumentError";
-import {Observable} from "../Observable";
-import PluginsManager from "../../utils/plugins-manager";
-import {nextTick} from "../../utils/helpers";
-
-/**
- * Creates a computed observable that automatically updates when its dependencies change.
- * The callback is re-executed whenever any dependency observable changes.
- *
- * @param {Function} callback - Function that returns the computed value
- * @param {Array<ObservableItem|ObservableChecker|ObservableProxy>|Function} [dependencies=[]] - Array of observables to watch, or batch function
- * @returns {ObservableItem} A new observable that updates automatically
- * @example
- * const firstName = Observable('John');
- * const lastName = Observable('Doe');
- * const fullName = Observable.computed(
- *   () => `${firstName.val()} ${lastName.val()}`,
- *   [firstName, lastName]
- * );
- *
- * // With batch function
- * const batch = Observable.batch(() => { ...  });
- * const computed = Observable.computed(() => { ... }, batch);
-*/
-Observable.computed = function(callback, dependencies = []) {
-    const initialValue = callback();
-    const observable = new ObservableItem(initialValue);
-    const getValues = () => dependencies.map((item) => item.val());
-    const updatedValue = nextTick(() => observable.set(callback(...getValues())));
-    if(process.env.NODE_ENV === 'development') {
-        PluginsManager.emit('CreateObservableComputed', observable, dependencies);
-    }
-
-    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 => {
-        if(Validator.isProxy(dependency)) {
-            dependency.$observables.forEach((observable) => {
-                observable.subscribe(updatedValue);
-            });
-            return;
-        }
-        dependency.subscribe(updatedValue);
-    });
-
-    return observable;
-};

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

@@ -1,48 +0,0 @@
-import Validator from "../../utils/validator";
-import {Observable} from "../Observable";
-import {ObservableObject} from "../ObservableObject";
-import ObservableItem from "../ObservableItem";
-
-
-Observable.init = function(initialValue, configs = null) {
-    return new ObservableObject(initialValue, configs)
-};
-
-/**
- *
- * @param {any[]} data
- * @return Proxy[]
- */
-Observable.arrayOfObject = function(data) {
-    return data.map(item => Observable.object(item));
-}
-
-/**
- * Get the value of an observable or an object of observables.
- * @param {ObservableItem|Object<ObservableItem>} data
- * @returns {{}|*|null}
- */
-Observable.value = function(data) {
-    if(data?.__$isObservableArray) {
-        const result = [];
-        for(let i = 0, length = data.length; i < length; i++) {
-            const item = data.at(i);
-            result.push(Observable.value(item));
-        }
-        return result;
-    }
-    if(data?.__$Observable) {
-        return data.val();
-    }
-    if(Validator.isProxy(data)) {
-        return data.$value;
-    }
-    return data;
-};
-
-ObservableItem.prototype.resolve = function () {
-    return Observable.value(this);
-};
-
-Observable.object = Observable.init;
-Observable.json = Observable.init;