hyperscript-rxjs 1.3.15 → 1.3.16

package/src/nodes/normalizeChildNodes.test.js

@@ -1,55 +0,0 @@
-import { normalizeChildNodes } from './normalizeChildNodes';
-
-describe('normalizeChildNodes', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    test('should return an empty array when no child nodes are provided', () => {
-        const result = normalizeChildNodes([]);
-        expect(result).toEqual([]);
-    });
-
-    test('should handle a single node', () => {
-        const div = document.createElement('div');
-        const result = normalizeChildNodes([div]);
-        expect(result).toEqual([div]);
-    });
-
-    test('should handle multiple nodes', () => {
-        const div1 = document.createElement('div');
-        const div2 = document.createElement('div');
-
-        const result = normalizeChildNodes([div1, div2]);
-        expect(result).toEqual([div1, div2]);
-    });
-
-    test('should handle an array of nodes', () => {
-        const div1 = document.createElement('div');
-        const div2 = document.createElement('div');
-
-        const result = normalizeChildNodes([[div1, div2]]);
-        expect(result).toEqual([div1, div2]);
-    });
-
-    test('should convert non-node values to text nodes', () => {
-
-        const result = normalizeChildNodes(['Hello', 123, true]);
-        expect(result.length).toBe(3);
-        expect(result[0].nodeType).toBe(Node.TEXT_NODE);
-        expect(result[0].textContent).toBe('Hello');
-        expect(result[1].textContent).toBe('123');
-        expect(result[2].textContent).toBe('true');
-    });
-
-    test('should handle mixed nodes and non-nodes', () => {
-        const div = document.createElement('div');
-
-        const result = normalizeChildNodes([div, 'Text', 42]);
-        expect(result.length).toBe(3);
-        expect(result[0]).toBe(div);
-        expect(result[1].nodeType).toBe(Node.TEXT_NODE);
-        expect(result[1].textContent).toBe('Text');
-        expect(result[2].textContent).toBe('42');
-    });
-});

package/src/nodes/parseHyperscriptArgs.d.ts

@@ -1,10 +0,0 @@
-/**
- * 解析 hyperscript 风格的参数，返回 props 和 childNodes。
- * 
- * @param args - hyperscript 风格的参数数组。
- * @returns 包含 props（对象）和 childNodes（数组）的对象。
- * @throws 如果参数不是数组会抛出错误。
- */
-export function parseHyperscriptArgs(
-  args: any[]
-): { props: Record<string, any>, childNodes: any[] };

package/src/nodes/parseHyperscriptArgs.js

@@ -1,57 +0,0 @@
-/**
- * 解析 hyperscript 风格的参数，返回 props 和 childNodes。
- * 
- * @param {any[]} args - hyperscript 风格的参数数组。
- * @returns {{ props: Record<string, any>, childNodes: any[] }} 包含 props（对象）和 childNodes（数组）的对象。
- * @throws 如果参数不是数组会抛出错误。
- */
-
-export function parseHyperscriptArgs(args) {
-    // 参数验证，确保 args 是一个数组
-    if (!Array.isArray(args)) {
-        throw new Error('参数 "args" 必须是一个数组。');
-    }
-
-    if (args.length === 0) {
-        return { props: {}, childNodes: [] };
-    } else {
-        let [first, ...rest] = args;
-
-        // 
-        if (isProps(first)) {
-            return {
-                props: first ? first : {},
-                childNodes: rest
-            };
-        } else {
-            // 如果第一个参数不是对象，则所有参数作为子节点
-            return { props: {}, childNodes: args };
-        }
-    }
-}
-
-/**
- * 如果第一个参数是 undefined、null 或普通对象（非数组），则返回 true。
- * 否则返回 false。
- * @param {unknown} value - 要检查的值
- * @returns {boolean}
- * 
- */
-function isProps(value) {
-    //// 基本检查: 空作为props的占位符（不建议，作为兼容）
-    if (value === undefined || value === null) {
-        return true;
-    }
-
-    // 基本检查：非对象直接返回false
-    if (typeof value !== 'object') {
-        return false;
-    }
-
-    // 检查原型链
-    const proto = Object.getPrototypeOf(value);
-
-    // 1. 原型为null（如Object.create(null)创建的对象）
-    // 2. 原型等于Object.prototype（普通对象）
-    return proto === null || proto === Object.prototype;
-}

