hyperscript-rxjs 1.3.14 → 1.3.15

package/package.json

@@ -3,38 +3,24 @@
     "rxjs": "7.8.2"
   },
   "devDependencies": {
-    "@babel/runtime-corejs3": "7.27.6",
     "@babel/core": "7.27.4",
-    "@babel/plugin-transform-runtime": "7.27.4",
     "@babel/preset-env": "7.27.2",
-    "@microsoft/api-extractor": "7.52.8",
     "@types/jest": "30.0.0",
-    "@webpack-cli/serve": "3.0.1",
-    "babel-jest": "30.0.0",
-    "babel-loader": "10.0.0",
-    "core-js": "3.43.0",
-    "jest": "30.0.0",
-    "jest-environment-jsdom": "30.0.0",
+    "babel-jest": "30.0.1",
+    "cross-env": "7.0.3",
+    "jest": "30.0.1",
+    "jest-environment-jsdom": "30.0.1",
     "jsdom": "26.1.0",
-    "regenerator-runtime": "0.14.1",
-    "rxjs": "7.8.2",
-    "tslib": "2.8.1",
-    "typescript": "5.8.3",
-    "webpack": "5.99.9",
-    "webpack-cli": "6.0.1"
+    "typescript": "5.8.3"
   },
   "scripts": {
-    "build": "webpack --config webpack.config.js",
-    "test": "jest",
     "type-check": "tsc --noEmit",
-    "dts:extract": "api-extractor run --local"
+    "test": "jest"
   },
   "name": "hyperscript-rxjs",
   "description": "A js UI library that uses rxjs to handle dom directly.",
-  "main": "dist/hyperscript-rxjs.js",
-  "types": "dist/hyperscript-rxjs.d.ts",
-  "version": "1.3.14",
   "author": "cuishengli<34696643@qq.com>",
+  "version": "1.3.15",
   "keywords": [
     "ui",
     "rxjs",
@@ -45,9 +31,14 @@
     "type": "git",
     "url": "git+https://github.com/xp44mm/hyperscript-rxjs.git"
   },
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
   "license": "LGPL-3.0-or-later",
   "files": [
-    "dist",
+    "src/**/*.js",
+    "src/**/*.d.ts",
     "README.md"
   ]
 }

package/src/array/advance.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Splits an array into two parts: the first `n` elements (in reverse order) and the remaining elements.
+ * 
+ * @param array - The input array to process.
+ * @param n - The number of elements to take from the start of the array.
+ * @returns A tuple where the first element is an array of the first `n` elements (in reverse order),
+ *          and the second element is the remaining elements of the array.
+ */
+export function advance<T>(array: T[], n: number): [T[], T[]];

package/src/array/advance.js

@@ -0,0 +1,13 @@
+/**
+ * @template T
+ * @param {Array<T>} array - 要处理的原数组
+ * @param {number} n - 要取出的元素个数
+ * @returns {[Array<T>, Array<T>]} - [已取出的元素数组, 剩余元素数组]
+ */
+export function advance(array, n) {
+    let taken = []
+    for (let i = 0; i < n; i++) {
+        taken[n - 1 - i] = array[i]
+    }
+    return [taken, array.slice(n)]
+}

package/src/array/advance.test.js

@@ -0,0 +1,12 @@
+import { advance } from './advance'
+
+describe('advance', () => {
+
+    test('advance test', () => {
+        let ls = [1, 2, 3, 4, 5]
+        let y = advance(ls,2)
+        let res = [[2, 1], [3, 4, 5]]
+        expect(y).toEqual(res)
+    })
+
+})

package/src/array/arrayInsert.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Inserts an element into an array at the specified position in place.
+ * 
+ * @param array - The array to modify.
+ * @param item - The element to insert.
+ * @param index - The position at which to insert the element (default is the end of the array).
+ */
+export function arrayInsert<T>(array: T[], item: T, index?: number): void;

package/src/array/arrayInsert.js

