hyperscript-rxjs 1.3.14 → 1.3.15

package/src/deep/deepCombineLatest.test.js

@@ -0,0 +1,36 @@
+import { BehaviorSubject,Observable } from 'rxjs'
+import { Deep } from './Deep'
+
+test('test deep CombineLatest', done => {
+    const model = {
+        a: {
+            b: new BehaviorSubject(0),
+            c: new BehaviorSubject(1),
+        },
+        x: [new BehaviorSubject(2), new BehaviorSubject(3)]
+    }
+
+    let deep = Deep.fromBehaviorSubject(model)
+    deep.entries.forEach(([k, v]) => {
+        console.log(k)
+        console.log(v)
+    })
+    
+    let obs = deep.combineLatest();
+    
+    expect(obs).toBeInstanceOf(Observable)
+
+    obs.subscribe({
+        next: data => {
+            console.log(data.entries)
+            //states.push(data)
+        }
+    })
+
+    model.a.b.next(10)
+    model.a.c.next(11)
+
+    done()
+
+})
+

package/src/deep/deepMerge.test.js

@@ -0,0 +1,34 @@
+import { BehaviorSubject, Observable } from 'rxjs'
+import { Deep } from './Deep'
+
+test('test deepMerge 1', done => {
+    let states = []
+
+    const source = {
+        a: {
+            b: new BehaviorSubject(0),
+            c: new BehaviorSubject(1),
+        },
+        x: [new BehaviorSubject(2), new BehaviorSubject(3)]
+    }
+    let deep = Deep.fromObservable(source)
+    let obs = deep.merge()
+    expect(obs).toBeInstanceOf(Observable)
+
+    obs.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()
+})
+

package/src/deep/differenceDeep.test.js

@@ -0,0 +1,31 @@
+import { Deep } from './Deep'
+
+test('difference Deep test', () => {
+  let dp = new Deep([
+    [[0], 0],
+    [[1], 1]
+  ])
+  let keys = [[1], [2]]
+  let y = dp.difference(keys)
+  expect(y.entries).toEqual([[[0], 0]])
+})
+
+
+test('difference Deep test with 过滤掉 user 相关的键路径', () => {
+
+  const deep = new Deep([
+    [['settings', 'theme'], 'dark'],
+    [['user', 'age'], 30],
+    [['user', 'name'], '张三'],
+  ]);
+
+  let keys = [
+    ['user', 'age'],
+    ['user', 'name'],
+  ]
+  const filtered = deep.difference(keys)
+  expect(filtered.entries).toEqual([
+    [['settings', 'theme'], 'dark']
+  ])
+
+})

package/src/deep/freshValueDeep.test.js

@@ -0,0 +1,17 @@
+import { Deep } from './Deep'
+
+test('freshValueDeep', () => {
+    let entries = [
+        [['a'], 0], [['b'], 1],
+        [['c', 0], 2],
+        [['c', 1], 3],
+        [['c', 2, 'e'], 4]
+    ]
+
+    let deep = new Deep(entries)
+    let obj = { a: 5, b: 6, c: [7, 8, { e: 9 }] }
+    let y = deep.freshValue(obj)
+    let e = [[['a'], 5], [['b'], 6], [['c', 0], 7], [['c', 1], 8], [['c', 2, 'e'], 9]]
+
+    expect(y.entries).toEqual(e)
+})

package/src/deep/index.d.ts

@@ -0,0 +1 @@
+export * from "./Deep"

package/src/deep/index.js

@@ -0,0 +1,2 @@
+export * from "./Deep"
+

package/src/deep/intersectDeep.test.js

@@ -0,0 +1,25 @@
+import { Deep } from './Deep'
+
+test('test intersectDeep', () => {
+    let entries = [
+        [[0, 0], 0], //*
+        [[0, 1], 1],
+        [[1, 0], 2],
+        [[1, 1], 3], //*
+    ]
+    let deep = new Deep(entries)
+
+    let keys = [
+        [0, 0],
+        [1, 1],
+    ]
+
+    let y = deep.intersect(keys)
+
+    let e = [
+        [[0, 0], 0],
+        [[1, 1], 3],
+    ]
+
+    expect(y.entries).toEqual(e)
+})

