@tempots/std 0.9.6 → 0.9.7

package/src/colors/hsl.ts

@@ -1,73 +0,0 @@
-import { clamp, nearEquals } from '../numbers'
-
-const TOLLERANCE = 0.0001
-
-export class HSL {
-  static fromString (s: string): HSL {
-    const m = s.match(
-      /^hsl\((\d+)(deg)?, ?(\d+(?:\.\d+)?)%?, ?(\d+(?:\.\d+)?)%?\)$/
-    )
-    if (m != null) {
-      const [, h, , s, l] = m
-      return new HSL(parseFloat(h), parseFloat(s), parseFloat(l))
-    } else {
-      throw new Error(`Invalid HSL string: ${s}`)
-    }
-  }
-
-  static ofChannels ([hue, saturation, lightness]: [
-    hue: number,
-    saturation: number,
-    lightness: number
-  ]): HSL {
-    return new HSL(hue, saturation * 100, lightness * 100)
-  }
-
-  readonly hue: number
-  readonly saturation: number
-  readonly lightness: number
-  /**
-   *
-   * @param hue Angle in degrees (0-360)
-   * @param saturation Percentage (0-100)
-   * @param lightness Percentage (0-100)
-   */
-  constructor (hue: number, saturation = 50, lightness = 50) {
-    this.hue = hue % 360.0
-    this.saturation = clamp(saturation, 0, 100)
-    this.lightness = clamp(lightness, 0, 100)
-  }
-
-  withHue (hue: number): HSL {
-    return new HSL(hue, this.saturation, this.lightness)
-  }
-
-  withSaturation (saturation: number): HSL {
-    return new HSL(this.hue, saturation, this.lightness)
-  }
-
-  withLightness (lightness: number): HSL {
-    return new HSL(this.hue, this.saturation, lightness)
-  }
-
-  toChannels (): [number, number, number] {
-    return [this.hue, this.saturation / 100, this.lightness / 100]
-  }
-
-  toString (): string {
-    return `hsl(${this.hue}deg, ${this.saturation}%, ${this.lightness}%)`
-  }
-
-  equals (other: HSL, tollerance = TOLLERANCE): boolean {
-    if (
-      (nearEquals(this.lightness, other.lightness, tollerance) &&
-        nearEquals(this.saturation, 0, tollerance)) ||
-      nearEquals(this.saturation, 100, tollerance)
-    ) { return true }
-    return (
-      nearEquals(this.hue, other.hue, tollerance) &&
-      nearEquals(this.saturation, other.saturation, tollerance) &&
-      nearEquals(this.lightness, other.lightness, tollerance)
-    )
-  }
-}

package/src/colors/hsla.ts

@@ -1,45 +0,0 @@
-import { clamp, nearEquals } from '../numbers'
-import { HSL } from './hsl'
-
-const TOLLERANCE = 0.0001
-
-export class HSLA extends HSL {
-  readonly alpha: number
-  /**
-   *
-   * @param hue Angle in degrees (0-360)
-   * @param saturation Percentage (0-100)
-   * @param lightness Percentage (0-100)
-   * @param alpha Percentage (0-100)
-   */
-  constructor (hue: number, saturation = 50, lightness = 50, alpha = 100) {
-    super(hue, saturation, lightness)
-    this.alpha = clamp(0, 1, alpha)
-  }
-
-  override withHue (hue: number): HSLA {
-    return new HSLA(hue, this.saturation, this.lightness, this.alpha)
-  }
-
-  override withSaturation (saturation: number): HSLA {
-    return new HSLA(this.hue, saturation, this.lightness, this.alpha)
-  }
-
-  override withLightness (lightness: number): HSLA {
-    return new HSLA(this.hue, this.saturation, lightness, this.alpha)
-  }
-
-  withAlpha (alpha: number): HSLA {
-    return new HSLA(this.hue, this.saturation, this.lightness, alpha)
-  }
-
-  override toString (): string {
-    return `hsla(${this.hue}deg, ${this.saturation}%, ${this.lightness}%, ${
-      this.alpha / 100
-    })`
-  }
-
-  override equals (other: HSLA, tollerance = TOLLERANCE): boolean {
-    return super.equals(other, tollerance) && nearEquals(this.alpha, other.alpha, tollerance)
-  }
-}

package/src/colors/hsluv.ts

