hyperscript-rxjs 1.3.14 → 1.3.15

package/src/object/restore.test.js

@@ -0,0 +1,124 @@
+import { BehaviorSubject } from 'rxjs'
+import { ObservableArray } from '../deep-rxjs/ObservableArray'
+import { pickBehaviorSubject } from './pickBehaviorSubject'
+import { restore } from './restore'
+
+test('BehaviorSubject happy', done => {
+    let source = new BehaviorSubject(0)
+    restore(source, 1)
+    expect(source.value).toEqual(1)
+    done()
+})
+
+test('array happy', done => {
+    let source = [
+        new BehaviorSubject(0),
+        new BehaviorSubject(0),
+    ]
+    restore(source, [1, 2])
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual([1, 2])
+    done()
+})
+
+test('array less', done => {
+    let source = [
+        new BehaviorSubject(0),
+        new BehaviorSubject(0),
+    ]
+    restore(source, [1])
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual([1, 0])
+    done()
+})
+
+test('nested happy', done => {
+    let model = {
+        title: new BehaviorSubject('compiler'),
+        keywords: [
+            new BehaviorSubject('lex'),
+            new BehaviorSubject('yacc'),
+        ]
+    }
+    let src = {
+        title: 'lang',
+        keywords: [
+            'js',
+            'fs',
+        ]
+    }
+    restore(model, src)
+
+    expect(model.title.value).toEqual(src.title)
+    expect(model.keywords[0].value).toEqual(src.keywords[0])
+    expect(model.keywords[1].value).toEqual(src.keywords[1])
+    done()
+})
+
+
+test('array too much', done => {
+    let source = [
+        new BehaviorSubject(0),
+        new BehaviorSubject(0),
+    ]
+    restore(source, [1, 2, 3])
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual([1, 2])
+    done()
+})
+
+test('object ignore member', done => {
+    let source = {
+        a: new BehaviorSubject(0),
+        b: 0
+    }
+    restore(source, { a: 1, b: 1 })
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual({ a: 1 })
+    done()
+})
+
+test('observable array happy', done => {
+    let source = new ObservableArray()
+
+    source.insertBefore(new BehaviorSubject(0))
+    source.insertBefore(new BehaviorSubject(0))
+    source.insertBefore(new BehaviorSubject(0))
+
+    restore(source, [1, 2, 3])
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual([1, 2, 3])
+    done()
+})
+
+test('observable array cut off', done => {
+    let source = new ObservableArray()
+
+    source.insertBefore(new BehaviorSubject(0))
+    source.insertBefore(new BehaviorSubject(0))
+    source.insertBefore(new BehaviorSubject(0))
+    source.insertBefore(new BehaviorSubject(0))
+
+    restore(source, [1, 2, 3])
+    let y = pickBehaviorSubject(source)
+    expect(y).toEqual([1, 2, 3])
+    done()
+})
+
+test('observable array complement', done => {
+    let model = new ObservableArray(()=>new BehaviorSubject(0))
+
+    let src = [1, 2, 3]
+    restore(model, src)
+
+    expect(model[0].value).toEqual(src[0])
+    expect(model[1].value).toEqual(src[1])
+    expect(model[2].value).toEqual(src[2])
+    done()
+})
+
+
+
+
+
+

package/src/object/splitObjectByObservable.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+
+/**
+ * 将对象属性按类型分为两部分：可观察对象（Observable）与普通值（非 Observable）。
+ * 
+ * @param obj - 要分割的对象，其属性值可能是 Observable 或普通值。
+ * @returns 一个数组，第一个对象包含所有 Observable 属性，第二个对象包含所有非 Observable 属性。
+ * @throws 如果参数不是一个非空对象会抛出错误。
+ */
+export function splitObjectByObservable(
+  obj: Record<string, any>
+): [Record<string, Observable<any>>, Record<string, any>];

package/src/object/splitObjectByObservable.js

