hyperscript-rxjs 1.3.13 → 1.3.15

package/src/comparers/Comparer.js

@@ -0,0 +1,149 @@
+import { distinctArray } from "./distinctArray.js";
+import { groupArrayBy } from "./groupArrayBy";
+import { groupSortedEntries } from "./groupSortedEntries";
+import { differenceSet } from "./differenceSet.js";
+import { findIndexInSet } from "./findIndexInSet.js";
+import { intersectSet } from "./intersectSet.js";
+import { isEqualset } from "./isEqualset.js";
+import { isSubset } from "./isSubset.js";
+import { isSuperset } from "./isSuperset.js";
+import { unionSet } from "./unionSet.js";
+import { sortedArrayToSet } from "./sortedArrayToSet.js";
+
+/**
+ * 用于比较和操作数组及集合的工具类。
+ *
+ * @public
+ * @template T
+ */
+export class Comparer {
+    /**
+     * @param {(a: T, b: T) => number} compare - 比较函数
+     */
+    constructor(compare) {
+        this.compare = compare;
+    }
+
+    /**
+     * 使用实例的比较函数对数组进行排序。
+     * @param {T[]} array - 要排序的数组
+     * @returns {T[]} 排序后的数组
+     */
+    sort(array) {
+        return array.sort(this.compare);
+    }
+
+    /**
+     * 移除数组中的重复值。
+     * @param {T[]} array - 要处理的数组
+     * @returns {T[]} 去重后的新数组
+     */
+    distinct(array) {
+        return distinctArray(array, (a, b) => this.compare(a, b) === 0);
+    }
+    
+    /**
+     * 将已排序的数组转为集合（去重）。
+     * @param {T[]} array - 已排序的数组
+     * @returns {T[]} 唯一元素数组
+     */
+    sortedArrayToSet(array) {
+        return sortedArrayToSet(array, this.compare);
+    }
+
+
+    /**
+     * 根据 getKey 生成的 key 对数组元素分组。
+     * @template U
+     * @param {U[]} array - 要分组的数组
+     * @param {(item:U) => T} getKey - 生成分组 key 的函数
+     * @returns {[T, U[]][]} 分组后的对象或数组
+     */
+    groupBy(array, getKey) {
+        return groupArrayBy(array, getKey, this.compare);
+    }
+
+    /**
+     * 对已排序的数组按 key 分组。
+     * @template V
+     * @param {[T,V][]} array - 已排序的数组
+     * @returns {[T, V[]][]} 分组结果
+     */
+    groupSortedEntries(array) {
+        return groupSortedEntries(array, this.compare);
+    }
+
+    /**
+     * 计算两个数组的差集。数组元素是升序排列
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {T[]} array1 中有而 array2 中没有的元素
+     */
+    differenceSet(array1, array2) {
+        return differenceSet(array1, array2, this.compare);
+    }
+
+    /**
+     * 计算两个数组的交集。
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {T[]} 同时存在于 array1 和 array2 的元素
+     */
+    intersectSet(array1, array2) {
+        return intersectSet(array1, array2, this.compare);
+    }
+
+    /**
+     * 计算两个数组的并集（去重）。
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {T[]} 两个数组的唯一元素合集
+     */
+    unionSet(array1, array2) {
+        return unionSet(array1, array2, this.compare);
+    }
+
+    /**
+     * 在集合（数组）中查找元素的索引。
+     * @param {T[]} set - 要查找的数组
+     * @param {T} element - 要查找的元素
+     * @returns {number} 元素在集合中的索引，未找到返回 -1
+     */
+    findIndexInSet(set, element) {
+        return findIndexInSet(set, element, this.compare);
+    }
+
+    /**
+     * 判断两个数组作为集合是否相等。
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {boolean} 如果集合相等返回 true，否则返回 false
+     */
+    isEqualset(array1, array2) {
+        return isEqualset(array1, array2, this.compare);
+    }
+
+    /**
+     * 判断第一个数组是否为第二个数组的子集。
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {boolean} 如果 array1 是 array2 的子集返回 true，否则返回 false
+     */
+    isSubset(array1, array2) {
+        return isSubset(array1, array2, this.compare);
+    }
+
+    /**
+     * 判断第一个数组是否为第二个数组的超集。
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {boolean} 如果 array1 是 array2 的超集返回 true，否则返回 false
+     */
+    isSuperset(array1, array2) {
+        return isSuperset(array1, array2, this.compare);
+    }
+
+}
+
+
+

package/src/comparers/comparers.d.ts