package/src/deep/intersectEntries.d.ts

@@ -0,0 +1,13 @@
+import { compareKeyPath } from '../comparison';
+
+/**
+ * Returns a new entries array where each entry's key exists in the given keys array.
+ * @private
+ * @param entries - An array of entries, where each entry is a tuple [keyPath, value].
+ * @param keys - An array of key paths to intersect with.
+ * @returns A new array of entries whose keys are present in the keys array.
+ */
+export function intersectEntries<T>(
+    entries: [(string|number)[],T][],
+    keys: (string|number)[][]
+): [(string|number)[],T][];

package/src/deep/intersectEntries.js

@@ -0,0 +1,37 @@
+import { compareKeyPath } from "../comparison"
+
+/**
+ * 返回一个新entries，每个entry的key都在keys中。
+ * @template T
+ * @param {[(string|number)[],T][]} entries
+ * @param {(string|number)[][]} keys
+ */
+export function intersectEntries(entries, keys) {
+
+    /**
+     * 
+     * @param {[(string|number)[],T][]} acc 
+     * @param {[(string|number)[],T][]} entries 
+     * @param {(string|number)[][]} keys 
+     * @returns {[(string|number)[],T][]}
+     */
+    const loop = (acc, entries, keys) => {// 由intersect修改而来
+        if (entries.length === 0 || keys.length === 0) {
+            return acc
+        } else {
+            switch (Math.sign(compareKeyPath(entries[0][0], keys[0]))) {
+                case 0:
+                    let yy = [...acc, entries[0]]
+                    return loop(yy, entries.slice(1), keys.slice(1))
+
+                case -1:
+                    return loop(acc, entries.slice(1), keys)
+
+                case 1:
+                default:
+                    return loop(acc, entries, keys.slice(1))
+            }
+        }
+    }
+    return loop([], entries, keys)
+}

package/src/deep/intersectEntries.test.js

@@ -0,0 +1,20 @@
+import { intersectEntries } from './intersectEntries'
+
+test('test intersectEntries', () => {
+    let x = [
+        [[0, 0], 0],
+        [[0, 1], 1],
+        [[1, 0], 2],
+        [[1, 1], 3]]
+
+    let keys = [
+        [0, 0],
+        [1, 1]
+    ]
+
+    let y = intersectEntries(x, keys)
+
+    let e = [[[0, 0], 0], [[1, 1], 3]]
+
+    expect(y).toEqual(e)
+})

package/src/deep/objectToDeep.test.js

@@ -0,0 +1,31 @@
+import { BehaviorSubject } from 'rxjs'
+import { pluckProperty } from '../object'
+import { Deep } from './Deep'
+
+
+test('test objectToDeep', () => {
+    let observables = {
+        a: new BehaviorSubject(0),
+        c: [
+            new BehaviorSubject(0),
+            {
+                e: new BehaviorSubject(0),
+            },
+        ],
+    }
+
+    let deep = Deep.fromObject(observables, (v, k, p) => v instanceof BehaviorSubject)
+
+    let keys = [
+        ['a'],
+        ['c', 0],
+        ['c', 1, 'e'],
+    ]
+
+    expect(deep.keys).toEqual(keys)
+
+    let entries = keys.map(k => [k, pluckProperty(observables, k)])
+    
+    expect(deep.entries).toEqual(entries)
+
+})

package/src/deep/replaceValueDeep.test.js

@@ -0,0 +1,21 @@
+import { Deep } from './Deep'
+
+test('replaceValueDeep', () => {
+    let entries = [
+        [['a'], 0],
+        [['b'], 1],
+        [['c', 0], 2], [['c', 1], 3], [['c', 2, 'e'], 4]]
+
+    let deep = new Deep(entries)
+
+    let values = [5, 6, 7, 8, 9]
+
+    let y = deep.replaceValue(values)
+
+    let e = [
+        [['a'], 5],
+        [['b'], 6],
+        [['c', 0], 7], [['c', 1], 8], [['c', 2, 'e'], 9]]
+
+    expect(y.entries).toEqual(e)
+})

package/src/deep/unionDeep.test.js

