hyperscript-rxjs 1.3.14 → 1.3.15

package/src/object/isEmptyObject.js

@@ -0,0 +1,13 @@
+import { isPlainObject } from './isPlainObject'
+
+/**
+ * 
+ * 判断对象是否为空对象（非数组、非 null，且无自有属性）。
+ * 
+ * @param {unknown} obj - 要判断的对象。
+ * @returns {boolean} 如果是空对象返回 true，否则返回 false。
+ * 
+ */
+export const isEmptyObject = (obj) => {
+    return isPlainObject(obj) && Object.keys(obj).length === 0
+}

package/src/object/isEmptyObject.test.js

@@ -0,0 +1,33 @@
+import { isEmptyObject } from './isEmptyObject.js';
+
+describe('isEmptyObject', () => {
+  test('should return true for an empty object', () => {
+    expect(isEmptyObject({})).toBe(true);
+  });
+
+  test('should return false for a non-empty object', () => {
+    expect(isEmptyObject({ key: 'value' })).toBe(false);
+  });
+
+  test('should return false for null', () => {
+    expect(isEmptyObject(null)).toBe(false);
+  });
+
+  test('should return false for undefined', () => {
+    expect(isEmptyObject(undefined)).toBe(false);
+  });
+
+  test('should return false for an array', () => {
+    expect(isEmptyObject([])).toBe(false);
+  });
+
+  test('should return false for a non-object value', () => {
+    expect(isEmptyObject('string')).toBe(false);
+    expect(isEmptyObject(123)).toBe(false);
+    expect(isEmptyObject(true)).toBe(false);
+  });
+
+  test('should return false for a function', () => {
+    expect(isEmptyObject(() => {})).toBe(false);
+  });
+});

package/src/object/isPlainObject.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 
+ * Type guard for plain objects (objects created via {} or Object.create(null))
+ * 
+ * @param value - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ * 
+ */
+export declare function isPlainObject(
+  value: unknown
+): value is Record<string, any>;

package/src/object/isPlainObject.js

@@ -0,0 +1,18 @@
+/**
+ * 检查一个值是否是普通对象（Plain Object）
+ * @param {unknown} value - 要检查的值
+ * @returns {boolean} - 返回是否是普通对象的类型谓词
+ */
+export function isPlainObject(value) {
+    // 基本检查：非对象或为null的直接返回false
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+
+    // 检查原型链
+    const proto = Object.getPrototypeOf(value);
+    
+    // 1. 原型为null（如Object.create(null)创建的对象）
+    // 2. 原型等于Object.prototype（普通对象）
+    return proto === null || proto === Object.prototype;
+}

package/src/object/nestedCombineLatest.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+
+/**
+ * 将对象格式的 Observable 转换为扁平对象的 Observable。
+ * 
+ * @param model - 对象格式的 Observable。
+ * @returns 一个 Observable，发出扁平化后的对象。
+ */
+export function nestedCombineLatest(
+  model: Record<string|number, any>,
+): Observable<Record<string|number, any>>;

package/src/object/nestedCombineLatest.js

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs'
+import { map } from 'rxjs/operators'
+
+import { Deep } from '../deep/Deep'
+
+///对象格式的Observale，转化成扁平格式的数据后，整个数组外面Observable
+/**
+ * 
+ * @param {Record<string|number, any>} model 
+ * @returns {Observable<Record<string|number, any>>}
+ */
+export function nestedCombineLatest(model) {
+    let deep = Deep.fromObservable(model)
+    return deep.combineLatest()
+        .pipe(
+            map(deep => deep.toObject())
+        )
+}

package/src/object/nestedCombineLatest.test.js

@@ -0,0 +1,25 @@
+import { of } from 'rxjs'
+import { nestedCombineLatest } from './nestedCombineLatest'
+
+test('test deepCombineLatest', done => {
+    const model = {
+        a: {
+            b: of(0),
+            c: of(1),
+        },
+        x: [of(2), of(3)],
+    }
+
+    nestedCombineLatest(model).subscribe({
+        next: data => {
+            expect(data).toEqual({
+                a: {
+                    b: 0,
+                    c: 1,
+                },
+                x: [2, 3],
+            })
+        },
+        complete: done,
+    })
+})

package/src/object/nestedMerge.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+
+/**
+ * 追踪对象属性的变化，返回变化属性的键路径和新值。
+ * 
+ * @param model - 任意对象或可观察对象。
+ * @returns 合并后的 Observable。
+ */
+export function nestedMerge(
+    model: Record<string|number, any>
+): Observable<[ (string | number)[], any ]>;