@@ -0,0 +1,41 @@
+import { isObservable, Observable } from 'rxjs';
+
+/**
+ * 将对象属性按类型分为两部分：可观察对象（Observable）与普通值（非 Observable）。
+ *
+ * @param {Record<string,any>} obj - 要分割的对象，其属性值可能是 Observable 或普通值。
+ * @returns {[Record<string, Observable<any>>, Record<string, any>]} - 返回一个数组，第一个对象包含所有 Observable 属性，第二个对象包含所有非 Observable 属性。
+ * @throws {Error} 如果参数不是一个非空对象。
+ */
+export function splitObjectByObservable(obj) {
+    // 参数检查，确保输入是一个非空对象
+    if (typeof obj !== 'object' || Array.isArray(obj) || obj === null) {
+        throw new Error('参数 "obj" 必须是一个非空对象。');
+    }
+
+    /**
+     * @type {Record<string, Observable<any>>}
+     */
+    let observables = {}; // 存储 Observable 属性
+    
+    /**
+     * @type {Record<string, any>}
+     */
+    let scalars = {}; // 存储非 Observable 属性
+
+    // 遍历对象的所有属性
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            let value = obj[key];
+
+            // 根据值的类型分类
+            if (isObservable(value)) {
+                observables[key] = value; // 如果是 Observable，存入 observables
+            } else {
+                scalars[key] = value; // 否则存入 scalars
+            }
+        }
+    }
+    //可观察对象（Observable）与普通值（非 Observable）
+    return [observables, scalars];
+}

package/src/object/splitObjectByObservable.test.js

@@ -0,0 +1,78 @@
+import { of } from 'rxjs';
+import { splitObjectByObservable } from './splitObjectByObservable';
+
+describe('splitObjectByObservable', () => {
+    test('should split object into observables and scalars', () => {
+        const obj = {
+            a: of(1), // Observable
+            b: 42,    // Scalar
+            c: 'hello', // Scalar
+            d: of('world'), // Observable
+        };
+
+        const [observables, scalars] = splitObjectByObservable(obj);
+
+        // 验证 Observable 部分
+        expect(observables).toEqual({
+            a: obj.a,
+            d: obj.d,
+        });
+
+        // 验证 Scalar 部分
+        expect(scalars).toEqual({
+            b: 42,
+            c: 'hello',
+        });
+    });
+
+    test('should handle an object with only observables', () => {
+        const obj = {
+            a: of(1),
+            b: of(2),
+        };
+
+        const [observables, scalars] = splitObjectByObservable(obj);
+
+        // 验证 Observable 部分
+        expect(observables).toEqual(obj);
+
+        // 验证 Scalar 部分为空
+        expect(scalars).toEqual({});
+    });
+
+    test('should handle an object with only scalars', () => {
+        const obj = {
+            a: 42,
+            b: 'hello',
+        };
+
+        const [observables, scalars] = splitObjectByObservable(obj);
+
+        // 验证 Observable 部分为空
+        expect(observables).toEqual({});
+
+        // 验证 Scalar 部分
+        expect(scalars).toEqual(obj);
+    });
+
+    test('should return empty objects for an empty input object', () => {
+        const obj = {};
+
+        const [observables, scalars] = splitObjectByObservable(obj);
+
+        // 验证 Observable 部分为空
+        expect(observables).toEqual({});
+
+        // 验证 Scalar 部分为空
+        expect(scalars).toEqual({});
+    });
+
+    test('should throw an error if input is not an object', () => {
+        let errorMessage = '参数 "obj" 必须是一个非空对象。';
+        expect(() => splitObjectByObservable(null)).toThrow(errorMessage);
+        expect(() => splitObjectByObservable(undefined)).toThrow(errorMessage);
+        expect(() => splitObjectByObservable(42)).toThrow(errorMessage);
+        expect(() => splitObjectByObservable('string')).toThrow(errorMessage);
+        expect(() => splitObjectByObservable([])).toThrow(errorMessage);
+    });
+});

