hyperscript-rxjs 1.3.14 → 1.3.15

package/src/comparison/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./compareDate"
+export * from "./compareEntries"
+export * from "./compareKey"
+export * from "./compareKeyPath"
+export * from "./compareNumber"
+export * from "./defaultCompare"
+export * from "./types"

package/src/comparison/index.js

@@ -0,0 +1,7 @@
+export * from "./compareDate"
+export * from "./compareEntries"
+export * from "./compareKey"
+export * from "./compareKeyPath"
+export * from "./compareNumber"
+export * from "./defaultCompare"
+export * from "./types"

package/src/comparison/infinity.test.js

@@ -0,0 +1,122 @@
+describe('The definition of Infinity', () => {
+    test('typeof', () => {
+        expect(typeof Infinity).toEqual('number')
+        expect(typeof -Infinity).toEqual('number')
+    })
+
+    test('Number', () => {
+        expect(Number.POSITIVE_INFINITY).toEqual(Infinity)
+        expect(Number.NEGATIVE_INFINITY).toEqual(-Infinity)
+    })
+})
+
+describe('The properties of Infinity', () => {
+    test('some examples', () => {
+        expect(Infinity).toBeGreaterThan(100)
+        expect(Infinity).toBeGreaterThan(Number.MAX_SAFE_INTEGER)
+        expect(Infinity).toBeGreaterThan(Number.MAX_VALUE)
+        expect(Infinity).toBeGreaterThan(100n)
+
+
+    })
+
+    test('arithmetical operations', () => {
+        expect(Infinity + 1).toEqual(Infinity)
+        expect(Infinity + Infinity).toEqual(Infinity)
+
+        expect(Infinity * 2).toEqual(Infinity)
+        expect(Infinity * Infinity).toEqual(Infinity)
+
+        expect(Infinity / 2).toEqual(Infinity)
+    })
+
+    test('result in finite numbers', () => {
+        expect(10 / Infinity).toEqual(0)
+    })
+
+    test('results in `Infinity`', () => {
+        expect(10 / 0).toEqual(Infinity)
+    })
+
+    test('results in `NaN`', () => {
+        expect(Infinity / Infinity).toBeNaN()
+        expect(Infinity % 2).toEqual(NaN)
+    })
+})
+
+describe('the negative infinity', () => {
+    test('some examples', () => {
+        expect(-Infinity).toBeLessThan(100)
+        expect(-Infinity).toBeLessThan(Number.MIN_SAFE_INTEGER)
+        expect(-Infinity).toBeLessThan(Number.MIN_VALUE)
+        expect(-Infinity).toBeLessThan(Infinity)
+
+    })
+
+    test('end up in negative infinity', () => {
+        expect(Infinity * -2).toEqual(-Infinity)
+        expect(Infinity / -1).toEqual(-Infinity)
+        expect(-2 / 0).toEqual(-Infinity)
+    })
+
+})
+
+
+describe('Checking for *Infinity*', () => {
+    test('an infinite value equals to an infinite value of the same sign', () => {
+        expect(Infinity).toEqual(Infinity)
+        expect(-Infinity).toEqual(-Infinity)
+        expect(-Infinity).not.toEqual(Infinity)
+
+    })
+
+    test('whether the provided value is finite', () => {
+        expect(Number.isFinite(Infinity)).toEqual(false)
+        expect(Number.isFinite(-Infinity)).toEqual(false)
+        expect(Number.isFinite(999)).toEqual(true)
+
+    })
+
+})
+
+describe('*Infinity* use cases', () => {
+
+})
+
+describe('Pitfalls of *Infinity*', () => {
+    test('Parsing numbers', () => {
+        expect(parseFloat('Infinity')).toEqual(Infinity)
+        expect(parseInt('Infinity', 10)).toEqual(NaN)
+    })
+
+    test('JSON serialization', () => {
+        const worker = {
+            salary: Infinity
+        };
+
+        let y = JSON.parse(JSON.stringify(worker))
+        let e = { "salary": null }
+
+        expect(y).toEqual(e)
+    })
+
+    test('Max number overflow', () => {
+
+        expect(2 * Number.MAX_VALUE).toEqual(Infinity)
+        expect(Math.pow(10, 1000)).toEqual(Infinity)
+
+    })
+
+    test('Math functions', () => {
+        expect(Math.max()).toEqual(-Infinity)
+        expect(Math.min()).toEqual(Infinity)
+
+    })
+
+
+
+})
+
+
+
+

package/src/comparison/typeof.test.js

