@planet-matrix/mobius-model 0.5.0 → 0.6.0

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

@@ -0,0 +1,66 @@
+import { expect, test } from "vitest"
+
+import {
+  colorStringToSrgbColorValue,
+  hexColorStringToSrgbColorValue,
+  hslColorStringToHslColorValue,
+  hslaColorStringToHslColorValue,
+  hsvColorStringToHsvColorValue,
+  hsvaColorStringToHsvColorValue,
+  isHexColorString,
+  rgbColorStringToSrgbColorValue,
+  rgbaColorStringToSrgbColorValue,
+} from "#Source/color/index.ts"
+
+test("isHexColorString validates supported hex formats", () => {
+  expect(isHexColorString("#F0A")).toBe(true)
+  expect(isHexColorString("11223344")).toBe(true)
+  expect(isHexColorString("#12")).toBe(false)
+})
+
+test("hexColorStringToSrgbColorValue supports short and long hex formats", () => {
+  expect(hexColorStringToSrgbColorValue("#F0A")).toEqual({ red: 255, green: 0, blue: 170, alpha: 1 })
+  expect(hexColorStringToSrgbColorValue("#112233")).toEqual({ red: 17, green: 34, blue: 51, alpha: 1 })
+  expect(hexColorStringToSrgbColorValue("#11223344")).toEqual({ red: 17, green: 34, blue: 51, alpha: 0.266_7 })
+  expect(() => hexColorStringToSrgbColorValue("#12")).toThrow(TypeError)
+})
+
+test("rgbColorStringToSrgbColorValue returns sRGB values", () => {
+  expect(rgbColorStringToSrgbColorValue("rgb(51, 102, 153)")).toEqual({ red: 51, green: 102, blue: 153, alpha: 1 })
+  expect(rgbColorStringToSrgbColorValue("rgb(0, 0, 0)")).toEqual({ red: 0, green: 0, blue: 0, alpha: 1 })
+})
+
+test("rgbaColorStringToSrgbColorValue returns sRGB values", () => {
+  expect(rgbaColorStringToSrgbColorValue("rgba(51, 102, 153, 0.5)")).toEqual({ red: 51, green: 102, blue: 153, alpha: 0.5 })
+  expect(() => rgbaColorStringToSrgbColorValue("rgba(51, 102, 153, 1.5)")).toThrow(RangeError)
+})
+
+test("hslColorStringToHslColorValue returns HSL values", () => {
+  expect(hslColorStringToHslColorValue("hsl(210, 50%, 40%)")).toEqual({ hue: 210, saturation: 0.5, lightness: 0.4, alpha: 1 })
+  expect(hslColorStringToHslColorValue("hsl(-30, 50%, 40%)")).toEqual({ hue: 330, saturation: 0.5, lightness: 0.4, alpha: 1 })
+  expect(() => hslColorStringToHslColorValue("hsl(210, 120%, 40%)")).toThrow(RangeError)
+})
+
+test("hslaColorStringToHslColorValue returns HSL values", () => {
+  expect(hslaColorStringToHslColorValue("hsla(210, 50%, 40%, 0.5)")).toEqual({ hue: 210, saturation: 0.5, lightness: 0.4, alpha: 0.5 })
+  expect(hslaColorStringToHslColorValue("hsla(0, 0%, 100%, 1)")).toEqual({ hue: 0, saturation: 0, lightness: 1, alpha: 1 })
+})
+
+test("hsvColorStringToHsvColorValue returns HSV values", () => {
+  expect(hsvColorStringToHsvColorValue("hsv(210, 66.67%, 60%)")).toEqual({ hue: 210, saturation: 0.666_7, value: 0.6, alpha: 1 })
+  expect(hsvColorStringToHsvColorValue("hsv(390, 50%, 60%)")).toEqual({ hue: 30, saturation: 0.5, value: 0.6, alpha: 1 })
+})
+
+test("hsvaColorStringToHsvColorValue returns HSV values", () => {
+  expect(hsvaColorStringToHsvColorValue("hsva(210, 66.67%, 60%, 0.5)")).toEqual({ hue: 210, saturation: 0.666_7, value: 0.6, alpha: 0.5 })
+  expect(hsvaColorStringToHsvColorValue("hsva(0, 0%, 100%, 1)")).toEqual({ hue: 0, saturation: 0, value: 1, alpha: 1 })
+  expect(() => hsvaColorStringToHsvColorValue("hsva(210, 66.67%, 60%, -0.1)")).toThrow(RangeError)
+})
+
+test("colorStringToSrgbColorValue folds supported string inputs into sRGB", () => {
+  expect(colorStringToSrgbColorValue("#336699")).toEqual({ red: 51, green: 102, blue: 153, alpha: 1 })
+  expect(colorStringToSrgbColorValue("hsl(210, 50%, 40%)")).toEqual({ red: 51, green: 102, blue: 153, alpha: 1 })
+  expect(colorStringToSrgbColorValue("hsv(210, 66.67%, 60%)")).toEqual({ red: 51, green: 102, blue: 153, alpha: 1 })
+  expect(colorStringToSrgbColorValue("rgb(51, 102, 153)")).toEqual({ red: 51, green: 102, blue: 153, alpha: 1 })
+  expect(() => colorStringToSrgbColorValue("foo(0, 0%, 0%)")).toThrow(TypeError)
+})

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