@@ -0,0 +1,13 @@
+/**
+ * insert a element at position in place.
+ * @param {any} array
+ * @param {any} item
+ * @param {any} index
+ */
+export function arrayInsert(array, item, index = array.length) {
+    const len = array.length
+    for (let i = len; i > index; i--) {
+        array[i] = array[i - 1]
+    }
+    array[index] = item
+}

package/src/array/arrayInsert.test.js

@@ -0,0 +1,13 @@
+import { arrayInsert } from './arrayInsert'
+
+describe('arrayInsert block', () => {
+
+    test('arrayInsert test', () => {
+        let array = [0, 1, 2, 3]
+        arrayInsert(array, '1', 1)
+
+        expect(array).toEqual([0, '1', 1, 2, 3])
+        expect(array.length).toEqual(5)
+    })
+
+})

package/src/array/arrayRemove.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Removes an element from an array at the specified position in place.
+ * 
+ * @param array - The array to modify.
+ * @param index - The position of the element to remove (default is the last element).
+ */
+export function arrayRemove<T>(array: T[], index?: number): void;

package/src/array/arrayRemove.js

@@ -0,0 +1,15 @@
+/**
+ * remove a element in place
+ * 
+ * @template T
+ * @param {T[]} array
+ * @param {number} index
+ */
+export function arrayRemove(array, index = array.length - 1) {
+    const len = array.length
+    for (let i = index; i < len - 1; i++) {
+        array[i] = array[i + 1]
+    }
+    Reflect.deleteProperty(array, len - 1)
+    array.length = len - 1
+}

package/src/array/arrayRemove.test.js

@@ -0,0 +1,13 @@
+import { arrayRemove } from './arrayRemove'
+
+describe('arrayRemove block', () => {
+
+test('arrayRemove test', () => {
+    let array = [0, 1, 2, 3]
+    arrayRemove(array, 1)
+    expect(array.length).toEqual(3)
+    expect(array).toEqual([0, 2, 3])
+
+})
+
+})

package/src/array/findLastIndex.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Finds the last index in an array where the callback function returns `true`.
+ * 
+ * @param array - The array to search.
+ * @param callbackFn - A function that is called for each element in the array. 
+ *                     It should return `true` for the element to match.
+ * @param lastIndex - The starting index for the search (default is the last index of the array).
+ * @returns The index of the last element that satisfies the callback function, or -1 if no such element is found.
+ */
+export function findLastIndex<T>(
+  array: T[],
+  callbackFn: (value: T, index: number) => boolean,
+  lastIndex?: number
+): number;

package/src/array/findLastIndex.js

@@ -0,0 +1,20 @@
+/**
+ * 查找数组中最后一个满足条件的元素索引。
+ *
+ * @public
+ * @template T
+ * @param {T[]} array - 要查找的数组
+ * @param {(value: T, index: number) => boolean} callbackFn - 判断函数，返回 true 表示找到
+ * @param {number} [lastIndex=array.length-1] - 可选，查找的起始索引（从后往前）
+ * @returns {number} - 最后一个满足条件的元素索引，未找到返回 -1
+ */
+export function findLastIndex(array, callbackFn, lastIndex = array.length - 1) {
+  lastIndex = Math.min(lastIndex, array.length - 1)
+  while (lastIndex >= 0) {
+    if (callbackFn(array[lastIndex], lastIndex)) {
+      return lastIndex;
+    }
+    lastIndex--
+  }
+  return -1;
+}

package/src/array/findLastIndex.test.js