package/src/nodes/parseHyperscriptArgs.test.js

@@ -1,85 +0,0 @@
-import { parseHyperscriptArgs } from './parseHyperscriptArgs';
-
-describe('parseHyperscriptArgs', () => {
-    test('should handle empty arguments', () => {
-        expect(parseHyperscriptArgs([])).toEqual({
-            props: {},
-            childNodes: [],
-        });
-    });
-
-    test('should handle single props object', () => {
-        expect(parseHyperscriptArgs([{}])).toEqual({
-            props: {},
-            childNodes: [],
-        });
-
-        expect(parseHyperscriptArgs([{ id: 'test' }])).toEqual({
-            props: { id: 'test' },
-            childNodes: [],
-        });
-
-        expect(parseHyperscriptArgs([null])).toEqual({
-            props: {},
-            childNodes: [],
-        });
-
-        expect(parseHyperscriptArgs([undefined])).toEqual({
-            props: {},
-            childNodes: [],
-        });
-    });
-
-    test('should handle single childNodes', () => {
-        expect(parseHyperscriptArgs([1])).toEqual({
-            props: {},
-            childNodes: [1],
-        });
-
-        expect(parseHyperscriptArgs(['Hello'])).toEqual({
-            props: {},
-            childNodes: ['Hello'],
-        });
-
-        expect(parseHyperscriptArgs([1, 2, 3])).toEqual({
-            props: {},
-            childNodes: [1, 2, 3],
-        });
-    });
-
-    test('should handle props and childNodes', () => {
-        expect(parseHyperscriptArgs([{ id: 'test' }, 'Hello'])).toEqual({
-            props: { id: 'test' },
-            childNodes: ['Hello'],
-        });
-
-        expect(parseHyperscriptArgs([{ id: 'test' }, 'Hello', 'World'])).toEqual({
-            props: { id: 'test' },
-            childNodes: ['Hello', 'World'],
-        });
-
-        expect(parseHyperscriptArgs([{ className: 'container' }, 1, 2, 3])).toEqual({
-            props: { className: 'container' },
-            childNodes: [1, 2, 3],
-        });
-    });
-
-    test('should handle only childNodes when first argument is not an object', () => {
-        expect(parseHyperscriptArgs([1, 2, 3])).toEqual({
-            props: {},
-            childNodes: [1, 2, 3],
-        });
-
-        expect(parseHyperscriptArgs(['Hello', 'World'])).toEqual({
-            props: {},
-            childNodes: ['Hello', 'World'],
-        });
-    });
-
-    test('should throw an error if args is not an array', () => {
-        expect(() => parseHyperscriptArgs(null)).toThrow('参数 "args" 必须是一个数组。');
-        expect(() => parseHyperscriptArgs(undefined)).toThrow('参数 "args" 必须是一个数组。');
-        expect(() => parseHyperscriptArgs({})).toThrow('参数 "args" 必须是一个数组。');
-        expect(() => parseHyperscriptArgs('string')).toThrow('参数 "args" 必须是一个数组。');
-    });
-});

package/src/nodes/pipeEvent.d.ts

@@ -1,15 +0,0 @@
-import { Observable, Subscription } from 'rxjs';
-
-/**
- * 为指定的 DOM 元素订阅事件流，并通过 pipe 对事件流进行处理。
- * 
- * @param elem - 要订阅事件的 DOM 元素。
- * @returns 一个函数，接受事件名称和处理函数（接收事件流 Observable，返回 Subscription），用于订阅和处理事件，返回元素本身。
- * @throws 如果参数无效会抛出错误。
- */
-export function pipeEvent(
-  elem: HTMLElement
-): (
-  event: string,
-  subscriber: (event$: Observable<Event>) => Subscription
-) => HTMLElement;

package/src/nodes/pipeEvent.js

