hyperscript-rxjs 1.3.14 → 1.3.15

package/src/comparers/isEqualset.d.ts

@@ -0,0 +1,22 @@
+
+/**
+ * Determines if two sets are equal.
+ * 
+ * - Two sets are considered equal if they have exactly the same members.
+ * - 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.
+ *                  Default is `defaultCompare`.
+ * @returns `true` if `set1` and `set2` are equal, otherwise `false`.
+ */
+export function isEqualset<T>(
+    set1: T[],
+    set2: T[],
+    compare: (a: T, b: T) => number
+): boolean;

package/src/comparers/isEqualset.js

@@ -0,0 +1,33 @@
+/**
+ * 判断两个集合是否相等（成员完全相同，顺序无关）。
+ * @template T
+ * @param {T[]} set1 - 第一个集合
+ * @param {T[]} set2 - 第二个集合
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {boolean} 如果集合相等返回 true，否则返回 false
+ */
+export function isEqualset(set1, set2, compare) {
+    /**
+     * @param {T[]} a
+     * @param {T[]} b
+     * @returns {boolean}
+     */
+    function loop(a, b) {
+        if (a.length === 0 && b.length === 0) {
+            return true
+        }
+
+        if (a.length > 0 && b.length > 0) {
+            let [a0, ...aa] = a
+            let [b0, ...bb] = b
+            if (compare(a0, b0) === 0) {
+                return loop(aa, bb)
+            } else {
+                return false
+            }
+        }
+
+        return false
+    }
+    return loop(set1, set2)
+}

package/src/comparers/isEqualset.test.js

@@ -0,0 +1,22 @@
+import { compareKeyPath, defaultCompare } from '../comparison'
+import { isEqualset } from './isEqualset'
+
+describe('set ops block', () => {
+    test('isEqualset test', () => {
+        let a = [1, 2]
+        let b = [1, 3]
+        let c = [1, 2, 3]
+
+        expect(isEqualset(a, [...a], defaultCompare)).toEqual(true)
+        expect(isEqualset(a, b, defaultCompare)).toEqual(false)
+        expect(isEqualset(a, c, defaultCompare)).toEqual(false)
+        expect(isEqualset(b, c, defaultCompare)).toEqual(false)
+    })
+
+    test('isequal keypath test', () => {
+        let a = [[1, 2], ['a', 'b']]
+        let b = [[1, 2], ['a', 'b']]
+
+        expect(isEqualset(a, b, compareKeyPath)).toEqual(true)
+    })
+})

package/src/comparers/isSubset.d.ts

@@ -0,0 +1,21 @@
+
+/**
+ * Determines if `set1` is a subset of `set2`.
+ * 
+ * - 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 (potential subset).
+ * @param set2 - The second sorted set (potential superset).
+ * @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 `true` if `set1` is a subset of `set2`, otherwise `false`.
+ */
+export function isSubset<T>(
+  set1: T[],
+  set2: T[],
+  compare?: (a: T, b: T) => number
+): boolean;

package/src/comparers/isSubset.js

@@ -0,0 +1,33 @@
+/**
+ * 判断 set1 是否为 set2 的子集（假定已排序）。
+ * @template T
+ * @param {T[]} set1 - 可能为子集的数组
+ * @param {T[]} set2 - 可能为超集的数组
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {boolean} 如果 set1 是 set2 的子集返回 true，否则返回 false
+ */
+export function isSubset(set1, set2, compare) {
+    /**
+     * @param {T[]} a
+     * @param {T[]} b
+     * @returns {boolean}
+     */
+    function loop(a, b) {
+        if (a.length === 0) {
+            return true
+        } else if (b.length === 0) {
+            return false
+        } else {
+            switch (Math.sign(compare(a[0], b[0]))) {
+                case -1:
+                    return false
+                case 0:
+                    return loop(a.slice(1), b.slice(1))
+                case 1: 
+                default:
+                    return loop(a, b.slice(1))
+            }
+        }
+    }
+    return loop(set1, set2)
+}

package/src/comparers/isSubset.test.js