package/src/object/nestedMerge.js

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs'
+import { Deep } from '../deep/Deep'
+
+/**
+ * 
+ * @param {Record<string|number, any>} model 
+ * @returns {Observable<[(string | number)[], any]>}
+ */
+export function nestedMerge(model) {
+    return Deep.fromObservable(model).merge()
+}

package/src/object/nestedMerge.test.js

@@ -0,0 +1,61 @@
+import { BehaviorSubject } from 'rxjs'
+import { nestedMerge } from './nestedMerge'
+import { pipe } from '../ramda'
+
+test('test nestedMerge 1', done => {
+    const source = {
+        a: {
+            b: new BehaviorSubject(0),
+            c: new BehaviorSubject(1),
+        },
+        x: [new BehaviorSubject(2), new BehaviorSubject(3)]
+    }
+
+    let states = []
+    nestedMerge(source).subscribe(data => { states.push(data) })
+
+    source.a.b.next(10)
+    source.x[1].next(13)
+
+    expect(states).toEqual([
+        [['a', 'b'], 0],
+        [['a', 'c'], 1],
+        [['x', 0], 2],
+        [['x', 1], 3],
+        [['a', 'b'], 10],
+        [['x', 1], 13],
+    ])
+
+    done()
+})
+
+
+test('test nestedMerge', done => {
+    const source = {
+        a: new BehaviorSubject(true),
+        b: new BehaviorSubject(true),
+        x: { c: [new BehaviorSubject(true)] },
+    }
+    let states = []
+    let obs =
+        pipe(
+            source,
+            nestedMerge,
+
+        );
+    obs.subscribe(data => { states.push(data) })
+
+    source.a.next(false)
+    source.b.next(false)
+    source.x.c[0].next(false)
+
+    expect(states).toEqual([
+        [['a'], true],
+        [['b'], true],
+        [['x', 'c', 0], true],
+        [['a'], false],
+        [['b'], false],
+        [['x', 'c', 0], false],
+    ])
+    done()
+})

package/src/object/pickBehaviorSubject.d.ts

@@ -0,0 +1,13 @@
+
+/**
+ * 
+ * 拾取对象中的 BehaviorSubject 值，作为叶子节点，忽略其他值。
+ * 
+ * @param model - 任意对象，内部递归查找 BehaviorSubject。
+ * @returns 只包含 BehaviorSubject 当前值的对象或数组结构。
+ * @throws 如果结构不符合预期会抛出错误。
+ * 
+ */
+export function pickBehaviorSubject(
+    model: Record<string | number, any> & { pickeys?: string[] }
+): Record<string | number, any>;

package/src/object/pickBehaviorSubject.js

@@ -0,0 +1,81 @@
+import { BehaviorSubject, isObservable } from 'rxjs'
+import { intersectObject } from '.'
+import { isRxType } from '../deep-rxjs/isRxType'
+import { ObservableArray } from '../deep-rxjs/ObservableArray'
+
+/**
+ * 
+ * 拾取对象中的BehaviorSubject值，作爲葉子節點，忽略其他值。
+ * 
+ * @param {Record<string|number,any> & { pickeys?: string [] }} model - 输入的数据结构，可以是对象、数组或BehaviorSubject
+ * @returns {Record<string|number,any>} - 返回只包含BehaviorSubject当前值的结构
+ * @throws {Error} 当输入不包含任何BehaviorSubject或结构不符合预期时抛出错误
+ */
+export function pickBehaviorSubject(model) {
+    let x = loop(model, '', null)
+    if (x.length === 1) {
+        return x[0][1]
+    } else {
+        throw new Error('pickBehaviorSubject')
+    }
+}
+
+/**
+ * 
+ * 递归遍历数据结构收集BehaviorSubject值
+ * 
+ * @param {any} value - 当前遍历的值
+ * @param {string|number} key - 当前键名
+ * @param {object|null} parent - 父级对象
+ * @returns {[string|number, any][]} - 返回收集到的键值对数组，每个元素是一个[key, value]元组
+ * @throws {Error} 当遇到不符合要求的数据结构时抛出错误
+ */
+function loop(value, key, parent) {
+    if (isObservable(value) && value instanceof BehaviorSubject) {
+        return [[key, value.value]]  //保存葉節點
+    } else if (value === null || typeof value !== 'object' || isRxType(value)) {
+        return []
+    } else if (value instanceof ObservableArray) {
+        let v = [...value]
+            .map((e, i) => {
+                let pelem = loop(e, i, value)
+                if (pelem.length === 1) {
+                    return pelem[0][1] //表示元素是正常叶节点
+                } else {
+                    throw new Error('dense Array') //非正常叶节点，有洞
+                }
+            })
+        return [[key, v]]
+    } else if (value instanceof Array) {
+        if (value.length === 0) {
+            return [] //空不可变数组，将丢弃。
+        } else {
+            let v = value.map((e, i) => {
+                let pelem = loop(e, i, value)
+                if (pelem.length === 1) {
+                    return pelem[0][1]
+                } else {
+                    throw new Error('dense Array')
+                }
+            })
+
+            return [[key, v]]
+        }
+    } else if ('pickeys' in value) {
+        return loop(intersectObject(value, value.pickeys()), key, parent)
+    } else {
+        let entries = Object.entries(value)
+        if (entries.length === 0) {
+            return []
+        } else {
+            let ee = entries
+                .map(([k, v]) => loop(v, k, parent))
+                .reduce((acc, val) => [...acc, ...val], [])
+            if (ee.length === 0) {
+                return []
+            } else {
+                return [[key, Object.fromEntries(ee)]]
+            }
+        }
+    }
+}