@@ -0,0 +1,46 @@
+import { expect, test } from "vitest"
+
+import {
+  hslColorValueToHslColorString,
+  hslColorValueToHslaColorString,
+  hsvColorValueToHsvColorString,
+  hsvColorValueToHsvaColorString,
+  srgbColorValueToHexColorString,
+  srgbColorValueToRgbColorString,
+  srgbColorValueToRgbaColorString,
+} from "#Source/color/index.ts"
+
+test("srgbColorValueToHexColorString serializes hex output", () => {
+  expect(srgbColorValueToHexColorString({ red: 51, green: 102, blue: 153, alpha: 0.5 })).toBe("#336699")
+  expect(srgbColorValueToHexColorString({ red: 51, green: 102, blue: 153, alpha: 0.5 }, { includeAlpha: true })).toBe("#33669980")
+})
+
+test("srgbColorValueToRgbColorString serializes rgb output", () => {
+  expect(srgbColorValueToRgbColorString({ red: 51, green: 102, blue: 153, alpha: 0.5 })).toBe("rgb(51, 102, 153)")
+  expect(srgbColorValueToRgbColorString({ red: 0, green: 0, blue: 0, alpha: 1 })).toBe("rgb(0, 0, 0)")
+})
+
+test("srgbColorValueToRgbaColorString serializes rgba output", () => {
+  expect(srgbColorValueToRgbaColorString({ red: 51, green: 102, blue: 153, alpha: 0.5 })).toBe("rgba(51, 102, 153, 0.5)")
+  expect(srgbColorValueToRgbaColorString({ red: 255, green: 255, blue: 255, alpha: 1 })).toBe("rgba(255, 255, 255, 1)")
+})
+
+test("hslColorValueToHslColorString serializes hsl output", () => {
+  expect(hslColorValueToHslColorString({ hue: 210, saturation: 0.5, lightness: 0.4, alpha: 0.5 })).toBe("hsl(210, 50%, 40%)")
+  expect(hslColorValueToHslColorString({ hue: 0, saturation: 0, lightness: 1, alpha: 1 })).toBe("hsl(0, 0%, 100%)")
+})
+
+test("hslColorValueToHslaColorString serializes hsla output", () => {
+  expect(hslColorValueToHslaColorString({ hue: 210, saturation: 0.5, lightness: 0.4, alpha: 0.5 })).toBe("hsla(210, 50%, 40%, 0.5)")
+  expect(hslColorValueToHslaColorString({ hue: 0, saturation: 0, lightness: 1, alpha: 1 })).toBe("hsla(0, 0%, 100%, 1)")
+})
+
+test("hsvColorValueToHsvColorString serializes hsv output", () => {
+  expect(hsvColorValueToHsvColorString({ hue: 210, saturation: 0.666_7, value: 0.6, alpha: 0.5 })).toBe("hsv(210, 66.67%, 60%)")
+  expect(hsvColorValueToHsvColorString({ hue: 0, saturation: 0, value: 1, alpha: 1 })).toBe("hsv(0, 0%, 100%)")
+})
+
+test("hsvColorValueToHsvaColorString serializes hsva output", () => {
+  expect(hsvColorValueToHsvaColorString({ hue: 210, saturation: 0.666_7, value: 0.6, alpha: 0.5 })).toBe("hsva(210, 66.67%, 60%, 0.5)")
+  expect(hsvColorValueToHsvaColorString({ hue: 0, saturation: 0, value: 1, alpha: 1 })).toBe("hsva(0, 0%, 100%, 1)")
+})

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