@@ -0,0 +1,41 @@
+import { findLastIndex } from './findLastIndex';
+
+describe('findLastIndex', () => {
+  test('should find last index of matching element', () => {
+    const array = [1, 2, 3, 4, 5, 4, 3];
+    const callback = (item) => item === 4;
+    expect(findLastIndex(array, callback)).toBe(5);
+  });
+
+  test('should return -1 when no element matches', () => {
+    const array = [1, 2, 3];
+    const callback = (item) => item === 5;
+    expect(findLastIndex(array, callback)).toBe(-1);
+  });
+
+  test('should work with empty array', () => {
+    const array = [];
+    const callback = (item) => item === 1;
+    expect(findLastIndex(array, callback)).toBe(-1);
+  });
+
+  test('should find index based on element and index', () => {
+    const array = [10, 20, 30, 20, 10];
+    const callback = (item, index) => item === 20 && index < 3;
+    expect(findLastIndex(array, callback)).toBe(1);
+  });
+
+  test('should start searching from specified index', () => {
+    const array = [1, 2, 3, 4, 3, 2, 1];
+    const callback = (item) => item === 3;
+    expect(findLastIndex(array, callback, 4)).toBe(4);
+    expect(findLastIndex(array, callback, 3)).toBe(2);
+  });
+
+  test('should handle edge cases', () => {
+    const array = [1, 2, 3];
+    // Start index out of bounds
+    expect(findLastIndex(array, () => true, 10)).toBe(2);
+    expect(findLastIndex(array, () => true, -2)).toBe(-1);
+  });
+});

package/src/array/index.d.ts

@@ -0,0 +1,9 @@
+export * from './advance'
+export * from './arrayInsert'
+export * from './arrayRemove'
+export * from './findLastIndex'
+export * from './isRange'
+export * from './rangeArray'
+export * from './unwrapArgs'
+export * from './zipArray'
+

package/src/array/index.js

@@ -0,0 +1,9 @@
+export * from './advance'
+export * from './arrayInsert'
+export * from './arrayRemove'
+export * from './findLastIndex'
+export * from './isRange'
+export * from './rangeArray'
+export * from './unwrapArgs'
+export * from './zipArray'
+

package/src/array/isRange.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if the input array represents a range of consecutive numbers starting from 0.
+ * 
+ * @param keys - An array of strings to check.
+ * @returns `true` if the array represents a range of consecutive numbers starting from 0, otherwise `false`.
+ */
+export function isRange(keys: string[]): boolean;

package/src/array/isRange.js

@@ -0,0 +1,15 @@
+/**
+ * 判断输入的字符串数组是否为从0开始的连续数字区间（如 ['0','1','2',...])。
+ *
+ * @public
+ * @param {string[]} keys - 要检查的字符串数组
+ * @returns {boolean} - 如果是从0开始的连续数字区间返回 true，否则返回 false
+ */
+export function isRange(keys) {
+    if (keys.every(key => /^\d+$/.test(key))) {
+        let nums = keys.map(key => parseInt(key))
+        return nums.every((v, i) => v === i)
+    }
+    return false
+}
+

package/src/array/isRange.test.js

@@ -0,0 +1,6 @@
+import { isRange } from "./isRange"
+
+test('isRange test', () => {
+    let act = isRange(['0', '1', '2'])
+    expect(act).toEqual(true)
+})

package/src/array/rangeArray.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates an array of numbers from 0 to `length - 1`.
+ * 
+ * @param length - The length of the array to create.
+ * @returns An array of numbers from 0 to `length - 1`.
+ */
+export function rangeArray(length: number): number[];

package/src/array/rangeArray.js

@@ -0,0 +1,10 @@
+/**
+ * 创建一个从 0 到 length-1 的数字数组。
+ *
+ * @public
+ * @param {number} length - 要创建的数组长度
+ * @returns {number[]} - 从 0 到 length-1 的数字数组
+ */
+export function rangeArray(length) {
+    return Array.from({ length }).map((v, i) => i)
+}

package/src/array/rangeArray.test.js

@@ -0,0 +1,11 @@
+import { rangeArray } from './rangeArray'
+
+//describe block
+describe('rangeArray', () => {
+    test('rangeArray', () => {
+        let y = rangeArray(3)
+        expect(y).toEqual([0,1,2])
+    })
+
+})
+

package/src/array/unwrapArgs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * unwraps an array of arguments simply. If the array contains a single element that is itself an array,
+ * it unwraps and returns that element. Otherwise, it returns the original array.
+ * 
+ * @param args - The array of arguments to process.
+ * @returns The unwrapped array if the input is a single array, otherwise the original array.
+ */
+export function unwrapArgs<T>(
+    args: (T|T[])[]
+): T[];