@@ -0,0 +1,21 @@
+import { Comparer } from './Comparer';
+
+/**
+ * A comparer instance using the default comparison logic.
+ */
+export const defaultComparer: Comparer<any>;
+
+/**
+ * A comparer instance for comparing keys.
+ */
+export const keyComparer: Comparer<number | string>;
+
+/**
+ * A comparer instance for comparing key paths.
+ */
+export const keyPathComparer: Comparer<(number | string)[]>;
+
+/**
+ * A comparer instance for comparing entries.
+ */
+export const entryComparer: Comparer<[(number | string)[], any]>;

package/src/comparers/comparers.js

@@ -0,0 +1,10 @@
+import { defaultCompare } from "../comparison/defaultCompare";
+import { compareKey } from "../comparison/compareKey";
+import { compareKeyPath } from "../comparison/compareKeyPath";
+import { compareEntries } from "../comparison/compareEntries";
+import { Comparer } from "./Comparer"
+
+export const defaultComparer = new Comparer(defaultCompare)
+export const keyComparer = new Comparer(compareKey)
+export const keyPathComparer = new Comparer(compareKeyPath)
+export const entryComparer = new Comparer(compareEntries)

package/src/comparers/differenceSet.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Computes the difference between two sorted sets (set1 - set2).
+ * 
+ * - Assumes both `set1` and `set2` are sorted.
+ * - Uses the provided `compare` function to determine the order and equality of elements.
+ * 
+ * @param set1 - The first sorted set.
+ * @param set2 - The second sorted set.
+ * @param compare - A comparison function that takes two elements and returns:
+ *                  - A negative number if the first element is less than the second.
+ *                  - 0 if the elements are equal.
+ *                  - A positive number if the first element is greater than the second.
+ *                  Default is `defaultCompare`.
+ * @returns A new array containing elements in `set1` that are not in `set2`.
+ */
+export function differenceSet<T>(
+  set1: T[],
+  set2: T[],
+  compare: (a: T, b: T) => number
+): T[];

package/src/comparers/differenceSet.js

@@ -0,0 +1,35 @@
+/**
+ * return set1 - set2
+ * @template T 
+ * @param {T[]} set1
+ * @param {T[]} set2
+ * @param {(a: T, b: T) => number} compare
+ * @returns {T[]}
+ */
+export function differenceSet(set1, set2, compare) {
+    /**
+     * @param {T[]} acc
+     * @param {T[]} a
+     * @param {T[]} b
+     * @returns {T[]}
+     */
+    function loop(acc, a, b) {
+        if (a.length === 0) {
+            return acc
+        } else if (b.length === 0) {
+            return [...acc, ...a]
+        } else {
+            let n = compare(a[0], b[0])
+            if (n === 0) {
+                return loop(acc, a.slice(1), b.slice(1))
+            } else if (n < 0) {
+                return loop([...acc, a[0]], a.slice(1), b)
+            }
+            else { // if (n > 0)
+                return loop(acc, a, b.slice(1))
+            }
+
+        }
+    }
+    return loop([], set1, set2)
+}

package/src/comparers/differenceSet.test.js

@@ -0,0 +1,11 @@
+import { differenceSet } from './differenceSet'
+import { defaultCompare } from '../comparison'
+
+
+test('differenceSet test', () => {
+    let a = ['A', 'B', 'C'].sort()
+    let b = ['C', 'D', 'E'].sort()
+
+    const s = differenceSet(a, b, defaultCompare)
+    expect(s).toEqual(['A', 'B'])
+})

package/src/comparers/distinctArray.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Removes duplicate elements from an array while maintaining the relative order of elements.
+ * 
+ * @param array - The input array to process.
+ * @param equals - A function to compare two elements for equality. 
+ *                 It should return `true` if the elements are equal, otherwise `false`.
+ *                 Default is `(a, b) => a === b`.
+ * @returns A new array with duplicates removed.
+ */
+export function distinctArray<T>(
+  array: T[],
+  equals: (a: T, b: T) => boolean
+): T[];

package/src/comparers/distinctArray.js

@@ -0,0 +1,30 @@
+/**
+ * 数组去重，并保持元素的相对顺序。
+ * @template T 
+ * @param {T[]} array
+ * @param {(a:T,b:T)=>number} equals
+ * @returns {T[]}
+ */
+export function distinctArray(array, equals) {
+    /**
+     * 递归处理去重
+     * @param {T[]} resultArray - 已去重的结果数组
+     * @param {T[]} rest - 剩余待处理的数组
+     * @returns {T[]} - 去重后的数组
+     */    
+    function loop(resultArray, rest) {
+        if (rest.length === 0) {
+            return resultArray
+        } else {
+            let [head, ...tail] = rest
+            if (resultArray.findIndex(e => equals(head, e)) < 0) {
+                return loop([...resultArray, head], tail)
+            } else {
+                return loop(resultArray, tail)
+            }
+
+        }
+    }
+
+    return loop([], array)
+}