@@ -1,49 +0,0 @@
-import { fromEvent } from 'rxjs';
-import { attachSubscriptionToNode } from './attachSubscriptionToNode';
-import { Observable, Subscription } from 'rxjs';
-
-/**
- * 为指定的 DOM 元素订阅事件流，并通过 pipe 对事件流进行处理。
- *
- * @param {HTMLElement} elem - 要订阅事件的 DOM 元素。
- * @returns {(e:string,s:(event$: Observable<Event>) => Subscription)=>HTMLElement} - 返回一个函数，该函数接受事件名称和处理函数，用于订阅和处理事件。
- * @throws {Error} 如果参数无效。
- */
-export function pipeEvent(elem) {
-    // 参数检查，确保 elem 是一个有效的 DOM 元素
-    if (!(elem instanceof HTMLElement)) {
-        throw new Error('参数 "elem" 必须是一个有效的 DOM 元素。');
-    }
-
-    return (
-        /**
-         * 
-         * @param {string} event 
-         * @param {(event$: Observable<Event>) => Subscription} subscriber 
-         * @returns 
-         */
-        function (event, subscriber) {
-            // 参数检查，确保 event 是字符串，subscriber 是函数
-            if (typeof event !== 'string') {
-                throw new Error('参数 "event" 必须是一个字符串。');
-            }
-            if (typeof subscriber !== 'function') {
-                throw new Error('参数 "subscriber" 必须是一个函数。');
-            }
-            let event$ = fromEvent(elem, event)// 创建事件流 Observable
-
-            try {
-                let subscription = subscriber(event$); // 订阅事件流并处理           
-                attachSubscriptionToNode(elem, subscription); // 将订阅附加到 DOM 元素，便于管理
-
-            } catch (error) {
-                console.error(`处理事件 "${event}" 时发生错误:`, error);
-                throw error;
-            }
-
-            // 返回元素本身，支持链式调用
-            return elem;
-        }
-    )
-
-}

package/src/nodes/pipeEvent.test.js

@@ -1,97 +0,0 @@
-import { fromEvent } from 'rxjs';
-import { pipeEvent } from './pipeEvent';
-import { attachSubscriptionToNode } from './attachSubscriptionToNode';
-
-jest.mock('rxjs', () => ({
-    fromEvent: jest.fn((elem, event) => ({
-        pipe: jest.fn(() => ({
-            subscribe: jest.fn(),
-        })),
-    })),
-}));
-
-jest.mock('./attachSubscriptionToNode');
-
-describe('pipeEvent', () => {
-    let elem;
-
-    beforeEach(() => {
-        elem = document.createElement('div');
-        document.body.appendChild(elem);
-        jest.clearAllMocks();
-    });
-
-    afterEach(() => {
-        document.body.removeChild(elem);
-    });
-
-    test('should throw an error if elem is not a valid DOM element', () => {
-        expect(() => pipeEvent(null)).toThrow('参数 "elem" 必须是一个有效的 DOM 元素。');
-        expect(() => pipeEvent({})).toThrow('参数 "elem" 必须是一个有效的 DOM 元素。');
-    });
-
-    test('should throw an error if event is not a string', () => {
-        const pipe = pipeEvent(elem);
-        expect(() => pipe(null, jest.fn())).toThrow('参数 "event" 必须是一个字符串。');
-        expect(() => pipe(123, jest.fn())).toThrow('参数 "event" 必须是一个字符串。');
-    });
-
-    test('should throw an error if subscriber is not a function', () => {
-        const pipe = pipeEvent(elem);
-        expect(() => pipe('click', null)).toThrow('参数 "subscriber" 必须是一个函数。');
-        expect(() => pipe('click', 123)).toThrow('参数 "subscriber" 必须是一个函数。');
-    });
-
-    test('should process the event stream and attach the subscription to the node', () => {
-        const mockEvent$ = {
-            pipe: jest.fn(() => ({
-                subscribe: jest.fn(),
-            })),
-        };
-        fromEvent.mockReturnValue(mockEvent$);
-
-        const subscriber = jest.fn((event$) => event$.pipe());
-        const pipe = pipeEvent(elem);
-
-        pipe('click', subscriber);
-
-        expect(fromEvent).toHaveBeenCalledWith(elem, 'click');
-        expect(subscriber).toHaveBeenCalledWith(mockEvent$);
-        expect(attachSubscriptionToNode).toHaveBeenCalledWith(elem, expect.any(Object));
-    });
-
-    test('should log an error and rethrow if subscriber fails', () => {
-        const mockEvent$ = {
-            pipe: jest.fn(() => ({
-                subscribe: jest.fn(),
-            })),
-        };
-        fromEvent.mockReturnValue(mockEvent$);
-
-        console.error = jest.fn();
-
-        const subscriber = jest.fn(() => {
-            throw new Error('Subscriber failed');
-        });
-        const pipe = pipeEvent(elem);
-
-        expect(() => pipe('click', subscriber)).toThrow('Subscriber failed');
-        expect(console.error).toHaveBeenCalledWith('处理事件 "click" 时发生错误:', expect.any(Error));
-    });
-
-    test('should return the element itself for chainable calls', () => {
-        const mockEvent$ = {
-            pipe: jest.fn(() => ({
-                subscribe: jest.fn(),
-            })),
-        };
-        fromEvent.mockReturnValue(mockEvent$);
-
-        const subscriber = jest.fn((event$) => event$.pipe());
-        const pipe = pipeEvent(elem);
-
-        const result = pipe('click', subscriber);
-
-        expect(result).toBe(elem);
-    });
-});

