@planet-matrix/mobius-model 0.5.0 → 0.6.0

package/tests/unit/timer/expiration/remaining-manager.spec.ts

@@ -0,0 +1,234 @@
+import { expect, test, vi } from "vitest"
+
+import { ExpirationManager } from "#Source/timer/index.ts"
+
+test("RemainingManager getRemaining only returns seconds for active expirations", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha" | "beta" | "gamma">({
+      enableRemainingManager: false,
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 2_500)
+    expirationManager.upsertExpiration("beta", Date.now() - 1)
+    expirationManager.upsertExpiration("gamma", Date.now() + 2_500)
+    expirationManager.removeExpiration("gamma")
+
+    expect(expirationManager.remainingManager.getRemaining("alpha")).toBe(3)
+    expect(expirationManager.remainingManager.getRemaining("beta")).toBeUndefined()
+    expect(expirationManager.remainingManager.getRemaining("gamma")).toBeUndefined()
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager getRemainingSnapshot only includes active expirations", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha" | "beta" | "gamma">({
+      enableRemainingManager: false,
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 1_500)
+    expirationManager.upsertExpiration("beta", Date.now() - 1)
+    expirationManager.upsertExpiration("gamma", Date.now() + 1_500)
+    expirationManager.removeExpiration("gamma")
+
+    expect(expirationManager.remainingManager.getRemainingSnapshot()).toEqual({ alpha: 2 })
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager emit only publishes changed snapshots", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: false,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 2_500)
+    expirationManager.remainingManager.emit()
+    vi.advanceTimersByTime(1_000)
+    expirationManager.remainingManager.emit()
+
+    expect(remainingSnapshots).toEqual([{ alpha: 3 }, { alpha: 2 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager start enables interval-driven updates", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: false,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 2_500)
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 3 }])
+
+    expirationManager.remainingManager.start()
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 3 }, { alpha: 1 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager stop disables interval-driven updates", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: true,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 3_500)
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }, { alpha: 3 }])
+
+    expirationManager.remainingManager.stop()
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }, { alpha: 3 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager pause suspends interval-driven updates", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: true,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 3_500)
+    vi.advanceTimersByTime(1_000)
+    expirationManager.remainingManager.pause()
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }, { alpha: 3 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager resume restarts interval-driven updates after pause", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: true,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 3_500)
+    expirationManager.remainingManager.pause()
+    vi.advanceTimersByTime(1_000)
+    expirationManager.remainingManager.resume()
+    vi.advanceTimersByTime(1_000)
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }, { alpha: 2 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})
+
+test("RemainingManager terminate stops future emissions", () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date(2_026, 0, 1, 0, 0, 0))
+
+  try {
+    const expirationManager = new ExpirationManager<"alpha">({
+      enableRemainingManager: true,
+    })
+    const remainingSnapshots: Array<{ alpha?: number | undefined }> = []
+
+    expirationManager.remainingManager.event.subscribe("remaining", (remaining): void => {
+      remainingSnapshots.push({ ...remaining })
+    })
+
+    expirationManager.upsertExpiration("alpha", Date.now() + 3_500)
+    expirationManager.remainingManager.terminate()
+    vi.advanceTimersByTime(2_000)
+    expirationManager.remainingManager.emit()
+
+    expect(remainingSnapshots).toEqual([{ alpha: 4 }])
+
+    expirationManager.terminate()
+  }
+  finally {
+    vi.clearAllTimers()
+    vi.useRealTimers()
+  }
+})

package/.oxlintrc.json

@@ -1,5 +0,0 @@
-{
-  "extends": [
-    "./node_modules/@planet-matrix/mobius-mono/src/internals/lint/oxlintrc.json"
-  ],
-}

package/src/random/uuid.ts

