hyperscript-rxjs 1.3.15 → 1.3.16

package/src/comparison/index.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

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

package/src/comparison/types.js

@@ -1,11 +0,0 @@
-/// 这个字符串数组列举了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

@@ -1,58 +0,0 @@
-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

@@ -1,267 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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)
-    })
-})