@typeonce/ritmo-math 0.12.0 → 0.14.0

package/src/internal/codec.ts

@@ -0,0 +1,21 @@
+import type { StandardSchema } from "@typeonce/ritmo/Descriptor"
+import type * as Result from "@typeonce/ritmo/Result"
+
+/**
+ * The codec of one math type, from its decode: a Standard Schema whose saved
+ * form is the raw shape. The value is already plain data, so it needs no
+ * `encode`.
+ */
+export const codecOf = <Raw, Value>(
+  decode: (raw: unknown) => Result.Result<Value, unknown>,
+  expected: string
+): StandardSchema<Raw, Value> => ({
+  "~standard": {
+    version: 1,
+    vendor: "ritmo-math",
+    validate: (raw) => {
+      const value = decode(raw)
+      return value.ok ? { value: value.value } : { issues: [{ message: `Expected ${expected}` }] }
+    }
+  }
+})

package/src/internal/scalar.ts

@@ -1,18 +1,33 @@
-import * as Brand from "@typeonce/ritmo/Brand"
 import * as Result from "@typeonce/ritmo/Result"
 import type * as Scalar from "../Scalar.ts"
+import { codecOf } from "./codec.ts"
 
-const finiteBrand = Brand.refine<Scalar.Finite, number, Scalar.Error>((value) =>
+// A branded number's constructors, guard, and codec, from its check.
+const refine = <Value extends number>(
+  validate: (raw: number) => Result.Result<Value, Scalar.Error>,
+  expected: string
+): Scalar.Constructor<Value> => ({
+  result: validate,
+  option: (raw) => {
+    const result = validate(raw)
+    return result.ok ? result.value : null
+  },
+  is: (raw): raw is Value => typeof raw === "number" && validate(raw).ok,
+  codec: codecOf<number, Value>((raw) => typeof raw === "number" ? validate(raw) : Result.failure(raw), expected)
+})
+
+export const Finite = refine<Scalar.Finite>((value) =>
   Number.isFinite(value)
     ? Result.success(value as Scalar.Finite)
     : Result.failure({
         tag: "Scalar/NotFinite",
         value
-      })
+      }),
+  "a finite number"
 )
 
-const nonNegativeBrand = Brand.refine<Scalar.NonNegative, number, Scalar.Error>((value) => {
-  const finite = finiteBrand.result(value)
+export const NonNegative = refine<Scalar.NonNegative>((value) => {
+  const finite = Finite.result(value)
   if (!finite.ok) {
     return finite
   }
@@ -23,10 +38,10 @@ const nonNegativeBrand = Brand.refine<Scalar.NonNegative, number, Scalar.Error>(
         tag: "Scalar/Negative",
         value
       })
-})
+}, "a finite number, 0 or more")
 
-const positiveBrand = Brand.refine<Scalar.Positive, number, Scalar.Error>((value) => {
-  const finite = finiteBrand.result(value)
+export const Positive = refine<Scalar.Positive>((value) => {
+  const finite = Finite.result(value)
   if (!finite.ok) {
     return finite
   }
@@ -37,11 +52,7 @@ const positiveBrand = Brand.refine<Scalar.Positive, number, Scalar.Error>((value
         tag: "Scalar/NonPositive",
         value
       })
-})
-
-export const Finite = finiteBrand
-export const NonNegative = nonNegativeBrand
-export const Positive = positiveBrand
+}, "a finite number above 0")
 
 export const clamp = (value: number, min: number, max: number): Scalar.Finite =>
   Math.min(Math.max(value, min), max) as Scalar.Finite

package/src/internal/size2.ts

@@ -1,3 +1,4 @@
+import { codecOf } from "./codec.ts"
 import * as Result from "@typeonce/ritmo/Result"
 import * as Scalar from "../Scalar.ts"
 import type * as Size2 from "../Size2.ts"
@@ -28,7 +29,7 @@ export const option = (raw: Size2.Raw): Size2.Size2 | null => {
   return next.ok ? next.value : null
 }
 
-export const is = (raw: Size2.Raw): raw is Size2.Raw & Size2.Size2 => result(raw).ok
+export const is = (raw: unknown): raw is Size2.Size2 => decode(raw).ok
 
 export const toRaw = (size: Size2.Size2): Size2.Raw => ({
   width: size.width,
@@ -44,5 +45,10 @@ export const height = (size: Size2.Size2): Scalar.NonNegative => size.height
 export const isRawShape = (raw: unknown): raw is Size2.Raw =>
   typeof raw === "object" && raw !== null && typeof (raw as Record<string, unknown>)["width"] === "number" && typeof (raw as Record<string, unknown>)["height"] === "number"
 
-export const decode = (raw: unknown): Result.Result<Size2.Size2, Size2.Error | Size2.DecodeError> =>
+/** Untrusted input without the raw shape. */
+type Malformed = { readonly tag: "Size2/Malformed"; readonly input: unknown }
+
+export const decode = (raw: unknown): Result.Result<Size2.Size2, Size2.Error | Malformed> =>
   isRawShape(raw) ? result(raw) : Result.failure({ tag: "Size2/Malformed", input: raw })
+
+export const codec = codecOf<Size2.Raw, Size2.Size2>(decode, "a size { width, height } of non-negative finite numbers")

package/src/internal/vector2.ts

@@ -1,3 +1,4 @@
+import { codecOf } from "./codec.ts"
 import * as Result from "@typeonce/ritmo/Result"
 import * as Scalar from "../Scalar.ts"
 import type * as Vector2 from "../Vector2.ts"
@@ -28,7 +29,7 @@ export const option = (raw: Vector2.Raw): Vector2.Vector2 | null => {
   return next.ok ? next.value : null
 }
 
-export const is = (raw: Vector2.Raw): raw is Vector2.Raw & Vector2.Vector2 => result(raw).ok
+export const is = (raw: unknown): raw is Vector2.Vector2 => decode(raw).ok
 
 export const toRaw = (vector: Vector2.Vector2): Vector2.Raw => ({
   x: vector.x,
@@ -111,5 +112,10 @@ export const normalizeXYOrZero = (x: number, y: number): {
 export const isRawShape = (raw: unknown): raw is Vector2.Raw =>
   typeof raw === "object" && raw !== null && typeof (raw as Record<string, unknown>)["x"] === "number" && typeof (raw as Record<string, unknown>)["y"] === "number"
 
-export const decode = (raw: unknown): Result.Result<Vector2.Vector2, Vector2.Error | Vector2.DecodeError> =>
+/** Untrusted input without the raw shape. */
+type Malformed = { readonly tag: "Vector2/Malformed"; readonly input: unknown }
+
+export const decode = (raw: unknown): Result.Result<Vector2.Vector2, Vector2.Error | Malformed> =>
   isRawShape(raw) ? result(raw) : Result.failure({ tag: "Vector2/Malformed", input: raw })
+
+export const codec = codecOf<Vector2.Raw, Vector2.Vector2>(decode, "a vector { x, y } of finite numbers")