@@ -0,0 +1,21 @@
+import { isSubset } from './isSubset'
+import { compareKeyPath, defaultCompare } from '../comparison'
+
+describe('isSubset block', () => {
+    test('isSubset test', () => {
+        let a = [1, 2]
+        let b = [1, 3]
+        let c = [1, 2, 3]
+
+        expect(isSubset(a, [...a], defaultCompare)).toEqual(true)
+        expect(isSubset(a, b, defaultCompare)).toEqual(false)
+        expect(isSubset(a, c, defaultCompare)).toEqual(true)
+    })
+
+    test('isSubset keypath test', () => {
+        let a = [[1, 2], ['a', 'b']]
+        let b = [[1, 2], ['a', 'b'], [3, 'x']]
+
+        expect(isSubset(a, b, compareKeyPath)).toEqual(true)
+    })
+})

package/src/comparers/isSuperset.d.ts

@@ -0,0 +1,21 @@
+
+/**
+ * Determines if `a` is a superset of `b`.
+ * 
+ * - Assumes both `a` and `b` are sorted in ascending order.
+ * - Uses the provided `compare` function to determine the order and equality of elements.
+ * 
+ * @param a - The first sorted set (potential superset).
+ * @param b - The second sorted set (potential subset).
+ * @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 `true` if `a` is a superset of `b`, otherwise `false`.
+ */
+export function isSuperset<T>(
+  a: T[],
+  b: T[],
+  compare?: (a: T, b: T) => number
+): boolean;

package/src/comparers/isSuperset.js

@@ -0,0 +1,13 @@
+import { isSubset } from './isSubset'
+
+/**
+ * 判断 a 是否为 b 的超集（假定已排序）。
+ * @template T
+ * @param {T[]} a - 可能为超集的数组
+ * @param {T[]} b - 可能为子集的数组
+ * @param {(x: T, y: T) => number} compare - 比较函数
+ * @returns {boolean} 如果 a 是 b 的超集返回 true，否则返回 false
+ */
+export function isSuperset(a, b, compare) {
+    return isSubset(b, a, compare)
+}

package/src/comparers/isSuperset.test.js

@@ -0,0 +1,21 @@
+import { isSuperset } from './isSuperset'
+import { compareKeyPath, defaultCompare } from '../comparison'
+
+describe('isSuperset block', () => {
+    test('isSuperset test', () => {
+        let a = [1, 2]
+        let b = [1, 3]
+        let c = [1, 2, 3]
+
+        expect(isSuperset(a, [...a], defaultCompare)).toEqual(true)
+        expect(isSuperset(a, b, defaultCompare)).toEqual(false)
+        expect(isSuperset(c, a, defaultCompare)).toEqual(true)
+    })
+
+    test('isSuperset keypath test', () => {
+        let a = [[1, 2], ['a', 'b'], [3, 'x']]
+        let b = [[1, 2], ['a', 'b']]
+
+        expect(isSuperset(a, b, compareKeyPath)).toEqual(true)
+    })
+})

package/src/comparers/sortedArrayToSet.d.ts

@@ -0,0 +1,20 @@
+
+/**
+ * Removes duplicates from a sorted array.
+ * 
+ * - Assumes the input array is sorted in ascending order.
+ * - Throws an error if the array is not sorted correctly.
+ * 
+ * @param sortedArray - The input array, which must be sorted in ascending order.
+ * @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 with duplicates removed.
+ * @throws Will throw an error if the input array is not sorted in ascending order.
+ */
+export function sortedArrayToSet<T>(
+  sortedArray: T[],
+  compare: (a: T, b: T) => number
+): T[];

package/src/comparers/sortedArrayToSet.js

@@ -0,0 +1,35 @@
+/**
+ * 数组去重，排序好后的数组去重。
+ * @template T
+ * @param {T[]} sortedArray - 已排序的数组
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {T[]} 去重后的新数组
+ */
+export function sortedArrayToSet(sortedArray, compare) {
+    /**
+     * @param {T[]} acc - 当前结果
+     * @param {T[]} sarray - 剩余待处理的数组
+     * @returns {T[]} 去重后的新数组
+     */
+    function loop(acc, sarray) {
+        if (sarray.length === 0) {
+            return acc
+        } else {
+            switch (Math.sign(compare(acc[acc.length - 1], sarray[0]))) {
+                case -1:
+                    return loop([...acc, sarray[0]], sarray.slice(1))
+                case 0:
+                    return loop(acc, sarray.slice(1))
+                case 1:
+                default:
+                    throw new Error('sort ascent')
+            }
+        }
+    }
+
+    if (sortedArray.length === 0) {
+        return []
+    } else {
+        return loop([sortedArray[0]], sortedArray.slice(1))
+    }
+}

