@planet-matrix/mobius-model 0.1.4 → 0.4.0

package/tests/unit/basic/stream.spec.ts

@@ -0,0 +1,120 @@
+import { expect, test } from "vitest"
+
+import {
+  streamConsumeInAsyncMacroTask,
+  streamConsumeInSyncMacroTask,
+  streamFromArray,
+  streamTransformInAsyncMacroTask,
+} from "#Source/basic/index.ts"
+
+test("streamFromArray creates a readable stream from array values", async () => {
+  const source = [1, 2, 3]
+  const values: number[] = []
+
+  const stream = streamFromArray(source)
+  for await (const value of stream) {
+    values.push(value)
+  }
+
+  expect(values).toEqual(source)
+})
+
+test("streamConsumeInSyncMacroTask consumes stream and handles callback errors", async () => {
+  const consumed: number[] = []
+  let doneCalled = false
+
+  await streamConsumeInSyncMacroTask<number>({
+    readableStream: streamFromArray([1, 2, 3]),
+    onValue: (chunk) => {
+      consumed.push(chunk)
+    },
+    onDone: () => {
+      doneCalled = true
+    },
+  })
+
+  expect(consumed).toEqual([1, 2, 3])
+  expect(doneCalled).toBe(true)
+
+  let errorMessage = ""
+  let doneCalledInErrorCase = false
+  await streamConsumeInSyncMacroTask<number>({
+    readableStream: streamFromArray([1, 2]),
+    onValue: (chunk) => {
+      if (chunk === 2) {
+        throw new Error("boom")
+      }
+    },
+    onDone: () => {
+      doneCalledInErrorCase = true
+    },
+    onError: (error) => {
+      errorMessage = error.message
+    },
+  })
+
+  expect(errorMessage).toContain("boom")
+  expect(doneCalledInErrorCase).toBe(false)
+})
+
+test("streamConsumeInAsyncMacroTask consumes stream and forwards callback failures", async () => {
+  const consumed: number[] = []
+  await new Promise<void>((resolve, reject) => {
+    streamConsumeInAsyncMacroTask<number>({
+      readableStream: streamFromArray([1, 2, 3]),
+      onValue: (chunk) => {
+        consumed.push(chunk)
+      },
+      onDone: () => {
+        resolve()
+      },
+      onError: (error) => {
+        reject(error)
+      },
+    })
+  })
+
+  expect(consumed).toEqual([1, 2, 3])
+
+  let errorMessage = ""
+  await new Promise<void>((resolve, reject) => {
+    streamConsumeInAsyncMacroTask<number>({
+      readableStream: streamFromArray([1]),
+      onValue: () => {
+        throw new Error("async-boom")
+      },
+      onDone: () => {
+        reject(new Error("onDone should not be called when onValue throws"))
+      },
+      onError: (error) => {
+        errorMessage = error.message
+        resolve()
+      },
+    })
+  })
+
+  expect(errorMessage).toContain("async-boom")
+})
+
+test("streamTransformInAsyncMacroTask transforms values and handles invalid inputs/errors", async () => {
+  expect(() => {
+    streamTransformInAsyncMacroTask<number, number>({})
+  }).toThrowError("Either readableStream or reader must be provided")
+
+  const transformed = streamTransformInAsyncMacroTask<number, number>({
+    readableStream: streamFromArray([1, 2, 3]),
+    onChunk: (chunk, controller) => {
+      if (chunk.done === true) {
+        controller.close()
+        return
+      }
+      controller.enqueue(chunk.value * 10)
+    },
+  })
+
+  const values: number[] = []
+  for await (const value of transformed) {
+    values.push(value)
+  }
+  expect(values).toEqual([10, 20, 30])
+})