package/src/nodes/subscribeEvent.d.ts

@@ -1,15 +0,0 @@
-import { Observer } from 'rxjs';
-
-/**
- * 为指定的 DOM 元素订阅事件流，并将订阅与元素绑定，便于管理。
- * 
- * @param elem - 要订阅事件的 DOM 元素。
- * @returns 一个函数，接受事件名称和观察者（函数或观察者对象），用于订阅事件，返回元素本身。
- * @throws 如果参数无效会抛出错误。
- */
-export function subscribeEvent(
-    elem: HTMLElement
-): (
-    event: string,
-    observer: ((value: Event) => void) | Partial<Observer<Event>>
-) => HTMLElement;

package/src/nodes/subscribeEvent.js

@@ -1,56 +0,0 @@
-import { fromEvent } from 'rxjs';
-import { attachSubscriptionToNode } from './attachSubscriptionToNode';
-
-/**
- * @template T
- * @typedef { import('rxjs').Observer<T> } Observer
- */
-
-/**
- * 为指定的 DOM 元素订阅事件流，并将订阅与元素绑定，便于管理。
- *
- * @param {HTMLElement} elem - 要订阅事件的 DOM 元素。
- * @returns {(e:string, o:((value: Event) => void) | Partial<Observer<Event>>) => HTMLElement} - 返回一个函数，该函数接受事件名称和观察者，用于订阅事件。
- * @throws {Error} 如果参数无效。
- * 
- */
-export function subscribeEvent(elem) {
-    // 参数检查，确保 elem 是一个有效的 DOM 元素
-    if (!(elem instanceof HTMLElement)) {
-        throw new Error('参数 "elem" 必须是一个有效的 DOM 元素。');
-    }
-
-    return (
-        /**
-         * @param {string} event 
-         * @param {((value: Event) => void) | Partial<Observer<Event>>} observer
-         * @returns 
-         */
-        (event, observer) => {
-            // 参数检查，确保 event 是字符串，observer 是函数或观察者对象
-            if (typeof event !== 'string') {
-                throw new Error('参数 "event" 必须是一个字符串。');
-            }
-            if ((typeof observer !== 'function' && typeof observer !== 'object') || observer === null) {
-                throw new Error('参数 "observer" 必须是一个函数或观察者对象。');
-            }
-
-            // 创建事件流 Observable
-            let event$ = fromEvent(elem, event);
-
-            // 订阅事件流
-            let subscription;
-            try {
-                subscription = event$.subscribe(observer);
-            } catch (error) {
-                console.error(`订阅事件 "${event}" 时发生错误:`, error);
-                throw error;
-            }
-
-            // 将订阅附加到 DOM 元素，便于管理
-            attachSubscriptionToNode(elem, subscription);
-
-            // 返回元素本身，支持链式调用
-            return elem;
-        });
-}

package/src/nodes/subscribeEvent.test.js