@@ -0,0 +1,33 @@
+import { expect, test } from "vitest"
+
+import {
+  xyzColorValueToRelativeLuminance,
+  xyzColorValueToTristimulusSum,
+  xyzColorValueToXyChromaticityValue,
+} from "#Source/color/index.ts"
+
+test("xyzColorValueToRelativeLuminance returns y channel", () => {
+  expect(xyzColorValueToRelativeLuminance({ x: 0.25, y: 0.3, z: 0.4, alpha: 1 })).toBe(0.3)
+  expect(xyzColorValueToRelativeLuminance({ x: 0, y: 0, z: 0, alpha: 1 })).toBe(0)
+})
+
+test("xyzColorValueToTristimulusSum returns x plus y plus z", () => {
+  expect(xyzColorValueToTristimulusSum({ x: 0.25, y: 0.3, z: 0.4, alpha: 1 })).toBe(0.95)
+  expect(xyzColorValueToTristimulusSum({ x: 0, y: 0, z: 0, alpha: 1 })).toBe(0)
+})
+
+test("xyzColorValueToXyChromaticityValue returns xy chromaticity coordinates", () => {
+  expect(xyzColorValueToXyChromaticityValue({ x: 0.25, y: 0.3, z: 0.4, alpha: 1 })).toEqual({
+    x: 0.263_158,
+    y: 0.315_789,
+  })
+
+  expect(xyzColorValueToXyChromaticityValue({ x: 0.412_456, y: 0.212_673, z: 0.019_334, alpha: 1 })).toEqual({
+    x: 0.64,
+    y: 0.33,
+  })
+
+  expect(() => xyzColorValueToXyChromaticityValue({ x: 0, y: 0, z: 0, alpha: 1 })).toThrow(
+    "XYZ tristimulus sum must be greater than 0 to compute xy chromaticity",
+  )
+})

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

@@ -0,0 +1,10 @@
+import { expect, test } from "vitest"
+
+import { createXyzColorValue } from "#Source/color/index.ts"
+
+test("createXyzColorValue validates non-negative channels", () => {
+  expect(createXyzColorValue({ x: 0.25, y: 0.3, z: 0.4, alpha: 1 }))
+    .toEqual({ x: 0.25, y: 0.3, z: 0.4, alpha: 1 })
+
+  expect(() => createXyzColorValue({ x: -0.1, y: 0.3, z: 0.4, alpha: 1 })).toThrow(RangeError)
+})

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

@@ -0,0 +1,18 @@
+import { expect, test } from "vitest"
+
+import {
+  linearRgbColorValueToXyzColorValue,
+  xyzColorValueToLinearRgbColorValue,
+} from "#Source/color/index.ts"
+
+test("xyzColorValueToLinearRgbColorValue converts XYZ values to Linear RGB", () => {
+  expect(xyzColorValueToLinearRgbColorValue({ x: 0.333_784_22, y: 0.371_900_46, z: 0.621_726_04, alpha: 1 }))
+    .toEqual({ red: 0.2, green: 0.4, blue: 0.6, alpha: 1 })
+})
+
+test("linearRgbColorValueToXyzColorValue converts Linear RGB values to XYZ", () => {
+  expect(linearRgbColorValueToXyzColorValue({ red: 0.2, green: 0.4, blue: 0.6, alpha: 1 }))
+    .toEqual({ x: 0.333_784, y: 0.371_9, z: 0.621_726, alpha: 1 })
+
+  expect(() => linearRgbColorValueToXyzColorValue({ red: Number.NaN, green: 0.4, blue: 0.6, alpha: 1 })).toThrow(RangeError)
+})

package/tests/unit/css/class.spec.ts

