@planet-matrix/mobius-model 0.4.0 → 0.6.0

package/tests/unit/abort/abort-manager.spec.ts

@@ -0,0 +1,225 @@
+import { expect, test } from "vitest"
+
+import {
+  ABORT_MANAGER_MODE,
+  AbortManager,
+  all,
+  any,
+  fromAbortFriendlyOptions,
+  fromAbortable,
+  fromWithAbortSignal,
+  getAbortSignal,
+  isAborted,
+} from "#Source/abort/index.ts"
+
+test("getAbortSignal resolves AbortSignal from supported abortables", () => {
+  const abortController = new AbortController()
+  const abortManager = new AbortManager({})
+
+  expect(getAbortSignal(abortController.signal)).toBe(abortController.signal)
+  expect(getAbortSignal(abortController)).toBe(abortController.signal)
+  expect(getAbortSignal(abortManager)).toBe(abortManager.abortSignal)
+})
+
+test("isAborted reflects abort state from abortables", () => {
+  const abortController = new AbortController()
+
+  expect(isAborted(abortController.signal)).toBe(false)
+  expect(isAborted(abortController)).toBe(false)
+
+  abortController.abort("stop")
+
+  expect(isAborted(abortController.signal)).toBe(true)
+  expect(isAborted(abortController)).toBe(true)
+})
+
+test("AbortManager constructor links upstream abortManager from options", () => {
+  const upstream = new AbortManager({})
+  const abortManager = new AbortManager({ abortManager: upstream })
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream.abort("upstream")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.isAborted mirrors internal abortSignal", () => {
+  const abortManager = new AbortManager({})
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  abortManager.abort("done")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.setMode sets mode and supports chaining", () => {
+  const abortManager = new AbortManager({})
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+
+  const returned = abortManager
+    .setMode(ABORT_MANAGER_MODE.ANY)
+    .addUpstreams([upstream1.signal, upstream2.signal])
+
+  expect(returned).toBe(abortManager)
+
+  upstream1.abort("one")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.addUpstreams makes manager abort when upstream condition is met", () => {
+  const abortManager = new AbortManager({})
+  const upstream = new AbortController()
+
+  abortManager.addUpstreams([upstream.signal])
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream.abort("upstream")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.removeUpstreams detaches selected upstreams", () => {
+  const abortManager = new AbortManager({})
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+
+  abortManager
+    .setMode(ABORT_MANAGER_MODE.ANY)
+    .addUpstreams([upstream1.signal, upstream2.signal])
+    .removeUpstreams([upstream1.signal])
+
+  upstream1.abort("ignored")
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream2.abort("active")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.removeAllUpstreams detaches all upstreams", () => {
+  const abortManager = new AbortManager({})
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+
+  abortManager
+    .setMode(ABORT_MANAGER_MODE.ANY)
+    .addUpstreams([upstream1.signal, upstream2.signal])
+    .removeAllUpstreams()
+
+  upstream1.abort("ignored")
+  upstream2.abort("ignored")
+
+  expect(abortManager.isAborted()).toBe(false)
+})
+
+test("AbortManager.tryToAbort evaluates mode conditions", () => {
+  const abortManager = new AbortManager({})
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+
+  abortManager
+    .setMode(ABORT_MANAGER_MODE.ALL)
+    .addUpstreams([upstream1.signal, upstream2.signal])
+
+  upstream1.abort("first")
+  abortManager.tryToAbort()
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream2.abort("second")
+  abortManager.tryToAbort()
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.abort aborts and applies auto-remove policy", () => {
+  class TestAbortManager extends AbortManager {
+    removeAllUpstreamsCalled = 0
+
+    override removeAllUpstreams(): this {
+      this.removeAllUpstreamsCalled = this.removeAllUpstreamsCalled + 1
+      return super.removeAllUpstreams()
+    }
+  }
+
+  const enabled = new TestAbortManager({ autoRemoveUpstreamsAfterAbort: true })
+  enabled.addUpstreams([new AbortController().signal])
+  enabled.abort("enabled")
+
+  const disabled = new TestAbortManager({ autoRemoveUpstreamsAfterAbort: false })
+  disabled.addUpstreams([new AbortController().signal])
+  disabled.abort("disabled")
+
+  expect(enabled.isAborted()).toBe(true)
+  expect(enabled.removeAllUpstreamsCalled).toBe(1)
+  expect(disabled.isAborted()).toBe(true)
+  expect(disabled.removeAllUpstreamsCalled).toBe(0)
+})
+
+test("fromAbortable creates manager from a single upstream abortable", () => {
+  const upstream = new AbortController()
+  const abortManager = fromAbortable(upstream)
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream.abort("stop")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("any creates manager that aborts when any upstream aborts", () => {
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+  const abortManager = any([upstream1.signal, null, undefined, upstream2.signal])
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream1.abort("first")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("all creates manager that aborts only when all upstreams abort", () => {
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+  const abortManager = all([upstream1.signal, null, undefined, upstream2.signal])
+
+  upstream1.abort("first")
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream2.abort("second")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("fromWithAbortSignal creates manager from options.abortSignal", () => {
+  const upstream = new AbortController()
+  const withSignal = fromWithAbortSignal({ abortSignal: upstream.signal })
+  const withoutSignal = fromWithAbortSignal({})
+
+  expect(withSignal.isAborted()).toBe(false)
+  expect(withoutSignal.isAborted()).toBe(false)
+
+  upstream.abort("stop")
+
+  expect(withSignal.isAborted()).toBe(true)
+  expect(withoutSignal.isAborted()).toBe(false)
+})
+
+test("fromAbortFriendlyOptions creates manager using abort-friendly options", () => {
+  const upstream = new AbortManager({})
+  const abortManager = fromAbortFriendlyOptions({ abortManager: upstream })
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream.abort("stop")
+
+  expect(abortManager.isAborted()).toBe(true)
+})

package/tests/unit/abort/abort-signal-listener-manager.spec.ts

@@ -0,0 +1,62 @@
+import { expect, test } from "vitest"
+
+import {
+  AbortSignalListenerManager,
+  getGlobalAbortSignalListenerManager,
+} from "#Source/abort/index.ts"
+
+test("AbortSignalListenerManager.hasEventListener checks managed listener state", () => {
+  const manager = new AbortSignalListenerManager()
+  const abortController = new AbortController()
+  const listener = (): void => {
+    void abortController
+  }
+
+  expect(manager.hasEventListener(abortController.signal, listener)).toBe(false)
+
+  manager.addEventListener(abortController.signal, listener)
+
+  expect(manager.hasEventListener(abortController.signal, listener)).toBe(true)
+
+  manager.removeEventListener(abortController.signal, listener)
+
+  expect(manager.hasEventListener(abortController.signal, listener)).toBe(false)
+})
+
+test("AbortSignalListenerManager.addEventListener registers listener for abort events", () => {
+  const manager = new AbortSignalListenerManager()
+  const abortController = new AbortController()
+  let count = 0
+  const listener = (): void => {
+    count = count + 1
+  }
+
+  manager.addEventListener(abortController.signal, listener)
+
+  abortController.abort("stop")
+
+  expect(count).toBe(1)
+})
+
+test("AbortSignalListenerManager.removeEventListener unregisters listener", () => {
+  const manager = new AbortSignalListenerManager()
+  const abortController = new AbortController()
+  let count = 0
+  const listener = (): void => {
+    count = count + 1
+  }
+
+  manager.addEventListener(abortController.signal, listener)
+  manager.removeEventListener(abortController.signal, listener)
+
+  abortController.abort("stop")
+
+  expect(count).toBe(0)
+})
+
+test("getGlobalAbortSignalListenerManager returns singleton instance", () => {
+  const first = getGlobalAbortSignalListenerManager()
+  const second = getGlobalAbortSignalListenerManager()
+
+  expect(first).toBe(second)
+})

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

@@ -192,7 +192,7 @@ test("arrayAny aliases arraySome", () => {
 
 test("arrayForEach applies the callback", () => {
   const target: number[] = []
-  arrayForEach((item) => target.push(item * 2), [1, 2, 3])
+  arrayForEach((item) => { target.push(item * 2) }, [1, 2, 3])
   expect(target).toEqual([2, 4, 6])
 })
 

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

@@ -1,6 +1,6 @@
 import { expect, test } from "vitest"
 
-import { excludeFields, includeFields } from "#Source/basic/object.ts"
+import { excludeFields, includeFields, objectDateFieldsToNumber } from "#Source/basic/object.ts"
 
 test("includeFields picks specified keys", () => {
   expect(includeFields({ a: 1, b: 2, c: 3 }, ["a", "c"])).toEqual({ a: 1, c: 3 })
@@ -13,3 +13,34 @@ test("excludeFields omits specified keys", () => {
   // @ts-expect-error - Testing behavior with undefined input
   expect(excludeFields(undefined, ["a"])).toEqual({})
 })
+
+test("objectDateFieldsToNumber converts top-level Date fields", () => {
+  const createdAt = new Date("2024-01-02T03:04:05.678Z")
+  const updatedAt = new Date("2024-02-03T04:05:06.789Z")
+  const nestedDate = new Date("2024-03-04T05:06:07.890Z")
+
+  const source = {
+    id: "x-1",
+    createdAt,
+    updatedAt,
+    nested: {
+      occurredAt: nestedDate,
+    },
+    optional: undefined as Date | undefined,
+    nullable: null as Date | null,
+  }
+
+  const result = objectDateFieldsToNumber(source)
+
+  expect(result).toEqual({
+    id: "x-1",
+    createdAt: createdAt.getTime(),
+    updatedAt: updatedAt.getTime(),
+    nested: {
+      occurredAt: nestedDate,
+    },
+    optional: undefined,
+    nullable: null,
+  })
+  expect(result).toBe(source)
+})

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

@@ -99,7 +99,7 @@ test("streamConsumeInAsyncMacroTask consumes stream and forwards callback failur
 test("streamTransformInAsyncMacroTask transforms values and handles invalid inputs/errors", async () => {
   expect(() => {
     streamTransformInAsyncMacroTask<number, number>({})
-  }).toThrowError("Either readableStream or reader must be provided")
+  }).toThrow("Either readableStream or reader must be provided")
 
   const transformed = streamTransformInAsyncMacroTask<number, number>({
     readableStream: streamFromArray([1, 2, 3]),

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

@@ -5,7 +5,6 @@ import {
   stringCamelCaseToKebabCase,
   stringHelloWord,
   stringKebabCaseToCamelCase,
-  stringRandom,
   stringSliceByUnits,
   stringSmartSplit,
   stringSplit,
@@ -13,14 +12,6 @@ import {
   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")

package/tests/unit/color/rgb/analyze.spec.ts

@@ -0,0 +1,110 @@
+import { expect, test } from "vitest"
+
+import {
+  doSrgbColorValuesMeetContrastRatio,
+  isLightSrgbColorValue,
+  linearRgbColorValueToRelativeLuminance,
+  linearRgbColorValueToTristimulusSum,
+  linearRgbColorValueToXyChromaticityValue,
+  pickReadableSrgbTextColorValue,
+  srgbColorValueToRelativeLuminance,
+  srgbColorValueToTristimulusSum,
+  srgbColorValueToXyChromaticityValue,
+  srgbColorValuesToContrastRatio,
+} from "#Source/color/index.ts"
+
+test("linearRgbColorValueToRelativeLuminance follows the explicit RGB branch pipeline", () => {
+  expect(linearRgbColorValueToRelativeLuminance({ red: 1, green: 0, blue: 0, alpha: 1 })).toBe(0.212_673)
+  expect(linearRgbColorValueToRelativeLuminance({ red: 1, green: 1, blue: 1, alpha: 1 })).toBe(1)
+})
+
+test("srgbColorValueToRelativeLuminance follows the explicit RGB branch pipeline", () => {
+  expect(srgbColorValueToRelativeLuminance({ red: 51, green: 102, blue: 153, alpha: 1 })).toBe(0.125_053)
+  expect(srgbColorValueToRelativeLuminance({ red: 255, green: 255, blue: 255, alpha: 1 })).toBe(1)
+})
+
+test("srgbColorValuesToContrastRatio supports accessibility-oriented comparisons", () => {
+  expect(srgbColorValuesToContrastRatio(
+    { red: 0, green: 0, blue: 0, alpha: 1 },
+    { red: 255, green: 255, blue: 255, alpha: 1 },
+  )).toBe(21)
+
+  expect(srgbColorValuesToContrastRatio(
+    { red: 51, green: 102, blue: 153, alpha: 1 },
+    { red: 51, green: 102, blue: 153, alpha: 1 },
+  )).toBe(1)
+})
+
+test("doSrgbColorValuesMeetContrastRatio validates thresholds and comparisons", () => {
+  expect(() => doSrgbColorValuesMeetContrastRatio(
+    { red: 0, green: 0, blue: 0, alpha: 1 },
+    { red: 255, green: 255, blue: 255, alpha: 1 },
+    0.99,
+  )).toThrow(RangeError)
+
+  expect(doSrgbColorValuesMeetContrastRatio(
+    { red: 0, green: 0, blue: 0, alpha: 1 },
+    { red: 255, green: 255, blue: 255, alpha: 1 },
+    7,
+  )).toBe(true)
+
+  expect(doSrgbColorValuesMeetContrastRatio(
+    { red: 120, green: 120, blue: 120, alpha: 1 },
+    { red: 255, green: 255, blue: 255, alpha: 1 },
+    4.5,
+  )).toBe(false)
+})
+
+test("pickReadableSrgbTextColorValue chooses the more readable candidate", () => {
+  expect(pickReadableSrgbTextColorValue({ red: 0, green: 102, blue: 204, alpha: 1 })).toEqual({
+    red: 255,
+    green: 255,
+    blue: 255,
+    alpha: 1,
+  })
+
+  expect(pickReadableSrgbTextColorValue(
+    { red: 250, green: 240, blue: 210, alpha: 1 },
+    {
+      darkColor: { red: 32, green: 32, blue: 32, alpha: 1 },
+      lightColor: { red: 255, green: 255, blue: 255, alpha: 1 },
+    },
+  )).toEqual({
+    red: 32,
+    green: 32,
+    blue: 32,
+    alpha: 1,
+  })
+})
+
+test("linearRgbColorValueToTristimulusSum follows the explicit RGB branch pipeline", () => {
+  expect(linearRgbColorValueToTristimulusSum({ red: 1, green: 0, blue: 0, alpha: 1 })).toBe(0.644_463)
+  expect(linearRgbColorValueToTristimulusSum({ red: 1, green: 1, blue: 1, alpha: 1 })).toBe(3.039_3)
+})
+
+test("srgbColorValueToTristimulusSum follows the explicit RGB branch pipeline", () => {
+  expect(srgbColorValueToTristimulusSum({ red: 51, green: 102, blue: 153, alpha: 1 })).toBe(0.562_889)
+  expect(srgbColorValueToTristimulusSum({ red: 255, green: 255, blue: 255, alpha: 1 })).toBe(3.039_3)
+})
+
+test("linearRgbColorValueToXyChromaticityValue follows the explicit RGB branch pipeline", () => {
+  expect(linearRgbColorValueToXyChromaticityValue({ red: 1, green: 0, blue: 0, alpha: 1 })).toEqual({
+    x: 0.64,
+    y: 0.33,
+  })
+})
+
+test("srgbColorValueToXyChromaticityValue follows the explicit RGB branch pipeline", () => {
+  expect(srgbColorValueToXyChromaticityValue({ red: 51, green: 102, blue: 153, alpha: 1 })).toEqual({
+    x: 0.210_775,
+    y: 0.222_163,
+  })
+})
+
+test("isLightSrgbColorValue uses relative luminance threshold", () => {
+  expect(isLightSrgbColorValue({ red: 255, green: 255, blue: 255, alpha: 1 })).toBe(true)
+  expect(isLightSrgbColorValue({ red: 0, green: 0, blue: 0, alpha: 1 })).toBe(false)
+  expect(isLightSrgbColorValue({ red: 128, green: 128, blue: 128, alpha: 1 }, 0.2)).toBe(true)
+
+  expect(() => isLightSrgbColorValue({ red: 128, green: 128, blue: 128, alpha: 1 }, 1.1)).toThrow(RangeError)
+})

package/tests/unit/color/rgb/construct.spec.ts

@@ -0,0 +1,56 @@
+import { expect, test } from "vitest"
+
+import {
+  createHslColorValue,
+  createHslColorValueByString,
+  createHsvColorValue,
+  createHsvColorValueByString,
+  createLinearRgbColorValue,
+  createSrgbColorValue,
+  createSrgbColorValueByString,
+} from "#Source/color/index.ts"
+
+test("createLinearRgbColorValue accepts finite linear channels", () => {
+  expect(createLinearRgbColorValue({ red: -0.25, green: 0.4, blue: 1.2, alpha: 1 }))
+    .toEqual({ red: -0.25, green: 0.4, blue: 1.2, alpha: 1 })
+
+  expect(createLinearRgbColorValue({ red: 0, green: 0, blue: 0, alpha: 0.5 }))
+    .toEqual({ red: 0, green: 0, blue: 0, alpha: 0.5 })
+
+  expect(() => createLinearRgbColorValue({ red: Number.NaN, green: 0.4, blue: 1.2, alpha: 1 })).toThrow(RangeError)
+})
+
+test("createSrgbColorValue validates byte channels", () => {
+  expect(createSrgbColorValue({ red: 51, green: 102, blue: 153, alpha: 0.5 }))
+    .toEqual({ red: 51, green: 102, blue: 153, alpha: 0.5 })
+
+  expect(() => createSrgbColorValue({ red: -1, green: 0, blue: 0, alpha: 1 })).toThrow(RangeError)
+  expect(() => createSrgbColorValue({ red: 0, green: 0, blue: 256, alpha: 1 })).toThrow(RangeError)
+})
+
+test("createHslColorValue normalizes hue and validates units", () => {
+  expect(createHslColorValue({ hue: -30, saturation: 0.5, lightness: 0.4, alpha: 1 }))
+    .toEqual({ hue: 330, saturation: 0.5, lightness: 0.4, alpha: 1 })
+  expect(() => createHslColorValue({ hue: 0, saturation: 1.5, lightness: 0.4, alpha: 1 })).toThrow(RangeError)
+})
+
+test("createHsvColorValue normalizes hue and validates units", () => {
+  expect(createHsvColorValue({ hue: 390, saturation: 0.5, value: 0.6, alpha: 1 }))
+    .toEqual({ hue: 30, saturation: 0.5, value: 0.6, alpha: 1 })
+  expect(() => createHsvColorValue({ hue: 0, saturation: 0.5, value: 1.5, alpha: 1 })).toThrow(RangeError)
+})
+
+test("createSrgbColorValueByString stays deterministic", () => {
+  expect(createSrgbColorValueByString("mobius")).toEqual(createSrgbColorValueByString("mobius"))
+  expect(createSrgbColorValueByString("mobius")).not.toEqual(createSrgbColorValueByString("planet"))
+})
+
+test("createHslColorValueByString stays deterministic", () => {
+  expect(createHslColorValueByString("mobius")).toEqual(createHslColorValueByString("mobius"))
+  expect(createHslColorValueByString("mobius")).not.toEqual(createHslColorValueByString("planet"))
+})
+
+test("createHsvColorValueByString stays deterministic", () => {
+  expect(createHsvColorValueByString("mobius")).toEqual(createHsvColorValueByString("mobius"))
+  expect(createHsvColorValueByString("mobius")).not.toEqual(createHsvColorValueByString("planet"))
+})

package/tests/unit/color/rgb/convert.spec.ts

@@ -0,0 +1,60 @@
+import { expect, test } from "vitest"
+
+import {
+  hslColorValueToSrgbColorValue,
+  hsvColorValueToSrgbColorValue,
+  linearRgbColorValueToSrgbColorValue,
+  srgbColorValueToHslColorValue,
+  srgbColorValueToHsvColorValue,
+  srgbColorValueToLinearRgbColorValue,
+} from "#Source/color/index.ts"
+
+test("linearRgbColorValueToSrgbColorValue converts in-gamut linear values to sRGB", () => {
+  expect(linearRgbColorValueToSrgbColorValue({ red: 1, green: 0, blue: 0, alpha: 0.5 }))
+    .toEqual({ red: 255, green: 0, blue: 0, alpha: 0.5 })
+
+  expect(linearRgbColorValueToSrgbColorValue({ red: 0.5, green: 0.5, blue: 0.5, alpha: 0.5 }))
+    .toEqual({ red: 188, green: 188, blue: 188, alpha: 0.5 })
+
+  expect(() => linearRgbColorValueToSrgbColorValue({ red: 1.2, green: 0, blue: 0, alpha: 1 })).toThrow(RangeError)
+})
+
+test("srgbColorValueToLinearRgbColorValue converts sRGB values to linear values", () => {
+  expect(srgbColorValueToLinearRgbColorValue({ red: 255, green: 0, blue: 0, alpha: 0.5 }))
+    .toEqual({ red: 1, green: 0, blue: 0, alpha: 0.5 })
+
+  expect(srgbColorValueToLinearRgbColorValue({ red: 128, green: 128, blue: 128, alpha: 0.5 }))
+    .toEqual({ red: 0.215_861, green: 0.215_861, blue: 0.215_861, alpha: 0.5 })
+})
+
+test("srgbColorValueToHslColorValue converts sRGB values to HSL", () => {
+  expect(srgbColorValueToHslColorValue({ red: 51, green: 102, blue: 153, alpha: 1 }))
+    .toEqual({ hue: 210, saturation: 0.5, lightness: 0.4, alpha: 1 })
+
+  expect(srgbColorValueToHslColorValue({ red: 128, green: 128, blue: 128, alpha: 1 }))
+    .toEqual({ hue: 0, saturation: 0, lightness: 0.501_961, alpha: 1 })
+})
+
+test("hslColorValueToSrgbColorValue converts HSL values to sRGB", () => {
+  expect(hslColorValueToSrgbColorValue({ hue: 210, saturation: 0.5, lightness: 0.4, alpha: 1 }))
+    .toEqual({ red: 51, green: 102, blue: 153, alpha: 1 })
+
+  expect(hslColorValueToSrgbColorValue({ hue: 0, saturation: 0, lightness: 0.501_961, alpha: 1 }))
+    .toEqual({ red: 128, green: 128, blue: 128, alpha: 1 })
+})
+
+test("srgbColorValueToHsvColorValue converts sRGB values to HSV", () => {
+  expect(srgbColorValueToHsvColorValue({ red: 51, green: 102, blue: 153, alpha: 1 }))
+    .toEqual({ hue: 210, saturation: 0.666_667, value: 0.6, alpha: 1 })
+
+  expect(srgbColorValueToHsvColorValue({ red: 128, green: 128, blue: 128, alpha: 1 }))
+    .toEqual({ hue: 0, saturation: 0, value: 0.501_961, alpha: 1 })
+})
+
+test("hsvColorValueToSrgbColorValue converts HSV values to sRGB", () => {
+  expect(hsvColorValueToSrgbColorValue({ hue: 210, saturation: 0.666_667, value: 0.6, alpha: 1 }))
+    .toEqual({ red: 51, green: 102, blue: 153, alpha: 1 })
+
+  expect(hsvColorValueToSrgbColorValue({ hue: 0, saturation: 0, value: 0.501_961, alpha: 1 }))
+    .toEqual({ red: 128, green: 128, blue: 128, alpha: 1 })
+})