@helios-lang/effect 0.1.5 → 0.1.6

package/src/internal/Base32.test.ts

@@ -1,219 +0,0 @@
-import { Effect, Either } from "effect"
-import { describe, it, expect } from "bun:test"
-import * as Base32 from "./Base32.js"
-import * as Utf8 from "./Utf8.js"
-
-/**
- * Some test vectors taken from https://chromium.googlesource.com/chromium/src/+/lkgr/components/base32/base32_unittest.cc
- */
-
-describe(`Base32.make()`, () => {
-  it("fails for non-32 char alphabet", () => {
-    expect(() => Base32.make({ alphabet: "abcdefg" })).toThrow()
-  })
-
-  it("fails for non-unique 32 char alphabet", () => {
-    expect(() =>
-      Base32.make({ alphabet: "aacdefghijklmnopqrstuvwxyz234567" })
-    ).toThrow()
-  })
-
-  it("fails for non-single char padding (0 chars)", () => {
-    expect(() =>
-      Base32.make({
-        alphabet: Base32.DEFAULT_ALPHABET,
-        padChar: ""
-      })
-    ).toThrow()
-  })
-
-  it("fails for non-single char padding (more than 1 chars)", () => {
-    expect(() =>
-      Base32.make({
-        alphabet: Base32.DEFAULT_ALPHABET,
-        padChar: "=="
-      })
-    ).toThrow()
-  })
-
-  it("fails if padding char is part of alphabet", () => {
-    expect(() =>
-      Base32.make({
-        alphabet: "abcdefghijklmnopqrstuvwxyz23456=",
-        padChar: "="
-      })
-    ).toThrow()
-  })
-})
-
-describe("Base32.DEFAULT.isValid()", () => {
-  it("returns true for an empty string", () => {
-    expect(Base32.DEFAULT.isValid("")).toBe(true)
-  })
-
-  it('returns true for "my"', () => {
-    expect(Base32.DEFAULT.isValid("my")).toBe(true)
-  })
-
-  it('returns false for "f0" (invalid char)', () => {
-    expect(Base32.DEFAULT.isValid("f0")).toBe(false)
-  })
-
-  it('returns false for "fo=" (bad alignment with padding)', () => {
-    expect(Base32.DEFAULT.isValid("fo=")).toBe(false)
-  })
-
-  it('returns false for "fo=o====" (interrupted padding)', () => {
-    expect(Base32.DEFAULT.isValid("fo=o====")).toBe(false)
-  })
-
-  it('returns false for "foo=====" (invalid padding length)', () => {
-    expect(Base32.DEFAULT.isValid("foo=====")).toBe(false)
-  })
-
-  it('returns false for "fooo====" (bad terminating char)', () => {
-    expect(Base32.DEFAULT.isValid("fooo====")).toBe(false)
-  })
-
-  it('returns true for "fooa===="', () => {
-    expect(Base32.DEFAULT.isValid("fooa====")).toBe(true)
-  })
-})
-
-describe("Base32.encode() without padding", () => {
-  const codec = Base32.make({})
-
-  it("returns an empty string for []", () => {
-    expect(codec.encode([])).toBe("")
-  })
-
-  it('returns "my" for the utf-8 bytes of "f"', () => {
-    expect(codec.encode(Utf8.encode("f"))).toBe("my")
-  })
-
-  it('returns "mzxq" for the utf-8 bytes of "fo"', () => {
-    expect(codec.encode(Utf8.encode("fo"))).toBe("mzxq")
-  })
-
-  it('returns "mzxw6" for the utf-8 bytes of "foo"', () => {
-    expect(codec.encode(Utf8.encode("foo"))).toBe("mzxw6")
-  })
-
-  it('returns "mzxw6yq" for the utf-8 bytes of "foob"', () => {
-    expect(codec.encode(Utf8.encode("foob"))).toBe("mzxw6yq")
-  })
-
-  it('returns "mzxw6ytb" for the utf-8 bytes of "fooba"', () => {
-    expect(codec.encode(Utf8.encode("fooba"))).toBe("mzxw6ytb")
-  })
-
-  it('returns "mzxw6ytboi" for the utf-8 bytes of "foobar"', () => {
-    expect(codec.encode(Utf8.encode("foobar"))).toBe("mzxw6ytboi")
-  })
-})
-
-describe("Base32.decode()", () => {
-  const paddingLessCodec = Base32.make({ alphabet: Base32.DEFAULT_ALPHABET })
-  const paddingCodec = Base32.make({
-    ...Base32.DEFAULT_PROPS,
-    strict: true
-  })
-
-  it("returns [] for an empty string", () => {
-    expect(Base32.DEFAULT.decode("")).toEqual(Either.right(new Uint8Array([])))
-  })
-
-  it('returns the utf-8 bytes of "f" for "my"', () => {
-    expect(paddingLessCodec.decode("my")).toEqual(
-      Either.right(Utf8.encode("f"))
-    )
-  })
-
-  it('returns the utf-8 bytes of "fo" for "mzxq"', () => {
-    expect(Base32.DEFAULT.decode("mzxq")).toEqual(
-      Either.right(Utf8.encode("fo"))
-    )
-  })
-
-  it('fails for "mzxq" if strict', () => {
-    expect(paddingCodec.decode("mzxq")._tag).toBe("Left")
-  })
-
-  it('returns the utf-8 btyes of "foo" for "mzxw6"', () => {
-    expect(Base32.DEFAULT.decode("mzxw6")).toEqual(
-      Either.right(Utf8.encode("foo"))
-    )
-  })
-
-  it('returns the utf-8 bytes of "foob" for "mzxw6yq"', () => {
-    expect(Base32.DEFAULT.decode("mzxw6yq")).toEqual(
-      Either.right(Utf8.encode("foob"))
-    )
-  })
-
-  it('returns the utf-8 bytes of "fooba" for "mzxw6ytb"', () => {
-    expect(Base32.DEFAULT.decode("mzxw6ytb")).toEqual(
-      Either.right(Utf8.encode("fooba"))
-    )
-  })
-
-  it('returns the utf-8 bytes of "foobar" for "mzxw6ytboi"', () => {
-    expect(Base32.DEFAULT.decode("mzxw6ytboi")).toEqual(
-      Either.right(Utf8.encode("foobar"))
-    )
-  })
-
-  it('fails for "0" (invalid char)', () => {
-    expect(Base32.DEFAULT.decode("0")._tag).toBe("Left")
-  })
-
-  it('fails for "1" (invalid char)', () => {
-    expect(Base32.DEFAULT.decode("1")._tag).toBe("Left")
-  })
-
-  it('fails for "8" (invalid char)', () => {
-    expect(Base32.DEFAULT.decode("8")._tag).toBe("Left")
-  })
-
-  it('fails for "9" (invalid char)', () => {
-    expect(Base32.DEFAULT.decode("9")._tag).toBe("Left")
-  })
-
-  it('fails for "$" (invalid char)', () => {
-    expect(Base32.DEFAULT.decode("$")._tag).toBe("Left")
-  })
-
-  it('returns the same for "mzxw6ytboi" as for "MZXW6YTBOI" (case insensitive)', () => {
-    const s = "mzxw6ytboi"
-
-    expect(Base32.DEFAULT.decode(s)).toEqual(
-      Base32.DEFAULT.decode(s.toUpperCase())
-    )
-  })
-})
-
-describe("Base32.decode()/Base32.encode() roundtrip", () => {
-  function roundtrip(encoded: string): string {
-    return Base32.DEFAULT.encode(Effect.runSync(Base32.DEFAULT.decode(encoded)))
-  }
-
-  it("fails for foo=====", () => {
-    expect(() => roundtrip("foo=====")).toThrow()
-  })
-
-  it("fails for foo====", () => {
-    expect(() => roundtrip("foo====")).toThrow()
-  })
-
-  it("fails for foo=b", () => {
-    expect(() => roundtrip("foo=b")).toThrow()
-  })
-
-  it("ok for fooa====", () => {
-    expect(roundtrip("fooa====")).toBe("fooa====")
-  })
-
-  it("fails for for fooo====", () => {
-    expect(() => roundtrip("fooo====")).toThrow()
-  })
-})