package/src/comparers/distinctArray.test.js

@@ -0,0 +1,10 @@
+import { distinctArray } from './distinctArray'
+
+describe('distinctArray block', () => {
+    test('distinctArray', () => {
+        let x = ['B', 'C', 'B', 'A']
+        let y = distinctArray(x, (a, b) => a === b)
+        let e = ['B', 'C', 'A']
+        expect(y).toEqual(e)
+    })
+})

package/src/comparers/findIndexInSet.d.ts

@@ -0,0 +1,20 @@
+
+/**
+ * Similar to `Array.findIndex`, returns the index of an element in a sorted set.
+ * 
+ * - Assumes the input set is sorted using the provided `compare` function.
+ * 
+ * @param set - The sorted array to search.
+ * @param e - The element to find.
+ * @param compare - A comparison function that takes two elements and returns:
+ *                  - A negative number if the first element is less than the second.
+ *                  - 0 if the elements are equal.
+ *                  - A positive number if the first element is greater than the second.
+ *                  Default is `defaultCompare`.
+ * @returns The index of the element in the set, or `-1` if not found.
+ */
+export function findIndexInSet<T>(
+  set: T[],
+  e: T,
+  compare: (a: T, b: T) => number
+): number;

package/src/comparers/findIndexInSet.js

@@ -0,0 +1,27 @@
+/**
+ * 同Array.findIndex，返回元素在集合中的索引位置
+ * 
+ * @template T
+ * @param {T[]} set Array.sort(compare)后的Array
+ * @param {T} e 是要查找的元素
+ * @param {(a:T,b:T)=>number} compare 元素的比较函数
+ */
+export function findIndexInSet(set, e, compare) {
+    /** @param {number} i  */
+    function loop(i) {
+        if (i === set.length) {
+            return -1
+        } else {
+            const n = compare(set[i], e)
+            if (n === 0) {
+                return i
+            } else if (n < 0) {
+                return loop(i + 1)
+            } else {
+                return -1
+            }
+        }
+    }
+
+    return loop(0)
+}

package/src/comparers/findIndexInSet.test.js

@@ -0,0 +1,8 @@
+import { findIndexInSet } from './findIndexInSet'
+import { defaultCompare } from '../comparison'
+
+test('find index', () => {
+    let st = ['A', 'B', 'C'].sort()
+    expect(findIndexInSet(st, 'B',defaultCompare)).toEqual(1)
+    expect(findIndexInSet(st, 'D',defaultCompare)).toEqual(-1)
+})

package/src/comparers/groupArrayBy.d.ts

@@ -0,0 +1,19 @@
+
+/**
+ * Groups an array of elements by a key generated by the provided `getKey` function.
+ * 
+ * - The array is first transformed into key-value pairs, sorted by the keys, and then grouped.
+ * 
+ * @param array - The input array to group.
+ * @param getKey - A function that takes an element and returns the key to group by.
+ * @param compare - A comparison function that takes two keys and returns:
+ *                  - A negative number if the first key is less than the second.
+ *                  - 0 if the keys are equal.
+ *                  - A positive number if the first key is greater than the second.
+ * @returns An array of grouped elements, where each group is represented as a tuple containing the key and an array of elements.
+ */
+export function groupArrayBy<T, K>(
+  array: T[],
+  getKey: (item: T) => K,
+  compare: (a: K, b: K) => number
+): [K, T[]][];

package/src/comparers/groupArrayBy.js

@@ -0,0 +1,29 @@
+import { groupSortedEntries } from './groupSortedEntries'
+
+/**
+ * 按指定的 key 函数对数组元素分组。
+ *
+ * 先将数组元素映射为 [key, value] 对，按 key 排序后，再分组。
+ *
+ * @public
+ * @template T, K
+ * @param {T[]} array - 要分组的数组
+ * @param {(item: T) => K} getKey - 生成分组 key 的函数
+ * @param {(a: K, b: K) => number} compare - key 的比较函数
+ * @returns {[K, T[]][]} 分组后的结果，每组为 [key, 元素数组]
+ */
+export function groupArrayBy(array, getKey, compare) {
+    if (array.length === 0) {
+        return []
+    }
+
+    let sortedEntries =
+        array.map(
+            /**
+             * @returns {[K, T]}
+             */
+            e => [getKey(e), e]
+        )
+            .sort(([ka], [kb]) => compare(ka, kb))
+    return groupSortedEntries(sortedEntries, compare)
+}