@@ -0,0 +1,157 @@
+import { expect, test } from "vitest"
+
+import {
+  addClass,
+  classArrayToClassObject,
+  classArrayToClassString,
+  classObjectToClassArray,
+  classObjectToClassString,
+  classStringToClassArray,
+  classStringToClassObject,
+  containClass,
+  formatClassToTarget,
+  neatenClassString,
+  prefixClassWith,
+  removeClass,
+  removePrefixOfClass,
+  replaceClass,
+  toClassArray,
+  toClassObject,
+  toClassString,
+  toggleClass,
+} from "#Source/css/index.ts"
+
+test("neatenClassString normalizes dots and spaces", () => {
+  expect(neatenClassString("mobius-base mobius-theme--light")).toBe("mobius-base mobius-theme--light")
+  expect(neatenClassString(".mobius-base.mobius-theme--light")).toBe("mobius-base mobius-theme--light")
+  expect(neatenClassString("  .mobius-base   mobius-theme--light  ")).toBe("mobius-base mobius-theme--light")
+})
+
+test("classStringToClassArray splits normalized class strings", () => {
+  expect(classStringToClassArray("mobius-base mobius-theme--light")).toEqual(["mobius-base", "mobius-theme--light"])
+  expect(classStringToClassArray(".mobius-base.mobius-theme--light")).toEqual(["mobius-base", "mobius-theme--light"])
+  expect(classStringToClassArray("  .mobius-base   mobius-theme--light  ")).toEqual(["mobius-base", "mobius-theme--light"])
+})
+
+test("classArrayToClassObject marks every class as true", () => {
+  expect(classArrayToClassObject(["mobius-base", "mobius-theme--light"]))
+    .toEqual({ "mobius-base": true, "mobius-theme--light": true })
+  expect(classArrayToClassObject(["mobius-base", ""]))
+    .toEqual({ "mobius-base": true })
+  expect(classArrayToClassObject([])).toEqual({})
+})
+
+test("classStringToClassObject converts strings through normalized array form", () => {
+  expect(classStringToClassObject("mobius-base mobius-theme--light"))
+    .toEqual({ "mobius-base": true, "mobius-theme--light": true })
+  expect(classStringToClassObject(".mobius-base.mobius-theme--light"))
+    .toEqual({ "mobius-base": true, "mobius-theme--light": true })
+})
+
+test("classObjectToClassArray keeps only truthy class names", () => {
+  expect(classObjectToClassArray({ active: true, disabled: false, primary: true }))
+    .toEqual(["active", "primary"])
+  expect(classObjectToClassArray({ "": true, active: true, disabled: false })).toEqual(["active"])
+  expect(classObjectToClassArray({ disabled: false })).toEqual([])
+})
+
+test("classArrayToClassString joins non-empty items with spaces", () => {
+  expect(classArrayToClassString(["mobius-base", "mobius-theme--light"]))
+    .toBe("mobius-base mobius-theme--light")
+  expect(classArrayToClassString(["mobius-base", "", "mobius-theme--light"]))
+    .toBe("mobius-base mobius-theme--light")
+})
+
+test("classObjectToClassString serializes only truthy keys", () => {
+  expect(classObjectToClassString({ active: true, disabled: false, primary: true }))
+    .toBe("active primary")
+  expect(classObjectToClassString({ "": true, active: true, disabled: false })).toBe("active")
+  expect(classObjectToClassString({ disabled: false })).toBe("")
+})
+
+test("toClassString preserves string input and serializes other shapes", () => {
+  expect(toClassString("  .button   active  ")).toBe("  .button   active  ")
+  expect(toClassString(["button", "active"])).toBe("button active")
+  expect(toClassString({ button: true, active: true, disabled: false })).toBe("button active")
+})
+
+test("toClassArray normalizes strings and clones arrays", () => {
+  const classArray = ["button", "", "active"]
+  const result = toClassArray(classArray)
+
+  expect(toClassArray(".button.active")).toEqual(["button", "active"])
+  expect(result).toEqual(["button", "active"])
+  expect(result).not.toBe(classArray)
+  expect(toClassArray({ button: true, active: true, disabled: false })).toEqual(["button", "active"])
+})
+
+test("toClassObject normalizes strings and clones objects", () => {
+  const classObject = { button: true, active: false, "": true }
+  const result = toClassObject(classObject)
+
+  expect(toClassObject("button active")).toEqual({ button: true, active: true })
+  expect(toClassObject(["button", "active"])).toEqual({ button: true, active: true })
+  expect(result).toEqual({ button: true, active: false })
+  expect(result).not.toBe(classObject)
+})
+
+test("formatClassToTarget returns the same external shape as target", () => {
+  expect(formatClassToTarget("", ["button", "active"])).toBe("button active")
+  expect(formatClassToTarget([], "button active")).toEqual(["button", "active"])
+  expect(formatClassToTarget({}, ["button", "active"])).toEqual({ button: true, active: true })
+})
+
+test("prefixClassWith adds prefixes only when missing", () => {
+  expect(prefixClassWith("pm-", "button active")).toBe("pm-button pm-active")
+  expect(prefixClassWith("pm-", ["button", "", "pm-active"])).toEqual(["pm-button", "pm-active"])
+  expect(prefixClassWith("pm-", { button: true, "": true, "pm-active": false }))
+    .toEqual({ "pm-button": true, "pm-active": false })
+})
+
+test("removePrefixOfClass removes prefixes only when present", () => {
+  expect(removePrefixOfClass("pm-", "pm-button pm-active plain")).toBe("button active plain")
+  expect(removePrefixOfClass("pm-", ["pm-button", "pm-", "plain"]))
+    .toEqual(["button", "plain"])
+  expect(removePrefixOfClass("pm-", { "pm-button": true, plain: false, "pm-": true }))
+    .toEqual({ button: true, plain: false })
+})
+
+test("addClass merges class names while preserving target shape", () => {
+  expect(addClass("button", "active primary")).toBe("button active primary")
+  expect(addClass(["button", ""], { active: true, primary: true, "": false }))
+    .toEqual(["button", "active", "primary"])
+  expect(addClass({ button: true }, ["active", "primary"]))
+    .toEqual({ button: true, active: true, primary: true })
+})
+
+test("removeClass removes selected class names while preserving target shape", () => {
+  expect(removeClass("button active primary", "active")).toBe("button primary")
+  expect(removeClass(["button", "active", "primary"], { active: true })).toEqual(["button", "primary"])
+  expect(removeClass({ button: true, active: true, primary: true }, ["active"]))
+    .toEqual({ button: true, active: false, primary: true })
+})
+
+test("toggleClass flips membership for each target class", () => {
+  expect(toggleClass("button active", "active primary")).toBe("button primary")
+  expect(toggleClass(["button", "active"], ["active", "", "primary"]))
+    .toEqual(["button", "primary"])
+  expect(toggleClass({ button: true, active: true }, ["active", "primary"]))
+    .toEqual({ button: true, active: false, primary: true })
+})
+
+test("replaceClass supports tuple arrays, string arrays, records, and string removals", () => {
+  expect(replaceClass("button active", [["active", "selected"]])).toBe("button selected")
+  expect(replaceClass("button active primary", ["active", "primary"])).toBe("button")
+  expect(replaceClass(["button", "active"], { active: "selected" })).toEqual(["button", "selected"])
+  expect(replaceClass({ button: true, active: true }, "active")).toEqual({ active: false, button: true })
+  expect(replaceClass({ "": true, button: true, active: false }, { "": "selected", active: "featured" }))
+    .toEqual({ button: true, featured: false })
+  expect(replaceClass("button active primary", [["active", ""], ["primary", "featured"]]))
+    .toBe("button featured")
+})
+
+test("containClass checks whether all required class names are present", () => {
+  expect(containClass("button active", "button active primary")).toBe(true)
+  expect(containClass(["button", "missing"], { button: true, active: true })).toBe(false)
+  expect(containClass({ button: true }, ["button", "active"])).toBe(true)
+})

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