package/src/array/unwrapArgs.js

@@ -0,0 +1,15 @@
+/**
+ * 简易unwrap参数数组。如果子节点是单个数组，则解构为子节点，否则返回原数组。
+ *
+ * @template T
+ * @param {(T|T[])[]} args - 子节点数组。
+ * @returns {T[]} - 解构后的子节点数组。
+ */
+export function unwrapArgs(args) {
+    return (
+        /** @type{T[]} */
+        (args.length === 1 && Array.isArray(args[0])
+            ? args[0]
+            : args
+        ));
+}

package/src/array/unwrapArgs.test.js

@@ -0,0 +1,33 @@
+import { unwrapArgs } from './unwrapArgs';
+
+describe('unwrapArgs', () => {
+    test('should unwrap a single nested array', () => {
+        const input = [[1, 2, 3]];
+        const result = unwrapArgs(input);
+        expect(result).toEqual([1, 2, 3]);
+    });
+
+    test('should return the original array if it contains multiple elements', () => {
+        const input = [1, 2, 3];
+        const result = unwrapArgs(input);
+        expect(result).toEqual([1, 2, 3]);
+    });
+
+    test('should return the original array if it is empty', () => {
+        const input = [];
+        const result = unwrapArgs(input);
+        expect(result).toEqual([]);
+    });
+
+    test('should return the original array if it contains a single non-array element', () => {
+        const input = ['hello'];
+        const result = unwrapArgs(input);
+        expect(result).toEqual(['hello']);
+    });
+
+    test('should handle deeply nested arrays by only unwrapping the first level', () => {
+        const input = [[[1, 2, 3]]];
+        const result = unwrapArgs(input);
+        expect(result).toEqual([[1, 2, 3]]);
+    });
+});

package/src/array/zipArray.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Combines two arrays into an array of tuples.
+ * 
+ * - If the arrays have different lengths, the longer array will be truncated to match the length of the shorter array.
+ * 
+ * @param a - The first array.
+ * @param b - The second array.
+ * @returns An array of tuples, where each tuple contains one element from `a` and one from `b`.
+ * @throws Will throw an error if either `a` or `b` is not an array.
+ */
+export function zipArray<T, U>(a: T[], b: U[]): [T, U][];

package/src/array/zipArray.js

@@ -0,0 +1,24 @@
+/**
+ * 合并两个数组为一个元组数组。
+ *
+ * 如果数组长度不同，将以较长的数组为基准，短数组对应位置为 undefined。
+ *
+ * @public
+ * @template T, U
+ * @param {T[]} a - 第一个数组
+ * @param {U[]} b - 第二个数组
+ * @returns {Array<[T, U]>} - 合并后的元组数组
+ * @throws {Error} 如果 a 或 b 不是数组
+ */
+export function zipArray(a, b) {
+    if (!Array.isArray(a) || !Array.isArray(b)) {
+        throw new Error("arrayZip(a,b):both a and b should be array")
+    }
+    if (a.length >= b.length) {
+        return a.map((v, i) => [v, b[i]])
+    }
+    else{
+        return b.map((v, i) => [a[i], v])
+    }
+}
+

package/src/array/zipArray.test.js

@@ -0,0 +1,16 @@
+import { zipArray } from './zipArray'
+
+describe('zipArray array ops', () => {
+test('eq test', () => {
+    let a = [1, 2, 3]
+    let b = ['a', 'b', 'c']
+    let e = [[1, 'a'], [2, 'b'], [3, 'c']]
+    expect(zipArray(a, b)).toEqual(e)
+})
+    test('gt test', () => {
+        expect(zipArray([1, 2, 3, 4], ['a', 'b', 'c'])).toEqual([[1, 'a'], [2, 'b'], [3, 'c'], [4, undefined]])
+    })
+    test('lt test', () => {
+        expect(zipArray([1, 2, 3], ['a', 'b', 'c', 'd'])).toEqual([[1, 'a'], [2, 'b'], [3, 'c'], [undefined, 'd']])
+    })
+})

package/src/comparers/Comparer.d.ts

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