@@ -1,88 +0,0 @@
-import { fromEvent } from 'rxjs';
-import { subscribeEvent } from './subscribeEvent';
-import { attachSubscriptionToNode } from './attachSubscriptionToNode';
-
-jest.mock('rxjs', () => ({
-    fromEvent: jest.fn((elem, event) => ({
-        subscribe: jest.fn((observer) => {
-            // 模拟事件触发
-            elem.addEventListener(event, observer);
-            return {
-                unsubscribe: () => elem.removeEventListener(event, observer), // 模拟取消订阅
-            };
-        }),
-    })),
-}));
-
-jest.mock('./attachSubscriptionToNode');
-
-describe('subscribeEvent', () => {
-    let elem;
-
-    beforeEach(() => {
-        elem = document.createElement('div');
-        jest.clearAllMocks();
-    });
-
-    test('should throw an error if elem is not a valid DOM element', () => {
-        expect(() => subscribeEvent(null)).toThrow('参数 "elem" 必须是一个有效的 DOM 元素。');
-        expect(() => subscribeEvent({})).toThrow('参数 "elem" 必须是一个有效的 DOM 元素。');
-    });
-
-    test('should throw an error if event is not a string', () => {
-        const subscribe = subscribeEvent(elem);
-        expect(() => subscribe(null, jest.fn())).toThrow('参数 "event" 必须是一个字符串。');
-        expect(() => subscribe(123, jest.fn())).toThrow('参数 "event" 必须是一个字符串。');
-    });
-
-    test('should throw an error if observer is not a function or object', () => {
-        const subscribe = subscribeEvent(elem);
-        expect(() => subscribe('click', null)).toThrow('参数 "observer" 必须是一个函数或观察者对象。');
-        expect(() => subscribe('click', 123)).toThrow('参数 "observer" 必须是一个函数或观察者对象。');
-    });
-
-    test('should subscribe to the event and attach the subscription to the node', () => {
-        const observer = jest.fn();
-        const subscribe = subscribeEvent(elem);
-
-        subscribe('click', observer);
-
-        expect(fromEvent).toHaveBeenCalledWith(elem, 'click');
-        expect(attachSubscriptionToNode).toHaveBeenCalledWith(elem, expect.any(Object));
-
-        // 模拟点击事件
-        elem.click();
-        expect(observer).toHaveBeenCalledTimes(1);
-    });
-
-    test('should return the element itself for chainable calls', () => {
-        const observer = jest.fn();
-        const subscribe = subscribeEvent(elem);
-
-        const result = subscribe('click', observer);
-
-        expect(result).toBe(elem);
-    });
-
-    test('should log an error and rethrow if subscription fails', () => {
-        const mockEvent$ = {
-            subscribe: jest.fn(() => {
-                throw new Error('Subscription failed');
-            }),
-        };
-        fromEvent.mockReturnValue(mockEvent$);
-
-        console.error = jest.fn();
-
-        const observer = jest.fn();
-        const subscribe = subscribeEvent(elem);
-
-        expect(() => subscribe('click', observer)).toThrow('Subscription failed');
-        expect(console.error).toHaveBeenCalledWith('订阅事件 "click" 时发生错误:', expect.any(Error));
-        // 还原环境
-        fromEvent.mockReset(); // 清除 fromEvent 的模拟
-        console.error.mockRestore(); // 还原 console.error
-
-    });
-
-});

package/src/object/index.d.ts

@@ -1,10 +0,0 @@
-export * from './intersectObject'
-export * from './isEmptyObject'
-export * from './isPlainObject'
-export * from './nestedCombineLatest'
-export * from './nestedMerge'
-export * from './pickBehaviorSubject'
-export * from './pluckProperty'
-export * from './restore'
-export * from './splitObjectByObservable'
-

package/src/object/index.js

@@ -1,11 +0,0 @@
-export * from './intersectObject'
-export * from './isEmptyObject'
-export * from './isPlainObject'
-export * from './nestedCombineLatest'
-export * from './nestedMerge'
-export * from './pickBehaviorSubject'
-export * from './pluckProperty'
-export * from './restore'
-export * from './splitObjectByObservable'
-
-

package/src/object/intersectObject.d.ts

