native-document 1.0.68 → 1.0.69

package/src/utils/filters/date.js

@@ -0,0 +1,95 @@
+import {createFilter, createMultiSourceFilter, getSecondsOfDay, isSameDay, toDate} from "./utils";
+
+export const dateEquals = (observableOrValue) => {
+    return createFilter(observableOrValue, (value, target) => {
+        if (!value || !target) return false;
+        return isSameDay(value, target);
+    });
+};
+
+export const dateBefore = (observableOrValue) => {
+    return createFilter(observableOrValue, (value, target) => {
+        if (!value || !target) return false;
+        return toDate(value) < toDate(target);
+    });
+};
+
+export const dateAfter = (observableOrValue) => {
+    return createFilter(observableOrValue, (value, target) => {
+        if (!value || !target) return false;
+        return toDate(value) > toDate(target);
+    });
+};
+
+export 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);
+        }
+    );
+};
+
+export 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();
+    });
+};
+
+export const timeAfter = (observableOrValue) => {
+    return createFilter(observableOrValue, (value, target) => {
+        return getSecondsOfDay(value) > getSecondsOfDay(target);
+    });
+};
+
+export const timeBefore = (observableOrValue) => {
+    return createFilter(observableOrValue, (value, target) => {
+        return getSecondsOfDay(value) < getSecondsOfDay(target);
+    });
+};
+
+export 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);
+        }
+    );
+};
+
+export const dateTimeEquals = (observableOrValue) => {
+    return createFilter(observableOrValue, (value, target) => {
+        if (!value || !target) return false;
+        return toDate(value).getTime() === toDate(target).getTime();
+    });
+};
+
+export const dateTimeAfter = (observableOrValue) => {
+    return createFilter(observableOrValue, (value, target) => {
+        if (!value || !target) return false;
+        return toDate(value) > toDate(target);
+    });
+};
+
+export const dateTimeBefore = (observableOrValue) => {
+    return createFilter(observableOrValue, (value, target) => {
+        if (!value || !target) return false;
+        return toDate(value) < toDate(target);
+    });
+};
+
+export 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);
+    });
+};

package/src/utils/filters/index.js

@@ -0,0 +1,4 @@
+export * from './utils';
+export * from './standard';
+export * from './date';
+export * from './strings';

package/src/utils/filters/standard.js

@@ -0,0 +1,137 @@
+import Validator from "../validator";
+import { createFilter, createMultiSourceFilter } from "./utils";
+
+
+export function equals(observableOrValue){
+    return createFilter(observableOrValue, (value, target) => value === target);
+}
+
+export function notEquals(observableOrValue){
+    return createFilter(observableOrValue, (value, target) => value !== target);
+}
+
+export function greaterThan(observableOrValue){
+    return createFilter(observableOrValue, (value, target) => value > target);
+}
+
+export function greaterThanOrEqual(observableOrValue){
+    return createFilter(observableOrValue, (value, target) => value >= target);
+}
+
+export function lessThan(observableOrValue){
+    return createFilter(observableOrValue, (value, target) => value < target);
+}
+
+export function lessThanOrEqual(observableOrValue){
+    return createFilter(observableOrValue, (value, target) => value <= target);
+}
+
+export function between(minObservableOrValue, maxObservableOrValue){
+    return createMultiSourceFilter(
+        [minObservableOrValue, maxObservableOrValue],
+        (value, [min, max]) => value >= min && value <= max
+    );
+}
+
+export function In(observableOrArray){
+    return createFilter(observableOrArray, (value, arr) => arr.includes(value));
+}
+
+export function notIn(observableOrArray){
+    return createFilter(observableOrArray, (value, arr) => !arr.includes(value));
+}
+
+export function isEmpty(observableOrValue = true){
+    return createFilter(observableOrValue, (value, shouldBeEmpty) => {
+        const isActuallyEmpty = !value || value === '' ||
+            (Array.isArray(value) && value.length === 0);
+
+        return shouldBeEmpty ? isActuallyEmpty : !isActuallyEmpty;
+    });
+}
+
+export function isNotEmpty(observableOrValue = true){
+    return createFilter(observableOrValue, (value, shouldBeNotEmpty) => {
+        const isActuallyNotEmpty = !!value && value !== '' &&
+            (!Array.isArray(value) || value.length > 0);
+
+        return shouldBeNotEmpty ? isActuallyNotEmpty : !isActuallyNotEmpty;
+    });
+}
+
+export 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));
+        }
+    );
+}
+
+export 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))
+    };
+}
+
+export 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))
+    };
+}
+
+export function not(filter){
+    return {
+        dependencies: filter.dependencies,
+        callback: (value) => !filter.callback(value)
+    };
+}
+
+export 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);
+        }
+    };
+}
+
+export const gt = greaterThan;
+export const gte = greaterThanOrEqual;
+export const lt = lessThan;
+export const lte = lessThanOrEqual;
+export const eq = equals;
+export const neq = notEquals;
+export const all = and;
+export const any = or;
+

package/src/utils/filters/strings.js

@@ -0,0 +1,35 @@
+import { createFilter, createMultiSourceFilter } from "./utils";
+
+
+export 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));
+    });
+}
+
+export const contains = includes;
+
+export 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));
+    });
+}
+
+export 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));
+    });
+}

package/src/utils/filters/utils.js

@@ -0,0 +1,41 @@
+import Validator from "../validator";
+
+export function toDate(value) {
+    if (value instanceof Date) return value;
+    return new Date(value);
+}
+
+export 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();
+}
+
+export function getSecondsOfDay(date) {
+    const d = toDate(date);
+    return (d.getHours() * 3600) + (d.getMinutes() * 60) + d.getSeconds();
+}
+
+export function createFilter(observableOrValue, callbackFn){
+    const isObservable = Validator.isObservable(observableOrValue);
+
+    return {
+        dependencies: isObservable ? observableOrValue : null,
+        callback: (value) => callbackFn(value, isObservable ? observableOrValue.val() : observableOrValue)
+    };
+}
+
+export 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())
+    };
+}

package/types/observable.d.ts

@@ -134,7 +134,7 @@ export interface ObservableConfig {
 
 export interface ObservableStatic {
     <T>(value: T, configs?: ObservableConfig | null): ObservableItem<T>;
-    array<T>(target: T[], configs?: ObservableConfig | null): ObservableArray<T>;
+    array<T>(target: T[] | null, configs?: ObservableConfig | null): ObservableArray<T>;
 
     init<T extends Record<string, any>>(value: T, configs?: ObservableConfig | null): ObservableProxy<T>;
     object<T extends Record<string, any>>(value: T, configs?: ObservableConfig | null): ObservableProxy<T>;

package/utils.js

@@ -1,8 +1,10 @@
 import NativeFetch from "./src/utils/fetch/NativeFetch";
 import { Service } from "./src/utils/service";
+import * as Filters from "./src/utils/filters/index";
 
 
 export {
     NativeFetch,
-    Service
+    Service,
+    Filters,
 };