package/src/comparers/sortedArrayToSet.test.js

@@ -0,0 +1,11 @@
+import { sortedArrayToSet } from './sortedArrayToSet'
+import { compareKeyPath, defaultCompare } from '../comparison'
+
+describe('sortedArrayToSet block', () => {
+    test('sortedArrayToSet', () => {
+        //输入数组应该用相同的比较函数先排序一遍
+        let sortedArray = ['A', 'B', 'B', 'C']
+        let y = sortedArrayToSet(sortedArray, defaultCompare)
+        expect(y).toEqual(['A', 'B', 'C'])
+    })
+})

package/src/comparers/unionSet.d.ts

@@ -0,0 +1,21 @@
+
+/**
+ * Computes the union of two sorted sets.
+ * 
+ * - 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 all unique elements from both sets, sorted.
+ */
+export function unionSet<T>(
+  set1: T[],
+  set2: T[],
+  compare: (a: T, b: T) => number
+): T[];

package/src/comparers/unionSet.js

@@ -0,0 +1,34 @@
+/**
+ * 计算两个有序数组的并集（去重）。
+ * @template T
+ * @param {T[]} set1 - 第一个已排序的数组
+ * @param {T[]} set2 - 第二个已排序的数组
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {T[]} 并集后的新数组
+ */
+export function unionSet(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) {
+            return [...acc, ...b]
+        } else if (b.length === 0) {
+            return [...acc, ...a]
+        } else {
+            switch (Math.sign(compare(a[0], b[0]))) {
+                case -1:
+                    return loop([...acc, a[0]], a.slice(1), b)
+                case 0:
+                    return loop([...acc, a[0]], a.slice(1), b.slice(1))
+                case 1:
+                default:
+                    return loop([...acc, b[0]], a, b.slice(1))
+            }
+        }
+    }
+    return loop([], set1, set2)
+}

package/src/comparers/unionSet.test.js

@@ -0,0 +1,11 @@
+import { unionSet } from './unionSet'
+import { compareKeyPath, defaultCompare } from '../comparison'
+
+describe('unionSet block', () => {})
+
+test('unions two sets', () => {
+    const set1 = ['a', 'b', 'c']
+    const set2 = ['b', 'd', 'wow']
+    const set3 = unionSet(set1, set2, defaultCompare )
+    expect(set3).toEqual(['a', 'b', 'c', 'd', 'wow'])
+})

package/src/comparison/compareDate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compares two dates by their numeric value.
+ * 
+ * @param a - The first date to compare.
+ * @param b - The second date to compare.
+ * @returns A negative number if `a` is earlier than `b`, 0 if they are equal, or a positive number if `a` is later than `b`.
+ */
+export function compareDate(a: Date, b: Date): number;

package/src/comparison/compareDate.js

@@ -0,0 +1,11 @@
+/**
+ * 比较两个日期对象的大小。
+ *
+ * @public
+ * @param {Date} a - 第一个日期
+ * @param {Date} b - 第二个日期
+ * @returns {number} 如果 a > b 返回正数，a < b 返回负数，相等返回 0
+ */
+export function compareDate(a, b) {
+    return a.valueOf() - b.valueOf()
+}

package/src/comparison/compareEntries.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Compares two entries (key-value pairs) based on their key paths.
+ * 
+ * - Uses `compareKeyPath` to compare the key paths of the two entries.
+ * 
+ * @param entry1 - The first entry, where the key is a key path (array of keys).
+ * @param entry2 - The second entry, where the key is a key path (array of keys).
+ * @returns A negative number if `entry1` is less than `entry2`, 0 if they are equal, or a positive number if `entry1` is greater than `entry2`.
+ */
+export function compareEntries(
+  entry1: [(number | string)[], any],
+  entry2: [(number | string)[], any]
+): number;

package/src/comparison/compareEntries.js

@@ -0,0 +1,13 @@
+import { compareKeyPath } from "./compareKeyPath"
+
+/**
+ * 比较两个 entries（key-value 对）。依据他们的 key path。
+ *
+ * @public
+ * @param {[(number|string)[], any]} entry1 - 第一个 entry，key 为 key path（键路径数组）
+ * @param {[(number|string)[], any]} entry2 - 第二个 entry，key 为 key path（键路径数组）
+ * @returns {number} 若 entry1 < entry2 返回负数，相等返回 0，大于返回正数
+ */
+export function compareEntries([keypath1], [keypath2]) {
+    return compareKeyPath(keypath1, keypath2)
+}