package/src/object/pickBehaviorSubject.test.js

@@ -0,0 +1,88 @@
+import { BehaviorSubject } from 'rxjs'
+import { pickBehaviorSubject } from './pickBehaviorSubject'
+import { ObservableArray } from '../deep-rxjs/ObservableArray'
+
+test('BehaviorSubject happy', done => {
+    let source = new BehaviorSubject(0)
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual(0)
+    done()
+})
+
+test('array happy', done => {
+    let source = [new BehaviorSubject(0), new BehaviorSubject(1)]
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual([0, 1])
+    done()
+})
+
+test('array error test', done => {
+    let source = [new BehaviorSubject(0), 'error']
+    expect(() => {
+        pickBehaviorSubject(source)
+    }).toThrow('dense Array')
+
+    done()
+})
+
+test('object happy', done => {
+    let source = { a: new BehaviorSubject(0), b: new BehaviorSubject(1) }
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual({ a: 0, b: 1 })
+    done()
+})
+
+test('object ignore all', done => {
+    let source = { a: 0, b: 1 }
+
+    expect(() => {
+        pickBehaviorSubject(source)
+    }).toThrow('pickBehaviorSubject')
+
+    done()
+})
+
+test('object ignore some', done => {
+    let source = {
+        a: new BehaviorSubject(0), b: 1, c: [], d: {}
+    }
+    let y = pickBehaviorSubject(source)
+
+    expect(y).toEqual({ a: 0 })
+    done()
+})
+
+test('pick observable array ignore some', done => {
+    let source = {
+        a: new ObservableArray()
+    }
+
+    source.a.insertBefore(new BehaviorSubject(0))
+    source.a.insertBefore(new BehaviorSubject(1))
+    source.a.insertBefore(new BehaviorSubject(2))
+
+    source.a[1].next('1')
+    let y = pickBehaviorSubject(source)
+
+    expect(y).toEqual({ a: [0,'1',2] })
+    done()
+})
+
+test('object pickeys', done => {
+    let source = {
+        a: new BehaviorSubject(0),
+        b: new BehaviorSubject(0),
+        pickeys() {
+            return ['a']
+        }
+    }
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual({ a: 0 })
+
+    done()
+})
+
+
+
+
+

package/src/object/pluckProperty.d.ts

@@ -0,0 +1,13 @@
+
+/**
+ * 获取对象的嵌套属性。
+ * 
+ * @param obj - 源对象或数组。
+ * @param keyPath - 属性访问路径数组。
+ * @returns 路径对应的属性值。
+ * @throws 当路径不存在时抛出 TypeError。
+ */
+export function pluckProperty(
+  obj: Record<string | number, any>,
+  keyPath: (string | number)[]
+): any;

package/src/object/pluckProperty.js

@@ -0,0 +1,24 @@
+/**
+ * 获取对象的嵌套属性
+ * @param {Record<string | number, any>} obj - 源对象/数组
+ * @param {(string|number)[]} keyPath - 属性访问路径数组
+ * @returns {any} 路径对应的属性值
+ * @throws {TypeError} 当路径不存在时抛出错误
+ */
+export function pluckProperty(obj, keyPath) {
+    // 类型检查
+    if (typeof obj !== 'object' || obj === null) {
+        throw new TypeError('First argument must be an object');
+    }
+
+    if (!Array.isArray(keyPath)) {
+        throw new TypeError('keyPath must be an array');
+    }
+
+    return keyPath.reduce((prev, curr) => {
+        if (prev == null || !(curr in prev)) {
+            throw new TypeError(`Property '${curr}' not found in path`);
+        }
+        return prev[curr];
+    }, obj);
+}