@@ -1,103 +0,0 @@
-
-const internalUUID_REGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-/**
- * Check whether input is a valid UUID string.
- *
- * @example
- * ```
- * // Expect: true
- * const example1 = isUuid("550e8400-e29b-41d4-a716-446655440000")
- * // Expect: false
- * const example2 = isUuid("not-a-uuid")
- * ```
- */
-export const isUuid = (input: string): boolean => {
-  return internalUUID_REGEXP.test(input)
-}
-
-/**
- * Assert input is a valid UUID string.
- *
- * @example
- * ```
- * // Expect: no throw
- * const example1 = assertUuid("550e8400-e29b-41d4-a716-446655440000")
- * // Expect: throws TypeError
- * const example2 = () => assertUuid("not-a-uuid")
- * ```
- *
- * @throws {TypeError} when input is not a valid UUID
- */
-export const assertUuid = (input: string): void => {
-  if (isUuid(input) === false) {
-    throw new TypeError(`Expected a valid UUID string, got: ${input}`)
-  }
-}
-
-/**
- * Get the version number from a valid UUID string.
- *
- * @example
- * ```
- * // Expect: 4
- * const example1 = getUuidVersion("550e8400-e29b-41d4-a716-446655440000")
- * // Expect: 1
- * const example2 = getUuidVersion("123e4567-e89b-12d3-a456-426614174000")
- * ```
- *
- * @throws {TypeError} when input is not a valid UUID
- */
-export const getUuidVersion = (input: string): number => {
-  // 1) Ensure the input is a syntactically valid UUID string.
-  //    If invalid, assertUuid throws TypeError and prevents unsafe parsing.
-  assertUuid(input)
-
-  // 2) Per UUID canonical format xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx,
-  //    the version nibble is the first hex digit of the 3rd group.
-  //    In a 36-char UUID string, that position is index 14.
-
-  // 3) Convert the single hex character (for example "4") to a base-10 number.
-  //    parseInt("4", 16) -> 4, parseInt("a", 16) -> 10.
-  return Number.parseInt(input[14]!, 16)
-}
-
-/**
- * Generate a RFC 4122 version-4 UUID string.
- *
- * @example
- * ```
- * const example1 = generateUuid()
- * // Expect: true
- * const example2 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(example1)
- * ```
- */
-export const generateUuid = (): string => {
-  if (typeof crypto === "object") {
-    if (typeof crypto.randomUUID === "function") {
-      return crypto.randomUUID()
-    }
-
-    if (typeof crypto.getRandomValues === "function" && typeof Uint8Array === "function") {
-      const buffer = new Uint8Array(16)
-      crypto.getRandomValues(buffer)
-
-      // Per RFC 4122, set bits for version and `clock_seq_hi_and_reserved`
-      buffer[6] = (buffer[6]! & 0x0F) | 0x40 // version 4
-      buffer[8] = (buffer[8]! & 0x3F) | 0x80 // variant 1
-
-      // Convert buffer to UUID string format
-      const hex = [...buffer].map(b => b.toString(16).padStart(2, "0")).join("")
-      return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
-    }
-  }
-
-  // Fallback for environments without crypto support
-  const fallbackUUID = (): string => {
-    const random = (a: number): string => {
-      return ((a ^ ((Math.random() * 16) >> (a / 4))) & 15).toString(16)
-    }
-    return "10000000-1000-4000-8000-100000000000".replaceAll(/[018]/g, (char: string) => random(Number(char)))
-  }
-
-  return fallbackUUID()
-}

package/tests/unit/random/uuid.spec.ts

@@ -1,37 +0,0 @@
-import { expect, test } from "vitest"
-
-import { assertUuid, generateUuid, getUuidVersion, isUuid } from "#Source/random/index.ts"
-
-test("isUuid validates UUID input", () => {
-  expect(isUuid("550e8400-e29b-41d4-a716-446655440000")).toBe(true)
-  expect(isUuid("550E8400-E29B-41D4-A716-446655440000")).toBe(true)
-  expect(isUuid("123e4567-e89b-12d3-a456-426614174000")).toBe(true)
-
-  expect(isUuid("not-a-uuid")).toBe(false)
-  expect(isUuid("550e8400e29b41d4a716446655440000")).toBe(false)
-  expect(isUuid("550e8400-e29b-91d4-a716-446655440000")).toBe(false)
-  expect(isUuid("550e8400-e29b-41d4-c716-446655440000")).toBe(false)
-})
-
-test("assertUuid throws on malformed input", () => {
-  expect(() => assertUuid("550e8400-e29b-41d4-a716-446655440000")).not.toThrow()
-  expect(() => assertUuid("not-a-uuid")).toThrow(TypeError)
-  expect(() => assertUuid("550e8400e29b41d4a716446655440000")).toThrow(TypeError)
-})
-
-test("getUuidVersion returns UUID version and throws on malformed input", () => {
-  expect(getUuidVersion("550e8400-e29b-41d4-a716-446655440000")).toBe(4)
-  expect(getUuidVersion("123e4567-e89b-12d3-a456-426614174000")).toBe(1)
-
-  expect(() => getUuidVersion("not-a-uuid")).toThrow(TypeError)
-})
-
-test("generateUuid returns RFC 4122 version-4 UUID format", () => {
-  const UUID_V4_REGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-  const value1 = generateUuid()
-  const value2 = generateUuid()
-
-  expect(value1).toMatch(UUID_V4_REGEXP)
-  expect(value2).toMatch(UUID_V4_REGEXP)
-  expect(value1).not.toBe(value2)
-})