native-document 1.0.68 → 1.0.70

package/dist/native-document.dev.js

@@ -1,10 +1,10 @@
 var NativeDocument = (function (exports) {
     'use strict';
 
-    let DebugManager$1 = {};
+    let DebugManager = {};
 
     {
-        DebugManager$1 = {
+        DebugManager = {
             enabled: false,
 
             enable() {
@@ -35,7 +35,7 @@ var NativeDocument = (function (exports) {
         };
 
     }
-    var DebugManager = DebugManager$1;
+    var DebugManager$1 = DebugManager;
 
     const MemoryManager = (function() {
 
@@ -84,7 +84,7 @@ var NativeDocument = (function (exports) {
                     }
                 }
                 if (cleanedCount > 0) {
-                    DebugManager.log('Memory Auto Clean', `🧹 Cleaned ${cleanedCount} orphaned observables`);
+                    DebugManager$1.log('Memory Auto Clean', `🧹 Cleaned ${cleanedCount} orphaned observables`);
                 }
             }
         };
@@ -207,7 +207,7 @@ var NativeDocument = (function (exports) {
                         try{
                             callback.call(plugin, ...data);
                         } catch (error) {
-                            DebugManager.error('Plugin Manager', `Error in plugin ${plugin.$name} for event ${eventName}`, error);
+                            DebugManager$1.error('Plugin Manager', `Error in plugin ${plugin.$name} for event ${eventName}`, error);
                         }
                     }
                 }
@@ -343,6 +343,7 @@ var NativeDocument = (function (exports) {
 
         operations = operations || DEFAULT_OPERATIONS;
         for(let i = 0, length = $listeners.length; i < length; i++) {
+            $listeners[i];
             $listeners[i]($currentValue, $previousValue, operations);
         }
     };
@@ -360,6 +361,7 @@ var NativeDocument = (function (exports) {
             callback.set ? callback.set(value) : callback(value);
         });
     };
+
     ObservableItem.prototype.triggerWatchers = function() {
         if(!this.$watchers) {
             return;
@@ -459,7 +461,7 @@ var NativeDocument = (function (exports) {
     ObservableItem.prototype.subscribe = function(callback, target = null) {
         this.$listeners = this.$listeners ?? [];
         if (this.$isCleanedUp) {
-            DebugManager.warn('Observable subscription', '⚠️ Attempted to subscribe to a cleaned up observable.');
+            DebugManager$1.warn('Observable subscription', '⚠️ Attempted to subscribe to a cleaned up observable.');
             return () => {};
         }
         if (typeof callback !== 'function') {
@@ -1000,7 +1002,7 @@ var NativeDocument = (function (exports) {
             }
             {
                 if (this[name] && !this.$localExtensions.has(name)) {
-                    DebugManager.warn('NDElement.extend', `Method "${name}" already exists and will be overwritten`);
+                    DebugManager$1.warn('NDElement.extend', `Method "${name}" already exists and will be overwritten`);
                 }
                 this.$localExtensions.set(name, method);
             }
@@ -1034,17 +1036,17 @@ var NativeDocument = (function (exports) {
             const method = methods[name];
 
             if (typeof method !== 'function') {
-                DebugManager.warn('NDElement.extend', `"${name}" is not a function, skipping`);
+                DebugManager$1.warn('NDElement.extend', `"${name}" is not a function, skipping`);
                 continue;
             }
 
             if (protectedMethods.has(name)) {
-                DebugManager.error('NDElement.extend', `Cannot override protected method "${name}"`);
+                DebugManager$1.error('NDElement.extend', `Cannot override protected method "${name}"`);
                 throw new NativeDocumentError(`Cannot override protected method "${name}"`);
             }
 
             if (NDElement.prototype[name]) {
-                DebugManager.warn('NDElement.extend', `Overwriting existing prototype method "${name}"`);
+                DebugManager$1.warn('NDElement.extend', `Overwriting existing prototype method "${name}"`);
             }
 
             NDElement.prototype[name] = method;
@@ -1190,7 +1192,7 @@ var NativeDocument = (function (exports) {
             const foundReserved = Object.keys(attributes).filter(key => reserved.includes(key));
 
             if (foundReserved.length > 0) {
-                DebugManager.warn('Validator', `Reserved attributes found: ${foundReserved.join(', ')}`);
+                DebugManager$1.warn('Validator', `Reserved attributes found: ${foundReserved.join(', ')}`);
             }
 
             return attributes;
@@ -1238,7 +1240,7 @@ var NativeDocument = (function (exports) {
         element.appendChild = function(child, before = null) {
             const parent = anchorEnd.parentNode;
             if(!parent) {
-                DebugManager.error('Anchor', 'Anchor : parent not found', child);
+                DebugManager$1.error('Anchor', 'Anchor : parent not found', child);
                 return;
             }
             before = before ?? anchorEnd;
@@ -1356,18 +1358,18 @@ var NativeDocument = (function (exports) {
      * @returns {ObservableItem}
      * @constructor
      */
-    function Observable(value, configs = null) {
+    function Observable$1(value, configs = null) {
         return new ObservableItem(value, configs);
     }
 
-    const $ = Observable;
-    const obs = Observable;
+    const $ = Observable$1;
+    const obs = Observable$1;
 
     /**
      *
      * @param {string} propertyName
      */
-    Observable.useValueProperty = function(propertyName = 'value') {
+    Observable$1.useValueProperty = function(propertyName = 'value') {
         Object.defineProperty(ObservableItem.prototype, propertyName, {
             get() {
                 return this.$currentValue;
@@ -1385,7 +1387,7 @@ var NativeDocument = (function (exports) {
      * @param id
      * @returns {ObservableItem|null}
      */
-    Observable.getById = function(id) {
+    Observable$1.getById = function(id) {
         const item = MemoryManager.getObservableById(parseInt(id));
         if(!item) {
             throw new NativeDocumentError('Observable.getById : No observable found with id ' + id);
@@ -1397,7 +1399,7 @@ var NativeDocument = (function (exports) {
      *
      * @param {ObservableItem} observable
      */
-    Observable.cleanup = function(observable) {
+    Observable$1.cleanup = function(observable) {
         observable.cleanup();
     };
 
@@ -1406,7 +1408,7 @@ var NativeDocument = (function (exports) {
      * @param {Boolean} enable
      * @param {{interval:Boolean, threshold:number}} options
      */
-    Observable.autoCleanup = function(enable = false, options = {}) {
+    Observable$1.autoCleanup = function(enable = false, options = {}) {
         if(!enable) {
             return;
         }
@@ -1554,7 +1556,7 @@ var NativeDocument = (function (exports) {
                     continue;
                 }
                 const observables = value.filter(item => Validator.isObservable(item));
-                value = Observable.computed(() => {
+                value = Observable$1.computed(() => {
                     return value.map(item => Validator.isObservable(item) ? item.val() : item).join(' ') || ' ';
                 }, observables);
             }
@@ -2203,7 +2205,7 @@ var NativeDocument = (function (exports) {
     String.prototype.use = function(args) {
         const value = this;
 
-        return Observable.computed(() => {
+        return Observable$1.computed(() => {
             return value.replace(/\$\{(.*?)}/g, (match, key) => {
                 const data = args[key];
                 if(Validator.isObservable(data)) {
@@ -2223,7 +2225,7 @@ var NativeDocument = (function (exports) {
                 return value;
             }
             const [_, id] = value.match(/\{\{#ObItem::\(([0-9]+)\)\}\}/);
-            return Observable.getById(id);
+            return Observable$1.getById(id);
         });
     };
 
@@ -2321,6 +2323,357 @@ var NativeDocument = (function (exports) {
         });
     };
 
+    function toDate(value) {
+        if (value instanceof Date) return value;
+        return new Date(value);
+    }
+
+    function isSameDay(date1, date2) {
+        const d1 = toDate(date1);
+        const d2 = toDate(date2);
+        return d1.getFullYear() === d2.getFullYear() &&
+            d1.getMonth() === d2.getMonth() &&
+            d1.getDate() === d2.getDate();
+    }
+
+    function getSecondsOfDay(date) {
+        const d = toDate(date);
+        return (d.getHours() * 3600) + (d.getMinutes() * 60) + d.getSeconds();
+    }
+
+    function createFilter(observableOrValue, callbackFn){
+        const isObservable = Validator.isObservable(observableOrValue);
+
+        return {
+            dependencies: isObservable ? observableOrValue : null,
+            callback: (value) => callbackFn(value, isObservable ? observableOrValue.val() : observableOrValue)
+        };
+    }
+
+    function createMultiSourceFilter(sources, callbackFn){
+        const observables = sources.filter(Validator.isObservable);
+
+        const getValues = () => sources.map(src =>
+            Validator.isObservable(src) ? src.val() : src
+        );
+
+        return {
+            dependencies: observables.length > 0 ? observables : null,
+            callback: (value) => callbackFn(value, getValues())
+        };
+    }
+
+    function equals(observableOrValue){
+        return createFilter(observableOrValue, (value, target) => value === target);
+    }
+
+    function notEquals(observableOrValue){
+        return createFilter(observableOrValue, (value, target) => value !== target);
+    }
+
+    function greaterThan(observableOrValue){
+        return createFilter(observableOrValue, (value, target) => value > target);
+    }
+
+    function greaterThanOrEqual(observableOrValue){
+        return createFilter(observableOrValue, (value, target) => value >= target);
+    }
+
+    function lessThan(observableOrValue){
+        return createFilter(observableOrValue, (value, target) => value < target);
+    }
+
+    function lessThanOrEqual(observableOrValue){
+        return createFilter(observableOrValue, (value, target) => value <= target);
+    }
+
+    function between(minObservableOrValue, maxObservableOrValue){
+        return createMultiSourceFilter(
+            [minObservableOrValue, maxObservableOrValue],
+            (value, [min, max]) => value >= min && value <= max
+        );
+    }
+
+    function inArray(observableOrArray){
+        return createFilter(observableOrArray, (value, arr) => arr.includes(value));
+    }
+
+    function notIn(observableOrArray){
+        return createFilter(observableOrArray, (value, arr) => !arr.includes(value));
+    }
+
+    function isEmpty(observableOrValue = true){
+        return createFilter(observableOrValue, (value, shouldBeEmpty) => {
+            const isActuallyEmpty = !value || value === '' ||
+                (Array.isArray(value) && value.length === 0);
+
+            return shouldBeEmpty ? isActuallyEmpty : !isActuallyEmpty;
+        });
+    }
+
+    function isNotEmpty(observableOrValue = true){
+        return createFilter(observableOrValue, (value, shouldBeNotEmpty) => {
+            const isActuallyNotEmpty = !!value && value !== '' &&
+                (!Array.isArray(value) || value.length > 0);
+
+            return shouldBeNotEmpty ? isActuallyNotEmpty : !isActuallyNotEmpty;
+        });
+    }
+
+    function match(patternObservableOrValue, asRegexObservableOrValue = true, flagsObservableOrValue = ''){
+        return createMultiSourceFilter(
+            [patternObservableOrValue, asRegexObservableOrValue, flagsObservableOrValue],
+            (value, [pattern, asRegex, flags]) => {
+                if (!pattern) return true;
+
+                if (asRegex){
+                    try {
+                        const regex = new RegExp(pattern, flags);
+                        return regex.test(String(value));
+                    } catch (error){
+                        console.warn('Invalid regex pattern:', pattern, error);
+                        return false;
+                    }
+                }
+
+                if (!flags || flags === ''){
+                    return String(value).toLowerCase().includes(String(pattern).toLowerCase());
+                }
+                return String(value).includes(String(pattern));
+            }
+        );
+    }
+
+    function and(...filters){
+        const dependencies = filters
+            .flatMap(f => f.dependencies ? (Array.isArray(f.dependencies) ? f.dependencies : [f.dependencies]) : [])
+            .filter(Validator.isObservable);
+
+        return {
+            dependencies: dependencies.length > 0 ? dependencies : null,
+            callback: (value) => filters.every(f => f.callback(value))
+        };
+    }
+
+    function or(...filters){
+        const dependencies = filters
+            .flatMap(f => f.dependencies ? (Array.isArray(f.dependencies) ? f.dependencies : [f.dependencies]) : [])
+            .filter(Validator.isObservable);
+
+        return {
+            dependencies: dependencies.length > 0 ? dependencies : null,
+            callback: (value) => filters.some(f => f.callback(value))
+        };
+    }
+
+    function not(filter){
+        return {
+            dependencies: filter.dependencies,
+            callback: (value) => !filter.callback(value)
+        };
+    }
+
+    function custom(callbackFn, ...observables){
+        const dependencies = observables.filter(Validator.isObservable);
+
+        return {
+            dependencies: dependencies.length > 0 ? dependencies : null,
+            callback: (value) => {
+                const values = observables.map(o =>
+                    Validator.isObservable(o) ? o.val() : o
+                );
+                return callbackFn(value, ...values);
+            }
+        };
+    }
+
+    const gt = greaterThan;
+    const gte = greaterThanOrEqual;
+    const lt = lessThan;
+    const lte = lessThanOrEqual;
+    const eq = equals;
+    const neq = notEquals;
+    const all = and;
+    const any = or;
+
+    const dateEquals = (observableOrValue) => {
+        return createFilter(observableOrValue, (value, target) => {
+            if (!value || !target) return false;
+            return isSameDay(value, target);
+        });
+    };
+
+    const dateBefore = (observableOrValue) => {
+        return createFilter(observableOrValue, (value, target) => {
+            if (!value || !target) return false;
+            return toDate(value) < toDate(target);
+        });
+    };
+
+    const dateAfter = (observableOrValue) => {
+        return createFilter(observableOrValue, (value, target) => {
+            if (!value || !target) return false;
+            return toDate(value) > toDate(target);
+        });
+    };
+
+    const dateBetween = (startObservableOrValue, endObservableOrValue) => {
+        return createMultiSourceFilter(
+            [startObservableOrValue, endObservableOrValue],
+            (value, [start, end]) => {
+                if (!value || !start || !end) return false;
+                const date = toDate(value);
+                return date >= toDate(start) && date <= toDate(end);
+            }
+        );
+    };
+
+    const timeEquals = (observableOrValue) => {
+        return createFilter(observableOrValue, (value, target) => {
+            if (!value || !target) return false;
+            const d1 = toDate(value);
+            const d2 = toDate(target);
+            return d1.getHours() === d2.getHours() &&
+                d1.getMinutes() === d2.getMinutes() &&
+                d1.getSeconds() === d2.getSeconds();
+        });
+    };
+
+    const timeAfter = (observableOrValue) => {
+        return createFilter(observableOrValue, (value, target) => {
+            if (!value || !target) return false;
+            return getSecondsOfDay(value) > getSecondsOfDay(target);
+        });
+    };
+
+    const timeBefore = (observableOrValue) => {
+        return createFilter(observableOrValue, (value, target) => {
+            if (!value || !target) return false;
+            return getSecondsOfDay(value) < getSecondsOfDay(target);
+        });
+    };
+
+    const timeBetween = (startObservableOrValue, endObservableOrValue) => {
+        return createMultiSourceFilter([startObservableOrValue, endObservableOrValue],
+            (value, [start, end]) => {
+                if (!value || !start || !end) return false;
+                const date = getSecondsOfDay(value);
+                return date >= getSecondsOfDay(start) && date <= getSecondsOfDay(end);
+            }
+        );
+    };
+
+    const dateTimeEquals = (observableOrValue) => {
+        return createFilter(observableOrValue, (value, target) => {
+            if (!value || !target) return false;
+            return toDate(value).getTime() === toDate(target).getTime();
+        });
+    };
+
+    const dateTimeAfter = (observableOrValue) => {
+        return createFilter(observableOrValue, (value, target) => {
+            if (!value || !target) return false;
+            return toDate(value) > toDate(target);
+        });
+    };
+
+    const dateTimeBefore = (observableOrValue) => {
+        return createFilter(observableOrValue, (value, target) => {
+            if (!value || !target) return false;
+            return toDate(value) < toDate(target);
+        });
+    };
+
+    const dateTimeBetween = (startObservableOrValue, endObservableOrValue) => {
+        return createMultiSourceFilter([startObservableOrValue, endObservableOrValue], (value, [start, end]) => {
+            if (!value || !start || !end) return false;
+            const date = toDate(value);
+            return date >= toDate(start) && date <= toDate(end);
+        });
+    };
+
+    function includes(observableOrValue, caseSensitive = false){
+        return createFilter(observableOrValue, (value, query) => {
+            if (!value) return false;
+            if (!query) return true;
+            if (!caseSensitive){
+                return String(value).toLowerCase().includes(String(query).toLowerCase());
+            }
+            return String(value).includes(String(query));
+        });
+    }
+
+    const contains = includes;
+
+    function startsWith(observableOrValue, caseSensitive = false){
+        return createFilter(observableOrValue, (value, query) => {
+            if (!query) return true;
+            if (!caseSensitive){
+                return String(value).toLowerCase().startsWith(String(query).toLowerCase());
+            }
+            return String(value).startsWith(String(query));
+        });
+    }
+
+    function endsWith(observableOrValue, caseSensitive = false){
+        return createFilter(observableOrValue, (value, query) => {
+            if (!query) return true;
+            if (!caseSensitive){
+                return String(value).toLowerCase().endsWith(String(query).toLowerCase());
+            }
+            return String(value).endsWith(String(query));
+        });
+    }
+
+    var index = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        all: all,
+        and: and,
+        any: any,
+        between: between,
+        contains: contains,
+        createFilter: createFilter,
+        createMultiSourceFilter: createMultiSourceFilter,
+        custom: custom,
+        dateAfter: dateAfter,
+        dateBefore: dateBefore,
+        dateBetween: dateBetween,
+        dateEquals: dateEquals,
+        dateTimeAfter: dateTimeAfter,
+        dateTimeBefore: dateTimeBefore,
+        dateTimeBetween: dateTimeBetween,
+        dateTimeEquals: dateTimeEquals,
+        endsWith: endsWith,
+        eq: eq,
+        equals: equals,
+        getSecondsOfDay: getSecondsOfDay,
+        greaterThan: greaterThan,
+        greaterThanOrEqual: greaterThanOrEqual,
+        gt: gt,
+        gte: gte,
+        inArray: inArray,
+        includes: includes,
+        isEmpty: isEmpty,
+        isNotEmpty: isNotEmpty,
+        isSameDay: isSameDay,
+        lessThan: lessThan,
+        lessThanOrEqual: lessThanOrEqual,
+        lt: lt,
+        lte: lte,
+        match: match,
+        neq: neq,
+        not: not,
+        notEquals: notEquals,
+        notIn: notIn,
+        or: or,
+        startsWith: startsWith,
+        timeAfter: timeAfter,
+        timeBefore: timeBefore,
+        timeBetween: timeBetween,
+        timeEquals: timeEquals,
+        toDate: toDate
+    });
+
     const mutationMethods = ['push', 'pop', 'shift', 'unshift', 'reverse', 'sort', 'splice'];
     const noMutationMethods = ['map', 'forEach', 'filter', 'reduce', 'some', 'every', 'find', 'findIndex', 'concat', 'includes', 'indexOf'];
 
@@ -2331,7 +2684,7 @@ var NativeDocument = (function (exports) {
      * @param {{propagation: boolean, deep: boolean, reset: boolean}|null} configs
      * @constructor
      */
-    const ObservableArray = function (target, configs) {
+    const ObservableArray = function (target, configs = null) {
         if(!Array.isArray(target)) {
             throw new NativeDocumentError('Observable.array : target must be an array');
         }
@@ -2433,13 +2786,80 @@ var NativeDocument = (function (exports) {
         this.trigger({ action: 'populate', args: [this.$currentValue, iteration, callback] });
     };
 
+
+    ObservableArray.prototype.where = function(predicates) {
+        const sourceArray = this;
+        const observableDependencies = [sourceArray];
+        const filterCallbacks = {};
+
+        for (const [key, rawPredicate] of Object.entries(predicates)) {
+            const predicate = Validator.isObservable(rawPredicate) ? match(rawPredicate, false) : rawPredicate;
+            if (predicate && typeof predicate === 'object' && 'callback' in predicate) {
+                filterCallbacks[key] = predicate.callback;
+
+                if (predicate.dependencies) {
+                    const deps = Array.isArray(predicate.dependencies)
+                        ? predicate.dependencies
+                        : [predicate.dependencies];
+                    observableDependencies.push(...deps);
+                }
+            } else if(typeof predicate === 'function') {
+                filterCallbacks[key] = predicate;
+            } else {
+                filterCallbacks[key] = (value) => value === predicate;
+            }
+        }
+
+        const viewArray = Observable.array();
+
+        const filters = Object.entries(filterCallbacks);
+        const updateView = () => {
+            const filtered = sourceArray.val().filter(item => {
+                for (const [key, callback] of filters) {
+                    if(key === '_') {
+                        if (!callback(item)) return false;
+                    } else {
+                        if (!callback(item[key])) return false;
+                    }
+                }
+                return true;
+            });
+
+            viewArray.set(filtered);
+        };
+
+        observableDependencies.forEach(dep => dep.subscribe(updateView));
+
+        updateView();
+
+        return viewArray;
+    };
+
+    ObservableArray.prototype.whereSome = function(fields, filter) {
+        return this.where({
+            _: {
+                dependencies: filter.dependencies,
+                callback: (item) => fields.some(field => filter.callback(item[field]))
+            }
+        });
+    };
+
+    ObservableArray.prototype.whereEvery = function(fields, filter) {
+        return this.where({
+            _: {
+                dependencies: filter.dependencies,
+                callback: (item) => fields.every(field => filter.callback(item[field]))
+            }
+        });
+    };
+
     /**
      *
      * @param {Array} target
      * @param {{propagation: boolean, deep: boolean, reset: boolean}|null} configs
      * @returns {ObservableArray}
      */
-    Observable.array = function(target, configs = null) {
+    Observable$1.array = function(target = [], configs = null) {
         return new ObservableArray(target, configs);
     };
 
@@ -2448,8 +2868,8 @@ var NativeDocument = (function (exports) {
      * @param {Function} callback
      * @returns {Function}
      */
-    Observable.batch = function(callback) {
-        const $observer = Observable(0);
+    Observable$1.batch = function(callback) {
+        const $observer = Observable$1(0);
         const batch = function() {
             if(Validator.isAsyncFunction(callback)) {
                 return (callback(...arguments)).then(() => {
@@ -2507,7 +2927,7 @@ var NativeDocument = (function (exports) {
      * @param {{propagation: boolean, deep: boolean, reset: boolean}|null} configs
      * @returns {Proxy}
      */
-    Observable.init = function(initialValue, configs = null) {
+    Observable$1.init = function(initialValue, configs = null) {
         const data = {};
         for(const key in initialValue) {
             const itemValue = initialValue[key];
@@ -2515,24 +2935,24 @@ var NativeDocument = (function (exports) {
                 if(configs?.deep !== false) {
                     const mappedItemValue = itemValue.map(item => {
                         if(Validator.isJson(item)) {
-                            return Observable.json(item, configs);
+                            return Observable$1.json(item, configs);
                         }
                         if(Validator.isArray(item)) {
-                            return Observable.array(item, configs);
+                            return Observable$1.array(item, configs);
                         }
-                        return Observable(item, configs);
+                        return Observable$1(item, configs);
                     });
-                    data[key] = Observable.array(mappedItemValue, configs);
+                    data[key] = Observable$1.array(mappedItemValue, configs);
                     continue;
                 }
-                data[key] = Observable.array(itemValue, configs);
+                data[key] = Observable$1.array(itemValue, configs);
                 continue;
             }
             if(Validator.isObservable(itemValue) || Validator.isProxy(itemValue)) {
                 data[key] = itemValue;
                 continue;
             }
-            data[key] = Observable(itemValue, configs);
+            data[key] = Observable$1(itemValue, configs);
         }
 
         const $reset = () => {
@@ -2544,10 +2964,10 @@ var NativeDocument = (function (exports) {
 
         const $val = () => ObservableObjectValue(data);
 
-        const $clone = () => Observable.init($val(), configs);
+        const $clone = () => Observable$1.init($val(), configs);
 
         const $updateWith = (values) => {
-            Observable.update(proxy, values);
+            Observable$1.update(proxy, values);
         };
 
         const $get = (key) => ObservableGet(data, key);
@@ -2585,8 +3005,8 @@ var NativeDocument = (function (exports) {
      * @param {any[]} data
      * @return Proxy[]
      */
-    Observable.arrayOfObject = function(data) {
-        return data.map(item => Observable.object(item));
+    Observable$1.arrayOfObject = function(data) {
+        return data.map(item => Observable$1.object(item));
     };
 
     /**
@@ -2594,7 +3014,7 @@ var NativeDocument = (function (exports) {
      * @param {ObservableItem|Object<ObservableItem>} data
      * @returns {{}|*|null}
      */
-    Observable.value = function(data) {
+    Observable$1.value = function(data) {
         if(Validator.isObservable(data)) {
             return data.val();
         }
@@ -2605,7 +3025,7 @@ var NativeDocument = (function (exports) {
             const result = [];
             for(let i = 0, length = data.length; i < length; i++) {
                 const item = data[i];
-                result.push(Observable.value(item));
+                result.push(Observable$1.value(item));
             }
             return result;
         }
@@ -2613,7 +3033,7 @@ var NativeDocument = (function (exports) {
     };
 
 
-    Observable.update = function($target, newData) {
+    Observable$1.update = function($target, newData) {
         const data = Validator.isProxy(newData) ? newData.$value : newData;
         const configs = $target.configs;
 
@@ -2628,9 +3048,9 @@ var NativeDocument = (function (exports) {
                     if(Validator.isObservable(firstElementFromOriginalValue) || Validator.isProxy(firstElementFromOriginalValue)) {
                         const newValues = newValue.map(item => {
                             if(Validator.isProxy(firstElementFromOriginalValue)) {
-                                return Observable.init(item, configs);
+                                return Observable$1.init(item, configs);
                             }
-                            return Observable(item, configs);
+                            return Observable$1(item, configs);
                         });
                         targetItem.set(newValues);
                         continue;
@@ -2642,15 +3062,15 @@ var NativeDocument = (function (exports) {
                 continue;
             }
             if(Validator.isProxy(targetItem)) {
-                Observable.update(targetItem, newValue);
+                Observable$1.update(targetItem, newValue);
                 continue;
             }
             $target[key] = newValue;
         }
     };
 
-    Observable.object = Observable.init;
-    Observable.json = Observable.init;
+    Observable$1.object = Observable$1.init;
+    Observable$1.json = Observable$1.init;
 
     /**
      *
@@ -2658,7 +3078,7 @@ var NativeDocument = (function (exports) {
      * @param {Array|Function} dependencies
      * @returns {ObservableItem}
      */
-    Observable.computed = function(callback, dependencies = []) {
+    Observable$1.computed = function(callback, dependencies = []) {
         const initialValue = callback();
         const observable = new ObservableItem(initialValue);
         const updatedValue = () => observable.set(callback());
@@ -2698,7 +3118,7 @@ var NativeDocument = (function (exports) {
              */
             use(name) {
                 const {observer: originalObserver, subscribers } = $stores.get(name);
-                const observerFollower = Observable(originalObserver.val());
+                const observerFollower = Observable$1(originalObserver.val());
                 const unSubscriber = originalObserver.subscribe(value => observerFollower.set(value));
                 const updaterUnsubscriber = observerFollower.subscribe(value => originalObserver.set(value));
                 observerFollower.destroy = () => {
@@ -2724,7 +3144,7 @@ var NativeDocument = (function (exports) {
              * @returns {ObservableItem}
              */
             create(name, value) {
-                const observer = Observable(value);
+                const observer = Observable$1(value);
                 $stores.set(name, { observer, subscribers: new Set()});
                 return observer;
             },
@@ -2815,14 +3235,14 @@ var NativeDocument = (function (exports) {
             }
 
             try {
-                const indexObserver = callback.length >= 2 ? Observable(indexKey) : null;
+                const indexObserver = callback.length >= 2 ? Observable$1(indexKey) : null;
                 let child = ElementCreator.getChild(callback(item, indexObserver));
                 if(!child) {
                     throw new NativeDocumentError("ForEach child can't be null or undefined!");
                 }
                 cache.set(keyId, { keyId, isNew: true, child: new WeakRef(child), indexObserver});
             } catch (e) {
-                DebugManager.error('ForEach', `Error creating element for key ${keyId}` , e);
+                DebugManager$1.error('ForEach', `Error creating element for key ${keyId}` , e);
                 throw e;
             }
             return keyId;
@@ -2988,7 +3408,7 @@ var NativeDocument = (function (exports) {
                 cache.delete(keyId);
             }
 
-            const indexObserver = isIndexRequired ? Observable(indexKey) : null;
+            const indexObserver = isIndexRequired ? Observable$1(indexKey) : null;
             let child = ElementCreator.getChild(callback(item, indexObserver));
             if(!child) {
                 throw new NativeDocumentError("ForEachArray child can't be null or undefined!");
@@ -3194,7 +3614,7 @@ var NativeDocument = (function (exports) {
      */
     const ShowIf = function(condition, child, { comment = null, shouldKeepInCache = true} = {}) {
         if(!(Validator.isObservable(condition)) && !Validator.isObservableWhenResult(condition)) {
-            return DebugManager.warn('ShowIf', "ShowIf : condition must be an Observable / "+comment, condition);
+            return DebugManager$1.warn('ShowIf', "ShowIf : condition must be an Observable / "+comment, condition);
         }
         const element = Anchor('Show if : '+(comment || ''));
 
@@ -3234,7 +3654,7 @@ var NativeDocument = (function (exports) {
      * @returns {DocumentFragment}
      */
     const HideIf = function(condition, child, configs) {
-        const hideCondition = Observable(!condition.val());
+        const hideCondition = Observable$1(!condition.val());
         condition.subscribe(value => hideCondition.set(!value));
 
         return ShowIf(hideCondition, child, configs);
@@ -3981,7 +4401,7 @@ var NativeDocument = (function (exports) {
                 window.history.pushState({ name: route.name(), params, path}, route.name() || path , path);
                 this.handleRouteChange(route, params, query, path);
             } catch (e) {
-                DebugManager.error('HistoryRouter', 'Error in pushState', e);
+                DebugManager$1.error('HistoryRouter', 'Error in pushState', e);
             }
         };
         /**
@@ -3994,7 +4414,7 @@ var NativeDocument = (function (exports) {
                 window.history.replaceState({ name: route.name(), params, path}, route.name() || path , path);
                 this.handleRouteChange(route, params, {}, path);
             } catch(e) {
-                DebugManager.error('HistoryRouter', 'Error in replaceState', e);
+                DebugManager$1.error('HistoryRouter', 'Error in replaceState', e);
             }
         };
         this.forward = function() {
@@ -4021,7 +4441,7 @@ var NativeDocument = (function (exports) {
                     }
                     this.handleRouteChange(route, params, query, path);
                 } catch(e) {
-                    DebugManager.error('HistoryRouter', 'Error in popstate event', e);
+                    DebugManager$1.error('HistoryRouter', 'Error in popstate event', e);
                 }
             });
             const { route, params, query, path } = this.resolve(defaultPath || (window.location.pathname+window.location.search));
@@ -4175,7 +4595,7 @@ var NativeDocument = (function (exports) {
                     listener(request);
                     next && next(request);
                 } catch (e) {
-                    DebugManager.warn('Route Listener', 'Error in listener:', e);
+                    DebugManager$1.warn('Route Listener', 'Error in listener:', e);
                 }
             }
         };
@@ -4334,7 +4754,7 @@ var NativeDocument = (function (exports) {
      */
     Router.create = function(options, callback) {
         if(!Validator.isFunction(callback)) {
-            DebugManager.error('Router', 'Callback must be a function', e);
+            DebugManager$1.error('Router', 'Callback must be a function', e);
             throw new RouterError('Callback must be a function');
         }
         const router = new Router(options);
@@ -4508,6 +4928,7 @@ var NativeDocument = (function (exports) {
 
     var utils = /*#__PURE__*/Object.freeze({
         __proto__: null,
+        Filters: index,
         NativeFetch: NativeFetch,
         Service: Service
     });
@@ -4516,7 +4937,7 @@ var NativeDocument = (function (exports) {
     exports.ElementCreator = ElementCreator;
     exports.HtmlElementWrapper = HtmlElementWrapper;
     exports.NDElement = NDElement;
-    exports.Observable = Observable;
+    exports.Observable = Observable$1;
     exports.PluginsManager = PluginsManager;
     exports.SingletonView = SingletonView;
     exports.Store = Store;