package/tests/unit/basic/string.spec.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "vitest"
+
+import {
+  stringCalculateUnits,
+  stringCamelCaseToKebabCase,
+  stringHelloWord,
+  stringKebabCaseToCamelCase,
+  stringRandom,
+  stringSliceByUnits,
+  stringSmartSplit,
+  stringSplit,
+  stringTruncate,
+  stringTruncateByUnits,
+} from "#Source/basic/index.ts"
+
+test("stringRandom returns expected output", () => {
+  const value = stringRandom(12)
+  expect(value).toHaveLength(12)
+
+  const constrained = stringRandom(10, "ab")
+  expect(constrained.split("").every(char => char === "a" || char === "b")).toBe(true)
+})
+
+test("stringCamelCaseToKebabCase converts correctly", () => {
+  expect(stringCamelCaseToKebabCase("helloWorld")).toBe("hello-world")
+  expect(stringCamelCaseToKebabCase("ab2Cd")).toBe("ab2-cd")
+})
+
+test("stringKebabCaseToCamelCase converts correctly", () => {
+  expect(stringKebabCaseToCamelCase("hello-world")).toBe("helloWorld")
+  expect(stringKebabCaseToCamelCase("ab2-cd")).toBe("ab2Cd")
+})
+
+test("stringHelloWord returns a greeting", () => {
+  const value = stringHelloWord()
+  expect(typeof value).toBe("string")
+  expect(value.length).toBeGreaterThan(0)
+})
+
+test("stringCalculateUnits counts half-width and full-width", () => {
+  expect(stringCalculateUnits("a中")).toBe(1.5)
+  expect(stringCalculateUnits("中文")).toBe(2)
+})
+
+test("stringTruncateByUnits respects unit limit", () => {
+  expect(stringTruncateByUnits("a中文", 1.5)).toBe("a中")
+  expect(stringTruncateByUnits("abc", 2)).toBe("abc")
+})
+
+test("stringSliceByUnits slices by unit indices", () => {
+  expect(stringSliceByUnits("a中文", 0, 1.5)).toBe("a中")
+  expect(stringSliceByUnits("中文ab", 1, 2)).toBe("文")
+})
+
+test("stringSplit returns overlapping chunks", () => {
+  expect(stringSplit({ input: "hello world", chunkSize: 5, chunkOverlap: 2 })).toEqual([
+    "hello",
+    "lo wo",
+    "world",
+  ])
+})
+
+test("stringSmartSplit respects max length", () => {
+  const parts = stringSmartSplit("a\nb\nc", 2)
+  expect(parts.join("\n")).toContain("a")
+  expect(parts.join("\n")).toContain("b")
+  expect(parts.join("\n")).toContain("c")
+  expect(parts.every(part => part.length <= 2)).toBe(true)
+})
+
+test("stringTruncate adds ellipsis", () => {
+  expect(stringTruncate("hello world", 5)).toBe("hello...")
+  expect(stringTruncate("hi", 5)).toBe("hi")
+})

package/tests/unit/basic/symbol.spec.ts

@@ -0,0 +1,72 @@
+import { expect, test } from "vitest"
+
+import {
+  symbolCreateGlobal,
+  symbolCreateLocal,
+  symbolGetDescription,
+  symbolGetKey,
+  symbolHasDescription,
+  symbolIsAnonymous,
+  symbolIsGlobal,
+  symbolIsLocal,
+  symbolIsWellKnown,
+  symbolToString,
+} from "#Source/basic/index.ts"
+
+test("symbolCreateLocal creates unique symbols", () => {
+  const first = symbolCreateLocal("demo")
+  const second = symbolCreateLocal("demo")
+  expect(typeof first).toBe("symbol")
+  expect(first === second).toBe(false)
+})
+
+test("symbolCreateGlobal returns registry symbols", () => {
+  const first = symbolCreateGlobal("demo")
+  const second = symbolCreateGlobal("demo")
+  expect(typeof first).toBe("symbol")
+  expect(first === second).toBe(true)
+  expect(first === Symbol.for("demo")).toBe(true)
+})
+
+test("symbolGetKey returns global key", () => {
+  expect(symbolGetKey(Symbol.for("demo"))).toBe("demo")
+  expect(symbolGetKey(Symbol("demo"))).toBeUndefined()
+})
+
+test("symbolIsGlobal checks registry membership", () => {
+  expect(symbolIsGlobal(Symbol.for("demo"))).toBe(true)
+  expect(symbolIsGlobal(Symbol("demo"))).toBe(false)
+})
+
+test("symbolIsLocal checks non-registry symbols", () => {
+  expect(symbolIsLocal(Symbol.for("demo"))).toBe(false)
+  expect(symbolIsLocal(Symbol("demo"))).toBe(true)
+})
+
+test("symbolHasDescription checks description presence", () => {
+  expect(symbolHasDescription(Symbol("demo"))).toBe(true)
+  // oxlint-disable-next-line symbol-description
+  expect(symbolHasDescription(Symbol())).toBe(false)
+})
+
+test("symbolGetDescription reads description", () => {
+  expect(symbolGetDescription(Symbol("demo"))).toBe("demo")
+  // oxlint-disable-next-line symbol-description
+  expect(symbolGetDescription(Symbol())).toBeUndefined()
+})
+
+test("symbolIsAnonymous checks empty description", () => {
+  expect(symbolIsAnonymous(Symbol("demo"))).toBe(false)
+  // oxlint-disable-next-line symbol-description
+  expect(symbolIsAnonymous(Symbol())).toBe(true)
+})
+
+test("symbolIsWellKnown detects well-known symbols", () => {
+  expect(symbolIsWellKnown(Symbol.iterator)).toBe(true)
+  expect(symbolIsWellKnown(Symbol("iterator"))).toBe(false)
+})
+
+test("symbolToString converts to string", () => {
+  expect(symbolToString(Symbol("demo"))).toBe("Symbol(demo)")
+  expect(symbolToString("demo")).toBeUndefined()
+})