@@ -1,73 +0,0 @@
-import { nearEquals } from '../numbers'
-
-const TOLLERANCE = 0.0001
-
-export class HSLuv {
-  static fromString (s: string): HSLuv {
-    const m = s.match(
-      /^hsluv\((\d+)(deg)?, ?(\d+(?:\.\d+)?)%?, ?(\d+(?:\.\d+)?)%?\)$/
-    )
-    if (m != null) {
-      const [, h, , s, l] = m
-      return new HSLuv(parseFloat(h), parseFloat(s), parseFloat(l))
-    } else {
-      throw new Error(`Invalid HSLuv string: ${s}`)
-    }
-  }
-
-  static ofChannels ([hue, saturation, lightness]: [
-    hue: number,
-    saturation: number,
-    lightness: number
-  ]): HSLuv {
-    return new HSLuv(hue, saturation, lightness)
-  }
-
-  readonly hue: number
-  readonly saturation: number
-  readonly lightness: number
-  /**
-   *
-   * @param hue Angle in degrees (0-360)
-   * @param saturation
-   * @param lightness
-   */
-  constructor (hue: number, saturation: number, lightness: number) {
-    this.hue = hue % 360.0
-    this.saturation = saturation
-    this.lightness = lightness
-  }
-
-  withHue (hue: number): HSLuv {
-    return new HSLuv(hue, this.saturation, this.lightness)
-  }
-
-  withSaturation (saturation: number): HSLuv {
-    return new HSLuv(this.hue, saturation, this.lightness)
-  }
-
-  withLightness (lightness: number): HSLuv {
-    return new HSLuv(this.hue, this.saturation, lightness)
-  }
-
-  toChannels (): [number, number, number] {
-    return [this.hue, this.saturation, this.lightness]
-  }
-
-  toString (): string {
-    return `hsluv(${this.hue}deg, ${this.saturation}%, ${this.lightness}%)`
-  }
-
-  equals (other: HSLuv, tollerance = TOLLERANCE): boolean {
-    if (
-      (nearEquals(this.lightness, other.lightness, tollerance) &&
-        nearEquals(this.saturation, 0, tollerance)) ||
-      nearEquals(this.saturation, 100, tollerance)
-    ) { return true }
-    return (
-      nearEquals(this.hue, other.hue, tollerance) &&
-      nearEquals(this.saturation, other.saturation, tollerance) &&
-      nearEquals(this.lightness, other.lightness, tollerance)
-    )
-  }
-}

package/src/colors/hsv.ts

