Phryxia

export type StateId = number
export type Char = '0' | '1'

export interface DFA {
    statesNumber: number
    rules: Record<Char, StateId>[]
    startState: StateId
    acceptStates: StateId[]
}

Phryxia

export interface StringIterator extends IterableIterator<string> {
    clone(): StringIterator 
}

export function createStringIterator(s: string, index: number = 0): StringIterator {
    return {
        next(): IteratorResult<string> {
            if (index >= s.length) {
                return {
                    done: true,

Phryxia

export function createDisjointSet(initialSize: number) {
    const roots = Array.from(new Array(initialSize), (_, index) => index)
    const sizes = roots.map(() => 1)
    let groups = initialSize

    // return the id of the set which given index-th element exists.
    // but set id may changes if further union operations are done.
    function find(index: number): number {
        if (roots[index] === index) return index
        return roots[index] = find(roots[index])

Phryxia

export function createExactFinder<T>(comp: (a: T, b: T) => number) {
  return (list: T[], target: T) => {
    let l = 0
    let r = list.length - 1

    while (l <= r) {
      const m = Math.ceil((l + r) / 2)
      const c = comp(list[m], target)

      if (c === 0) return m

Phryxia

import { DependencyList, EffectCallback, useEffect } from 'react'

type Destructor = () => void
type AsyncDestructor = () => Promise<void>
type AsyncEffectCallback = () => Promise<void | Destructor | AsyncDestructor>

export function useAsyncEffect(callback: EffectCallback | AsyncEffectCallback, deps?: DependencyList) {
  useEffect(() => {
    const mayPromise = callback()

Phryxia

// why [A]? check https://github.com/microsoft/TypeScript/issues/31751
type Equal<A, B> = 
  [A] extends [B] ?
    [B] extends [A] ?
      true :
    false :
  false

// [A, ...?] -> A
type First<T> =

Phryxia

type CartessianType<T> =
  T extends [] ? 
    [] :
  T extends [(infer R)[], ...infer Rest] ?
    [R, ...CartessianType<Rest>] :
  T extends (infer R)[][] ?
    [R] : 
  never

function cartessianProduct<T extends unknown[]>(...sets: T): CartessianType<T>[]

Phryxia

interface RetryOption {
  name?: string
  isintermediateLogged: boolean
  interval?: number // second
  maxTries: number
}

export async function retry<T>(
  job: () => Promise<T> | T,
  { name, isintermediateLogged, interval = 0, maxTries }: RetryOption

Phryxia

// You need to hook based modal system. If it's not, you may tweak upon your system.
import { useModal } from './ModalProvider'

export interface UseConfirmOptions {
  title: string
  confirmText: string
  cancelText: string
}

export function useConfirm(props: UseConfirmOptions) {

Phryxia

/**
 * @param obj anything
 * @param isSafe whether protect mutual dependency cycle case
 * @returns every primitive properties of nested objects or arrays
 */
function deepValues(obj: any, isSafe: boolean = false): any[] {
  const out = [] as any[]
  const dup = [] as (any[] | object)[]

  function traverse(current: any) {