@@ -1,12 +0,0 @@
-/**
- * 创建一个新对象，仅包含指定 keys 的属性。
- * 
- * @param obj - 源对象。
- * @param keys - 要保留的属性名数组。
- * @returns 新对象，仅包含指定属性。
- * @throws 如果 obj 不是对象或 keys 不是数组会抛出 TypeError。
- */
-export function intersectObject(
-  obj: Record<string,any>,
-  keys: string[]
-): Record<string,any>;

package/src/object/intersectObject.js

@@ -1,23 +0,0 @@
-/**
- * Creates an object composed of the picked object properties.
- * @param {Record<string,any>} obj - Source object
- * @param {string[]} keys - Array of property keys to pick
- * @returns {Record<string,any>} New object with picked properties
- * @throws {TypeError} If obj is not an object or keys is not an array
- */
-export function intersectObject(obj, keys) {
-  // 类型检查
-  if (typeof obj !== 'object' || obj === null) {
-    throw new TypeError('First argument must be an object');
-  }
-  
-  if (!Array.isArray(keys)) {
-    throw new TypeError('Second argument must be an array');
-  }
-
-  return Object.fromEntries(
-    keys
-      .filter(key => key in obj)
-      .map(key => [key, obj[key]])
-  );
-}

package/src/object/intersectObject.test.js

@@ -1,69 +0,0 @@
-import { intersectObject } from './intersectObject.js'
-
-describe('intersectObject', () => {
-  // 基础测试用例
-  test('should pick existing properties from object', () => {
-    const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 };
-    const keys = ['a', 'd', 'e'];
-    const result = intersectObject(obj, keys);
-    expect(result).toEqual({ a: 1, d: 4, e: 5 });
-  });
-
-  // 1. 测试部分键不存在的情况
-  test('should ignore non-existent keys', () => {
-    const obj = { name: 'Alice', age: 25 };
-    const keys = ['name', 'city', 'country'];
-    const result = intersectObject(obj, keys);
-    expect(result).toEqual({ name: 'Alice' });
-  });
-
-  // 2. 测试空键数组的情况
-  test('should return empty object for empty keys array', () => {
-    const obj = { a: 1, b: 2 };
-    const keys = [];
-    const result = intersectObject(obj, keys);
-    expect(result).toEqual({});
-  });
-
-  // 3. 测试空对象的情况
-  test('should return empty object when source is empty', () => {
-    const obj = {};
-    const keys = ['a', 'b', 'c'];
-    const result = intersectObject(obj, keys);
-    expect(result).toEqual({});
-  });
-
-  // 4. 测试继承属性的情况
-  test('should include inherited properties when using "in" operator', () => {
-    const parent = { inheritedProp: 'value' };
-    const obj = Object.create(parent);
-    obj.ownProp = 'ownValue';
-    const keys = ['inheritedProp', 'ownProp', 'nonExistent'];
-    const result = intersectObject(obj, keys);
-    expect(result).toEqual({ inheritedProp: 'value', ownProp: 'ownValue' });
-  });
-
-  // 扩展建议1: 类型检查
-  describe('type checking', () => {
-    test('should throw error when first argument is not an object', () => {
-      expect(() => intersectObject(null, ['a'])).toThrow();
-      expect(() => intersectObject(123, ['a'])).toThrow();
-      expect(() => intersectObject('string', ['a'])).toThrow();
-    });
-
-    test('should throw error when second argument is not an array', () => {
-      expect(() => intersectObject({}, null)).toThrow();
-      expect(() => intersectObject({}, 123)).toThrow();
-      expect(() => intersectObject({}, 'string')).toThrow();
-    });
-  });
-
-  // 可选: 测试Symbol键的情况
-  test('should work with Symbol keys', () => {
-    const sym = Symbol('symbolKey');
-    const obj = { [sym]: 'symbolValue', regularKey: 'regularValue' };
-    const keys = [sym, 'regularKey'];
-    const result = intersectObject(obj, keys);
-    expect(result).toEqual({ [sym]: 'symbolValue', regularKey: 'regularValue' });
-  });
-});

package/src/object/isEmptyObject.d.ts

@@ -1,7 +0,0 @@
-/**
- * 判断对象是否为空对象（非数组、非 null，且无自有属性）。
- * 
- * @param obj - 要判断的对象。
- * @returns 如果是空对象返回 true，否则返回 false。
- */
-export function isEmptyObject(obj: unknown): boolean;