native-document 1.0.257 → 1.0.258

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "native-document",
-  "version": "1.0.257",
+  "version": "1.0.258",
   "description": "A reactive JavaScript framework that preserves native DOM simplicity without sacrificing modern features",
   "author": "AfroCodeur <https://github.com/afrocodeur>",
   "license": "MIT",

package/src/core/data/Observable.js

@@ -12,6 +12,7 @@ import './observable-helpers/observable.prototypes';
 import ObservableResource from './ObservableResource';
 import {Formatters} from '../utils/formatters';
 import Ref from './Ref';
+import ObservableQuery from './ObservableQuery';
 /**
  *
  * @param {*} value
@@ -188,9 +189,16 @@ Observable.auto = (value, options = null) => {
     if(value == null) {
         return new ObservableItem(value, options);
     }
+    if(value.__$Observable) {
+        return value;
+    }
     if(Validator.isArray(value)) {
         return new ObservableArray(value, options);
-    } else if(typeof value === 'object') {
+    }
+    else if(typeof value === 'object') {
+        if(!Validator.isJson(value)) {
+            return value;
+        }
         return new ObservableObject(value, options);
     }
     return new ObservableItem(value, options);
@@ -252,6 +260,10 @@ Observable.collection = function() {
     return new Ref(true);
 };
 
+Observable.from = function(target) {
+    return new ObservableQuery(target);
+};
+
 ObservableItem.prototype.resolve = function () {
     return Observable.value(this);
 };

package/src/core/data/ObservableArray.js

@@ -30,7 +30,7 @@ const ObservableArray = function (target, configs = { propagation: false, deep:
     }
 
 
-    if(configs?.deep) {
+    if(configs?.deep !== false) {
         target = target.map(toObservable);
         this.interceptMutations((data, operations) => {
             if(!operations.action || ['push', 'unshift', 'set', 'splice'].includes(operations.action)) {

package/src/core/data/ObservableQuery.js

@@ -0,0 +1,153 @@
+
+
+export default function ObservableQuery($target) {
+    if(!(this instanceof ObservableQuery)) {
+        return new ObservableQuery($target);
+    }
+
+    if(!$target?.__$isObservableArray) {
+        throw new Error('ObservableQuery target must be a ObservableArray');
+    }
+
+    this.$target = $target;
+    this.$parentMap = new Map([$target]);
+    this.$currentResultData = $target;
+}
+
+ObservableQuery.prototype.flush = function () {
+    this.$currentResultData = this.$target;
+    return this;
+};
+
+const predicateFns = {
+    gt:  (source, target) => source.valueOf() > target.valueOf(),
+    gte: (source, target) => source.valueOf() >= target.valueOf(),
+    lt:  (source, target) => source.valueOf() < target.valueOf(),
+    lte: (source, target) => source.valueOf() <= target.valueOf(),
+    eq:  (source, target) => source.valueOf() === target.valueOf(),
+    neq: (source, target) => source.valueOf() !== target.valueOf(),
+    in:  (source, target) => target.includes(source.valueOf()),
+    nin: (source, target) => !target.includes(source.valueOf()),
+};
+
+const getPredicateFn = (column, predicate) => {
+    if(typeof column === 'function') {
+        return column;
+    }
+    if(predicate == null) {
+        return (element) => {
+            return element[column] == null;
+        };
+    }
+    if(typeof predicate?.valueOf === 'function') {
+        return (element) => {
+            return element[column]?.valueOf() === predicate?.valueOf();
+        };
+    }
+    const operator = Object.keys(predicate).at(0);
+    if(!operator) {
+        return () => true;
+    }
+    const value = Object.values(predicate).at(0);
+    const operation = predicateFns[operator];
+    if(!operation) {
+        throw new Error('Unknown predicate operator '+operator);
+    }
+
+    return (element) => operation(element[column], value);
+};
+
+// --------------------------------------------------------------------------------------------------------------------
+ObservableQuery.prototype.where =  function(column, predicate) {
+    const predicateFn = getPredicateFn(column, predicate);
+    this.$currentResultData = this.$currentResultData.valueOf().flatMap((item) => {
+        if(item?.__$isObservableArray || Array.isArray(item)) {
+            const values = item.filter(predicateFn).filter(Boolean);
+            values.forEach((value) => {
+                this.$parentMap.set(value, item);
+            });
+            return values;
+        }
+        return predicateFn(item) ? [item] : [];
+    });
+    return this;
+};
+
+ObservableQuery.prototype.in = function(relation) {
+
+    this.$currentResultData = this.$currentResultData
+        .map((parentElement) => {
+            const childCollection = typeof relation === 'function' ?  relation(parentElement) : parentElement[relation];
+            if(childCollection) {
+                this.$parentMap.set(childCollection, parentElement);
+            }
+            return childCollection;
+        })
+        .filter(Boolean);
+
+    return this;
+};
+
+ObservableQuery.prototype.first = function() {
+
+    return this.$currentResultData[0] ?? null;
+};
+
+ObservableQuery.prototype.all = function() {
+
+    return this.$currentResultData;
+};
+
+
+// --------------------------------------------------------------------------------------------------------------------
+ObservableQuery.prototype.count = function() {
+    return this.$currentResultData.length;
+};
+
+ObservableQuery.prototype.exists = function() {
+    return this.$currentResultData.length > 0;
+};
+
+ObservableQuery.prototype.sum = function(key) {
+    return this.$currentResultData.reduce((acc, element) => {
+        return acc + element[key]?.valueOf();
+    }, 0);
+};
+
+ObservableQuery.prototype.map = function(fn) {
+    return this.$currentResultData.map(fn);
+};
+
+
+// --------------------------------------------------------------------------------------------------------------------
+
+ObservableQuery.prototype.set = function(dataset) {
+    this.$currentResultData.forEach((element) => {
+        for(const key in dataset) {
+            const prop = element[key];
+            const value = dataset[key];
+            if(prop?.__$isObservable) {
+                prop.set(value);
+                return;
+            }
+            element[key] = value;
+        }
+    });
+    return this.flush();
+};
+
+ObservableQuery.prototype.delete = function() {
+    this.$currentResultData.forEach((element) => {
+        const parent = this.$parentMap.get(element) ?? this.$target;
+        const indexOfElement = parent.indexOf(element);
+        parent.splice(indexOfElement, 1);
+    });
+    return this.flush();
+};
+
+ObservableQuery.prototype.push = function(value) {
+    this.$currentResultData.forEach((element) => {
+        element.push && element.push(value);
+    });
+    return this.flush();
+};

package/src/core/data/ObservableRelationQuery.js

@@ -0,0 +1,5 @@
+
+
+export default function ObservableRelationQuery($parent, relation) {
+
+}

package/types/observable-query.d.ts

@@ -0,0 +1,67 @@
+import type { ObservableArray, ObservableItem } from './observable';
+
+type PredicateOperator = 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq' | 'in' | 'nin';
+
+type PredicateFn<T> = (element: T) => boolean;
+
+type Predicate<T> =
+    | null
+    | { [K in PredicateOperator]?: any }
+    | PredicateFn<T>;
+
+type Dataset<T> = Partial<{
+    [K in keyof T]: T[K] extends ObservableItem<infer V> ? V : T[K];
+}>;
+
+/**
+ * Fluent query builder for ObservableArray collections.
+ * Supports filtering, navigation into nested relations, aggregation and mutations.
+ *
+ * @template T - Type of items in the target ObservableArray
+ *
+ * @example
+ * // Select
+ * $.from($events).where('id', 1).first();
+ *
+ * // Navigate into relation
+ * $.from($events).where('id', 1).in('tickets').where('type', 'VIP').all();
+ *
+ * // Delete from relation
+ * $.from($events).in('tickets').where('type', 'VIP').delete();
+ *
+ * // Insert into relation
+ * $.from($events).where('id', 1).in('tickets').push(newTicket);
+ *
+ * // Update
+ * $.from($events).where('id', 1).set({ name: 'New name' });
+ *
+ * // Aggregation
+ * $.from($events).in('tickets').sum('price');
+ * $.from($events).where('active', true).count();
+ */
+export declare function ObservableQuery<T = any>(
+    target: ObservableArray<T>
+): ObservableQueryInstance<T>;
+
+export interface ObservableQueryInstance<T = any> {
+
+    // -- Navigation / filtering -----------------------------------------------
+    flush(): this;
+    where(column: keyof T | PredicateFn<T>, predicate?: Predicate<T>): this;
+    in(relation: keyof T | ((element: T) => any)): ObservableQueryInstance<any>;
+
+    // -- Read -----------------------------------------------------------------
+    first(): T | null;
+    all(): T[];
+
+    // -- Aggregation ----------------------------------------------------------
+    count(): number;
+    exists(): boolean;
+    sum(key: keyof T): number;
+    map<U>(fn: (element: T) => U): U[];
+
+    // -- Mutations ------------------------------------------------------------
+    set(dataset: Dataset<T>): this;
+    delete(): this;
+    push(value: any): this;
+}

package/types/observable.d.ts

@@ -1,5 +1,6 @@
 import { FilterResult, PredicateMap } from './filters';
 import Ref, {RefItem} from './ref';
+import {ObservableQueryInstance} from "./observable-query";
 
 export type Unsubscribe = () => void;
 
@@ -340,6 +341,7 @@ export interface ObservableStatic {
     json<T extends Record<string, any>>(value: T, configs?: ObservableConfig | null): ObservableObject<T>;
 
     auto<T>(value: T): ObservableArray<T>|ObservableObject<T>|ObservableItem<T>;
+    from<T>(value: ObservableArray<T>): ObservableQueryInstance<T>;
 
     resource<T = any>(
         fn: (...args: any[]) => Promise<T>,