@@ -1,75 +0,0 @@
-import { clamp, nearEquals } from '../numbers'
-
-const TOLLERANCE = 0.0001
-
-export class HSV {
-  static fromString (s: string): HSV {
-    const m = s.match(
-      /^hsv\((\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%\)$/i
-    )
-    if (m != null) {
-      const [, h, s, v] = m
-      return new HSV(parseFloat(h), parseFloat(s), parseFloat(v))
-    } else {
-      throw new Error(`Invalid HSV string: ${s}`)
-    }
-  }
-
-  static ofChannels ([hue, saturation, value]: [
-    hue: number,
-    saturation: number,
-    value: number
-  ]): HSV {
-    return new HSV(
-      hue % 360.0,
-      clamp(saturation * 100, 0, 100),
-      clamp(value * 100, 0, 100)
-    )
-  }
-
-  readonly hue: number
-  readonly saturation: number
-  readonly value: number
-  /**
-   *
-   * @param hue Angle in degrees (0-360)
-   * @param saturation Percentage (0-100)
-   * @param value Percentage (0-100)
-   */
-  constructor (hue: number, saturation: number, value: number) {
-    this.hue = hue
-    this.saturation = saturation
-    this.value = value
-  }
-
-  withHue (h: number): HSV {
-    return new HSV(h, this.saturation, this.value)
-  }
-
-  withSaturation (s: number): HSV {
-    return new HSV(this.hue, s, this.value)
-  }
-
-  withValue (v: number): HSV {
-    return new HSV(this.hue, this.saturation, v)
-  }
-
-  toChannels (): [number, number, number] {
-    return [this.hue, this.saturation / 100, this.value / 100]
-  }
-
-  toString (): string {
-    return `hsv(${this.hue}, ${this.saturation}, ${this.value})`
-  }
-
-  equals (other: HSV, tollerance = TOLLERANCE): boolean {
-    if (
-      nearEquals(this.value, other.value, tollerance) && (nearEquals(this.saturation, 0, tollerance) || nearEquals(this.saturation, 100, tollerance))
-    ) { return true }
-    return (
-      nearEquals(this.hue, other.hue, tollerance) &&
-      nearEquals(this.saturation, other.saturation, tollerance) &&
-      nearEquals(this.value, other.value, tollerance)
-    )
-  }
-}

package/src/colors/lab.ts

@@ -1,69 +0,0 @@
-import { clamp, nearEquals } from '../numbers'
-
-const TOLLERANCE = 0.0001
-
-export class LAB {
-  static fromString (s: string): LAB {
-    const m = s.match(
-      /^lab\((\d+(?:\.\d+)?)°, ?(\d+(?:\.\d+)?)°, ?(\d+(?:\.\d+)?)°\)$/
-    )
-    if (m != null) {
-      const [, lightness, a, b] = m
-      return new LAB(parseFloat(lightness), parseFloat(a), parseFloat(b))
-    } else {
-      throw new Error(`Invalid LAB string: ${s}`)
-    }
-  }
-
-  static ofChannels ([lightness, a, b]: [
-    lightness: number,
-    a: number,
-    b: number
-  ]): LAB {
-    return new LAB(lightness, a, b)
-  }
-
-  readonly lightness: number
-  readonly a: number
-  readonly b: number
-  /**
-   *
-   * @param lightness Lightness in range (0, 100)
-   * @param a usually in the range (~-150, ~+150) - not clamped
-   * @param b usually in the range (~-150, ~+150) - not clamped
-   */
-  constructor (lightness: number, a: number, b: number) {
-    this.lightness = clamp(lightness, 0, 100)
-    this.a = a
-    this.b = b
-  }
-
-  withL (l: number): LAB {
-    return new LAB(l, this.a, this.b)
-  }
-
-  withA (a: number): LAB {
-    return new LAB(this.lightness, a, this.b)
-  }
-
-  withB (b: number): LAB {
-    return new LAB(this.lightness, this.a, b)
-  }
-
-  toChannels (): [number, number, number] {
-    return [this.lightness, this.a, this.b]
-  }
-
-  toString (): string {
-    return `lab(${this.lightness}, ${this.a}, ${this.b})`
-  }
-
-  equals (other: LAB, tollerance = TOLLERANCE): boolean {
-    if (nearEquals(this.lightness, other.lightness, tollerance) && ((nearEquals(this.lightness, 100, tollerance)) || nearEquals(this.lightness, 0, tollerance))) { return true }
-    return (
-      nearEquals(this.lightness, other.lightness, tollerance) &&
-      nearEquals(this.a, other.a, tollerance) &&
-      nearEquals(this.b, other.b, tollerance)
-    )
-  }
-}

package/src/colors/lch.ts

@@ -1,53 +0,0 @@
-import { nearEquals } from '../numbers'
-
-const TOLLERANCE = 0.0001
-
-export class LCH {
-  static ofChannels ([l, c, h]: [l: number, c: number, h: number]): LCH {
-    return new LCH(l, c, h)
-  }
-
-  readonly luminance: number
-  readonly chroma: number
-  readonly hue: number
-  /**
-   *
-   * @param luminance Luminance in cd/m^2
-   * @param chroma
-   * @param hue Angle in degrees (0-360)
-   */
-  constructor (luminance: number, chroma: number, hue: number) {
-    this.luminance = luminance < 0 ? 0 : luminance
-    this.chroma = chroma
-    this.hue = hue % 360
-  }
-
-  withLightness (l: number): LCH {
-    return new LCH(l, this.chroma, this.hue)
-  }
-
-  withChroma (c: number): LCH {
-    return new LCH(this.luminance, c, this.hue)
-  }
-
-  withHue (h: number): LCH {
-    return new LCH(this.luminance, this.chroma, h)
-  }
-
-  toChannels (): [number, number, number] {
-    return [this.luminance, this.chroma, this.hue]
-  }
-
-  toString (): string {
-    return `lch(${this.luminance}, ${this.chroma}, ${this.hue})`
-  }
-
-  equals (other: LCH, tollerance = TOLLERANCE): boolean {
-    if (nearEquals(this.luminance, other.luminance, tollerance) && ((nearEquals(this.luminance, 100, tollerance)) || nearEquals(this.luminance, 0, tollerance))) { return true }
-    return (
-      nearEquals(this.luminance, other.luminance, tollerance) &&
-      nearEquals(this.chroma, other.chroma, tollerance) &&
-      nearEquals(this.hue, other.hue, tollerance)
-    )
-  }
-}

package/src/colors/luv.ts

@@ -1,56 +0,0 @@
-import { nearEquals } from '../numbers'
-
-const TOLLERANCE = 0.0001
-
-export class LUV {
-  static ofChannels ([l, u, v]: [l: number, u: number, v: number]): LUV {
-    return new LUV(l, u, v)
-  }
-
-  readonly l: number
-  readonly u: number
-  readonly v: number
-  /**
-   *
-   * @param l
-   * @param u range (0, 1)
-   * @param v range (0, 1)
-   */
-  constructor (l: number, u: number, v: number) {
-    this.l = l
-    this.u = u
-    this.v = v
-  }
-
-  withL (l: number): LUV {
-    return new LUV(l, this.u, this.v)
-  }
-
-  withU (u: number): LUV {
-    return new LUV(this.l, u, this.v)
-  }
-
-  withV (v: number): LUV {
-    return new LUV(this.l, this.u, v)
-  }
-
-  toChannels (): [number, number, number] {
-    return [this.l, this.u, this.v]
-  }
-
-  toString (): string {
-    return `luv(${this.l}, ${this.u}, ${this.v})`
-  }
-
-  equals (other: LUV, tollerance = TOLLERANCE): boolean {
-    if (
-      (nearEquals(this.l, other.l, tollerance) && nearEquals(this.l, 1, tollerance)) ||
-      nearEquals(this.l, 0, tollerance)
-    ) { return true }
-    return (
-      nearEquals(this.l, other.l, tollerance) &&
-      nearEquals(this.u, other.u, tollerance) &&
-      nearEquals(this.v, other.v, tollerance)
-    )
-  }
-}

package/src/colors/rgb.ts

@@ -1,55 +0,0 @@
-import { clampInt } from '../numbers'
-
-export class RGB {
-  static fromString (s: string): RGB {
-    const m = s.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i)
-    if (m != null) {
-      const r = parseInt(m[1], 16)
-      const g = parseInt(m[2], 16)
-      const b = parseInt(m[3], 16)
-      return RGB.fromRGB(r, g, b)
-    } else {
-      throw new Error(`Invalid RGB string: ${s}`)
-    }
-  }
-
-  static fromRGB (r: number, g: number, b: number): RGB {
-    return new RGB(
-      (clampInt(Math.round(r), 0, 255) << 16) |
-        (clampInt(Math.round(g), 0, 255) << 8) |
-        clampInt(Math.round(b), 0, 255)
-    )
-  }
-
-  static ofChannels ([r, g, b]: [r: number, g: number, b: number]): RGB {
-    return RGB.fromRGB(r * 255, g * 255, b * 255)
-  }
-
-  constructor (readonly value: number) {}
-
-  get red (): number {
-    return (this.value >> 16) & 0xff
-  }
-
-  get green (): number {
-    return (this.value >> 8) & 0xff
-  }
-
-  get blue (): number {
-    return this.value & 0xff
-  }
-
-  toChannels (): [number, number, number] {
-    return [this.red / 255, this.green / 255, this.blue / 255]
-  }
-
-  toString (): string {
-    return `#${this.red.toString(16).padStart(2, '0')}${this.green
-      .toString(16)
-      .padStart(2, '0')}${this.blue.toString(16).padStart(2, '0')}`
-  }
-
-  equals (other: RGB): boolean {
-    return this.value === other.value
-  }
-}