package/src/comparers/groupArrayBy.test.js

@@ -0,0 +1,38 @@
+import { groupArrayBy } from './groupArrayBy'
+import { defaultCompare } from '../comparison'
+
+describe('groupArrayBy', function () {
+    test('group array by', function () {
+        const students = [
+            { name: 'Abby', score: 84 },
+            { name: 'Brad', score: 73 },
+            { name: 'Chris', score: 89 },
+            { name: 'Eddy', score: 58 },
+            { name: 'Gillian', score: 91 },
+        ]
+        let getKey = student => (student.score > 80 ? '录取' : '淘汰')
+        const x = groupArrayBy(students, getKey, defaultCompare)
+
+        ///返回的group key保留输入顺序。
+        let y = [
+            [
+                '录取',
+                [
+                    { name: 'Abby', score: 84 },
+                    { name: 'Chris', score: 89 },
+                    { name: 'Gillian', score: 91 },
+                ],
+            ],
+            [
+                '淘汰',
+                [
+                    { name: 'Brad', score: 73 },
+                    { name: 'Eddy', score: 58 },
+                ],
+            ],
+        ]
+
+        expect(x).toEqual(y)
+    })
+
+})

package/src/comparers/groupSortedEntries.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Groups an array of sorted key-value entries into an array of groups, 
+ * where each group contains entries with the same key.
+ * 
+ * - Assumes the input `sortedEntries` is already sorted by keys in ascending order.
+ * 
+ * @param sortedEntries - An array of key-value pairs, where the keys are already sorted in ascending order.
+ * @param compare - A comparison function that takes two keys and returns:
+ *                  - 0 if the keys are equal.
+ *                  - A negative number if the first key is less than the second.
+ *                  - A positive number if the first key is greater than the second.
+ * @returns An array of groups, where each group is a tuple containing a key and an array of values associated with that key.
+ */
+export function groupSortedEntries<K, V>(
+  sortedEntries: [K, V][],
+  compare: (a: K, b: K) => number
+): [K, V[]][];

package/src/comparers/groupSortedEntries.js

@@ -0,0 +1,38 @@
+
+/**
+ * Groups an array of sorted key-value entries into an array of groups, 
+ * where each group contains entries with the same key.
+ *
+ * @template K, V
+ * @param {[K, V][]} sortedEntries - An array of key-value pairs, 
+ * where the keys are already sorted in ascending order.
+ * @param {(a:K,b:K)=>number} compare - A comparison function that takes two keys 
+ * and returns a number: 0 if the keys are equal, a negative number if the first key 
+ * is less than the second, and a positive number otherwise.
+ * @returns {[K, V[]][]} An array of groups, where each group is a tuple 
+ * containing a key and an array of values associated with that key.
+ */
+export function groupSortedEntries(sortedEntries, compare) {
+    if (sortedEntries.length === 0) {
+        return []
+    }
+
+    const [head,...tail] = sortedEntries
+    /** @type {[K, V[]]} */
+    const firstGroup = [head[0], [head[1]]]
+
+    return tail.reduce(
+        (groups, [k, v]) => {
+            let [k0, group] = groups[groups.length - 1]
+            if (compare(k0, k) === 0) {
+                group.push(v)
+            } else {
+                groups.push([k, [v]])
+            }
+            return groups
+        },
+        [firstGroup]
+    )
+
+}
+

package/src/comparers/groupSortedEntries.test.js