@@ -0,0 +1,64 @@
+describe('Basic usage', () => {
+    test('Number', () => {
+        expect(typeof 37).toEqual('number');
+        expect(typeof 3.14).toEqual('number');
+        expect(typeof (42)).toEqual('number');
+        expect(typeof Math.LN2).toEqual('number');
+        expect(typeof Infinity).toEqual('number');
+        expect(typeof NaN).toEqual('number'); // Despite being "Not-A-Number"
+        expect(typeof Number('1')).toEqual('number');      // Number tries to parse things into numbers
+        expect(typeof Number('shoe')).toEqual('number');   // including values that cannot be type coerced to a number
+
+        expect(typeof 42n).toEqual('bigint');
+    })
+
+    test('String', () => {
+        expect(typeof '').toEqual('string');
+        expect(typeof 'bla').toEqual('string');
+        expect(typeof `template literal`).toEqual('string');
+        expect(typeof '1').toEqual('string'); // note that a number within a string is still typeof string
+        expect(typeof (typeof 1)).toEqual('string'); // typeof always returns a string
+        expect(typeof String(1)).toEqual('string'); // String converts anything into a string, safer than toString
+    })
+
+    test('Boolean', () => {
+        expect(typeof true).toEqual('boolean');
+        expect(typeof false).toEqual('boolean');
+        expect(typeof Boolean(1)).toEqual('boolean'); // Boolean() will convert values based on if they're truthy or falsy
+        expect(typeof !!(1)).toEqual('boolean'); // two calls of the ! (logical NOT) operator are equivalent to Boolean()
+    })
+
+    test('Symbol', () => {
+        expect(typeof Symbol()).toEqual('symbol')
+        expect(typeof Symbol('foo')).toEqual('symbol')
+        expect(typeof Symbol.iterator).toEqual('symbol')
+    })
+
+    test('Undefined', () => {
+        expect(typeof undefined).toEqual('undefined')
+        expect(typeof declaredButUndefinedVariable).toEqual('undefined')
+        expect(typeof undeclaredVariable).toEqual('undefined')
+    })
+
+    test('Object', () => {
+        expect(typeof { a: 1 }).toEqual('object')
+
+        // use Array.isArray or Object.prototype.toString.call
+        // to differentiate regular objects from arrays
+        expect(typeof [1, 2, 4]).toEqual('object')
+
+        expect(typeof new Date()).toEqual('object')
+        expect(typeof /regex/).toEqual('object') // See Regular expressions section for historical results
+
+        // The following are confusing, dangerous, and wasteful. Avoid them.
+        expect(typeof new Boolean(true)).toEqual('object')
+        expect(typeof new Number(1)).toEqual('object')
+        expect(typeof new String('abc')).toEqual('object')
+    })
+
+    test('Function', () => {
+        expect(typeof function () { }).toEqual('function')
+        expect(typeof class C { }).toEqual('function')
+        expect(typeof Math.sin).toEqual('function')
+    })
+})

package/src/comparison/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * JavaScript 基本数据类型名称数组
+ * typeof 返回的所有类型字符串
+ */
+export declare const types: string[];

package/src/comparison/types.js

@@ -0,0 +1,11 @@
+/// 这个字符串数组列举了JavaScript 中所有基本数据类型（primitive types）的名称。typeof 返回值域
+export const types = [
+    "undefined",    // 未定义类型，表示未赋值的变量
+    "object",      // 对象类型（包括 null 和所有对象/数组/日期等）
+    "boolean",     // 布尔类型（true/false）
+    "number",      // 数字类型（包括整数和浮点数）
+    "bigint",     // 大整数类型（ES2020 新增，表示任意精度的整数）
+    "string",      // 字符串类型
+    "symbol",     // Symbol 类型（ES2015 新增，表示唯一标识符）
+    "function"    // 函数类型（虽然 typeof 返回 'function'，但函数本质是 object 的子类型）
+]

package/src/deep/Deep.d.ts

