types.ts

// Use 'Prettify Symbols Mode' VSCode Extension to display `foo7` as `foo?`
declare global {
  function p(...args: unknown[]): void
  function inspect(v: unknown): void
  /** Converts anytihng to compact format `{ a: 1, b: [1, 'c']}`,
    * could be parsed with the `from_s`, relaxed json or yaml. */
  function to_s(v: unknown): string
  /** Parses both json, relaxed json, and output of the `to_s`, example `{ k: 1 }` */
  function from_s<T = unknown>(v: string): T
  function equal7<T>(a: T, b: T): boolean
  function compare<T>(a: T, b: T): number
  function raise(message: string): never
  function error_message(e: unknown, msg?: string): string
  function ensure<T>(v: T, message?: string): NonNullable<T>

  function size(o: Record<string, unknown> | { size(): number }): number
  function keys<K extends string>(o: Record<K, unknown>): K[]
  function values<V>(o: Record<string, V>): V[]
  function entries<K extends string, V>(o: Record<K, V>): [K, V][]
  function empty7(o: Record<string, unknown> | { size(): number }): boolean
  function has_key7<K>(o: { has_key7(k: K): boolean }, k: K): boolean
  function has_key7<K extends string, V>(o: Record<K, V>, k: K): boolean
  function has_key7<V>(o: Record<string, V>, k: string): boolean

  /** Doesn't work for custom classes */
  function deep_clone<T>(o: T): T
  /** Doesn't work for custom classes */
  function shallow_clone<T>(o: T): T

  function string7(v: unknown): v is string
  function number7(v: unknown): v is number
  function boolean7(v: unknown): v is boolean
  function array7(v: unknown): v is unknown[]
  /** Also matches Function and Array are they are also objects */
  function object7(v: unknown): v is object
  function record7(v: unknown): v is Record<string, unknown>
  function nil7(v: unknown): v is nil
  function function7(v: unknown): v is Function

  function next_tick(cb: () => void): void
  function sleep(ms: number): Promise<void>

  type nil = undefined
  var nil: undefined
  function nil7(v: unknown): v is undefined

  interface Object {
    compare<T>(this: T, other: T): number
    hash_code(): number
    /** Fixed equality, so `[1].equal7([1]) == true` */
    equal7<T>(this: T, other: T): boolean
    /** Converts object to compact format, relaxed json `{ a: 1, b: [1, 'c']}`,
     * could be parsed with the `from_s`, relaxed json or yaml. */
    to_s(): string
  }
  interface ObjectConstructor {
    /** List all keys, including inherited from prototype chain */
    all_keys(o: object): string[]
    from<T>(entries: [string, T][]): { [key: string]: T }
  }

  interface Boolean {
  }
  interface BooleanConstructor {
    parse(s: string): boolean | undefined
  }

  interface Number {
    floor(): number
    ceil(): number
    abs(): number
    min(v: number): number
    max(v: number): number
    pow(v: number): number
    div(v: number): number
    rem(v: number): number
    div_rem(v: number): [number, number]
    pluralize(singular: string, plural?: string): string
    round(digits?: number): number
  }
  interface NumberConstructor {
    parse(s: string): number | undefined
  }

  interface String {
    empty7(): boolean
    has7(v: string | RegExp): boolean
    get(i: number): string
    /** Both indexes inclusive, both could be negative, last is `-1`, indexes not allowed to be out of bounds */
    get(i: number, i2: number): string
    /** Both indexes inclusive, both could be negative, last is `-1`, indexes allowed to be out of bounds */
    get_relaxed(i: number, i2: number): string
    plus(other: string): string
    indent(n: number): string
    downcase(): string
    upcase(): string
    ljust(n: number, c?: string): string
    rjust(n: number, c?: string): string
    uniq(): string
    /** Fixed version of `split` which is broken */
    divide(sep: string | RegExp, limit?: number): string[]
    dedent(): string
    size(): number
    /** Index inclusive, could be negative, by default `start_i = 0` */
    start_with7(pattern: string | RegExp, start_i?: number): boolean
    /** Index inclusive, could be negative, by default `end_i = -1` */
    end_with7(pattern: string | RegExp, end_i?: number): boolean
  }

  interface RegExp {
    parse(s: string): string[]
    parse1(s: string): string
    parse2(s: string): [string, string]
    parse3(s: string): [string, string, string]
    parse_named(s: string): Record<string, string>
  }

  interface Enumerable<V> {
    [Symbol.iterator](): Iterator<V>
    empty7(): boolean
    filter(op: (v: V) => boolean): V[]
    map<R>(op: (v: V) => R): R[]
    each(op: (v: V) => void): void
    all7(op: (v: V) => boolean): boolean
    some7(op: (v: V) => boolean): boolean
    has7(op: V | ((v: V) => boolean)): boolean
    /** Uses `this.compare` */
    order(): V[]
    order(op: (a: V, b: V) => number): V[]
    order(op: (v: V) => unknown): V[]
    order(op: ((a: V, b: V) => number) | ((v: V) => unknown)): V[]
    inverse(): V[]
    /** Uses `this.eq7` and `this.hash_code` for speed. */
    uniq(): V[]
    uniq(op: (v: V) => unknown): V[]
    join(sep?: string): string
    partition(op: (v: V) => boolean): [V[], V[]]
    count(op: V | ((v: V) => boolean)): number
    min_i<R>(op?: ((v: V) => R)): number
    max_i<R>(op?: ((v: V) => R)): number
    min(this: number[]): number
    min<R>(op: ((v: V) => R)): R
    max(this: number[]): number
    max<R>(op: ((v: V) => R)): R
    group<K>(op: (v: V) => K): Hash<K, V[]>
    to_hash<K>(op: (v: V) => K): Hash<K, V>
    to_set(): HSet<V>
    to_object(op: (v: V) => string): { [key: string]: V }
    filter_map(): NonNullable<V>[]
    filter_map<R>(op: (v: V) => R | nil): R[]
    batch(n: number): V[][]

    quantile(this: Enumerable<number>, q: number, sorted7?: boolean): number
    median(this: Enumerable<number>, sorted7?: boolean): number
    mean(this: Enumerable<number>): number
    sum(this: Enumerable<number>): number
  }

  interface Array<T> extends Enumerable<T> {
    get(i: number): T
    /** Both indexes inclusive, both could be negative, last is `-1`, indexes not allowed to be out of bounds */
    get(i: number, i2: number): T[]
    /** Both indexes inclusive, both could be negative, last is `-1`, indexes allowed to be out of bounds */
    get_relaxed(i: number, i2: number): T[]
    set(i: number, v: T): void
    size(): number
    add(...v: T[]): void
    delete_at(i: number): T
    del_at(i: number): T
    delete(op: T | ((v: T, i: number) => boolean)): void
    del(op: T | ((v: T, i: number) => boolean)): void
    find_i(op: T | ((v: T, i: number) => boolean)): number | undefined
    cap(n: number): T[]
    prepend(v: T): void
  }
  interface ArrayConstructor {
    fill<T>(n: number, op: T | ((i: number) => T)): T[]
  }

  interface Function {
    to_safe<Args extends any[], R>(this: ((...args: [...Args]) => R)): ((...args: [...Args]) => Result<R>)
    debounce<F extends (...args: any[]) => void>(this: F, timeout: number, immediate?: boolean): F
    once<F extends Function>(f: F): F
  }

  class Hash<K, V> {
    constructor()
    get(k: K): V
    get_or(k: K, dflt: V | ((k: K) => V)): V
    set(k: K, v: V): void
    del(...keys: K[]): void
    has_key7(k: K): boolean
    keys(): K[]
    values(): V[]
    entries(): [K, V][]
    size(): number
    empty7(): boolean
    to_object(this: Hash<string, V>): Record<string, V>

    [Symbol.iterator](): Iterator<[K, V]>
    filter(op: (v: V, k: K) => boolean): Hash<K, V>
    map<R>(op: (v: V, k: K) => R): Hash<K, R>
    each(op: (v: V, k: K) => void): void
  }

  function H<V>(items: Record<string, V>): Hash<string, V>
  function H<K, V>(...items: [K, V][]): Hash<K, V>

  class HSet<T> implements Enumerable<T> {
    constructor(...items: T[])
    add(v: T): void
    del(v: T): void
    has7(v: T): boolean
    has7(op: (v: T, i: number) => boolean): boolean
    size(): number
    clear(): void
  }
  interface HSet<T> extends Enumerable<T> {}

  interface Assert {
    (cond: boolean, message?: string | (() => string)): void
    equal<T>(a: T, b: T, message?: string | (() => string)): void
    fail(cb: () => void, message?: string | (() => string)): void
    // Approximatelly equal, for real numbers
    aequal(a: number, b: number, message?: string | (() => string), delta_relative?: number): void
    never(v: never): never
  }
  var assert: Assert

  interface PromiseConstructor {
    /** Order of result is the same. Order of execution not specified, could be sequential, parallel or random. */
    map<T, R>(list: T[], op: (v: T) => Promise<R>): Promise<R[]>

    map_parallel<T, R>(list: T[], op: (v: T) => Promise<R>): Promise<R[]>
    map_sequential<T, R>(list: T[], op: (v: T) => Promise<R>): Promise<R[]>
  }
}