package/src/internal/Base32.ts

@@ -1,341 +0,0 @@
-import { Encoding, Either } from "effect"
-import * as Bits from "./Bits.js"
-
-export interface Base32 {
-  readonly alphabet: string
-  readonly padChar: string
-  readonly strict: boolean
-
-  /**
-   * @param encoded
-   * @returns array of bytes
-   */
-  decode(encoded: string): Either.Either<Uint8Array, Encoding.DecodeException>
-
-  /**
-   * @param encoded
-   * @returns array of numbers in range [0,32)
-   */
-  decodeRaw(encoded: string): Either.Either<number[], Encoding.DecodeException>
-
-  /**
-   * @param bytes
-   * @returns base32 encoded string
-   */
-  encode(bytes: string | Uint8Array | number[]): string
-
-  /**
-   *
-   * @param bytes
-   * @returns array of numbers in range [0,32)
-   */
-  encodeRaw(bytes: string | Uint8Array | number[]): number[]
-
-  /**
-   * Checks if encoded bytes are valid base32
-   * @param encoded
-   */
-  isValid(encoded: string): boolean
-}
-
-export type Props =
-  | {
-      alphabet?: string
-    }
-  | {
-      alphabet?: string
-      padChar: string
-      strict?: boolean
-    }
-
-export const DEFAULT_ALPHABET = "abcdefghijklmnopqrstuvwxyz234567" as const
-
-export const DEFAULT_PAD_CHAR = "=" as const
-
-export const DEFAULT_PROPS: Props = {
-  alphabet: DEFAULT_ALPHABET,
-  padChar: DEFAULT_PAD_CHAR,
-  strict: false
-}
-
-export const DEFAULT: Base32 = /* @__PURE__ */ make()
-
-/**
- * @param props
- * @returns
- */
-export function make(props: Props = DEFAULT_PROPS): Base32 {
-  const alphabet = props.alphabet ?? DEFAULT_ALPHABET
-  const padChar = "padChar" in props ? props.padChar : ""
-  const strict = "strict" in props ? (props.strict ?? false) : false
-
-  if (alphabet.length != 32) {
-    throw new Error(
-      `Expected base32 alphabet with 32 characters, got ${alphabet.length} characters`
-    )
-  }
-
-  if (new Set(alphabet.split("")).size != 32) {
-    throw new Error(
-      "Invalid base32 alphabet, doesn't consist 32 unique characters"
-    )
-  }
-
-  if ("padChar" in props && padChar.length != 1) {
-    throw new Error("Expected single base32 padChar")
-  }
-
-  if ("padChar" in props && alphabet.indexOf(padChar) != -1) {
-    throw new Error("Base32 padChar can't be part of alphabet")
-  }
-
-  return new Base32Impl(alphabet, padChar, strict)
-}
-
-class Base32Impl implements Base32 {
-  readonly alphabet: string
-  readonly padChar: string
-  readonly strict: boolean
-
-  constructor(alphabet: string, padChar: string, strict: boolean) {
-    this.alphabet = alphabet
-    this.padChar = padChar
-    this.strict = strict
-  }
-
-  /**
-   * Decodes a Base32 string into bytes.
-   * @param encoded
-   * @returns
-   */
-  decode(encoded: string): Either.Either<Uint8Array, Encoding.DecodeException> {
-    const writer = Bits.makeWriter()
-
-    const rawResult = this.decodeRaw(encoded)
-
-    if (rawResult._tag == "Left") {
-      return Either.left(rawResult.left)
-    }
-
-    const raw = rawResult.right
-
-    const n = raw.length
-
-    raw.forEach((code, i) => {
-      if (i == n - 1) {
-        // last, make sure we align to byte
-
-        const nCut = n * 5 - 8 * Math.floor((n * 5) / 8)
-
-        const bits = Bits.pad(code.toString(2), 5)
-
-        writer.writeBits(bits.slice(0, 5 - nCut))
-      } else {
-        const bits = Bits.pad(code.toString(2), 5)
-
-        writer.writeBits(bits)
-      }
-    })
-
-    const result = writer.finalize(false)
-
-    return Either.right(new Uint8Array(result))
-  }
-
-  /**
-   * @param encoded
-   * @returns array with numbers in range [0,32)
-   */
-  decodeRaw(
-    encoded: string
-  ): Either.Either<number[], Encoding.DecodeException> {
-    const trimResult = trim(encoded, this.padChar, this.strict)
-
-    if (trimResult._tag == "Left") {
-      return Either.left(trimResult.left)
-    }
-
-    encoded = trimResult.right
-
-    const n = encoded.length
-
-    const res: number[] = []
-
-    for (let i = 0; i < n; i++) {
-      const c = encoded[i]
-
-      if (c == this.padChar) {
-        // TODO: yield with Effect
-        return Either.left(
-          Encoding.DecodeException(
-            encoded,
-            `Unexpected padding character '${c}' at position ${i}`
-          )
-        )
-      }
-
-      const code = this.alphabet.indexOf(c.toLowerCase())
-
-      if (code < 0) {
-        return Either.left(
-          Encoding.DecodeException(
-            encoded,
-            `Invalid base32 character '${c}' at position ${i}`
-          )
-        )
-      } else if (i == n - 1) {
-        const nBitsExtra = n * 5 - Math.floor((n * 5) / 8) * 8
-
-        if ((((1 << nBitsExtra) - 1) & code) != 0) {
-          return Either.left(
-            Encoding.DecodeException(
-              encoded,
-              `Invalid base32 final character '${c}'`
-            )
-          )
-        }
-      }
-
-      res.push(code)
-    }
-
-    return Either.right(res)
-  }
-
-  /**
-   * Encodes bytes in using Base32.
-   * @param bytes hex encoded or list of uint8 numbers
-   * @returns
-   */
-  encode(bytes: string | number[] | Uint8Array): string {
-    const s = this.encodeRaw(bytes)
-      .map((c) => this.alphabet[c])
-      .join("")
-
-    const n = s.length
-
-    if (n % 8 != 0 && this.padChar.length != 0) {
-      return s + new Array(8 - (n % 8)).fill(this.padChar).join("")
-    } else {
-      return s
-    }
-  }
-
-  /**
-   * @param bytes
-   * @returns {number[]} list of numbers between 0 and 32
-   */
-  encodeRaw(bytes: string | number[] | Uint8Array): number[] {
-    const result: number[] = []
-
-    const reader = Bits.makeReader(bytes, false)
-
-    while (!reader.isAtEnd()) {
-      result.push(reader.readBits(5))
-    }
-
-    return result
-  }
-
-  /**
-   * Checks if all the characters in `encoded` are in the given base32 alphabet.
-   * Checks lengths if their pad characters at the end
-   * @param encoded
-   * @returns
-   */
-  isValid(encoded: string): boolean {
-    let n = encoded.length
-
-    if (
-      this.padChar.length == 1 &&
-      (this.strict || encoded.endsWith(this.padChar))
-    ) {
-      if (encoded.length % 8 != 0) {
-        return false
-      }
-
-      const iPad = encoded.indexOf(this.padChar)
-
-      for (let i = iPad + 1; i < n; i++) {
-        if (encoded.at(i) != this.padChar) {
-          return false
-        }
-      }
-
-      const nPad = n - iPad
-
-      if (nPad != 6 && nPad != 4 && nPad != 3 && nPad != 1) {
-        return false
-      }
-
-      encoded = encoded.slice(0, iPad)
-
-      n = iPad
-    }
-
-    // the last char can't be any possible number
-
-    return encoded.split("").every((c, i) => {
-      const code = this.alphabet.indexOf(c.toLowerCase())
-
-      if (code < 0) {
-        return false
-      }
-
-      if (i == n - 1) {
-        const nBitsExtra = n * 5 - Math.floor((n * 5) / 8) * 8
-
-        return (((1 << nBitsExtra) - 1) & code) == 0
-      } else {
-        return true
-      }
-    })
-  }
-}
-
-/**
- * Trims the padding, asserting it is correctly formed
- * @param encoded
- * @param padChar
- * @returns
- */
-function trim(
-  encoded: string,
-  padChar: string,
-  strict: boolean
-): Either.Either<string, Encoding.DecodeException> {
-  if (padChar.length == 1) {
-    let n = encoded.length
-
-    while (n >= 0 && encoded.at(n - 1) == padChar) {
-      n -= 1
-    }
-
-    // length alignment is only checked if there are some padding characters at the end
-    if ((strict || n < encoded.length) && encoded.length % 8 != 0) {
-      return Either.left(
-        Encoding.DecodeException(
-          encoded,
-          "Invalid length (expected multiple of 8)"
-        )
-      )
-    }
-
-    const nPad = encoded.length - n
-
-    if (nPad != 0) {
-      if (nPad != 6 && nPad != 4 && nPad != 3 && nPad != 1) {
-        return Either.left(
-          Encoding.DecodeException(
-            encoded,
-            "Invalid number of base32 padding characters"
-          )
-        )
-      }
-    }
-
-    return Either.right(encoded.slice(0, n))
-  } else {
-    return Either.right(encoded)
-  }
-}