@@ -0,0 +1,30 @@
+import { Deep } from './Deep'
+
+test('unionDeep test', () => {
+    let ent1 = [
+        [["a", "b"], 0],
+        [["a", "c"], 1], //*
+    ]
+
+    let ent2 = [
+        [["a", "c"], 'x'], //*
+        [["a", "d"], 2],
+        [["a", "e"], 3],
+        [["f"], 4],
+    ]
+
+    //a,b中的键不能重复
+    let deep1 = new Deep(ent1)
+    let deep2 = deep1.union(ent2)
+    let e = [
+        [["a", "b"], 0],
+        [["a", "c"], 1], //*
+        [["a", "c"], 'x'], //*
+        [["a", "d"], 2],
+        [["a", "e"], 3],
+        [["f"], 4],
+    ]
+    
+    expect(deep2.entries).toEqual(e)
+})
+

package/src/deep/zipValueDeep.test.js

@@ -0,0 +1,21 @@
+import { Deep } from './Deep'
+
+test('zipValueDeep', () => {
+    let entries = [
+        [['a'], 0],
+        [['b'], 1],
+        [['c', 0], 2],
+        [['c', 1], 3],
+        [['c', 2, 'e'], 4]]
+    let deep = new Deep(entries)
+    let values = [5, 6, 7, 8, 9]
+    let y = deep.zipValue(values)
+    let e = [
+        [['a'], [0, 5]],
+        [['b'], [1, 6]],
+        [['c', 0], [2, 7]],
+        [['c', 1], [3, 8]],
+        [['c', 2, 'e'], [4, 9]]
+    ]
+    expect(y.entries).toEqual(e)
+})

package/src/deep-rxjs/ObservableArray.d.ts

@@ -0,0 +1,55 @@
+import { Subject, Observable } from 'rxjs';
+
+/**
+ * ObservableArray 是一个可观察的数组，支持 insertBefore、removeChild、replaceChild 操作，
+ * 并通过 RxJS Subject 通知变化，适用于响应式 DOM 操作场景。
+ */
+export class ObservableArray<T = any> extends Array<T> {
+    constructor(newItem: () => T);
+
+    /**
+     * 变化通知的 Subject。
+     * 事件元组类型: ['insertBefore', T, number] | ['removeChild', number] | ['replaceChild', T, number]
+     */
+    action$: Subject<['insertBefore', T, number] | ['removeChild', number] | ['replaceChild', T, number]>;
+
+    /**
+     * 插入元素事件流，发出 [item, index]。
+     */
+    insertBefore$: Observable<[T, number]>;
+
+    /**
+     * 删除元素事件流，发出 index。
+     */
+    removeChild$: Observable<number>;
+
+    /**
+     * 替换元素事件流，发出 [item, index]。
+     */
+    replaceChild$: Observable<[T, number]>;
+
+    /**
+     * 在指定位置插入元素，并通知变化。
+     * @param item 要插入的元素
+     * @param index 插入位置，默认为数组末尾
+     */
+    insertBefore(item: T, index?: number): void;
+
+    /**
+     * 删除指定位置的元素，并通知变化。
+     * @param index 删除位置，默认为数组末尾
+     */
+    removeChild(index?: number): void;
+
+    /**
+     * 替换指定位置的元素，并通知变化。
+     * @param item 新元素
+     * @param index 替换位置
+     */
+    replaceChild(item: T, index: number): void;
+
+    /**
+     * 附加一个默认子元素
+     */
+    appendChild(): void;
+}

package/src/deep-rxjs/ObservableArray.js