package/src/colors/rgba.ts

@@ -1,53 +0,0 @@
-import { clampInt } from '../numbers'
-
-export class RGBA {
-  static fromString (s: string): RGBA {
-    const m = s.match(
-      /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i
-    )
-    if (m != null) {
-      const r = parseInt(m[1], 16)
-      const g = parseInt(m[2], 16)
-      const b = parseInt(m[3], 16)
-      const a = parseInt(m[4], 16)
-      return RGBA.fromRGBA(r, g, b, a)
-    } else {
-      throw new Error(`Invalid RGBA string: ${s}`)
-    }
-  }
-
-  static fromRGBA (r: number, g: number, b: number, a: number): RGBA {
-    return new RGBA(
-      (clampInt(r, 0, 255) << 24) |
-        (clampInt(g, 0, 255) << 16) |
-        (clampInt(b, 0, 255) << 8) |
-        clampInt(a, 0, 255)
-    )
-  }
-
-  constructor (readonly value: number) {}
-
-  get red (): number {
-    return (this.value >> 24) & 0xff
-  }
-
-  get green (): number {
-    return (this.value >> 16) & 0xff
-  }
-
-  get blue (): number {
-    return (this.value >> 8) & 0xff
-  }
-
-  get alpha (): number {
-    return this.value & 0xff
-  }
-
-  toString (): string {
-    return `rgba(${this.red}, ${this.green}, ${this.blue}, ${this.alpha / 256})`
-  }
-
-  equals (other: RGBA): boolean {
-    return this.value === other.value
-  }
-}

