@synnaxlabs/x 0.55.0 → 0.56.1

package/src/spatial/base.ts

@@ -9,99 +9,7 @@
 
 import { z } from "zod";
 
-// Tuples
+export * from "@/spatial/types.gen";
 
 export const numberCouple = z.tuple([z.number(), z.number()]);
 export type NumberCouple<T extends number | bigint = number> = [T, T];
-
-// Direction
-
-export const DIRECTIONS = ["x", "y"] as const;
-export const directionZ = z.enum(DIRECTIONS);
-export type Direction = z.infer<typeof directionZ>;
-
-// Location
-
-export const OUTER_LOCATIONS = ["top", "right", "bottom", "left"] as const;
-export const outerLocationZ = z.enum(OUTER_LOCATIONS);
-export type OuterLocation = z.infer<typeof outerLocationZ>;
-
-export const X_LOCATIONS = ["left", "right"] as const;
-export const xLocationZ = z.enum(X_LOCATIONS);
-export type XLocation = z.infer<typeof xLocationZ>;
-
-export const Y_LOCATIONS = ["top", "bottom"] as const;
-export const yLocationZ = z.enum(Y_LOCATIONS);
-export type YLocation = z.infer<typeof yLocationZ>;
-
-export const CENTER_LOCATIONS = ["center"] as const;
-export const centerLocationZ = z.enum(CENTER_LOCATIONS);
-export type CenterLocation = z.infer<typeof centerLocationZ>;
-
-export const LOCATIONS = ["top", "right", "bottom", "left", "center"] as const;
-export const locationZ = z.enum(LOCATIONS);
-export type Location = z.infer<typeof locationZ>;
-
-// Alignment
-
-export const ALIGNMENTS = ["start", "center", "end"] as const;
-export const alignmentZ = z.enum(ALIGNMENTS);
-export type Alignment = z.infer<typeof alignmentZ>;
-
-// Order
-
-export const ORDERS = ["first", "last"] as const;
-export const orderZ = z.enum(ORDERS);
-export type Order = z.infer<typeof orderZ>;
-
-// XY
-
-export const clientXyZ = z.object({ clientX: z.number(), clientY: z.number() });
-export type ClientXY = z.infer<typeof clientXyZ>;
-
-// Dimensions
-
-export const dimensionsZ = z.object({ width: z.number(), height: z.number() });
-export type Dimensions = z.infer<typeof dimensionsZ>;
-
-export const signedDimensionsZ = z.object({
-  signedWidth: z.number(),
-  signedHeight: z.number(),
-});
-export type SignedDimensions = z.infer<typeof signedDimensionsZ>;
-
-export type Dimension = "width" | "height";
-export type SignedDimension = "signedWidth" | "signedHeight";
-
-// Bounds
-
-export const boundsZ = z.object({ lower: z.number(), upper: z.number() });
-
-// Generic bounds interface (supports bigint)
-export interface Bounds<T extends number | bigint = number> {
-  lower: T;
-  upper: T;
-}
-
-export type CrudeBounds<T extends number | bigint = number> =
-  | Bounds<T>
-  | NumberCouple<T>;
-
-// Derived/complex types
-
-export const crudeDirection = z.enum([
-  "x",
-  "y",
-  ...OUTER_LOCATIONS,
-  ...CENTER_LOCATIONS,
-]);
-export type CrudeDirection = z.infer<typeof crudeDirection>;
-export type CrudeXDirection = "x" | "left" | "right";
-export type CrudeYDirection = "y" | "top" | "bottom";
-export type AngularDirection = "clockwise" | "counterclockwise";
-export const crudeLocation = z.union([
-  directionZ,
-  z.enum([...OUTER_LOCATIONS, ...CENTER_LOCATIONS]),
-  z.instanceof(String),
-]);
-export type CrudeLocation = z.infer<typeof crudeLocation>;

package/src/spatial/bounds/bounds.ts

@@ -9,11 +9,11 @@
 
 import { abs, add, equal as mathEqual, min as mathMin, sub } from "@/math/math";
 import { type numeric } from "@/numeric";
-import { type Bounds, boundsZ, type CrudeBounds } from "@/spatial/base";
+import { type Bounds, boundsZ, type NumberCouple } from "@/spatial/base";
 
 export { type Bounds, boundsZ };
 