package/src/object/pluckProperty.test.js

@@ -0,0 +1,37 @@
+import { pluckProperty } from './pluckProperty';
+
+describe('pluckProperty', () => {
+    test('basic array access', () => {
+        const arr = [0, 1];
+        expect(pluckProperty(arr, [1])).toBe(1);
+    });
+
+    test('basic object access', () => {
+        const obj = { a: 1 };
+        expect(pluckProperty(obj, ['a'])).toBe(1);
+    });
+
+    test('nested access', () => {
+        const obj = { a: [1, 2] };
+        expect(pluckProperty(obj, ['a', 0])).toBe(1);
+    });
+
+    test('should throw on invalid path', () => {
+        expect(() => pluckProperty({}, ['a'])).toThrow(TypeError);
+        expect(() => pluckProperty({ a: {} }, ['a', 'b'])).toThrow(TypeError);
+    });
+
+    test('should throw on null/undefined', () => {
+        expect(() => pluckProperty(null, ['a'])).toThrow(TypeError);
+        expect(() => pluckProperty(undefined, ['a'])).toThrow(TypeError);
+    });
+
+    test('should throw if keyPath is not array', () => {
+        expect(() => pluckProperty({}, 'a')).toThrow(TypeError);
+    });
+
+    test('empty path returns original object', () => {
+        const obj = {};
+        expect(pluckProperty(obj, [])).toBe(obj);
+    });
+});

package/src/object/restore.d.ts

@@ -0,0 +1,12 @@
+
+/**
+ * 更新 ViewModel 为新值 src，递归同步 BehaviorSubject、ObservableArray、数组和对象的内容。
+ * 
+ * @param model - 需要更新的 ViewModel（可为 BehaviorSubject、ObservableArray、数组或对象）。
+ * @param src - 新值，结构应与 model 对应。
+ * @returns 返回更新后的 model。
+ */
+export function restore(
+    model: Record<string | number, any>,
+    src: Record<string | number, any>
+): Record<string | number, any>;

package/src/object/restore.js

@@ -0,0 +1,69 @@
+import { BehaviorSubject } from 'rxjs'
+import { isRxType } from '../deep-rxjs/isRxType'
+import { ObservableArray } from '../deep-rxjs/ObservableArray'
+
+/**
+ * Updates a reactive model with new values from a source object.
+ * Recursively synchronizes BehaviorSubject, ObservableArray, array and object contents.
+ * 
+ * @param {Record<string | number, any>} model - The reactive model to update (can be BehaviorSubject, ObservableArray, array or object)
+ * @param {Record<string | number, any>} src - The new values to restore, should match the structure of the model
+ * @returns
+ */
+export function restore(model, src) {
+    loop(model, src)
+    // return model
+}
+
+/**
+ * Recursively updates model values from source
+ * @param {any & {appendChild?: (c:any) => void }} o - Current model node to update
+ * @param {any} src - Corresponding source value
+ */
+function loop(o, src) {
+    if (o instanceof BehaviorSubject) {
+        // Input value
+        o.next(src)
+    } else if (o === null || typeof o !== 'object' || isRxType(o)) {
+        // noop
+    } else if (o instanceof ObservableArray) {
+        let len = o.length
+        let diffcount = len - src.length
+        if (diffcount > 0) {
+            // Truncate if longer
+            Array.from({ length: diffcount })
+                .map((e, i) => len - 1 - i)
+                .forEach((last) => {
+                    o.removeChild(last)
+                })
+        } else if (diffcount < 0) {
+            // Extend if shorter
+            Array.from({ length: -diffcount })
+                .map((e, i) => len + i)
+                .forEach(i => {
+                    // Add an item to the end of an Array
+                    o.appendChild()
+                })
+        }
+
+        // After alignment, update each element's value
+        for (let i of o.keys()) {
+            loop(o[i], src[i])
+        }
+    } else if (o instanceof Array) {
+        // Regular array, tuple
+        let indexes = o.length < src.length ? o : src
+        // Ignore extra src elements, noop for missing elements
+        for (let i of indexes.keys()) {
+            // todo: Throw error when o[i] is not settable?
+            loop(o[i], src[i])
+        }
+    } else if (typeof o === 'object') {
+        // Recursively process object properties
+        Object.entries(o)
+            .filter(([k, v]) => k in src) // Intersection
+            .forEach(([k, v]) => {
+                loop(v, src[k])
+            })
+    }
+}