package/src/colors/srgb.ts

@@ -1,72 +0,0 @@
-import { clamp, nearEquals } from '../numbers'
-
-const TOLLERANCE = 0.001
-
-export class SRGB {
-  static fromString (s: string): SRGB {
-    const m = s.match(
-      /^rgb\((\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%\)$/
-    )
-    if (m != null) {
-      const [, red, blue, green] = m
-      return new SRGB(parseFloat(red), parseFloat(blue), parseFloat(green))
-    } else {
-      throw new Error(`Invalid RGB string: ${s}`)
-    }
-  }
-
-  static ofChannels ([red, blue, green]: [
-    red: number,
-    blue: number,
-    green: number
-  ]): SRGB {
-    return new SRGB(
-      clamp(red * 100, 0, 100),
-      clamp(blue * 100, 0, 100),
-      clamp(green * 100, 0, 100)
-    )
-  }
-
-  readonly red: number
-  readonly blue: number
-  readonly green: number
-  /**
-   *
-   * @param red Percentage (0-100)
-   * @param blue Percentage (0-100)
-   * @param green Percentage (0-100)
-   */
-  constructor (red: number, blue: number, green: number) {
-    this.red = clamp(red, 0, 100)
-    this.blue = clamp(blue, 0, 100)
-    this.green = clamp(green, 0, 100)
-  }
-
-  withRed (red: number): SRGB {
-    return new SRGB(red, this.blue, this.green)
-  }
-
-  withBlue (blue: number): SRGB {
-    return new SRGB(this.red, blue, this.green)
-  }
-
-  withGreen (green: number): SRGB {
-    return new SRGB(this.red, this.blue, green)
-  }
-
-  toString (): string {
-    return `rgb(${this.red}%, ${this.blue}%, ${this.green}%)`
-  }
-
-  toChannels (): [number, number, number] {
-    return [this.red / 100, this.blue / 100, this.green / 100]
-  }
-
-  equals (other: SRGB, tollerance = TOLLERANCE): boolean {
-    return (
-      nearEquals(this.red, other.red, tollerance) &&
-      nearEquals(this.blue, other.blue, tollerance) &&
-      nearEquals(this.green, other.green, tollerance)
-    )
-  }
-}

package/src/colors/xyz.ts

@@ -1,52 +0,0 @@
-import { nearEquals } from '../numbers'
-
-const TOLLERANCE = 0.0001
-
-export class XYZ {
-  static ofChannels ([x, y, z]: [x: number, y: number, z: number]): XYZ {
-    return new XYZ(x, y, z)
-  }
-
-  readonly x: number
-  readonly y: number
-  readonly z: number
-  /**
-   *
-   * @param x
-   * @param y 100 is the brightest white
-   * @param z
-   */
-  constructor (x: number, y: number, z: number) {
-    this.x = x
-    this.y = y
-    this.z = z
-  }
-
-  withX (x: number): XYZ {
-    return new XYZ(x, this.y, this.z)
-  }
-
-  withY (y: number): XYZ {
-    return new XYZ(this.x, y, this.z)
-  }
-
-  withZ (z: number): XYZ {
-    return new XYZ(this.x, this.y, z)
-  }
-
-  toString (): string {
-    return `XYZ(${this.x}, ${this.y}, ${this.z})`
-  }
-
-  toChannels (): [number, number, number] {
-    return [this.x, this.y, this.z]
-  }
-
-  equals (other: XYZ, tollerance = TOLLERANCE): boolean {
-    return (
-      nearEquals(this.x, other.x, tollerance) &&
-      nearEquals(this.y, other.y, tollerance) &&
-      nearEquals(this.z, other.z, tollerance)
-    )
-  }
-}