@@ -0,0 +1,20 @@
+import { expect, test } from "vitest"
+
+import { useFactory } from "#Source/environment/basic.ts"
+
+test("useFactory executes selected branch by availability", () => {
+  const useEnabled = useFactory(() => 42, () => true)
+  const useDisabled = useFactory(() => 42, () => false)
+
+  const enabledResult = useEnabled(
+    (value) => value + 1,
+    () => -1,
+  )
+  const disabledResult = useDisabled(
+    (value) => value + 1,
+    () => -1,
+  )
+
+  expect(enabledResult).toBe(43)
+  expect(disabledResult).toBe(-1)
+})

package/tests/unit/environment/device.spec.ts

@@ -0,0 +1,146 @@
+import { expect, test, vi } from "vitest"
+
+import {
+  getDeviceInfo,
+  getDeviceNavigatorInfo,
+  getDeviceScreenInfo,
+  parseUserAgent,
+} from "#Source/environment/device.ts"
+
+const setupForGetDeviceNavigatorInfo = (): (() => void) => {
+  vi.stubGlobal("navigator", {
+    oscpu: "Windows NT 10.0",
+    hardwareConcurrency: 8,
+    deviceMemory: 16,
+    maxTouchPoints: 5,
+    platform: "Win32",
+    devicePosture: { type: "continuous" },
+    connection: {
+      downlink: 10,
+      downlinkMax: 100,
+      effectiveType: "4g",
+      rtt: 40,
+      saveData: false,
+      type: "wifi",
+    },
+    onLine: true,
+    cookieEnabled: true,
+    language: "en-US",
+    languages: ["en-US", "zh-CN"],
+    pdfViewerEnabled: true,
+    userAgent:
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+  })
+
+  return () => {
+    vi.unstubAllGlobals()
+  }
+}
+test("getDeviceNavigatorInfo collects navigator metadata", () => {
+  const restore = setupForGetDeviceNavigatorInfo()
+
+  const info = getDeviceNavigatorInfo()
+
+  expect(info.oscpu).toBe("Windows NT 10.0")
+  expect(info.hardwareConcurrency).toBe(8)
+  expect(info.connectionType).toBe("wifi")
+  expect(info.languages).toEqual(["en-US", "zh-CN"])
+
+  restore()
+})
+
+test("parseUserAgent normalizes user-agent metadata", () => {
+  const userAgent =
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
+
+  const info = parseUserAgent(userAgent)
+
+  expect(info.ua).toBe(userAgent)
+  expect(typeof info.browserIsBot).toBe("boolean")
+  expect(typeof info.browserIsChromeFamily).toBe("boolean")
+  expect(typeof info.deviceIsAppleSilicon).toBe("boolean")
+})
+
+const setupForGetDeviceScreenInfo = (): (() => void) => {
+  vi.stubGlobal("document", {
+    documentElement: {
+      clientWidth: 1_200,
+      clientHeight: 700,
+      scrollWidth: 2_000,
+      scrollHeight: 3_000,
+    },
+  })
+  vi.stubGlobal("window", {
+    devicePixelRatio: 2,
+    screen: {
+      width: 1_920,
+      height: 1_080,
+      availWidth: 1_900,
+      availHeight: 1_060,
+      orientation: { type: "landscape-primary" },
+    },
+    outerWidth: 1_400,
+    outerHeight: 900,
+    innerWidth: 1_200,
+    innerHeight: 700,
+    visualViewport: {
+      width: 1_180,
+      height: 680,
+      offsetLeft: 10,
+      offsetTop: 8,
+      pageLeft: 0,
+      pageTop: 0,
+      scale: 1,
+    },
+  })
+  vi.stubGlobal("getComputedStyle", () => ({
+    getPropertyValue: (name: string): string => {
+      if (name.includes("top")) {
+        return "10"
+      }
+      if (name.includes("bottom")) {
+        return "20"
+      }
+      if (name.includes("left")) {
+        return "30"
+      }
+      if (name.includes("right")) {
+        return "40"
+      }
+      return "0"
+    },
+  }))
+
+  return () => {
+    vi.unstubAllGlobals()
+  }
+}
+test("getDeviceScreenInfo collects screen and viewport metadata", () => {
+  const restore = setupForGetDeviceScreenInfo()
+
+  const info = getDeviceScreenInfo()
+
+  expect(info.pixelRatio).toBe(2)
+  expect(info.screenWidth).toBe(1_920)
+  expect(info.viewportAvailableWidth).toBe(1_200)
+  expect(info.safeAreaTop).toBe(10)
+  expect(info.safeAreaRight).toBe(40)
+
+  restore()
+})
+
+test("getDeviceInfo aggregates navigator, user-agent, and screen metadata", () => {
+  const restore1 = setupForGetDeviceNavigatorInfo()
+  const restore2 = setupForGetDeviceScreenInfo()
+
+  const userAgent =
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
+  const info = getDeviceInfo(userAgent)
+
+  expect(info.navigator.language).toBe("en-US")
+  expect(info.userAgent.ua).toBe(userAgent)
+  expect(info.screen.viewportHeight).toBe(700)
+
+  restore1()
+  restore2()
+})