package/src/comparison/compareKey.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compares two values and returns a number indicating their relative order.
+ * 
+ * - If both values are of the same type, it uses `defaultCompare` for comparison.
+ * - Strings are considered greater than numbers.
+ * 
+ * @param a - The first value to compare (can be a `number` or `string`).
+ * @param b - The second value to compare (can be a `number` or `string`).
+ * @returns A negative number if `a` is less than `b`, 0 if they are equal, or a positive number if `a` is greater than `b`.
+ */
+export function compareKey(a: number | string, b: number | string): number;

package/src/comparison/compareKey.js

@@ -0,0 +1,25 @@
+import { defaultCompare } from './defaultCompare.js'
+
+/**
+ * 
+ * Compares two values and returns a number indicating their relative order.
+ * @param {number|string} a - The first value to compare.
+ * @param {number|string} b - The second value to compare.
+ * @returns {number} -1 if a < b, 1 if a > b, or 0 if they are equal.
+ * 
+ */
+export function compareKey(a, b) {
+    let type1 = typeof a
+    let type2 = typeof b
+
+    if (type1 === type2) {
+        return defaultCompare(a,b)
+    }
+
+    //string > number
+    if (type1 === 'string') {
+        return 1
+    }
+
+    return -1
+}

package/src/comparison/compareKey.test.js

@@ -0,0 +1,21 @@
+import { compareKey } from './compareKey'
+
+describe('compare key', () => {
+    test('number compare', () => {
+        expect(compareKey(1, 2)).toEqual(-1)
+        expect(compareKey(2, 2)).toEqual(0)
+        expect(compareKey(2, 1)).toEqual(1)
+    })
+
+    test('string compare', () => {
+        expect(compareKey("80", "9")).toEqual(-1)
+        expect(compareKey('80', '80')).toEqual(0)
+        expect(compareKey('9', '80')).toEqual(1)
+    })
+
+    test('number string compare', () => {
+        expect(compareKey(1, 'x')).toEqual(-1)
+        expect(compareKey('x', 1)).toEqual(1)
+    })
+
+})

package/src/comparison/compareKeyPath.d.ts

@@ -0,0 +1,15 @@
+import { compareKey } from './compareKey';
+
+/**
+ * Compares two key paths (arrays of keys) lexicographically.
+ * 
+ * - Two empty arrays are considered equal.
+ * - An empty array is considered less than a non-empty array.
+ * - A non-empty array is considered greater than an empty array.
+ * - If the first elements of both arrays are equal, the comparison continues recursively with the remaining elements.
+ * 
+ * @param a - The first key path (array of keys) to compare.
+ * @param b - The second key path (array of keys) to compare.
+ * @returns A negative number if `a` is less than `b`, 0 if they are equal, or a positive number if `a` is greater than `b`.
+ */
+export function compareKeyPath(a: (number | string)[], b: (number | string)[]): number;

package/src/comparison/compareKeyPath.js

@@ -0,0 +1,33 @@
+import { compareKey } from './compareKey.js'
+
+/**
+ * 比较两个 key path（键路径数组）。
+ *
+ * @public
+ * @param {(number|string)[]} a - 第一个 key path
+ * @param {(number|string)[]} b - 第二个 key path
+ * @returns {number} 若 a < b 返回负数，相等返回 0，大于返回正数
+ */
+export function compareKeyPath(a, b) {
+    //两个空数组相等
+    if (a.length === 0 && b.length === 0) {
+        return 0
+    }
+
+    //空数组小于非空数组。
+    if (a.length === 0) {
+        return -1
+    }
+
+    //非空数组大于空数组。
+    if (b.length === 0) {
+        return 1
+    }
+
+    //两个数组每次从0位出一个元素，进行比较。
+    let [a0, ...aa] = a
+    let [b0, ...bb] = b
+
+    //两个元素相等，递归比较剩余数组。
+    return compareKey(a0, b0) || compareKeyPath(aa, bb)
+}

package/src/comparison/compareKeyPath.test.js