package/src/internal/BigEndian.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { Either } from "effect"
-import * as BigEndian from "./BigEndian.js"
-import { toHex } from "./Bytes.js"
-
-describe("BigEndian.decode", () => {
-  it("returns 255n for [255]", () => {
-    expect(BigEndian.decode([255])).toEqual(Either.right(255n))
-  })
-
-  it("returns 255n for [0, 0, 0, 255]", () => {
-    expect(BigEndian.decode([0, 0, 0, 255])).toEqual(Either.right(255n))
-  })
-
-  it("fails for [256] (invalid byte)", () => {
-    expect(BigEndian.decode([256])._tag).toBe("Left")
-  })
-
-  it("fails for [3.14] (invalid byte)", () => {
-    expect(BigEndian.decode([3.14])._tag).toBe("Left")
-  })
-
-  it("fails for [-1] (invalid byte)", () => {
-    expect(BigEndian.decode([-1])._tag).toBe("Left")
-  })
-
-  it("fails for empty bytes", () => {
-    expect(BigEndian.decode([])._tag).toBe("Left")
-  })
-
-  describe("BigEndian.decode compared to alt formula", () => {
-    const alt = (bytes: number[]): bigint => {
-      let sum = 0n
-      bytes = bytes.slice().reverse()
-      bytes.forEach((b, i) => {
-        sum += BigInt(b) * (1n << BigInt(i * 8))
-      })
-      return sum
-    }
-
-    const testVector: number[][] = [
-      [0x00],
-      [0x80],
-      [0xff],
-      [0xff, 0xff],
-      [0xfe, 0xfe],
-      [0x80, 0x80],
-      [0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89]
-    ]
-
-    testVector.forEach((t) => {
-      it(`ok for #${toHex(t)}`, () => {
-        expect(BigEndian.decode(t)).toEqual(Either.right(alt(t)))
-      })
-    })
-  })
-})
-
-describe("BigEndian.encode", () => {
-  it("returns [1, 0] for 256", () => {
-    expect(BigEndian.encode(256)).toEqual([1, 0])
-  })
-
-  it("returns [0] for 0", () => {
-    expect(BigEndian.encode(0)).toEqual([0])
-  })
-
-  it("returns [0] for 0n", () => {
-    expect(BigEndian.encode(0n)).toEqual([0])
-  })
-
-  it("fails for a non-whole number", () => {
-    expect(() => BigEndian.encode(0.5)).toThrow()
-  })
-
-  it("fails for a negative number", () => {
-    expect(() => BigEndian.encode(-1n)).toThrow()
-  })
-})