package/src/props/getNestedProperty.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 根据属性路径数组读取对象的嵌套属性值。
+ * 
+ * @param obj - 要读取属性的对象。
+ * @param keyPath - 属性路径数组，例如 ['a', 'b'] 表示 obj.a.b。
+ * @returns 返回目标属性的值，如果路径为空数组，则返回对象本身。
+ * @throws 如果路径中的某一级属性不存在或输入无效会抛出错误。
+ */
+export function getNestedProperty(
+    obj: Record<string | number, any>,
+    keyPath: (string | number)[]
+): any;

package/src/props/getNestedProperty.js

@@ -0,0 +1,31 @@
+/**
+ * 根据属性路径数组读取对象的嵌套属性值。
+ * @param {Record<string | number, any>} obj - 要读取属性的对象。
+ * @param {(string | number)[]} keyPath - 属性路径数组，例如 ['a', 'b'] 表示 obj.a.b。
+ * @returns {any} - 返回目标属性的值，如果路径为空数组，则返回对象本身。
+ * @throws {Error} 如果路径中的某一级属性不存在或输入无效。
+ */
+export function getNestedProperty(obj, keyPath) {
+    if (!Array.isArray(keyPath)) {
+        throw new Error('The "pathArray" parameter must be an array.');
+    }
+
+    if (!obj || typeof obj !== 'object') {
+        throw new Error('The "obj" parameter must be a non-null object.');
+    }
+
+    return keyPath.reduce((currentObj, key) => {
+        if (currentObj === null || currentObj === undefined) {
+            throw new Error(`Cannot read property "${key}" of null or undefined.`);
+        }
+
+        if (typeof key === 'string' && typeof currentObj === 'object' && key in currentObj) {
+            return /** @type {Record<string, any>} */ (currentObj)[key];
+        } else if (typeof key === 'number' && Array.isArray(currentObj) && key >= 0 && key < currentObj.length) {
+            return currentObj[key];
+        } else {
+            throw new Error(`Property "${key}" does not exist on the object.`);
+        }
+
+    }, obj);
+}

package/src/props/getNestedProperty.test.js

@@ -0,0 +1,72 @@
+import { getNestedProperty } from './getNestedProperty';
+
+describe('getNestedProperty', () => {
+    test('should return the object itself if pathArray is empty', () => {
+        const obj = { a: 1 };
+        expect(getNestedProperty(obj, [])).toBe(obj);
+    });
+
+    test('should return a simple property value', () => {
+        const obj = { a: 1 };
+        expect(getNestedProperty(obj, ['a'])).toBe(1);
+    });
+
+    test('should return a nested property value', () => {
+        const obj = { a: { b: { c: 42 } } };
+        expect(getNestedProperty(obj, ['a', 'b', 'c'])).toBe(42);
+    });
+
+    test('should throw an error if a property in the path does not exist', () => {
+        const obj = { a: { b: { c: 42 } } };
+        expect(() => getNestedProperty(obj, ['a', 'x'])).toThrow(
+            'Property "x" does not exist on the object.'
+        );
+        expect(() => getNestedProperty(obj, ['a', 'b', 'd'])).toThrow(
+            'Property "d" does not exist on the object.'
+        );
+    });
+
+    test('should throw an error if the pathArray is not an array', () => {
+        const obj = { a: 1 };
+        expect(() => getNestedProperty(obj, null)).toThrow(
+            'The "pathArray" parameter must be an array.'
+        );
+        expect(() => getNestedProperty(obj, 'a')).toThrow(
+            'The "pathArray" parameter must be an array.'
+        );
+    });
+
+    test('should throw an error if the obj parameter is not an object', () => {
+        expect(() => getNestedProperty(null, ['a'])).toThrow(
+            'The "obj" parameter must be a non-null object.'
+        );
+        expect(() => getNestedProperty(undefined, ['a'])).toThrow(
+            'The "obj" parameter must be a non-null object.'
+        );
+        expect(() => getNestedProperty(42, ['a'])).toThrow(
+            'The "obj" parameter must be a non-null object.'
+        );
+    });
+
+    test('should handle deeply nested properties', () => {
+        const obj = { a: { b: { c: { d: 'value' } } } };
+        expect(getNestedProperty(obj, ['a', 'b', 'c', 'd'])).toBe('value');
+    });
+
+    test('should handle properties with special characters', () => {
+        const obj = { 'data-value': { 'inner.prop': 'test' } };
+        expect(getNestedProperty(obj, ['data-value', 'inner.prop'])).toBe('test');
+    });
+
+    test('should handle arrays as part of the path', () => {
+        const obj = { a: [{ b: 42 }] };
+        expect(getNestedProperty(obj, ['a', 0, 'b'])).toBe(42);
+    });
+
+    test('should throw an error if accessing an array index that does not exist', () => {
+        const obj = { a: [{ b: 42 }] };
+        expect(() => getNestedProperty(obj, ['a', 1, 'b'])).toThrow(
+            'Property "1" does not exist on the object.'
+        );
+    });
+});

