Options
All
  • Public
  • Public/Protected
  • All
Menu

@adorkable/eunomia-typescript

Index

Type aliases

Color: number
ColorGradientSharedSize: "closest-side" | "closest-corner" | "farthest-side" | "farthest-corner"
ColorSet: Color[]
RandomFunction: () => number

Type declaration

    • (): number
    • Random function signature

      Returns number

ValueAndDrift: { allowedDrift: number; value: number }

Type declaration

  • allowedDrift: number
  • value: number

Variables

BlackAndWhite: ColorSet = ...
httpInsecure: "http" = "http"
httpSecure: "https" = "https"
randomNoFunctionAvailableError: "No random function available, either provide a function or initialize random globally" = 'No random function available, either provide a function or initialize random globally'

Error message returned when calling random before it has been initialized

webSocketInsecure: "ws" = "ws"
webSocketSecure: "wss" = "wss"

Functions

  • applyRandomDrift(originalValue: number, allowedDrift: number, randomFunction?: RandomFunction): number
  • applyRandomOffset(originalValue: number, offset: number, randomFunction?: RandomFunction): number
  • applyRandomOffsetClamped(originalValue: number, offset: number, minimum: number, maximum: number, method?: ClampMethod, randomFunction?: RandomFunction): number
  • clamp(number: number, minimum: number, maximum: number): number
  • clamp will automatically flip minimum and maximum if minimum is greater than maximum

    Parameters

    • number: number

      number to clamp

    • minimum: number

      minimum value

    • maximum: number

      maximum value

    Returns number

  • colorHexStringToColorType(color: string): number
  • colorTypeToHexString(color: number): string
  • colorTypeWithAlphaToHexString(color: number, alpha: number): string
  • Parameters

    • color: number
    • alpha: number

    Returns string

  • compareArrayContents(left: readonly any[], right: readonly any[]): Promise<boolean>
  • Parameters

    • left: readonly any[]
    • right: readonly any[]

    Returns Promise<boolean>

  • encodeURLParametersFromObject(paramsObject: object): string
  • findValidUnionValue<T, V>(value: V, values: readonly T[]): T
  • Find if an unknown value is within a Typescript safe "union" values array

    throws

    InvalidUnionValueError if value not found

    example

    const sheepNames = ['Capn Frisky', 'Mr. Snugs', 'Lambchop'] as const type SheepName = typeof sheepNames[number] try { const validValue: SheepName = findValidUnionValue(JSON.parse('"Capn Frisky"'), sheepNames) } catch (e) { if (e instanceof InvalidUnionValueException) { console.error(e.message) return } throw e }

    Type parameters

    • T

    • V

    Parameters

    • value: V

      Value to test

    • values: readonly T[]

      "Union" values array

    Returns T

    found value if found

  • flattenMap<ResultType>(items: any): ResultType[]
  • Type parameters

    • ResultType

    Parameters

    • items: any

    Returns ResultType[]

  • getKeyValue(from: any, key: string): any
  • hasValue(test?: any): boolean
  • hashStringToArrayIndex(string: string, array: readonly any[]): number
  • Parameters

    • string: string
    • array: readonly any[]

    Returns number

  • hashStringToArrayValue<ValueType>(string: string, array: readonly ValueType[]): ValueType
  • Type parameters

    • ValueType

    Parameters

    • string: string
    • array: readonly ValueType[]

    Returns ValueType

  • httpString(req?: any): string
  • humanReadableDateTimeFormatter(dateTime: string | Date): string
  • Parameters

    • dateTime: string | Date

    Returns string

  • humanReadableSinceDateTimeFormatter(dateTime: string | Date): string
  • Parameters

    • dateTime: string | Date

    Returns string

  • Initialize module instance-wide random function

    Parameters

    • seed: any

      Random seed

    Returns RandomFunction

    Module instance-wide random function

  • isValidUnionValue<T, V>(value: V, values: readonly T[]): boolean
  • Test if an unknown value is within a Typescript safe "union" values array

    rethrows

    unexpected Errors

    example

    const sheepNames = ['Capn Frisky', 'Mr. Snugs', 'Lambchop'] as const type SheepName = typeof sheepNames[number] if (isValidUnionValue(JSON.parse('"Capn Frisky"'), sheepNames)) { }

    Type parameters

    • T

    • V

    Parameters

    • value: V

      Value to test

    • values: readonly T[]

      "Union" values array

    Returns boolean

    true if value is valid, otherwise false

  • lerp(value: number, from: number, to: number): number
  • Linear interpolate a percent between two values

    Parameters

    • value: number

      amount to interpolate between 0 and 1

    • from: number

      start of range to interpolate

    • to: number

      end of range to interpolate

    Returns number

  • map(value: number, fromStart: number, fromEnd: number, toStart: number, toEnd: number): number
  • Map a value from one range to another

    Parameters

    • value: number

      value to map from original range

    • fromStart: number

      start of original range

    • fromEnd: number

      end of original range

    • toStart: number

      start of range to map to

    • toEnd: number

      end of range to map to

    Returns number

  • mapArrayToIndexMap<ArrayValueType>(items: readonly ArrayValueType[], mapTo?: (value: ArrayValueType, indexKey: string) => ArrayValueType): Promise<Record<string, ArrayValueType>>
  • Type parameters

    • ArrayValueType

    Parameters

    • items: readonly ArrayValueType[]
    • Optional mapTo: (value: ArrayValueType, indexKey: string) => ArrayValueType
        • (value: ArrayValueType, indexKey: string): ArrayValueType
        • Parameters

          • value: ArrayValueType
          • indexKey: string

          Returns ArrayValueType

    Returns Promise<Record<string, ArrayValueType>>

  • mapFilter(items: Object, include: (value: any, key: string) => boolean): Object
  • Parameters

    • items: Object
    • include: (value: any, key: string) => boolean
        • (value: any, key: string): boolean
        • Parameters

          • value: any
          • key: string

          Returns boolean

    Returns Object

  • mapForEach(items: any, forEach: (value: any, key: string) => void): void
  • Parameters

    • items: any
    • forEach: (value: any, key: string) => void
        • (value: any, key: string): void
        • Parameters

          • value: any
          • key: string

          Returns void

    Returns void

  • mapIndexMapToArray<ResultType>(indexMap: any, mapTo?: (value: any, indexKey: string) => ResultType): ResultType[]
  • Type parameters

    • ResultType

    Parameters

    • indexMap: any
    • Optional mapTo: (value: any, indexKey: string) => ResultType
        • (value: any, indexKey: string): ResultType
        • Parameters

          • value: any
          • indexKey: string

          Returns ResultType

    Returns ResultType[]

  • mapMap(items: Object, mapTo: (value: any, key: string) => any): Object
  • Parameters

    • items: Object
    • mapTo: (value: any, key: string) => any
        • (value: any, key: string): any
        • Parameters

          • value: any
          • key: string

          Returns any

    Returns Object

  • mapMapToArray<ResultType>(items: Object, mapTo?: (value: any, key: string) => ResultType): ResultType[]
  • Type parameters

    • ResultType

    Parameters

    • items: Object
    • Optional mapTo: (value: any, key: string) => ResultType
        • (value: any, key: string): ResultType
        • Parameters

          • value: any
          • key: string

          Returns ResultType

    Returns ResultType[]

  • mapReduce<ResultType>(items: Object, reducer: (accumulatedValue: ResultType, currentItem: any, currentKey: string) => ResultType, initialValue: ResultType): ResultType
  • Type parameters

    • ResultType

    Parameters

    • items: Object
    • reducer: (accumulatedValue: ResultType, currentItem: any, currentKey: string) => ResultType
        • (accumulatedValue: ResultType, currentItem: any, currentKey: string): ResultType
        • Parameters

          • accumulatedValue: ResultType
          • currentItem: any
          • currentKey: string

          Returns ResultType

    • initialValue: ResultType

    Returns ResultType

  • mapsEqual<ResultType>(leftItems: any, rightItems: any, isEqual: (leftItem: ResultType, rightItem: ResultType) => boolean): boolean
  • Type parameters

    • ResultType

    Parameters

    • leftItems: any
    • rightItems: any
    • isEqual: (leftItem: ResultType, rightItem: ResultType) => boolean
        • (leftItem: ResultType, rightItem: ResultType): boolean
        • Parameters

          • leftItem: ResultType
          • rightItem: ResultType

          Returns boolean

    Returns boolean

  • mean(values: number[]): number
  • median(values: number[]): number
  • mergeMaps(itemsArray: Object[]): Object
  • Parameters

    • itemsArray: Object[]

    Returns Object

  • mirror(number: number, minimum: number, maximum: number): number
  • Parameters

    • number: number
    • minimum: number
    • maximum: number

    Returns number

  • notEmpty<TValue>(value: undefined | null | TValue): value is TValue
  • Type parameters

    • TValue

    Parameters

    • value: undefined | null | TValue

    Returns value is TValue

  • orderMinMax(minimum: number, maximum: number): [number, number]
  • Parameters

    • minimum: number
    • maximum: number

    Returns [number, number]

  • orderedMinMaxWrapper(perform: (number: number, minimum: number, maximum: number) => number): (number: number, minimum: number, maximum: number) => number
  • Parameters

    • perform: (number: number, minimum: number, maximum: number) => number
        • (number: number, minimum: number, maximum: number): number
        • Parameters

          • number: number
          • minimum: number
          • maximum: number

          Returns number

    Returns (number: number, minimum: number, maximum: number) => number

      • (number: number, minimum: number, maximum: number): number
      • Parameters

        • number: number
        • minimum: number
        • maximum: number

        Returns number

  • parseNumberList(numberList: string, separator?: string | RegExp, radix?: number): number[]
  • Parameters

    • numberList: string
    • separator: string | RegExp = ...
    • radix: number = 10

    Returns number[]

  • parseNumberWithLetterScale(numberString: string): number
  • parseStringList(stringList: string, separator?: string | RegExp): string[]
  • Parameters

    • stringList: string
    • separator: string | RegExp = ...

    Returns string[]

  • parseURLQueryToObject(queryString: string): Object
  • Generate a random number

    throws

    RandomNoFunctionAvailableError if no random function is available

    Parameters

    • Optional randomFunction: RandomFunction

      optionally overridable random function, if void falls back to the module instance-wide random function

    Returns number

    Randomly generated number

  • Generate a random boolean value

    throws

    RandomNoFunctionAvailableError if no random function is available

    Parameters

    • Optional randomFunction: RandomFunction

      optionally overridable random function, if void falls back to the module instance-wide random function

    Returns boolean

    Randomly generated boolean value

  • randomIndexValueInArray(withinArray: readonly any[], randomFunction?: RandomFunction): number
  • Return a random index valid for the provided array

    throws

    RandomNoFunctionAvailableError if no random function is available

    Parameters

    • withinArray: readonly any[]

      Array to return index from

    • Optional randomFunction: RandomFunction

      optionally overridable random function, if void falls back to the module instance-wide random function

    Returns number

    Valid random index

  • randomNumberBetweenValues(minimum: number, maximum: number, randomFunction?: RandomFunction): number
  • randomString(minimumLength?: number, maximumLength?: number, characterSet?: string, randomFunction?: RandomFunction): string
  • Generate a random string

    Parameters

    • Optional minimumLength: number

      minimum length of returned string, defaults to 0

    • Optional maximumLength: number

      maximum length of returned string, defaults to 2^15 (what seems to be a safe value for browsers)

    • Optional characterSet: string

      optional set of characters to select from randomly

    • Optional randomFunction: RandomFunction

      optionally overridable random function, if void falls back to the module instance-wide random function

    Returns string

    Randomly generated string

  • randomValueInArray<TypeOfValue>(withinArray: readonly TypeOfValue[], randomFunction?: RandomFunction): TypeOfValue
  • Return a random value for the provided array

    Type parameters

    • TypeOfValue

    Parameters

    • withinArray: readonly TypeOfValue[]

      Array to return value from

    • Optional randomFunction: RandomFunction

      optionally overridable random function, if void falls back to the module instance-wide random function

    Returns TypeOfValue

    Random value from the provided array

  • separateURLQuery(uri: string): string
  • setKeyValue(to: any, key: string, value: any): void
  • sleep(seconds: number): Promise<unknown>
  • Parameters

    • seconds: number

    Returns Promise<unknown>

  • webSocketString(req?: any): string
  • wrap(number: number, minimum: number, maximum: number): number
  • Parameters

    • number: number
    • minimum: number
    • maximum: number

    Returns number

Generated using TypeDoc