@@ -0,0 +1,94 @@
+import { Subject } from 'rxjs'
+import { filter, map } from 'rxjs/operators'
+import { arrayInsert, arrayRemove } from '../array'
+
+/**
+ * ObservableArray 是一个可观察的数组，支持 insertBefore、removeChild、replaceChild 操作，
+ * 并通过 RxJS Subject 通知变化，适用于响应式 DOM 操作场景。
+ * 
+ * @template T
+ * @extends Array<T>
+ */
+export class ObservableArray extends Array {
+    /**
+     * @constructor 创建一个 ObservableArray 实例。禁止传参。
+     * @param {()=>T} newItem
+     * @throws {Error} 如果传入参数则抛出异常。
+     */
+    constructor(newItem) {
+        super();
+        this.newitem = newItem
+
+        /**
+         * 变化通知的 Subject。
+         * @type {Subject<any[]>}
+         */
+        this.action$ = new Subject()
+
+        /**
+         * 插入元素事件流，发出 [item, index]。
+         * @type {import('rxjs').Observable<[T, number]>}
+         */
+        this.insertBefore$ =
+            this.action$.pipe(
+                filter(([action]) => action === 'insertBefore'),
+                map(([_, item, index]) => [item, index]),
+            )
+
+        /**
+         * 删除元素事件流，发出 index。
+         * @type {import('rxjs').Observable<number>}
+         */
+        this.removeChild$ =
+            this.action$.pipe(
+                filter(([action]) => action === 'removeChild'),
+                map(([_, index]) => index),
+            )
+
+        /**
+         * 替换元素事件流，发出 [item, index]。
+         * @type {import('rxjs').Observable<[T, number]>}
+         */
+        this.replaceChild$ =
+            this.action$.pipe(
+                filter(([action]) => action === 'replaceChild'),
+                map(([_, item, index]) => [item, index]),
+            )
+    }
+
+    /**
+     * 在指定位置插入元素，并通知变化。
+     * @param {T} item 要插入的元素
+     * @param {number} [index=this.length] 插入位置，默认为数组末尾
+     */
+    insertBefore(item, index = this.length) {
+        arrayInsert(this, item, index)
+        this.action$.next(['insertBefore', item, index])
+    }
+
+    /**
+     * 删除指定位置的元素，并通知变化。
+     * @param {number} [index=this.length-1] 删除位置，默认为数组末尾
+     */
+    removeChild(index = this.length - 1) {
+        arrayRemove(this, index)
+        this.action$.next(['removeChild', index])
+    }
+
+    /**
+     * 替换指定位置的元素，并通知变化。
+     * @param {T} item 新元素
+     * @param {number} index 替换位置
+     */
+    replaceChild(item, index) {
+        this[index] = item
+        this.action$.next(['replaceChild', item, index])
+    }
+    /**
+     * 附加一个默认子元素
+     */
+    appendChild(){
+        this.insertBefore(this.newitem(), this.length)
+    }
+
+}

package/src/deep-rxjs/ObservableArray.test.js

@@ -0,0 +1,117 @@
+import { ObservableArray } from './ObservableArray'
+
+test('ObservableArray is Array', () => {
+    let arr = new ObservableArray()
+    expect(Array.isArray(arr)).toEqual(true)
+})
+
+test('test insertBefore', done => {
+    let states = []
+    let arr = new ObservableArray()
+
+    arr.insertBefore$.subscribe(([item, index]) => { states.push(['insertBefore', item, index]) })
+    arr.insertBefore(4)
+    arr.insertBefore(3)
+    arr.insertBefore(2, 0)
+
+    expect(states).toEqual([
+        ['insertBefore', 4, 0],
+        ['insertBefore', 3, 1],
+        ['insertBefore', 2, 0],
+    ])
+
+    expect([...arr]).toEqual([2, 4, 3])
+    expect(arr.length).toEqual(3)
+
+    done()
+})
+
+test('test removeChild', done => {
+    let states = []
+    let arr = new ObservableArray()
+    arr.removeChild$.subscribe(index => { states.push(['removeChild', index]) })
+
+    arr.insertBefore(4)
+    arr.insertBefore(3)
+
+    expect([...arr]).toEqual([4, 3])
+    expect(arr.length).toEqual(2)
+    arr.removeChild()
+    arr.removeChild(0)
+    expect(arr.length).toEqual(0)
+
+    expect(states).toEqual([
+        ['removeChild', 1],
+        ['removeChild', 0],
+    ])
+
+    expect([...arr]).toEqual([])
+
+    done()
+})
+
+test('test default argument', done => {
+    let arr = new ObservableArray()
+
+    arr.insertBefore(4)
+    arr.insertBefore(3)
+
+    expect([...arr]).toEqual([4, 3])
+    arr.insertBefore(2)
+    expect([...arr]).toEqual([4, 3, 2])
+
+    arr.removeChild()
+    expect([...arr]).toEqual([4, 3])
+
+    arr.removeChild()
+    expect([...arr]).toEqual([4])
+
+
+    done()
+})
+
+test('test replaceChild', done => {
+    let states = []
+    let arr = new ObservableArray()
+
+    arr.replaceChild$.subscribe(([item, index]) => { states.push(['replaceChild', item, index]) })
+
+    arr.insertBefore(4)
+    arr.insertBefore(3)
+    arr.insertBefore(2, 0)
+
+    expect([...arr]).toEqual([2, 4, 3])
+
+    arr.replaceChild('4', 1)
+
+    expect(states).toEqual([
+        ['replaceChild', '4', 1],
+    ])
+
+    expect([...arr]).toEqual([2, '4', 3])
+
+    done()
+})
+
+test('test action', done => {
+    let states = []
+    let arr = new ObservableArray()
+
+    arr.action$.subscribe(a => { states.push(a) })
+
+    arr.insertBefore('a')
+    arr.replaceChild('b', 0)
+    arr.removeChild()
+
+    expect(states).toEqual([
+        ['insertBefore', 'a', 0],
+        ['replaceChild', 'b', 0],
+        ['removeChild', 0],
+
+    ])
+
+    expect([...arr]).toEqual([])
+
+    done()
+})
+