package/src/props/index.d.ts

@@ -0,0 +1,7 @@
+export * from './getNestedProperty';
+export * from './parsePropName';
+export * from './setProp';
+export * from './setProps';
+export * from './subscribeProp';
+
+

package/src/props/index.js

@@ -0,0 +1,7 @@
+export * from './getNestedProperty';
+export * from './parsePropName';
+export * from './setProp';
+export * from './setProps';
+export * from './subscribeProp';
+
+

package/src/props/parsePropName.d.ts

@@ -0,0 +1,13 @@
+
+/**
+ * 解析嵌套的 DOM 属性路径，并返回目标对象和属性名。
+ * 
+ * @param props - 属性路径字符串，支持嵌套属性（如 "style.color"）。
+ * @param obj - 起始对象，通常是一个 DOM 元素。
+ * @returns [目标对象, 属性名]，如 [obj.style, "color"]。
+ * @throws 如果路径中的某一级属性不存在或输入无效会抛出错误。
+ */
+export function parsePropName(
+  props: string,
+  obj: Record<string, any>
+): [Record<string, any>, string];

package/src/props/parsePropName.js

@@ -0,0 +1,45 @@
+import { getNestedProperty } from './getNestedProperty';
+
+/**
+ * 解析嵌套的 DOM 属性路径，并返回目标对象和属性名。
+ *
+ * @param {string} props - 属性路径，是 DOM API 的属性，不需要引号包裹，支持嵌套属性（如 "style.color"）。
+ * @param {Record<string, any>} obj - 起始对象，通常是一个 DOM 元素。
+ * @returns {[Record<string, any>, string]} - 返回一个数组，表示叶节点，其中第一个元素是目标对象，第二个元素是属性名。（如 [obj.style, "color"]）。
+ * @throws {Error} 如果路径中的某一级属性不存在或输入无效。
+ */
+export function parsePropName(props, obj) {
+    if (typeof props !== 'string') {
+        throw new Error('The "prop" parameter must be a string.');
+    }
+    
+    /**
+     * @param {any} target
+     * @param {string} prop
+     * @returns {[any, string]}
+     */
+    function getTargetAndProp(target, prop) {
+        if (!target || typeof target !== 'object') {
+            throw new Error('The "obj" parameter must be a non-null object.');
+        }
+
+        if (!(prop in target)) {
+            throw new Error(`Property "${prop}" does not exist on the target object.`);
+        }
+
+        return [target, prop];
+    }
+
+    if (props.includes('.')) {
+        const pathArray = props.split('.')
+        const prop = pathArray.pop()
+        if(!prop){
+            throw new Error('The "prop" parameter must be a non-empty string.');
+        }
+        const target = getNestedProperty(obj, pathArray)
+        return getTargetAndProp(target, prop)
+
+    } else {
+        return getTargetAndProp(obj, props)
+    }
+}