@@ -0,0 +1,58 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+
+export declare class Deep<T> {
+    constructor(entries: [(string | number)[], T][]);
+
+    readonly entries: [(string | number)[], T][];
+    readonly keys: (string | number)[][];
+    getValues(): T[];
+
+    /**
+     * 将深度数据结构转换为普通对象。
+     * 
+     * @returns {Record<string|number, any>} 转换后的普通对象。
+     */
+    toObject(): Record<string | number, any>;
+
+    findIndex(searchKeyPath: (string | number)[]): number;
+
+    structuralEqual(keys: (string | number)[][]): boolean;
+    structuralSubset(keys: (string | number)[][]): boolean;
+    structuralSuperset(keys: (string | number)[][]): boolean;
+
+    intersect(keys: (string | number)[][]): Deep<T>;
+    difference(keys: (string | number)[][]): Deep<T>;
+    /**
+     * 后来者赢(参数赢)
+     * @param entries 
+     */
+    union(entries: [(string | number)[], T][]): Deep<T>;
+
+    map<U>(
+        callbackfn: (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => U,
+        thisArg?: any
+    ): Deep<U>;
+    filter(
+        predicate: (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => boolean,
+        thisArg?: any
+    ): Deep<T>;
+    forEach(
+        callbackfn: (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => void,
+        thisArg?: any
+    ): void;
+
+    freshValue(obj: Record<string | number, any>): Deep<any>;
+    replaceValue<U>(values: U[]): Deep<U>;
+    zipValue<U>(values: U[]): Deep<[T, U]>;
+
+    combineLatest<U>(): Observable<Deep<U>>;
+    merge<U>(): Observable<[(string | number)[], U]>;
+
+    static fromObject(
+        obj: Record<string | number, any>,
+        filter?: (value: any, key: string | number, keyPath: (string | number)[]) => boolean
+    ): Deep<any>;
+    static fromBehaviorSubject(obj: Record<string | number, any>): Deep<BehaviorSubject<any>>;
+    static fromObservable(obj: Record<string | number, any>): Deep<Observable<any>>;
+}
+

package/src/deep/Deep.js

@@ -0,0 +1,267 @@
+import { BehaviorSubject, isObservable, Observable, combineLatest, from, Subscription } from 'rxjs'
+import { map, mergeMap } from 'rxjs/operators'
+
+import { zipArray } from "../array"
+import { pluckProperty } from '../object'
+import { keyPathComparer, entryComparer } from '../comparers'
+import { tojs, flat } from '../structures'
+import { intersectEntries } from './intersectEntries'
+
+
+/**
+ * 深度（嵌套）数据结构类，用于处理按键路径排序的键值对集合。
+ * 提供了多种操作方法，包括集合操作、序列操作和数据转换。
+ * 
+ * @template T
+ * 
+ */
+export class Deep {
+    /**
+     * 构造函数。
+     *
+     * @param {[(string|number)[], T][]} entries - 按键路径排序的键值对数组。键值对已经按keypath排序。
+     */
+    constructor(entries) {
+        this._entries = entries
+        this._keys = this._entries.map(([k]) => k)
+    }
+
+    ///基本數據屬性
+
+    get entries() { return this._entries }
+
+    get keys() { return this._keys }
+
+    getValues() {
+        return this.entries.map(([k, v]) => v)
+    }
+
+    ///构造正常数据对象
+    /**
+     * 将深度数据结构转换为普通对象。
+     * 
+     * @returns {Record<string|number, any>} 转换后的普通对象。
+     */
+    toObject() {
+        return tojs(this.entries)
+    }
+
+    ///單個讀取
+
+    /**
+     * 
+     * @param {(string|number)[]} searchKeyPath 
+     * @returns 
+     */
+    findIndex(searchKeyPath) {
+        return keyPathComparer.findIndexInSet(this.keys, searchKeyPath)
+    }
+
+    ///集合操作
+
+    /**
+     * 
+     * @param {(string|number)[][]} keys 
+     * @returns 
+     */
+    structuralEqual(keys) {
+        return keyPathComparer.isEqualset(this.keys, keys)
+    }
+
+    /**
+     * 
+     * @param {(string|number)[][]} keys 
+     * @returns 
+     */
+    structuralSubset(keys) {
+        return keyPathComparer.isSubset(this.keys, keys)
+    }
+
+    /**
+     * 
+     * @param {(string|number)[][]} keys 
+     * @returns 
+     */
+    structuralSuperset(keys) {
+        return keyPathComparer.isSuperset(this.keys, keys)
+    }
+
+    /**
+     * @param {(string|number)[][]} keys
+     * @this {Deep<T>}
+     * @returns {Deep<T>}
+     */
+    intersect(keys) {
+        let entries = intersectEntries(this.entries, keys)
+        return new Deep(entries)
+    }
+
+    /**
+     * 
+     * @param {(string|number)[][]} keys
+     * @this {Deep<T>}
+     * @returns {Deep<T>}
+     */
+    difference(keys) {
+        let newkeys = keyPathComparer.differenceSet(this.keys, keys)
+        return this.intersect(newkeys)
+    }
+
+    /**
+     * 后来者赢(参数赢)
+     * @param {[(string | number)[], T][]} entries 
+     * @returns 
+     */
+    union(entries) {
+        let entries2 = entryComparer.sort([...this.entries, ...entries])
+        return new Deep(entries2)
+    }
+
+
+    /// 序列操作符
+
+    /**
+     * 
+     * @template U
+     * @param {(value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => U} callbackfn 返回的是值，而不是键值对，KeyPath保持不变
+     * @param {Deep<T>} [thisArg]
+     * @this {Deep<T>}
+     * @returns {Deep<U>}
+     * 
+     */
+    map(callbackfn, thisArg) {
+        let values = this.entries.map(callbackfn, thisArg)
+        return this.replaceValue(values)
+    }
+
+    /**
+     * 
+     * @param {(value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => boolean} predicate 
+     * @param {Deep<T>} [thisArg]
+     * @returns 
+     */
+    filter(predicate, thisArg) {
+        let entries = this.entries.filter(predicate, thisArg)
+        return new Deep(entries)
+    }
+
+    /**
+     * 
+     * @param { (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => void} callbackfn 
+     * @param {Deep<T>} [thisArg]
+     * @returns 
+     */
+    forEach(callbackfn, thisArg) {
+        this.entries.forEach(callbackfn, thisArg)
+    }
+
+    /// 值操作
+
+    /**
+     * 修改部分个别数值
+     * @param {Record<string|number,any>} obj 
+     * @this {Deep<T>}
+     * @returns 
+     */
+    freshValue(obj) {
+        let entries = this.keys.map(
+            /**
+             * @returns {[(string | number)[],any]}
+             */
+            k => [k, pluckProperty(obj, k)]
+        )
+        return new Deep(entries)
+
+    }
+
+    /**
+     * 按列替换数值
+     * @template U
+     * @param {U[]} values
+     * @this {Deep<T>}
+     * @returns {Deep<U>}
+     */
+    replaceValue(values) {
+        let entries = zipArray(this.keys, values)
+        return new Deep(entries)
+    }
+
+    /**
+     * 按列替换数值，保留原有数值
+     * @template U
+     * @param {U[]} values
+     * @this {Deep<T>}
+     * @returns {Deep<[T,U]>}
+     */
+    zipValue(values) {
+        return this.replaceValue(zipArray(this.getValues(), values))
+    }
+
+    /// rxjs操作符
+
+    /**
+     * 返回Observable of 总体的当前值
+     * @template U
+     * @this {Deep<Observable<U>>}
+     * @returns {Observable<Deep<U>>}
+     */
+    combineLatest() {
+        let values = this.getValues()
+        return combineLatest(values).pipe(
+            map(values => this.replaceValue(values))
+        )
+    }
+
+    /**
+     * 返回发射消息的那一个成员的路径以及新值。
+     * @template U
+     * @this {Deep<Observable<U>>}
+     * @returns {Observable<[(string|number)[], U]>}
+     */
+    merge() {
+        return from(this.entries).pipe(
+            mergeMap(([keyPath, value$]) =>
+                value$.pipe(
+                    map(
+                        /**
+                         * @returns {[(string|number)[], U]}
+                         */
+                        value => [keyPath, value])
+                )))
+    }
+
+    /// 静态构造方法
+
+    /**
+     * 
+     * @param {{[_:string|number]:any}} obj 
+     * @param {(value: any, key: string | number, keyPath: (string | number)[]) => boolean} [filter]
+     * @returns 
+     */
+    static fromObject(obj, filter = () => false) {
+        let arr = flat(obj, filter)
+        let entries = entryComparer.sort(arr)
+        return new Deep(entries)
+    }
+
+    /**
+     * @template T
+     * @param {{[_:string|number]:any}} obj 
+     * @returns {Deep<BehaviorSubject<T>>}
+     */
+    static fromBehaviorSubject(obj) {
+        return Deep.fromObject(obj, v => isObservable(v) || v instanceof Subscription)
+            .filter(([k, v]) => v instanceof BehaviorSubject)
+    }
+
+    /**
+     * @template T
+     * @param {{[_:string|number]:any}} obj 
+     * @returns 
+     */
+    static fromObservable(obj) {
+        return Deep.fromObject(obj, v => isObservable(v) || v instanceof Subscription)
+            .filter(([k, v]) => isObservable(v))
+    }
+
+}

package/src/deep/Deep.test.js

@@ -0,0 +1,130 @@
+import { Deep } from './Deep'
+
+// let data = {
+//     a: {
+//         a: 0,
+//         b: 1,
+//     },
+//     b: [2, 3],
+// }
+
+// let entries = [[['a', 'a'], 0], [['a', 'b'], 1], [['b', 0], 2], [['b', 1], 3]]
+
+test('constructor entries', () => {
+    let entries = [[['a', 'a'], 0], [['a', 'b'], 1], [['b', 0], 2], [['b', 1], 3]]
+    let deep = new Deep(entries)
+    let y = deep.entries
+    expect(y).toEqual(entries)
+})
+
+test('deep keys', () => {
+    let entries = [[['a', 'a'], 0], [['a', 'b'], 1], [['b', 0], 2], [['b', 1], 3]]
+    let deep = new Deep(entries)
+
+    let keys = [['a', 'a'], ['a', 'b'], ['b', 0], ['b', 1]]
+    expect(deep.keys).toEqual(keys)
+})
+
+test('deep getValues', () => {
+    let entries = [[['a', 'a'], 0], [['a', 'b'], 1], [['b', 0], 2], [['b', 1], 3]]
+    let deep = new Deep(entries)
+    let values = [0, 1, 2, 3]
+    expect(deep.getValues()).toEqual(values)
+})
+
+test('deep toObject', () => {
+    let entries = [[['a', 'a'], 0], [['a', 'b'], 1], [['b', 0], 2], [['b', 1], 3]]
+    let deep = new Deep(entries)
+    let data = {
+        a: {
+            a: 0,
+            b: 1,
+        },
+        b: [2, 3],
+    }
+    expect(deep.toObject()).toEqual(data)
+})
+
+test('deep findIndex', () => {
+    let entries = [[['a', 'a'], 0], [['a', 'b'], 1], [['b', 0], 2], [['b', 1], 3]]
+    let deep = new Deep(entries)
+    let keyPath = ['a', 'b']
+    expect(deep.findIndex(keyPath)).toEqual(1)
+})
+
+test('keys & values', () => {
+    let entries = [[['a'], 0], [['b'], 1], [['c', 0], 2], [['c', 1], 3], [['c', 2, 'e'], 4]]
+
+    let deep = new Deep(entries)
+
+    let keys = [['a'], ['b'], ['c', 0], ['c', 1], ['c', 2, 'e']]
+
+    expect(deep.keys).toEqual(keys)
+    expect(deep.getValues()).toEqual([0, 1, 2, 3, 4])
+})
+
+test('find index', () => {
+    let entries = [[['a'], 0], [['b'], 1], [['c', 0], 2], [['c', 1], 3], [['c', 2, 'e'], 4]]
+
+    let deep = new Deep(entries)
+
+    let i = deep.findIndex(['c', 0])
+    expect(i).toEqual(2)
+
+    let j = deep.findIndex(['no exist', 0])
+    expect(j).toEqual(-1)
+})
+
+test('test to object', () => {
+    let entries = [[['a'], 0], [['b'], 1], [['c', 0], 2], [['c', 1], 3], [['c', 2, 'e'], 4]]
+
+    let deep = new Deep(entries)
+    let obj = {
+        a: 0,
+        b: 1,
+        c: [
+            2,
+            3,
+            {
+                e: 4,
+            },
+        ],
+    }
+
+    expect(deep.toObject()).toEqual(obj)
+})
+
+describe('structural comparison', () => {
+    test('structuralEqual', () => {
+        let deep = new Deep([[['a'], 0], [['b'], 1], [['c', 0], 2], [['c', 1], 3], [['c', 2, 'e'], 4]])
+        let keys = [['a'], ['b'], ['c', 0], ['c', 1], ['c', 2, 'e']]
+        let y = deep.structuralEqual(keys)
+        expect(y).toEqual(true)
+    })
+
+    test('structuralSubset', () => {
+        let deep = new Deep([[['a'], 0], [['c', 0], 2], [['c', 1], 3], [['c', 2, 'e'], 4]])
+        let keys = [
+            ['a'],
+            ['b'], //*
+            ['c', 0],
+            ['c', 1],
+            ['c', 2, 'e'],
+        ]
+        let y = deep.structuralSubset(keys)
+        expect(y).toEqual(true)
+    })
+
+    test('structuralSuperset', () => {
+        let deep = new Deep([[['a'], 0], [['b'], 1], [['c', 0], 2], [['c', 1], 3], [['c', 2, 'e'], 4]])
+        let keys = [
+            ['a'],
+            //['b'],
+            ['c', 0],
+            ['c', 1],
+            ['c', 2, 'e'],
+        ]
+        let y = deep.structuralSuperset(keys)
+        expect(y).toEqual(true)
+    })
+})