package/src/deep-rxjs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isRxType'
+export * from './ObservableArray'

package/src/deep-rxjs/index.js

@@ -0,0 +1,2 @@
+export * from './isRxType'
+export * from './ObservableArray'

package/src/deep-rxjs/isRxType.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 检查对象是否为 RxJS 类型。
+ *
+ * `isRxType` 函数用于判断给定的对象是否为 RxJS 的 `Observable` 或 `Subscription` 类型。
+ *
+ * @param obj - 要检查的对象。
+ * @returns 如果对象是 `Observable` 或 `Subscription`，返回 `true`；否则返回 `false`。
+ */
+export declare function isRxType(obj: any): boolean;

package/src/deep-rxjs/isRxType.js

@@ -0,0 +1,15 @@
+import { isObservable, Subscription } from 'rxjs'
+
+/**
+ * 检查对象是否为 RxJS 类型。
+ *
+ * `isRxType` 函数用于判断给定的对象是否为 RxJS 的 `Observable` 或 `Subscription` 类型。
+ *
+ * @param {any} obj - 要检查的对象。
+ * @returns {boolean} - 如果对象是 `Observable` 或 `Subscription`，返回 `true`；否则返回 `false`。
+ *
+ */
+export function isRxType(obj) {
+    return typeof obj === 'object' && obj && 
+        (isObservable(obj) || obj instanceof Subscription)
+}

package/src/deep-rxjs/isRxType.test.js

@@ -0,0 +1,43 @@
+import { of, Subscription } from 'rxjs';
+import { isRxType } from './isRxType';
+
+describe('isRxType', () => {
+    test('should return true for an Observable', () => {
+        const observable = of(1);
+        expect(isRxType(observable)).toBe(true);
+    });
+
+    test('should return true for a Subscription', () => {
+        const subscription = new Subscription();
+        expect(isRxType(subscription)).toBe(true);
+    });
+
+    test('should return false for a plain object', () => {
+        const obj = {};
+        expect(isRxType(obj)).toBe(false);
+    });
+
+    test('should return null for null', () => {
+        expect(isRxType(null)).toBe(null);
+    });
+
+    test('should return false for undefined', () => {
+        expect(isRxType(undefined)).toBe(false);
+    });
+
+    test('should return false for a primitive value', () => {
+        expect(isRxType(42)).toBe(false);
+        expect(isRxType('string')).toBe(false);
+        expect(isRxType(true)).toBe(false);
+    });
+
+    test('should return false for a function', () => {
+        const func = () => {};
+        expect(isRxType(func)).toBe(false);
+    });
+
+    test('should return false for an array', () => {
+        const arr = [];
+        expect(isRxType(arr)).toBe(false);
+    });
+});