package/src/props/parsePropName.test.js

@@ -0,0 +1,67 @@
+import { parsePropName } from './parsePropName';
+
+describe('parsePropName', () => {
+    test('should parse a simple property', () => {
+        const obj = { id: 'test' };
+        const [target, prop] = parsePropName('id', obj);
+        expect(target).toBe(obj);
+        expect(prop).toBe('id');
+    });
+
+    test('should parse a nested property', () => {
+        const obj = { style: { color: 'red' } };
+        const [target, prop] = parsePropName('style.color', obj);
+        expect(target).toBe(obj.style);
+        expect(prop).toBe('color');
+    });
+
+    test('should throw an error if the property does not exist in a simple path', () => {
+        const obj = { id: 'test' };
+        expect(() => parsePropName('name', obj)).toThrow(
+            'Property "name" does not exist on the target object.'
+        );
+    });
+
+    test('should throw an error if the property does not exist in a nested path', () => {
+        const obj = { style: { color: 'red' } };
+        expect(() => parsePropName('style.background', obj)).toThrow(
+            'Property "background" does not exist on the target object.'
+        );
+    });
+
+    test('should throw an error if the prop parameter is not a string', () => {
+        const obj = { id: 'test' };
+        expect(() => parsePropName(null, obj)).toThrow(
+            'The "prop" parameter must be a string.'
+        );
+        expect(() => parsePropName(123, obj)).toThrow(
+            'The "prop" parameter must be a string.'
+        );
+    });
+
+    test('should throw an error if the obj parameter is not an object', () => {
+        expect(() => parsePropName('id', null)).toThrow(
+            'The "obj" parameter must be a non-null object.'
+        );
+        expect(() => parsePropName('id', undefined)).toThrow(
+            'The "obj" parameter must be a non-null object.'
+        );
+        expect(() => parsePropName('id', 123)).toThrow(
+            'The "obj" parameter must be a non-null object.'
+        );
+    });
+
+    test('should handle deeply nested properties', () => {
+        const obj = { a: { b: { c: { d: 'value' } } } };
+        const [target, prop] = parsePropName('a.b.c.d', obj);
+        expect(target).toBe(obj.a.b.c);
+        expect(prop).toBe('d');
+    });
+
+    test('should throw an error if a deeply nested property does not exist', () => {
+        const obj = { a: { b: { c: {} } } };
+        expect(() => parsePropName('a.b.c.d', obj)).toThrow(
+            'Property "d" does not exist on the target object.'
+        );
+    });
+});

package/src/props/setProp.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 设置一个元素对象的任意嵌套路径属性的值。
+ * 如果是 CSS 类名，值为真则添加类名，值为假则移除类名。
+ * 如果是普通属性或嵌套属性则设置该属性值。
+ * 
+ * @param root - 要设置属性的 DOM 元素。
+ * @param key - 属性名称，支持普通属性、嵌套属性（如 "style.color"）或以 "." 开头的类名（如 ".active"）。
+ * @param value - 要设置的属性值。如果是布尔值，用于控制类名的添加或移除。
+ * @returns 返回元素本身，支持链式调用。
+ * @throws 如果参数无效或设置失败会抛出错误。
+ */
+export function setProp(
+  root: HTMLElement,
+  key: string,
+  value: any
+): HTMLElement;

package/src/props/setProp.js