@@ -0,0 +1,46 @@
+import { defaultCompare } from '../comparison'
+import { groupSortedEntries } from './groupSortedEntries'
+
+describe('groupSortedEntries', function () {
+    test('sorted key value pairs', () => {
+        //console.log(x)
+        let x = [
+            ['录取', { name: 'Abby', score: 84 }],
+            ['录取', { name: 'Chris', score: 89 }],
+            ['录取', { name: 'Dianne', score: 99 }],
+            ['录取', { name: 'Gillian', score: 91 }],
+            ['录取', { name: 'Irene', score: 85 }],
+            ['淘汰', { name: 'Brad', score: 73 }],
+            ['淘汰', { name: 'Eddy', score: 58 }],
+            ['淘汰', { name: 'Fred', score: 67 }],
+            ['淘汰', { name: 'Hannah', score: 78 }],
+            ['淘汰', { name: 'Jack', score: 69 }],
+        ]
+
+        let e = groupSortedEntries(x, defaultCompare)
+        let y = [
+            [
+                '录取',
+                [
+                    { name: 'Abby', score: 84 },
+                    { name: 'Chris', score: 89 },
+                    { name: 'Dianne', score: 99 },
+                    { name: 'Gillian', score: 91 },
+                    { name: 'Irene', score: 85 },
+                ],
+            ],
+            [
+                '淘汰',
+                [
+                    { name: 'Brad', score: 73 },
+                    { name: 'Eddy', score: 58 },
+                    { name: 'Fred', score: 67 },
+                    { name: 'Hannah', score: 78 },
+                    { name: 'Jack', score: 69 },
+                ],
+            ],
+        ]
+
+        expect(y).toEqual(e)
+    })
+})

package/src/comparers/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./Comparer"
+export * from "./comparers"
+// export * from "./differenceSet"
+// export * from "./distinctArray"
+// export * from "./findIndexInSet"
+// export * from "./groupArrayBy"
+// export * from "./groupSortedEntries"
+// export * from "./intersectSet"
+// export * from "./isEqualset"
+// export * from "./isSubset"
+// export * from "./isSuperset"
+// export * from "./sortedArrayToSet"
+// export * from "./unionSet"
+

package/src/comparers/index.js

@@ -0,0 +1,14 @@
+export * from "./Comparer"
+export * from "./comparers"
+// export * from "./differenceSet"
+// export * from "./distinctArray"
+// export * from "./findIndexInSet"
+// export * from "./groupArrayBy"
+// export * from "./groupSortedEntries"
+// export * from "./intersectSet"
+// export * from "./isEqualset"
+// export * from "./isSubset"
+// export * from "./isSuperset"
+// export * from "./sortedArrayToSet"
+// export * from "./unionSet"
+

package/src/comparers/intersectSet.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Computes the intersection of two sorted sets.
+ * 
+ * - Assumes both `set1` and `set2` are sorted in ascending order.
+ * - Uses the provided `compare` function to determine the order and equality of elements.
+ * 
+ * @param set1 - The first sorted set.
+ * @param set2 - The second sorted set.
+ * @param compare - A comparison function that takes two elements and returns:
+ *                  - A negative number if the first element is less than the second.
+ *                  - 0 if the elements are equal.
+ *                  - A positive number if the first element is greater than the second.
+ * @returns A new array containing elements that are present in both `set1` and `set2`.
+ */
+export function intersectSet<T>(
+  set1: T[],
+  set2: T[],
+  compare: (a: T, b: T) => number
+): T[];

package/src/comparers/intersectSet.js

@@ -0,0 +1,35 @@
+/**
+ * 计算两个有序数组的交集。
+ * @template T
+ * @param {T[]} set1 - 第一个已排序的数组
+ * @param {T[]} set2 - 第二个已排序的数组
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {T[]} 两数组的交集
+ */
+export function intersectSet(set1, set2, compare) {
+    /**
+     * 递归计算交集
+     * @param {T[]} acc - 当前交集结果
+     * @param {T[]} a - 剩余的 set1
+     * @param {T[]} b - 剩余的 set2
+     * @returns {T[]} 交集
+     */
+    function loop(acc, a, b) {
+        if (a.length === 0 || b.length === 0) {
+            return acc
+        } else {
+            //每次去掉最大的元素
+            switch (Math.sign(compare(a[0], b[0]))) {
+                case -1:
+                    return loop(acc, a.slice(1), b)
+                case 0:
+                    return loop([...acc, a[0]], a.slice(1), b.slice(1))
+                case 1:
+                default:
+                    return loop(acc, a, b.slice(1))
+            }
+        }
+    }
+
+    return loop([], set1, set2)
+}

package/src/comparers/intersectSet.test.js

@@ -0,0 +1,14 @@
+import { intersectSet } from './intersectSet'
+import { defaultCompare } from '../comparison'
+
+
+test('intersectSet test', () => {
+    //输入数组应该排序sort()
+    let a = [1, 2]
+    let b = [1, 3]
+    let c = [1, 2, 3]
+
+    expect(intersectSet(a, b, defaultCompare)).toEqual([1])
+    expect(intersectSet(a, c, defaultCompare)).toEqual(a)
+    expect(intersectSet(b, c, defaultCompare)).toEqual(b)
+})