@synnaxlabs/x 0.42.3 → 0.43.0

package/src/binary/codec.ts

@@ -7,8 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { decode, encode, ExtensionCodec } from "@msgpack/msgpack";
-import { type z } from "zod";
+import { type z } from "zod/v4";
 
 import { caseconv } from "@/caseconv";
 import { isObject } from "@/identity";
@@ -35,10 +34,10 @@ export interface Codec {
    * @param data - The data to decode.
    * @param schema - The schema to decode the data with.
    */
-  decode: <P extends z.ZodTypeAny>(
+  decode: <P extends z.ZodType>(
     data: Uint8Array | ArrayBuffer,
     schema?: P,
-  ) => z.output<P>;
+  ) => z.infer<P>;
 }
 
 /** JSONCodec is a JSON implementation of Codec. */
@@ -56,33 +55,24 @@ export class JSONCodec implements Codec {
     return this.encoder.encode(this.encodeString(payload));
   }
 
-  decode<P extends z.ZodTypeAny>(
-    data: Uint8Array | ArrayBuffer,
-    schema?: P,
-  ): z.output<P> {
+  decode<P extends z.ZodType>(data: Uint8Array | ArrayBuffer, schema?: P): z.infer<P> {
     return this.decodeString(this.decoder.decode(data), schema);
   }
 
-  decodeString<P extends z.ZodTypeAny>(data: string, schema?: P): z.output<P> {
+  decodeString<P extends z.ZodType>(data: string, schema?: P): z.infer<P> {
     const parsed = JSON.parse(data);
     const unpacked = caseconv.snakeToCamel(parsed);
-    return schema != null ? schema.parse(unpacked) : (unpacked as z.output<P>);
+    return schema != null ? schema.parse(unpacked) : (unpacked as z.infer<P>);
   }
 
   encodeString(payload: unknown): string {
     const caseConverted = caseconv.camelToSnake(payload);
     return JSON.stringify(caseConverted, (_, v) => {
       if (ArrayBuffer.isView(v)) return Array.from(v as Uint8Array);
-      if (isObject(v) && "encode_value" in v) {
-        if (typeof v.value === "bigint") return v.value.toString();
-        return v.value;
-      }
       if (typeof v === "bigint") return v.toString();
       return v;
     });
   }
-
-  static registerCustomType(): void {}
 }
 
 /**
@@ -96,10 +86,7 @@ export class CSVCodec implements Codec {
     return new TextEncoder().encode(csvString);
   }
 
-  decode<P extends z.ZodTypeAny>(
-    data: Uint8Array | ArrayBuffer,
-    schema?: P,
-  ): z.output<P> {
+  decode<P extends z.ZodType>(data: Uint8Array | ArrayBuffer, schema?: P): z.infer<P> {
     const csvString = new TextDecoder().decode(data);
     return this.decodeString(csvString, schema);
   }
@@ -111,7 +98,7 @@ export class CSVCodec implements Codec {
     const keys = Object.keys(payload[0]);
     const csvRows = [keys.join(",")];
 
-    payload.forEach((item: any) => {
+    payload.forEach((item) => {
       const values = keys.map((key) => JSON.stringify(item[key] ?? ""));
       csvRows.push(values.join(","));
     });
@@ -119,15 +106,15 @@ export class CSVCodec implements Codec {
     return csvRows.join("\n");
   }
 
-  decodeString<P extends z.ZodTypeAny>(data: string, schema?: P): z.output<P> {
+  decodeString<P extends z.ZodType>(data: string, schema?: P): z.infer<P> {
     const [headerLine, ...lines] = data
       .trim()
       .split("\n")
       .map((line) => line.trim());
     if (headerLine.length === 0)
-      return schema != null ? schema.parse({}) : ({} as z.output<P>);
+      return schema != null ? schema.parse({}) : ({} as z.infer<P>);
     const headers = headerLine.split(",").map((header) => header.trim());
-    const result: { [key: string]: any[] } = {};
+    const result: { [key: string]: unknown[] } = {};
 
     headers.forEach((header) => {
       result[header] = [];
@@ -142,78 +129,35 @@ export class CSVCodec implements Codec {
       });
     });
 
-    return schema != null ? schema.parse(result) : (result as z.output<P>);
+    return schema != null ? schema.parse(result) : (result as z.infer<P>);
   }
 
-  private parseValue(value?: string): any {
+  private parseValue(value?: string): unknown {
     if (value == null || value.length === 0) return null;
     const num = Number(value);
     if (!isNaN(num)) return num;
     if (value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
     return value;
   }
-
-  static registerCustomType(): void {}
 }
 
 export class TextCodec implements Codec {
   contentType = "text/plain";
 
   encode(payload: unknown): Uint8Array {
-    return new TextEncoder().encode(payload as string);
+    if (typeof payload !== "string")
+      throw new Error("TextCodec.encode payload must be a string");
+    return new TextEncoder().encode(payload);
   }
 
-  decode<P extends z.ZodTypeAny>(
-    data: Uint8Array | ArrayBuffer,
-    schema?: P,
-  ): z.output<P> {
+  decode<P extends z.ZodType>(data: Uint8Array | ArrayBuffer, schema?: P): z.infer<P> {
     const text = new TextDecoder().decode(data);
-    return schema != null ? schema.parse(text) : (text as z.output<P>);
-  }
-}
-
-const extensionCodec = new ExtensionCodec();
-
-extensionCodec.register({
-  type: 0,
-  encode: (value: unknown): Uint8Array | null => {
-    if (ArrayBuffer.isView(value)) {
-      const array = Array.from(value as Uint8Array);
-      return encode(array, { extensionCodec });
-    }
-    if (isObject(value) && "encode_value" in value) {
-      if (typeof value.value === "bigint")
-        return encode(value.value.toString(), { extensionCodec });
-      return encode(value.value, { extensionCodec });
-    }
-    if (typeof value === "bigint") return encode(value.toString(), { extensionCodec });
-    return null;
-  },
-  decode: (data: Uint8Array) => decode(data, { extensionCodec }),
-});
-
-export class MsgPackCodec implements Codec {
-  contentType = "application/msgpack";
-
-  encode(payload: unknown): Uint8Array {
-    const caseConverted = caseconv.camelToSnake(payload);
-    const d = encode(caseConverted, { extensionCodec });
-    return d.slice();
-  }
-
-  decode<P extends z.ZodTypeAny>(
-    data: Uint8Array | ArrayBuffer,
-    schema?: P,
-  ): z.output<P> {
-    const decoded = decode(data, { extensionCodec });
-    const unpacked = caseconv.snakeToCamel(decoded);
-    return schema != null ? schema.parse(unpacked) : (unpacked as z.output<P>);
+    return schema != null ? schema.parse(text) : (text as z.infer<P>);
   }
-
-  static registerCustomType(): void {}
 }
 
 export const JSON_CODEC = new JSONCodec();
 export const CSV_CODEC = new CSVCodec();
 export const TEXT_CODEC = new TextCodec();
-export const MSGPACK_CODEC = new MsgPackCodec();
+
+export const ENCODERS: Codec[] = [JSON_CODEC];

package/src/breaker/breaker.ts

@@ -7,7 +7,7 @@
 // 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 { z } from "zod/v4";
 
 import { sleep } from "@/sleep";
 import { type CrudeTimeSpan, TimeSpan } from "@/telem";
@@ -45,13 +45,13 @@ export class Breaker {
   }
 }
 
-export const breakerConfig = z.object({
+export const breakerConfigZ = z.object({
   baseInterval: TimeSpan.z.optional(),
   maxRetries: z.number().optional(),
   scale: z.number().optional(),
 });
 
-export interface Config extends Omit<z.infer<typeof breakerConfig>, "baseInterval"> {
+export interface Config extends Omit<z.infer<typeof breakerConfigZ>, "baseInterval"> {
   baseInterval?: CrudeTimeSpan;
   maxRetries?: number;
   scale?: number;

package/src/caseconv/caseconv.ts

@@ -33,6 +33,8 @@ const createConverter = (
     opt = validateOptions(opt);
     const res: UnknownRecord = {};
     const anyObj = obj as UnknownRecord;
+    if ("toJSON" in anyObj && typeof anyObj.toJSON === "function")
+      return converter(anyObj.toJSON(), opt);
     Object.keys(anyObj).forEach((key) => {
       let value = anyObj[key];
       const nkey = f(key);
@@ -115,7 +117,7 @@ export const capitalize = (str: string): string => {
 export interface Options {
   recursive: boolean;
   recursiveInArray?: boolean;
-  keepTypesOnRecursion?: any[];
+  keepTypesOnRecursion?: Function[];
 }
 
 /**
@@ -133,12 +135,12 @@ const validateOptions = (opt: Options = defaultOptions): Options => {
   return opt;
 };
 
-const isArrayObject = (obj: any): boolean => obj != null && Array.isArray(obj);
+const isArrayObject = (obj: unknown): boolean => obj != null && Array.isArray(obj);
 
-const isValidObject = (obj: any): boolean =>
+const isValidObject = (obj: unknown): boolean =>
   obj != null && typeof obj === "object" && !Array.isArray(obj);
 
-const belongToTypes = (obj: any, types?: any[]): boolean =>
+const belongToTypes = (obj: unknown, types?: Function[]): boolean =>
   (types || []).some((Type) => obj instanceof Type);
 
 /**

package/src/change/change.ts

@@ -7,11 +7,11 @@
 // 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 { z } from "zod/v4";
 
 export type Variant = "set" | "delete";
 
-export const Z = <V extends z.ZodTypeAny>(value: V) =>
+export const Z = <V extends z.ZodType>(value: V) =>
   z.object({
     variant: z.enum(["set", "delete"]),
     key: z.string(),

package/src/color/color.spec.ts

@@ -149,6 +149,84 @@ describe("color.Color", () => {
     });
   });
 
+  describe("isDark", () => {
+    test("black is dark", () => {
+      expect(color.isDark("#000000")).toBe(true);
+    });
+
+    test("white is not dark", () => {
+      expect(color.isDark("#ffffff")).toBe(false);
+    });
+
+    test("mid gray is not dark", () => {
+      expect(color.isDark("#808080")).toBe(true);
+    });
+
+    test("dark red is dark", () => {
+      expect(color.isDark("#800000")).toBe(true);
+    });
+
+    test("light blue is not dark", () => {
+      expect(color.isDark("#add8e6")).toBe(false);
+    });
+
+    test("handles RGB array input", () => {
+      expect(color.isDark([0, 0, 0])).toBe(true);
+      expect(color.isDark([255, 255, 255])).toBe(false);
+    });
+
+    test("handles RGBA array input", () => {
+      expect(color.isDark([0, 0, 0, 0.5])).toBe(true);
+      expect(color.isDark([255, 255, 255, 0.5])).toBe(false);
+    });
+
+    test("handles Color object input", () => {
+      const darkColor = color.construct("#000000");
+      const lightColor = color.construct("#ffffff");
+      expect(color.isDark(darkColor)).toBe(true);
+      expect(color.isDark(lightColor)).toBe(false);
+    });
+  });
+
+  describe("isLight", () => {
+    test("white is light", () => {
+      expect(color.isLight("#ffffff")).toBe(true);
+    });
+
+    test("black is not light", () => {
+      expect(color.isLight("#000000")).toBe(false);
+    });
+
+    test("mid gray is not light", () => {
+      expect(color.isLight("#808080")).toBe(false);
+    });
+
+    test("dark red is not light", () => {
+      expect(color.isLight("#800000")).toBe(false);
+    });
+
+    test("light blue is light", () => {
+      expect(color.isLight("#add8e6")).toBe(true);
+    });
+
+    test("handles RGB array input", () => {
+      expect(color.isLight([255, 255, 255])).toBe(true);
+      expect(color.isLight([0, 0, 0])).toBe(false);
+    });
+
+    test("handles RGBA array input", () => {
+      expect(color.isLight([255, 255, 255, 0.5])).toBe(true);
+      expect(color.isLight([0, 0, 0, 0.5])).toBe(false);
+    });
+
+    test("handles Color object input", () => {
+      const lightColor = color.construct("#ffffff");
+      const darkColor = color.construct("#000000");
+      expect(color.isLight(lightColor)).toBe(true);
+      expect(color.isLight(darkColor)).toBe(false);
+    });
+  });
+
   describe("grayness", () => {
     const tests: Array<[string, number]> = [
       ["#000000", 1],
@@ -509,11 +587,11 @@ describe("color.Color", () => {
       expect(color.equals(c1, c2)).toBe(true);
     });
 
-    test("undefined values return false", () => {
+    test("comparing to undefined", () => {
       const c1: color.RGB = [255, 0, 0];
       expect(color.equals(c1, undefined)).toBe(false);
       expect(color.equals(undefined, c1)).toBe(false);
-      expect(color.equals(undefined, undefined)).toBe(false);
+      expect(color.equals(undefined, undefined)).toBe(true);
     });
 
     test("comparing color with itself returns true", () => {
@@ -678,4 +756,37 @@ describe("color.Color", () => {
       expect(color.isColor([0, 0, 0, 1.1])).toBe(false);
     });
   });
+
+  describe("isZero", () => {
+    test("returns true for zero color", () => {
+      expect(color.isZero([0, 0, 0, 0])).toBe(true);
+    });
+
+    test("returns false for non-zero RGB values", () => {
+      expect(color.isZero([1, 0, 0, 0])).toBe(false);
+      expect(color.isZero([0, 1, 0, 0])).toBe(false);
+      expect(color.isZero([0, 0, 1, 0])).toBe(false);
+    });
+
+    test("returns false for non-zero alpha", () => {
+      expect(color.isZero([0, 0, 0, 0.1])).toBe(false);
+      expect(color.isZero([0, 0, 0, 1])).toBe(false);
+    });
+
+    test("returns false for undefined input", () => {
+      expect(color.isZero(undefined)).toBe(false);
+    });
+
+    test("returns false for null input", () => {
+      expect(color.isZero(null as any)).toBe(false);
+    });
+
+    test("returns false for hex color", () => {
+      expect(color.isZero("#000000")).toBe(false);
+    });
+
+    test("returns false for constructed color", () => {
+      expect(color.isZero(color.construct("#000000"))).toBe(false);
+    });
+  });
 });

package/src/color/color.ts

@@ -7,29 +7,61 @@
 // 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 { z } from "zod/v4";
 
+/** A regex to match hex colors. */
 const hexRegex = /^#?([0-9a-f]{6}|[0-9a-f]{8})$/i;
+
+/** A zod schema for a hex color. */
 const hexZ = z.string().regex(hexRegex);
+/** A zod schema for an RGB value. */
 const rgbValueZ = z.number().min(0).max(255);
+/** A zod schema for an alpha value between 0 and 1. */
 const alphaZ = z.number().min(0).max(1);
+/** A zod schema for an RGBA color. */
 const rgbaZ = z.tuple([rgbValueZ, rgbValueZ, rgbValueZ, alphaZ]);
+/** A zod schema for an RGB color. */
 const rgbZ = z.tuple([rgbValueZ, rgbValueZ, rgbValueZ]);
+/** A zod schema for a legacy color object. */
 const legacyObjectZ = z.object({ rgba255: rgbaZ });
-
-/** A color in RGBA format. */
-export type RGBA = [number, number, number, number];
-/** A color in HSLA format. */
-export type HSLA = [number, number, number, number];
-/** A color in RGB format. */
-export type RGB = [number, number, number];
-/** A color in hex format. */
+/** A zod schema for a hue value between 0 and 360. */
+const hueZ = z.number().min(0).max(360);
+/** A zod schema for a saturation value between 0 and 100. */
+const saturationZ = z.number().min(0).max(100);
+/** A zod schema for a lightness value between 0 and 100. */
+const lightnessZ = z.number().min(0).max(100);
+/** A zod schema for an HSLA color. */
+const hslaZ = z.tuple([hueZ, saturationZ, lightnessZ, alphaZ]);
+
+/** A color in RGBA format. See https://en.wikipedia.org/wiki/RGBA_color_model */
+export type RGBA = z.infer<typeof rgbaZ>;
+/** A color in HSLA format. See https://en.wikipedia.org/wiki/HSL_and_HSV */
+export type HSLA = z.infer<typeof hslaZ>;
+/** A color in RGB format. See https://en.wikipedia.org/wiki/RGB_color_model */
+export type RGB = z.infer<typeof rgbZ>;
+/** A color in hex format. See https://en.wikipedia.org/wiki/Web_colors */
 export type Hex = z.infer<typeof hexZ>;
-/** A color in RGBA format. Used as the standard representation of a color in this package. */
-export type Color = RGBA;
-/** A legacy color object. */
+
+/** A legacy color object. Used for backwards compatibility. */
 type LegacyObject = z.infer<typeof legacyObjectZ>;
 
+/** A zod schema for a crude color representation. */
+export const crudeZ = z.union([hexZ, rgbZ, rgbaZ, hslaZ, legacyObjectZ]);
+/**
+ * An unparsed representation of a color i.e. a value that can be converted into
+ * a Color object.
+ */
+export type Crude = Hex | RGBA | Color | RGB | LegacyObject;
+
+/** A zod schema to parse color values from various crude representations. */
+export const colorZ = crudeZ.transform((v) => construct(v));
+
+/**
+ * A color in RGBA format. Used as the standard representation of a color in this package.
+ * See https://en.wikipedia.org/wiki/RGBA_color_model
+ */
+export type Color = RGBA;
+
 /** @returns true if the given color can be parsed into a valid color object. */
 export const isCrude = (color: unknown): color is Crude =>
   colorZ.safeParse(color).success;
@@ -38,12 +70,6 @@ export const isCrude = (color: unknown): color is Crude =>
 export const isColor = (color: unknown): color is Color =>
   rgbaZ.safeParse(color).success;
 
-/**
- * An unparsed representation of a color i.e. a value that can be converted into
- * a Color object.
- */
-export type Crude = Hex | RGBA | Color | string | RGB | LegacyObject;
-
 /**
  * Converts a crude color to its most meaningful CSS format.
  * @returns undefined if the color is undefined.
@@ -51,13 +77,18 @@ export type Crude = Hex | RGBA | Color | string | RGB | LegacyObject;
  * @returns the color directly if it is a css variable.
  * @throws if the color does not match any of the preceding conditions.
  */
-export const cssString = (color?: Crude): string | undefined => {
+export interface CSSString {
+  (color: Crude): string;
+  (color?: Crude): string | undefined;
+}
+
+export const cssString = ((color?: Crude): string | undefined => {
   if (color == null) return undefined;
   const res = colorZ.safeParse(color);
   if (res.success) return rgbaCSS(res.data);
   if (typeof color === "string") return color;
   throw res.error;
-};
+}) as CSSString;
 
 /**
  * @constructor Creates a new color from the given color value. The color value can be
@@ -74,15 +105,15 @@ export const cssString = (color?: Crude): string | undefined => {
  * alpha value, this value will be ignored. Defaults to 1.
  */
 export const construct = (color: Crude, alpha: number = 1): Color => {
+  color = crudeZ.parse(color);
   if (typeof color === "string") return fromHex(color, alpha);
   if (Array.isArray(color)) {
     if (color.length < 3 || color.length > 4)
       throw new Error(`Invalid color: [${color.join(", ")}]`);
-    if (color.length === 3) return [...color, alpha] as RGBA;
+    if (color.length === 3) return [...color, alpha];
     return color;
   }
-  if (typeof color === "object" && "rgba255" in color) return color.rgba255;
-  throw new Error(`Invalid color: ${JSON.stringify(color)}`);
+  return color.rgba255;
 };
 
 /**
@@ -90,7 +121,7 @@ export const construct = (color: Crude, alpha: number = 1): Color => {
  * representations of the same color are considered equal (e.g. hex and rgba).
  */
 export const equals = (a?: Crude, b?: Crude): boolean => {
-  if (a == null || b == null) return false;
+  if (a == null || b == null) return a == b;
   const a_ = construct(a);
   const b_ = construct(b);
   return a_.every((v, i) => v === b_[i]);
@@ -174,10 +205,12 @@ export const setAlpha = (color: Crude, alpha: number): Color => {
   if (alpha > 100)
     throw new Error(`Color opacity must be between 0 and 100, got ${alpha}`);
   if (alpha > 1) alpha /= 100;
-  return [r, g, b, alpha] as Color;
+  return [r, g, b, alpha];
 };
-
-/** @returns the luminance of the color, between 0 and 1. */
+/**
+ * @returns the luminance of the color, between 0 and 1.
+ * @see https://en.wikipedia.org/wiki/Relative_luminance for more information.
+ */
 export const luminance = (color: Crude): number => {
   const [r, g, b] = rgb1(color).map((v) =>
     v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4,
@@ -185,7 +218,10 @@ export const luminance = (color: Crude): number => {
   return Number((0.2126 * r + 0.7152 * g + 0.0722 * b).toFixed(3));
 };
 
-/** @returns the grayness of the color, between 0 and 1. */
+/**
+ * @returns an approximation of the colors 'grayness' from 0 to 1 by measuring the
+ * deviation between the RGB values of the color.
+ */
 export const grayness = (color: Crude): number => {
   const [r, g, b] = rgb1(color);
   const deviation = Math.max(r, g, b) - Math.min(r, g, b);
@@ -196,8 +232,11 @@ export const grayness = (color: Crude): number => {
  * @returns the contrast ratio between this color and the given color. The contrast
  * ratio is a number between 1 and 21, where 1 is the lowest contrast and 21 is the
  * highest.
- * @param other
- * @returns
+ * @param a - The first color to compare.
+ * @param b - The second color to compare.
+ * @returns The contrast ratio between the two colors.
+ *
+ * @see https://www.accessibility-developer-guide.com/knowledge/colours-and-contrast/how-to-calculate/
  */
 export const contrast = (a: Crude, b: Crude): number => {
   const a_ = construct(a);
@@ -214,33 +253,25 @@ export const pickByContrast = (source: Crude, ...colors: Crude[]): Color => {
   if (colors.length === 0)
     throw new Error("[Color.pickByContrast] - must provide at least one color");
   const source_ = construct(source);
-  const [best] = colors
-    .map((c) => construct(c))
-    .sort((a, b) => contrast(source_, b) - contrast(source_, a));
-  return best;
+  const [best] = colors.sort((a, b) => contrast(source_, b) - contrast(source_, a));
+  return construct(best);
 };
 
 /** @returns true if the color is dark i.e. it has a luminance less than 0.5. */
 export const isDark = (color: Crude): boolean => luminance(color) < 0.5;
 
-/** @returns true if the color is light i.e. the luminance is greater than or equal to 0.5. */
-export const isLight = (color: Crude): boolean => !isDark(color);
-
-/** A zod schema to parse color values from various crude representations. */
-export const colorZ = z
-  .union([hexZ, rgbaZ, rgbZ, legacyObjectZ])
-  .transform((v) => construct(v));
+/** @returns true if the color is light i.e. the luminance is greater than 0.5. */
+export const isLight = (color: Crude): boolean => luminance(color) > 0.5;
 
 /** @returns a color parsed from a hex string with an alpha value. */
-const fromHex = (hex_: string, alpha: number = 1): RGBA => {
-  const valid = hexZ.safeParse(hex_);
-  if (!valid.success) throw new Error(`Invalid hex color: ${hex_}`);
-  hex_ = stripHash(hex_);
+const fromHex = (hex: string, alpha: number = 1): RGBA => {
+  hex = hexZ.parse(hex);
+  hex = stripHash(hex);
   return [
-    hexToRgba(hex_, 0),
-    hexToRgba(hex_, 2),
-    hexToRgba(hex_, 4),
-    hex_.length === 8 ? hexToRgba(hex_, 6) / 255 : alpha,
+    hexToRgba(hex, 0),
+    hexToRgba(hex, 2),
+    hexToRgba(hex, 4),
+    hex.length === 8 ? hexToRgba(hex, 6) / 255 : alpha,
   ];
 };
 
@@ -251,8 +282,9 @@ const rgbaToHex = (n: number): string => Math.floor(n).toString(16).padStart(2,
 const hexToRgba = (s: string, n: number): number => parseInt(s.slice(n, n + 2), 16);
 const stripHash = (hex: string): string => (hex.startsWith("#") ? hex.slice(1) : hex);
 
-/** @returns a color parsed from an HSLA tuple. */
-export const fromHSLA = (hsla: RGBA): RGBA => {
+/** @returns parse a color from an HSLA tuple. */
+export const fromHSLA = (hsla: HSLA): RGBA => {
+  hsla = hslaZ.parse(hsla);
   let [h, s, l] = hsla;
   const a = hsla[3];
   h /= 360;
@@ -265,15 +297,15 @@ export const fromHSLA = (hsla: RGBA): RGBA => {
   else {
     const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
     const p = 2 * l - q;
-    r = hueToRgb(p, q, h + 1 / 3);
-    g = hueToRgb(p, q, h);
-    b = hueToRgb(p, q, h - 1 / 3);
+    r = hueToRGB(p, q, h + 1 / 3);
+    g = hueToRGB(p, q, h);
+    b = hueToRGB(p, q, h - 1 / 3);
   }
 
   return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a];
 };
 
-const hueToRgb = (p: number, q: number, t: number): number => {
+const hueToRGB = (p: number, q: number, t: number): number => {
   if (t < 0) t += 1;
   if (t > 1) t -= 1;
   if (t < 1 / 6) return p + (q - p) * 6 * t;
@@ -283,6 +315,7 @@ const hueToRgb = (p: number, q: number, t: number): number => {
 };
 
 const rgbaToHSLA = (rgba: RGBA): HSLA => {
+  rgba = rgbaZ.parse(rgba);
   let [r, g, b] = rgba;
   const a = rgba[3];
   r /= 255;
@@ -293,7 +326,7 @@ const rgbaToHSLA = (rgba: RGBA): HSLA => {
   const min = Math.min(r, g, b);
   let h: number;
   let s: number;
-  let l: number = (max + min) / 2;
+  let l = (max + min) / 2;
 
   if (max === min)
     h = s = 0; // achromatic
@@ -314,9 +347,6 @@ const rgbaToHSLA = (rgba: RGBA): HSLA => {
   return [Math.round(h), Math.round(s), Math.round(l), a];
 };
 
-/** A zod schema for a crude color representation. */
-export const crudeZ = z.union([hexZ, rgbaZ, z.string(), rgbZ, legacyObjectZ]);
-
 /** The color black. */
 export const BLACK = construct("#000000");
 /** The color white. */

package/src/color/external.ts

@@ -10,4 +10,3 @@
 export * from "@/color/color";
 export * from "@/color/gradient";
 export * from "@/color/palette";
-export * from "@/color/transformColorsToHex";