@@ -0,0 +1,42 @@
+import { parsePropName } from './parsePropName';
+
+/**
+ * 
+ * 设置一个元素对象的任意嵌套路径属性的值，如果是CSS类名，值为真则添加类名，值为假则移除类名。如果是普通属性或嵌套属性则设置改属性值。
+ *
+ * @param {HTMLElement} root - 要设置属性的 DOM 元素。
+ * @param {string} key - 属性名称，支持普通属性、嵌套属性（如 "style.color"）或以 "." 开头的类名（如 ".active"）。
+ * @param {*} value - 要设置的属性值。如果是布尔值，用于控制类名的添加或移除。
+ * @returns {HTMLElement} - 返回元素本身，支持链式调用。
+ * @throws {Error} 如果参数无效或设置失败。
+ * 
+ */
+export function setProp(root, key, value) {
+    if (!(root instanceof HTMLElement)) {
+        throw new Error('The "element" parameter must be a valid DOM element.');
+    }
+    if (typeof key !== 'string') {
+        throw new Error('The "key" parameter must be a string.');
+    }
+
+    // CSS 类名操作
+    if (key.charAt(0) === '.') {
+        const className = key.substring(1);
+
+        if (className.length === 0) {
+            throw new Error('The class name cannot be empty.');
+        }
+
+        if (value) {
+            root.classList.add(className); // 添加类名
+        } else {
+            root.classList.remove(className); // 移除类名
+        }
+    } else {
+        // 普通属性或嵌套属性设置
+        const [target, prop] = parsePropName(key, root); // 解析属性路径
+        target[prop] = value; // 设置属性值
+    }
+
+    return root; // 返回元素本身，支持链式调用
+}

package/src/props/setProp.test.js

@@ -0,0 +1,59 @@
+import { setProp } from './setProp';
+
+describe('setProp', () => {
+    let div;
+
+    beforeEach(() => {
+        div = document.createElement('div');
+    });
+
+    test('should add a CSS class when value is true', () => {
+        setProp(div, '.active', true);
+        expect(div.classList.contains('active')).toBe(true);
+    });
+
+    test('should remove a CSS class when value is false', () => {
+        div.classList.add('active');
+        setProp(div, '.active', false);
+        expect(div.classList.contains('active')).toBe(false);
+    });
+
+    test('should throw an error if the class name is empty', () => {
+        expect(() => setProp(div, '.', true)).toThrow('The class name cannot be empty.');
+    });
+
+    test('should set a simple property', () => {
+        setProp(div, 'id', 'myDiv');
+        expect(div.id).toBe('myDiv');
+    });
+
+    test('should set a nested property', () => {
+        setProp(div, 'style.color', 'red');
+        expect(div.style.color).toBe('red');
+    });
+
+    test('should throw an error if the key is not a string', () => {
+        expect(() => setProp(div, null, 'value')).toThrow('The "key" parameter must be a string.');
+        expect(() => setProp(div, 123, 'value')).toThrow('The "key" parameter must be a string.');
+    });
+
+    test('should throw an error if the element is not a valid DOM element', () => {
+        expect(() => setProp(null, 'id', 'myDiv')).toThrow(
+            'The "element" parameter must be a valid DOM element.'
+        );
+        expect(() => setProp({}, 'id', 'myDiv')).toThrow(
+            'The "element" parameter must be a valid DOM element.'
+        );
+    });
+
+    test('should throw an error if setting a nested property fails', () => {
+        expect(() => setProp(div, 'nonexistent.property', 'value')).toThrow(
+            'Property "nonexistent" does not exist on the object.'
+        );
+    });
+
+    test('should support chainable calls', () => {
+        const result = setProp(div, 'id', 'myDiv');
+        expect(result).toBe(div);
+    });
+});

package/src/props/setProps.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+
+/**
+ * 为 DOM 元素设置属性，包括静态属性和动态属性（Observable）。
+ * 
+ * @param element - 要设置属性的 DOM 元素。
+ * @param props - 包含属性键值对的对象，其中值可以是普通值或 Observable。
+ * @returns 返回元素本身，支持链式调用。
+ * @throws 如果参数无效或设置属性失败会抛出错误。
+ */
+export function setProps(
+    element: HTMLElement,
+    props: Record<string, any | Observable<any>>
+): HTMLElement;