native-document 1.0.68 → 1.0.70

package/src/utils/filters/date.js

@@ -0,0 +1,97 @@
+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) => {
+        if (!value || !target) return false;
+        return getSecondsOfDay(value) > getSecondsOfDay(target);
+    });
+};
+
+export const timeBefore = (observableOrValue) => {
+    return createFilter(observableOrValue, (value, target) => {
+        if (!value || !target) return false;
+        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 inArray(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/filters/dates.d.ts

@@ -0,0 +1,43 @@
+import { ObservableItem } from '../observable';
+import { FilterResult } from './types';
+
+export type DateValue = Date | string | number | ObservableItem<Date | string | number>;
+
+export function toDate(value: Date | string | number): Date;
+
+export function isSameDay(date1: Date | string | number, date2: Date | string | number): boolean;
+
+export function getSecondsOfDay(date: Date | string | number): number;
+
+export function dateEquals(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateBefore(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateAfter(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateBetween(
+    startObservableOrValue: DateValue,
+    endObservableOrValue: DateValue
+): FilterResult<DateValue>;
+
+export function timeEquals(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function timeAfter(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function timeBefore(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function timeBetween(
+    startObservableOrValue: DateValue,
+    endObservableOrValue: DateValue
+): FilterResult<DateValue>;
+
+export function dateTimeEquals(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateTimeAfter(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateTimeBefore(observableOrValue: DateValue): FilterResult<DateValue>;
+
+export function dateTimeBetween(
+    startObservableOrValue: DateValue,
+    endObservableOrValue: DateValue
+): FilterResult<DateValue>;

package/types/filters/standard.d.ts

@@ -0,0 +1,71 @@
+import { ObservableOrValue, FilterResult } from './types';
+import {ObservableItem} from "../observable";
+
+
+export function equals<T>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function notEquals<T>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function greaterThan<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function greaterThanOrEqual<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function lessThan<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function lessThanOrEqual<T extends number | Date>(
+    observableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function between<T extends number | Date>(
+    minObservableOrValue: ObservableOrValue<T>,
+    maxObservableOrValue: ObservableOrValue<T>
+): FilterResult<T>;
+
+export function inArray<T>(
+    observableOrArray: ObservableOrValue<T[]>
+): FilterResult<T>;
+
+export function notIn<T>(
+    observableOrArray: ObservableOrValue<T[]>
+): FilterResult<T>;
+
+export function isEmpty(
+    observableOrValue?: ObservableOrValue<boolean>
+): FilterResult<ObservableOrValue<boolean>>;
+
+export function isNotEmpty(
+    observableOrValue?: ObservableOrValue<boolean>
+): FilterResult<ObservableOrValue<boolean>>;
+
+export function match(
+    patternObservableOrValue: ObservableOrValue<string | RegExp>,
+    asRegexObservableOrValue?: ObservableOrValue<boolean>,
+    flagsObservableOrValue?: ObservableOrValue<string>
+): FilterResult<string | RegExp>;
+
+export function and<T>(...filters: FilterResult<T>[]): FilterResult<T>;
+
+export function or<T>(...filters: FilterResult<T>[]): FilterResult<T>;
+
+export function not<T>(filter: FilterResult<T>): FilterResult<T>;
+
+
+
+export const gt: typeof greaterThan;
+export const gte: typeof greaterThanOrEqual;
+export const lt: typeof lessThan;
+export const lte: typeof lessThanOrEqual;
+export const eq: typeof equals;
+export const neq: typeof notEquals;
+export const all: typeof and;
+export const any: typeof or;

package/types/filters/strings.d.ts

@@ -0,0 +1,21 @@
+import {FilterResult, ObservableOrValue} from './types';
+
+export function contains(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;
+
+export function includes(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;
+
+export function startsWith(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;
+
+export function endsWith(
+    observableOrValue: ObservableOrValue<string>,
+    caseSensitive?: boolean
+): FilterResult<string>;

package/types/filters/types.d.ts

@@ -0,0 +1,20 @@
+import { ObservableItem } from '../observable';
+
+export interface FilterResult<T = any> {
+    dependencies: ObservableItem | ObservableItem[] | null;
+    callback: (value: T) => boolean;
+}
+
+export type ObservableOrValue<T> = T | ObservableItem<T>;
+
+export type Predicate<T = any> =
+    | T
+    | ((value: T) => boolean)
+    | FilterResult<T>
+    | ObservableItem<T>;
+
+export type PredicateMap<T> = {
+    [K in keyof T]?: Predicate<T[K]>;
+} & {
+    _?: FilterResult<T>;
+};

package/types/observable.d.ts

@@ -1,3 +1,5 @@
+import {FilterResult, PredicateMap} from "./filters/types";
+
 export type Unsubscribe = () => void;
 
 // Observable system type definitions
@@ -89,6 +91,10 @@ export interface ObservableArray<T> extends ObservableItem<T[]> {
     at(index: number): T | undefined;
     findIndex(callback: (value: T, index: number, array: T[]) => boolean): number;
     concat(...items: (T | T[])[]): T[];
+
+    where(predicates: PredicateMap<T>): ObservableArray<T>;
+    whereSome<K extends keyof T>(fields: K[], filter: FilterResult<T[K]>): ObservableArray<T>;
+    whereEvery<K extends keyof T>(fields: K[], filter: FilterResult<T[K]>): ObservableArray<T>;
 }
 
 export type ObservableProxy<T extends Record<string, any>> = {
@@ -134,7 +140,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,
 };