package/src/internal/BigEndian.ts

@@ -1,67 +0,0 @@
-import { Either, Encoding } from "effect"
-import { DecodeException } from "./Bytes.js"
-
-/**
- * Converts a list of big endian uint8 numbers into an unbounded int
- * @param bytes
- * @returns
- * @throws
- * If `bytes` is empty
- * @throws
- * If any input number is out of range [0,256) or not a whole number
- */
-export function decode(
-  bytes: number[] | Uint8Array
-): Either.Either<bigint, Encoding.DecodeException> {
-  if (bytes.length == 0) {
-    return Either.left(DecodeException(bytes, "Empty bytes"))
-  }
-
-  let p = 1n
-  let total = 0n
-
-  for (let i = bytes.length - 1; i >= 0; i--) {
-    const b = bytes[i]
-
-    if (b < 0 || b > 255 || b % 1.0 != 0.0) {
-      return Either.left(
-        DecodeException(bytes, `Invalide bytes '${b}' at position ${i}`)
-      )
-    }
-
-    total += BigInt(b) * p
-
-    p *= 256n
-  }
-
-  return Either.right(total)
-}
-
-/**
- * Converts an unbounded integer into a list of big endian uint8 numbers.
- * @param x
- * @returns
- * @throws
- * If `x` isn't a whole number
- * @throws
- * If `x` is negative.
- */
-export function encode(x: number | bigint): number[] {
-  if (typeof x == "number") {
-    return encode(BigInt(x))
-  } else if (x < 0n) {
-    throw new RangeError(`Unexpected negative number: ${x}`)
-  } else if (x == 0n) {
-    return [0]
-  } else {
-    const res: number[] = []
-
-    while (x > 0n) {
-      res.unshift(Number(x % 256n))
-
-      x = x / 256n
-    }
-
-    return res
-  }
-}