hyperscript-rxjs 1.3.14 → 1.3.15

package/src/ramda/pipe.js

@@ -0,0 +1,27 @@
+/**
+ * 数据优先的管道处理工具（从左向右执行）
+ * 适合一次性数据处理流程
+ * @param {*} initialValue - 初始值
+ * @param {...Function} fns - 要应用的函数管道（从左向右执行）
+ * @returns {*} 经过管道处理后的结果
+ * @throws {TypeError} 当参数包含非函数时抛出错误
+ */
+export const pipe = (initialValue, ...fns) => {
+  // 无函数时直接返回初始值
+  if (fns.length === 0) return initialValue;
+
+  // 类型检查（遇到第一个错误就抛出）
+  const firstNonFunctionIndex = fns.findIndex(fn => typeof fn !== 'function');
+  if (firstNonFunctionIndex !== -1) {
+    const invalidFn = fns[firstNonFunctionIndex];
+    const errorType =
+      invalidFn === null ? 'null' :
+        invalidFn === undefined ? 'undefined' :
+          typeof invalidFn;
+    throw new TypeError(
+      `所有管道函数必须是函数，但第 ${firstNonFunctionIndex} 个参数是: ${errorType}`
+    );
+  }
+
+  return fns.reduce((acc, fn) => fn(acc), initialValue);
+};

package/src/ramda/pipe.test.js

@@ -0,0 +1,77 @@
+import { pipe } from './pipe';
+
+describe('pipe function', () => {
+    describe('基础功能', () => {
+        test('空函数列表时返回初始值', () => {
+            expect(pipe(42)).toBe(42);
+            expect(pipe('hello')).toBe('hello');
+            expect(pipe(null)).toBeNull();
+            expect(pipe(undefined)).toBeUndefined();
+        });
+
+        test('从左向右正确执行函数管道', () => {
+            const add1 = x => x + 1;
+            const square = x => x * x;
+            const double = x => x * 2;
+
+            const result = pipe(3, double, square, add1);
+            expect(result).toBe(37); // ((3*2)^2)+1 = 37
+        });
+
+        test('处理单函数情况', () => {
+            const mockFn = jest.fn(x => x.toUpperCase());
+            const result = pipe('test', mockFn);
+
+            expect(result).toBe('TEST');
+            expect(mockFn).toHaveBeenCalledWith('test');
+        });
+    });
+
+    describe('类型检查', () => {
+        test('检测第一个非函数参数并报错', () => {
+            const errorCases = [
+                { input: [42], expected: '第 0 个参数是: number' },
+                { input: [x => x, null], expected: '第 1 个参数是: null' },
+                { input: [undefined, x => x], expected: '第 0 个参数是: undefined' },
+                { input: ['text', x => x], expected: '第 0 个参数是: string' },
+                { input: [{}, x => x], expected: '第 0 个参数是: object' },
+                { input: [[], x => x], expected: '第 0 个参数是: object' }
+            ];
+
+            errorCases.forEach(({ input, expected }) => {
+                expect(() => pipe('initial', ...input)).toThrow(TypeError);
+                expect(() => pipe('initial', ...input)).toThrow(expected);
+            });
+        });
+
+        test('混合类型参数中检测第一个错误', () => {
+            const add1 = x => x + 1;
+            expect(() => pipe(1, add1, 'text', 42, null))
+                .toThrow('第 1 个参数是: string');
+        });
+    });
+
+    describe('边界情况', () => {
+        test('处理undefined中间值', () => {
+            const noop = () => undefined;
+            const toString = x => String(x);
+
+            const result = pipe(123, noop, toString);
+            expect(result).toBe('undefined');
+        });
+
+        test('处理null中间值', () => {
+            const returnNull = () => null;
+            const defaultToZero = x => x ?? 0;
+
+            const result = pipe(123, returnNull, defaultToZero);
+            expect(result).toBe(0);
+        });
+
+        test('空函数参数列表', () => {
+            expect(pipe(42)).toBe(42);
+            expect(pipe(null)).toBeNull();
+            expect(pipe(undefined)).toBeUndefined();
+        });
+    });
+});

package/src/ramda/unfold.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 通过不断调用 fn 生成值，直到 fn 返回 falsy。
+ * @public
+ * @param fn - 生成函数，接收当前 seed，返回 [value, nextSeed] 或 falsy。
+ * @param seed - 初始种子值。
+ * @returns 由 fn 生成的所有 value 组成的数组。
+ */
+export function unfold<T, S>(
+  fn: (seed: S) => [T, S] | false | null | undefined,
+  seed: S
+): T[];

package/src/ramda/unfold.js

@@ -0,0 +1,20 @@
+/**
+ * 通过不断调用 fn 生成值，直到 fn 返回 falsy。
+ *
+ * @public
+ * @template T, S
+ * @param {(seed: S) => [T, S] | false | null | undefined} fn - 生成函数，接收当前 seed，返回 [value, nextSeed] 或 falsy。
+ * @param {S} seed - 初始种子值。
+ * @returns {Array<T>} 由 fn 生成的所有 value 组成的数组。
+ * @this *
+ */
+export function unfold(fn, seed) {
+  let result = [];
+
+  let resultSeedPair = fn.call(this, seed);
+  while (resultSeedPair && resultSeedPair.length) {
+    result[result.length] = resultSeedPair[0];
+    resultSeedPair = fn.call(this, resultSeedPair[1]);
+  }
+  return result;
+}

package/src/ramda/unfold.test.js

@@ -0,0 +1,29 @@
+import { unfold } from './unfold.js'
+
+describe('unfold', function () {
+  test('unfolds simple functions with a starting point to create a list', function () {
+    let fn = function (n) { if (n > 0) { return [n, n - 1]; } }
+    let seed = 10
+    let y = unfold(fn, seed)
+    let res = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+    expect(y).toEqual(res);
+  });
+
+  test('is cool!', function () {
+    let fib = function (n) {
+      let count = 0;
+      return function (pair) {
+        count += 1;
+        if (count <= n) {
+          return [pair[0], [pair[1], pair[0] + pair[1]]];
+        }
+      };
+    };
+    let fn = fib(10)
+    let seed = [0, 1]
+    let y = unfold(fn, seed)
+    let res = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+    expect(y).toEqual(res);
+  });
+
+});