package/tests/unit/basic/temporal.spec.ts

@@ -0,0 +1,78 @@
+import { expect, test, vi } from "vitest"
+
+import {
+  temporalFormatToRelativeTime,
+  temporalFormatToWechatRelativeTime,
+  temporalFormatToYYYYMMDD,
+  temporalFormatToYYYYMMDDhhmmss,
+  temporalFormatTohhmmss,
+  temporalHumanize,
+  temporalIsOutdated,
+} from "#Source/basic/index.ts"
+
+test("temporalIsOutdated returns expected values", () => {
+  const now = new Date(2_024, 0, 2, 0, 0, 0).getTime()
+  const nowSpy = vi.spyOn(Date, "now").mockReturnValue(now)
+
+  expect(temporalIsOutdated(new Date(now - 1_000))).toBe(true)
+  expect(temporalIsOutdated(new Date(now + 1_000))).toBe(false)
+  expect(temporalIsOutdated("not-a-date")).toBe(false)
+
+  nowSpy.mockRestore()
+})
+
+test("temporalFormatToYYYYMMDD formats dates", () => {
+  const timestamp = new Date(2_000, 0, 2, 3, 4, 5).getTime()
+
+  expect(temporalFormatToYYYYMMDD(timestamp)).toBe("2000-01-02")
+  expect(temporalFormatToYYYYMMDD(timestamp, "/")).toBe("2000/01/02")
+})
+
+test("temporalFormatTohhmmss formats times", () => {
+  const timestamp = new Date(2_000, 0, 2, 3, 4, 5).getTime()
+
+  expect(temporalFormatTohhmmss(timestamp)).toBe("03:04:05")
+  expect(temporalFormatTohhmmss(timestamp, "-")).toBe("03-04-05")
+})
+
+test("temporalFormatToYYYYMMDDhhmmss formats date and time", () => {
+  const timestamp = new Date(2_000, 0, 2, 3, 4, 5).getTime()
+
+  expect(temporalFormatToYYYYMMDDhhmmss(timestamp)).toBe("2000-01-02 03:04:05")
+})
+
+test("temporalFormatToRelativeTime returns expected labels", () => {
+  const now = new Date(2_024, 0, 2, 0, 0, 0).getTime()
+  const nowSpy = vi.spyOn(Date, "now").mockReturnValue(now)
+
+  expect(temporalFormatToRelativeTime(now - 30_000)).toBe("刚刚")
+  expect(temporalFormatToRelativeTime(now - 120_000)).toBe("2 分钟前")
+  expect(temporalFormatToRelativeTime(now - 3_600_000)).toBe("1 小时前")
+  expect(temporalFormatToRelativeTime(now - 90_000_000)).toBe("昨天")
+  expect(temporalFormatToRelativeTime(now - 259_200_000)).toBe("一周内")
+  expect(temporalFormatToRelativeTime(now - 691_200_000)).toBe("2023-12-25 00:00:00")
+
+  nowSpy.mockRestore()
+})
+
+test("temporalFormatToWechatRelativeTime formats WeChat-style labels", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_024, 0, 3, 12, 0, 0))
+
+  expect(temporalFormatToWechatRelativeTime({ timestamp: new Date(2_024, 0, 3, 9, 5, 0).getTime() })).toBe("09:05")
+  expect(temporalFormatToWechatRelativeTime({ timestamp: new Date(2_024, 0, 2, 9, 0, 0).getTime() })).toBe("昨天")
+  expect(temporalFormatToWechatRelativeTime({ timestamp: new Date(2_024, 0, 2, 9, 0, 0).getTime(), alwaysShowTime: true })).toBe("昨天 09:00")
+  expect(temporalFormatToWechatRelativeTime({ timestamp: new Date(2_024, 0, 1, 8, 0, 0).getTime() })).toBe("星期一")
+  expect(temporalFormatToWechatRelativeTime({ timestamp: new Date(2_023, 11, 24, 18, 30, 0).getTime() })).toBe("23/12/24")
+
+  vi.useRealTimers()
+})
+
+test("temporalHumanize returns expected labels", () => {
+  const nowSpy = vi.spyOn(Date, "now").mockReturnValue(3_600_000)
+
+  expect(temporalHumanize(3_600_000)).toBe("刚刚")
+  expect(temporalHumanize(0)).toBe("1 小时前")
+
+  nowSpy.mockRestore()
+})