@@ -0,0 +1,28 @@
+import { compareKeyPath } from './compareKeyPath.js'
+
+describe('compare key path', () => {
+    test('empty array compare', () => {
+        expect(compareKeyPath([], [1])).toEqual(-1)
+        expect(compareKeyPath([], [])).toEqual(0)
+        expect(compareKeyPath([1], [])).toEqual(1)
+    })
+
+    //可比元素不同
+    test('elem different compare', () => {
+        expect(compareKeyPath([0], [1])).toEqual(-1)
+        expect(compareKeyPath([0, 1], [1])).toEqual(-1)
+        expect(compareKeyPath([0], [1, 2])).toEqual(-1)
+    })
+
+    //可比元素相同，长度不同
+    test('elem same compare', () => {
+        expect(compareKeyPath([0], [0])).toEqual(0)
+        expect(compareKeyPath([0, 1], [0])).toEqual(1)
+        expect(compareKeyPath([0], [0, 2])).toEqual(-1)
+    })
+
+    test('example compare', () => {
+        expect(compareKeyPath(['key', 0], ['key', 1])).toEqual(-1)
+    })
+
+})

package/src/comparison/compareNumber.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compares two numbers or bigints, including special handling for `NaN` and `Infinity`.
+ * 
+ * - `NaN` is considered the largest value.
+ * - Supports comparison of `number` and `bigint` types.
+ * 
+ * @param a - The first value to compare (can be `number` or `bigint`).
+ * @param b - The second value to compare (can be `number` or `bigint`).
+ * @returns A negative number if `a` is less than `b`, 0 if they are equal, or a positive number if `a` is greater than `b`.
+ */
+export function compareNumber(a: number | bigint, b: number | bigint): number;

package/src/comparison/compareNumber.js

@@ -0,0 +1,27 @@
+import { defaultCompare } from './defaultCompare'
+
+/**
+ * 可以比较NaN,Infinity,number,bigint
+ * @param {number|bigint} a
+ * @param {number|bigint} b
+ */
+export function compareNumber(a, b) {
+    if (Number.isNaN(a) && Number.isNaN(b)) {
+        return 0
+    }
+
+    //NaN最大
+    if (Number.isNaN(a)) {
+        return 1
+    }
+
+    if (Number.isNaN(b)) {
+        return -1
+    }
+
+    return defaultCompare(a, b)
+
+}
+
+
+

package/src/comparison/compareNumber.test.js

@@ -0,0 +1,21 @@
+import { compareNumber } from './compareNumber'
+
+describe('Basic usage', () => {
+    test('nan', () => {
+        expect(compareNumber(NaN, NaN)).toEqual(0)
+    })
+
+    test('nan Infinity', () => {
+        expect(compareNumber(NaN, Infinity)).toEqual(1)
+        expect(compareNumber(NaN, 0n)).toEqual(1)
+
+    })
+
+    test('Infinity bigint', () => {
+        expect(compareNumber(Infinity, 0n)).toEqual(1)
+        expect(compareNumber(-Infinity, 0n)).toEqual(-1)
+    })
+
+
+
+})

package/src/comparison/defaultCompare.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compares two values using the default comparison logic.
+ * 
+ * @param a - The first value to compare.
+ * @param b - The second value to compare.
+ * @returns A negative number if `a` is less than `b`, 0 if they are equal, or a positive number if `a` is greater than `b`.
+ */
+export function defaultCompare<T>(a: T, b: T): number;

package/src/comparison/defaultCompare.js

@@ -0,0 +1,12 @@
+/**
+ * 默认比较函数，适用于可比较的基本类型。
+ *
+ * @public
+ * @template T
+ * @param {T} a - 第一个值
+ * @param {T} b - 第二个值
+ * @returns {number} 如果 a > b 返回 1，a < b 返回 -1，相等返回 0
+ */
+export function defaultCompare(a, b) {
+    return a > b ? 1 : a < b ? -1 : 0
+}

package/src/comparison/defaultCompare.test.js

@@ -0,0 +1,24 @@
+import { defaultCompare } from './defaultCompare'
+
+describe('Basic usage', () => {
+    test('Undefined', () => {
+        expect(defaultCompare(undefined, undefined)).toEqual(0)
+    })
+
+    test('null', () => {
+        expect(defaultCompare(null, null)).toEqual(0)
+    })
+
+    test('nan', () => {
+        expect(defaultCompare(NaN, NaN)).toEqual(0)
+    })
+
+    test('+ Infinity', () => {
+        expect(defaultCompare(Infinity, Infinity)).toEqual(0)
+    })
+
+    test('- Infinity', () => {
+        expect(defaultCompare(- Infinity, - Infinity)).toEqual(0)
+    })
+
+})