-export type Crude<T extends numeric.Value = number> = CrudeBounds<T>;
+export type Crude<T extends numeric.Value = number> = Bounds<T> | NumberCouple<T>;
 
 /** Options for the `construct` function. */
 interface ConstructOptions {
@@ -209,7 +209,7 @@ export const clamp = <T extends numeric.Value>(bounds: Crude<T>, target: T): T =
  */
 export const contains = <T extends numeric.Value>(
   bounds: Crude<T>,
-  target: T | CrudeBounds<T>,
+  target: T | Crude<T>,
 ): boolean => {
   const _bounds = construct(bounds);
   if (typeof target === "number" || typeof target === "bigint")
@@ -594,7 +594,7 @@ export const traverse = <T extends numeric.Value = number>(
   if (dir === 0) return start;
 
   let remainingDist = dist;
-  let currentPosition = start as number | bigint;
+  let currentPosition = start;
 
   while (mathEqual(remainingDist, 0) === false) {
     // Find the bound we're currently in or adjacent to
@@ -607,15 +607,15 @@ export const traverse = <T extends numeric.Value = number>(
       const b = _bounds[index];
       let distanceInBound: T;
       if (dir > 0) distanceInBound = sub(b.upper, currentPosition);
-      else distanceInBound = sub(currentPosition, b.lower) as T;
+      else distanceInBound = sub(currentPosition, b.lower);
 
       if (distanceInBound > (0 as T)) {
         const moveDist = mathMin(abs(remainingDist), distanceInBound);
-        currentPosition = add(currentPosition, dir > 0 ? moveDist : -moveDist) as T;
+        currentPosition = add(currentPosition, dir > 0 ? moveDist : -moveDist);
         remainingDist = sub<T>(remainingDist, dir > 0 ? moveDist : -moveDist);
 
         // If we've exhausted the distance, return the current position
-        if (mathEqual(remainingDist, 0)) return currentPosition as T;
+        if (mathEqual(remainingDist, 0)) return currentPosition;
         continue;
       }
     }
@@ -626,17 +626,17 @@ export const traverse = <T extends numeric.Value = number>(
       const nextBounds = _bounds.filter((b) => b.lower > currentPosition);
       if (nextBounds.length > 0) currentPosition = nextBounds[0].lower;
       // No more bounds in this direction
-      else return currentPosition as T;
+      else return currentPosition;
     } else {
       // Move to the previous bound's upper value
       const prevBounds = _bounds.filter((b) => b.upper < currentPosition);
       if (prevBounds.length > 0)
         currentPosition = prevBounds[prevBounds.length - 1].upper;
       // No more bounds in this direction
-      else return currentPosition as T;
+      else return currentPosition;
     }
   }
-  return currentPosition as T;
+  return currentPosition;
 };
 
 /**

package/src/spatial/box/box.ts

@@ -32,7 +32,7 @@ export const domRect = z.object({
 export const box = z.object({
   one: xy.xyZ,
   two: xy.xyZ,
-  root: location.corner,
+  root: location.cornerZ,
 });
 
 export type Box = z.infer<typeof box>;
@@ -50,7 +50,7 @@ export const ZERO = { one: xy.ZERO, two: xy.ZERO, root: location.TOP_LEFT };
  */
 export const DECIMAL = { one: xy.ZERO, two: xy.ONE, root: location.BOTTOM_LEFT };
 
-export const copy = (b: Box, root?: location.CornerXY): Box => ({
+export const copy = (b: Box, root?: location.Corner): Box => ({
   one: b.one,
   two: b.two,
   root: root ?? b.root,
@@ -71,7 +71,7 @@ export const construct = (
   second?: number | xy.XY | dimensions.Dimensions | dimensions.Signed,
   width: number = 0,
   height: number = 0,
-  coordinateRoot?: location.CornerXY,
+  coordinateRoot?: location.Corner,
 ): Box => {
   const b: Box = {
     one: { ...xy.ZERO },
@@ -339,7 +339,7 @@ export const yBounds = (b: Crude): bounds.Bounds => {
   return { lower: b_.one.y, upper: b_.two.y };
 };
 
-export const reRoot = (b: Box, corner: location.CornerXY): Box => copy(b, corner);
+export const reRoot = (b: Box, corner: location.Corner): Box => copy(b, corner);
 
 export const edgePoints = (b: Crude, loc: location.Location): [xy.XY, xy.XY] => {
   const b_ = construct(b);
@@ -461,7 +461,7 @@ export const constructWithAlternateRoot = (
   width: number,
   height: number,
   currRoot: location.XY,
-  newRoot: location.CornerXY,
+  newRoot: location.Corner,
 ): Box => {
   const first = { x, y };
   const second = { x: x + width, y: y + height };

package/src/spatial/direction/direction.ts

@@ -7,30 +7,29 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import z from "zod";
+
 import {
   type AngularDirection,
-  type CrudeDirection,
-  crudeDirection,
-  type CrudeXDirection,
-  type CrudeYDirection,
+  CENTER_LOCATIONS,
   type Dimension,
   type Direction,
   DIRECTIONS,
   directionZ,
   type Location,
+  OUTER_LOCATIONS,
   type SignedDimension,
   Y_LOCATIONS,
   type YLocation,
-} from "@/spatial/base";
+} from "@/spatial/types.gen";
 
 export { type Direction, DIRECTIONS, directionZ };
 
-export const crude = crudeDirection;
-
-export type Crude = CrudeDirection;
-export type CrudeX = CrudeXDirection;
-export type CrudeY = CrudeYDirection;
 export type Angular = AngularDirection;
+export const crudeZ = z.enum(["x", "y", ...OUTER_LOCATIONS, ...CENTER_LOCATIONS]);
+export type Crude = z.infer<typeof crudeZ>;
+export type CrudeX = "x" | "left" | "right";
+export type CrudeY = "y" | "top" | "bottom";
 
 export const construct = (c: Crude): Direction => {
   if (DIRECTIONS.includes(c as Direction)) return c as Direction;
@@ -38,24 +37,24 @@ export const construct = (c: Crude): Direction => {
   return "x";
 };
 
-export const swap = (direction: CrudeDirection): Direction =>
+export const swap = (direction: Crude): Direction =>
   construct(direction) === "x" ? "y" : "x";
 
-export const dimension = (direction: CrudeDirection): Dimension =>
+export const dimension = (direction: Crude): Dimension =>
   construct(direction) === "x" ? "width" : "height";
 
-export const location = (direction: CrudeDirection): Location =>
+export const location = (direction: Crude): Location =>
   construct(direction) === "x" ? "left" : "top";
 
-export const isDirection = (c: unknown): c is Direction => crude.safeParse(c).success;
+export const isDirection = (c: unknown): c is Direction => crudeZ.safeParse(c).success;
 
-export const signedDimension = (direction: CrudeDirection): SignedDimension =>
+export const signedDimension = (direction: Crude): SignedDimension =>
   construct(direction) === "x" ? "signedWidth" : "signedHeight";
 
-export const isX = (direction: CrudeDirection): direction is CrudeXDirection => {
+export const isX = (direction: Crude): direction is CrudeX => {
   if (direction === "center") return false;
   return construct(direction) === "x";
 };
 
-export const isY = (direction: CrudeDirection): direction is CrudeYDirection =>
+export const isY = (direction: Crude): direction is CrudeY =>
   construct(direction) === "y";

package/src/spatial/external.ts

@@ -13,7 +13,6 @@ export * from "@/spatial/dimensions";
 export * from "@/spatial/direction";
 export * from "@/spatial/location";
 export * from "@/spatial/scale";
-export * as spatial from "@/spatial/spatial";
 export * from "@/spatial/sticky";
-export * from "@/spatial/types.gen";
+export * as spatial from "@/spatial/types.gen";
 export * from "@/spatial/xy";

package/src/spatial/location/location.ts

@@ -15,10 +15,11 @@ import {
   CENTER_LOCATIONS,
   type CenterLocation,
   centerLocationZ,
-  type CrudeLocation,
-  crudeLocation,
+  type CornerLocation,
+  cornerLocationZ,
   type Direction,
   DIRECTIONS,
+  directionZ,
   type Location,
   LOCATIONS,
   locationZ,
@@ -43,15 +44,18 @@ export {
   Y_LOCATIONS,
 };
 
-export const x = xLocationZ;
-export const y = yLocationZ;
-export const center = centerLocationZ;
+export const xZ = xLocationZ;
+export const yZ = yLocationZ;
+export const centerZ = centerLocationZ;
 export const outerZ = outerLocationZ;
+export const cornerZ = cornerLocationZ;
 
 export type X = XLocation;
 export type Y = YLocation;
 export type Outer = OuterLocation;
 export type Center = CenterLocation;
+export type Corner = CornerLocation;
+export type CornerString = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
 
 const SWAPPED: Record<Location, Location> = {
   top: "bottom",
@@ -67,10 +71,12 @@ const ROTATIONS: Record<Outer, Record<AngularDirection, Outer>> = {
   bottom: { clockwise: "right", counterclockwise: "left" },
   left: { clockwise: "bottom", counterclockwise: "top" },
 };
-
-export const crude = crudeLocation;
-
-export type Crude = CrudeLocation;
+export const crudeZ = z.union([
+  directionZ,
+  z.enum([...OUTER_LOCATIONS, ...CENTER_LOCATIONS]),
+  z.instanceof(String),
+]);
+export type Crude = z.infer<typeof crudeZ>;
 
 export const construct = (cl: Crude): Location => {
   if (cl instanceof String) return cl as Location;
@@ -93,16 +99,12 @@ export const xy = z.object({
   x: xLocationZ.or(centerLocationZ),
   y: yLocationZ.or(centerLocationZ),
 });
-export const corner = z.object({ x: xLocationZ, y: yLocationZ });
-
 export type XY = z.infer<typeof xy>;
-export type CornerXY = z.infer<typeof corner>;
-export type CornerXYString = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
 
-export const TOP_LEFT: CornerXY = Object.freeze({ x: "left", y: "top" });
-export const TOP_RIGHT: CornerXY = Object.freeze({ x: "right", y: "top" });
-export const BOTTOM_LEFT: CornerXY = Object.freeze({ x: "left", y: "bottom" });
-export const BOTTOM_RIGHT: CornerXY = Object.freeze({ x: "right", y: "bottom" });
+export const TOP_LEFT: Corner = Object.freeze({ x: "left", y: "top" });
+export const TOP_RIGHT: Corner = Object.freeze({ x: "right", y: "top" });
+export const BOTTOM_LEFT: Corner = Object.freeze({ x: "left", y: "bottom" });
+export const BOTTOM_RIGHT: Corner = Object.freeze({ x: "right", y: "bottom" });
 export const CENTER: XY = Object.freeze({ x: "center", y: "center" });
 export const TOP_CENTER: XY = Object.freeze({ x: "center", y: "top" });
 export const BOTTOM_CENTER: XY = Object.freeze({ x: "center", y: "bottom" });

package/src/spatial/scale/scale.ts

@@ -417,12 +417,12 @@ export class Scale<T extends numeric.Value = number> {
 export class XY {
   x: Scale<number>;
   y: Scale<number>;
-  currRoot: location.CornerXY | null;
+  currRoot: location.Corner | null;
 
   constructor(
     x: Scale<number> = new Scale<number>(),
     y: Scale<number> = new Scale<number>(),
-    root: location.CornerXY | null = null,
+    root: location.Corner | null = null,
   ) {
     this.x = x;
     this.y = y;

package/src/spatial/sticky/sticky.spec.ts

@@ -134,7 +134,7 @@ describe("sticky", () => {
     ];
     SPECS.forEach(({ value, valid }, i) => {
       test(`xy schema ${i}`, () => {
-        const result = sticky.xy.safeParse(value);
+        const result = sticky.xyZ.safeParse(value);
         expect(result.success).toBe(valid);
       });
     });
@@ -196,7 +196,7 @@ describe("sticky", () => {
     ];
     SPECS.forEach(({ value, valid }, i) => {
       test(`completeXY schema ${i}`, () => {
-        const result = sticky.completeXY.safeParse(value);
+        const result = sticky.completeXYZ.safeParse(value);
         expect(result.success).toBe(valid);
       });
     });

package/src/spatial/sticky/sticky.ts

@@ -7,25 +7,18 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import z from "zod";
+import type z from "zod";
 
 import { box } from "@/spatial/box";
 import { location } from "@/spatial/location";
+import { type StickyXY, stickyXYZ } from "@/spatial/types.gen";
 import { xy as base } from "@/spatial/xy";
 
-export const completeXY = base.xyZ.extend({
-  root: location.corner,
-  units: z.object({
-    x: z.enum(["px", "decimal"]),
-    y: z.enum(["px", "decimal"]),
-  }),
-});
+export const xyZ = stickyXYZ;
+export type XY = StickyXY;
 
-export type CompleteXY = z.infer<typeof completeXY>;
-
-export const xy = completeXY.partial({ root: true, units: true });
-
-export interface XY extends z.infer<typeof xy> {}
+export const completeXYZ = stickyXYZ.required({ root: true, units: true });
+export type CompleteXY = z.infer<typeof completeXYZ>;
 
 interface ToCSSReturn extends Partial<Record<location.Outer, string>> {}
 

package/src/spatial/types.gen.ts

@@ -11,10 +11,56 @@
 
 import { z } from "zod";
 
+import { type numeric } from "@/numeric";
+
+export const X_LOCATIONS = ["left", "right"] as const;
+export const xLocationZ = z.enum(X_LOCATIONS);
+export type XLocation = z.infer<typeof xLocationZ>;
+
+export const Y_LOCATIONS = ["top", "bottom"] as const;
+export const yLocationZ = z.enum(Y_LOCATIONS);
+export type YLocation = z.infer<typeof yLocationZ>;
+
+export const STICKY_UNITS = ["px", "decimal"] as const;
+export const stickyUnitZ = z.enum(STICKY_UNITS);
+export type StickyUnit = z.infer<typeof stickyUnitZ>;
+
 export const OUTER_LOCATIONS = ["top", "right", "bottom", "left"] as const;
 export const outerLocationZ = z.enum(OUTER_LOCATIONS);
 export type OuterLocation = z.infer<typeof outerLocationZ>;
 
+export const DIRECTIONS = ["x", "y"] as const;
+export const directionZ = z.enum(DIRECTIONS);
+export type Direction = z.infer<typeof directionZ>;
+
+export const ANGULAR_DIRECTIONS = ["clockwise", "counterclockwise"] as const;
+export const angularDirectionZ = z.enum(ANGULAR_DIRECTIONS);
+export type AngularDirection = z.infer<typeof angularDirectionZ>;
+
+export const CENTER_LOCATIONS = ["center"] as const;
+export const centerLocationZ = z.enum(CENTER_LOCATIONS);
+export type CenterLocation = z.infer<typeof centerLocationZ>;
+
+export const LOCATIONS = ["top", "right", "bottom", "left", "center"] as const;
+export const locationZ = z.enum(LOCATIONS);
+export type Location = z.infer<typeof locationZ>;
+
+export const ALIGNMENTS = ["start", "center", "end"] as const;
+export const alignmentZ = z.enum(ALIGNMENTS);
+export type Alignment = z.infer<typeof alignmentZ>;
+
+export const ORDERS = ["first", "last"] as const;
+export const orderZ = z.enum(ORDERS);
+export type Order = z.infer<typeof orderZ>;
+
+export const DIMENSIONS = ["width", "height"] as const;
+export const dimensionZ = z.enum(DIMENSIONS);
+export type Dimension = z.infer<typeof dimensionZ>;
+
+export const SIGNED_DIMENSIONS = ["signedWidth", "signedHeight"] as const;
+export const signedDimensionZ = z.enum(SIGNED_DIMENSIONS);
+export type SignedDimension = z.infer<typeof signedDimensionZ>;
+
 /**
  * XY is a 2D coordinate point with x and y values. Used for positioning
  * elements in two-dimensional space.
@@ -26,3 +72,97 @@ export const xyZ = z.object({
   y: z.number(),
 });
 export interface XY extends z.infer<typeof xyZ> {}
+
+/** CornerLocation is an anchor corner for positioning. */
+export const cornerLocationZ = z.object({
+  /** x is the horizontal anchor. */
+  x: xLocationZ,
+  /** y is the vertical anchor. */
+  y: yLocationZ,
+});
+export interface CornerLocation extends z.infer<typeof cornerLocationZ> {}
+
+/** StickyUnits specifies the measurement units for sticky positioning. */
+export const stickyUnitsZ = z.object({
+  /** x is the horizontal unit. */
+  x: stickyUnitZ,
+  /** y is the vertical unit. */
+  y: stickyUnitZ,
+});
+export interface StickyUnits extends z.infer<typeof stickyUnitsZ> {}
+
+/** Dimensions is a 2D size with width and height values. */
+export const dimensionsZ = z.object({
+  /** width is the width in pixels. */
+  width: z.number(),
+  /** height is the height in pixels. */
+  height: z.number(),
+});
+export interface Dimensions extends z.infer<typeof dimensionsZ> {}
+
+/**
+ * SignedDimensions is a 2D size whose width and height components carry sign, allowing
+ * negative values to express direction.
+ */
+export const signedDimensionsZ = z.object({
+  /** signedWidth is the signed width. */
+  signedWidth: z.number(),
+  /** signedHeight is the signed height. */
+  signedHeight: z.number(),
+});
+export interface SignedDimensions extends z.infer<typeof signedDimensionsZ> {}
+
+/**
+ * ClientXY is a 2D coordinate point expressed in client (viewport) space, matching
+ * the shape of DOM mouse events.
+ */
+export const clientXYZ = z.object({
+  /** clientX is the horizontal coordinate in client (viewport) space. */
+  clientX: z.number(),
+  /** clientY is the vertical coordinate in client (viewport) space. */
+  clientY: z.number(),
+});
+export interface ClientXY extends z.infer<typeof clientXYZ> {}
+
+/**
+ * Bounds is a closed-open interval [lower, upper) over an ordered numeric value
+ * space. The TypeScript binding is generic over T so callers can express
+ * bounds over either number or bigint values; other languages emit a
+ * concrete float64-based type.
+ */
+export const boundsZ = <T extends numeric.Value = number>(t?: z.ZodType<T>) =>
+  z.object({
+    /** lower is the inclusive lower bound. */
+    lower: t ?? z.number(),
+    /** upper is the exclusive upper bound. */
+    upper: t ?? z.number(),
+  });
+export interface Bounds<T extends numeric.Value = number> {
+  lower: T;
+  upper: T;
+}
+
+/** Viewport is the camera state of a viewport. */
+export const viewportZ = z.object({
+  /** zoom is the zoom level where 1.0 equals 100%. */
+  zoom: z.number().default(1),
+  /** position is the (x, y) pan offset of the viewport. */
+  position: xyZ,
+});
+export interface Viewport extends z.infer<typeof viewportZ> {}
+
+/**
+ * StickyXY is a position that can be anchored to different corners of a
+ * container with configurable units (pixels or decimal fractions).
+ */
+export const stickyXYZ = z.object({
+  /** x is the horizontal coordinate. */
+  x: z.number(),
+  /** y is the vertical coordinate. */
+  y: z.number(),
+  /** root is the optional anchor corner for the position. */
+  root: cornerLocationZ.optional(),
+  /** units is the optional unit specification for the coordinates. */
+  units: stickyUnitsZ.optional(),
+});
+export interface StickyXY extends z.infer<typeof stickyXYZ> {}

package/src/spatial/xy/xy.ts

@@ -12,19 +12,19 @@ import { z } from "zod";
 import {
   type AngularDirection,
   type ClientXY,
-  clientXyZ,
-  type CrudeDirection,
+  clientXYZ,
   dimensionsZ,
   type Direction,
   type NumberCouple,
   numberCouple,
   signedDimensionsZ,
+  type XY,
+  xyZ,
 } from "@/spatial/base";
-import { direction as dir } from "@/spatial/direction";
+import { direction as dir, type direction } from "@/spatial/direction";
 import { type location } from "@/spatial/location";
-import { type XY, xyZ } from "@/spatial/types.gen";
 
-export { type ClientXY as Client, clientXyZ, type XY, xyZ };
+export { type ClientXY as Client, clientXYZ, type XY, xyZ };
 
 /** A crude representation of a {@link XY} coordinate as a zod schema. */
 export const crudeZ = z.union([
@@ -33,7 +33,7 @@ export const crudeZ = z.union([
   numberCouple,
   dimensionsZ,
   signedDimensionsZ,
-  clientXyZ,
+  clientXYZ,
 ]);
 
 /** A crude representation of a {@link XY} coordinate. */
@@ -141,7 +141,7 @@ export const translate: Translate = (a, b, v, ...cb): XY => {
  * @returns the given coordinate the given direction set to the given value.
  * @example set({ x: 1, y: 2 }, "x", 3) // { x: 3, y: 2 }
  */
-export const set = (c: Crude, direction: CrudeDirection, value: number): XY => {
+export const set = (c: Crude, direction: direction.Crude, value: number): XY => {
   const xy = construct(c);
   const d = dir.construct(direction);
   if (d === "x") return { x: value, y: xy.y };