package/tests/unit/{signal/computed.spec.ts → reactor/alien-signals-computed.spec.ts}

@@ -1,5 +1,10 @@
 import { expect, test } from 'vitest';
-import { computed, signal } from '#Source/index.ts';
+
+import { computed, signal } from '#Source/reactor/index.ts';
+
+/**
+ * 这个测试文件应该与 https://github.com/stackblitz/alien-signals/blob/master/tests/computed.spec.ts 保持同步。
+ */
 
 test('should correctly propagate changes through computed signals', () => {
   /**
@@ -11,7 +16,7 @@ test('should correctly propagate changes through computed signals', () => {
    *    |
    *   c3
    */
-  const src = signal(0);
+  const src = signal(() => 0);
   const c1 = computed(() => src.get() % 2);
   const c2 = computed(() => c1.get());
   const c3 = computed(() => c2.get());
@@ -33,7 +38,7 @@ test('should propagate updated source value through chained computations', () =>
    *       \   /
    *         d
    */
-  const src = signal(0);
+  const src = signal(() => 0);
   const a = computed(() => src.get());
   const b = computed(() => a.get() % 2);
   const c = computed(() => src.get());
@@ -50,11 +55,11 @@ test('should handle flags are indirectly updated during resolve pending', () =>
    *      |
    *      b
    *     / \
-   *    c   d
+   *    c   |
    *     \ /
    *      d
    */
-  const a = signal(false);
+  const a = signal(() => false);
   const b = computed(() => a.get());
   const c = computed(() => {
     b.get();
@@ -76,17 +81,17 @@ test('should not update if the signal value is reverted', () => {
    *    |
    *   c1
    */
-  let times = 0;
-  const src = signal(0);
+  const src = signal(() => 0);
+  let c1RunTimes = 0;
   const c1 = computed(() => {
-    times = times + 1;
+    c1RunTimes = c1RunTimes + 1;
     return src.get();
   });
 
   expect(c1.get()).toBe(0);
-  expect(times).toBe(1);
+  expect(c1RunTimes).toBe(1);
   src.set(1);
   src.set(0);
   expect(c1.get()).toBe(0);
-  expect(times).toBe(1);
+  expect(c1RunTimes).toBe(1);
 });

package/tests/unit/reactor/alien-signals-effect-scope.spec.ts

@@ -0,0 +1,86 @@
+import { expect, test } from 'vitest';
+
+import { effect, effectScope, signal } from '#Source/reactor/index.ts';
+
+/**
+ * 这个测试文件应该与 https://github.com/stackblitz/alien-signals/blob/master/tests/effectScope.spec.ts 保持同步。
+ */
+
+test('should not trigger after dispose', () => {
+  /**
+   *    count
+   *      |
+   *     e(inner)
+   *      |
+   *     e(scope)
+   */
+  const count = signal(() => 1);
+  let innerEffectRunTimes = 0;
+  const scope = effectScope(() => {
+    effect(() => {
+      innerEffectRunTimes = innerEffectRunTimes + 1;
+      count.get();
+    });
+    expect(innerEffectRunTimes).toBe(1);
+
+    count.set(2);
+    expect(innerEffectRunTimes).toBe(2);
+  });
+
+  count.set(3);
+  expect(innerEffectRunTimes).toBe(3);
+  scope.dispose();
+  count.set(4);
+  expect(innerEffectRunTimes).toBe(3);
+});
+
+test('should dispose inner effects if created in an effect', () => {
+  /**
+   *       source
+   *         |
+   *      e(inner)
+   *         |
+   *      e(scope)
+   *         |
+   *      e(outer)
+   */
+  const source = signal(() => 1);
+  let innerEffectRunTimes = 0;
+  effect(() => {
+    const scope = effectScope(() => {
+      effect(() => {
+        source.get();
+        innerEffectRunTimes = innerEffectRunTimes + 1;
+      });
+    });
+    expect(innerEffectRunTimes).toBe(1);
+
+    source.set(2);
+    expect(innerEffectRunTimes).toBe(2);
+    scope.dispose();
+    source.set(3);
+    expect(innerEffectRunTimes).toBe(2);
+  });
+});
+
+test('should track signal updates in an inner scope when accessed by an outer effect', () => {
+  /**
+   *       source
+   *         |
+   *      e(scope)
+   *         |
+   *      e(outer)
+   */
+  const source = signal(() => 1);
+  let outerEffectRunTimes = 0;
+  effect(() => {
+    effectScope(() => {
+      source.get();
+    });
+    outerEffectRunTimes = outerEffectRunTimes + 1;
+  });
+
+  expect(outerEffectRunTimes).toBe(1);
+  source.set(2);
+  expect(outerEffectRunTimes).toBe(2);
+});