Class Tag

Hierarchy (View Summary)

Constructors

constructor

Properties

append concat count drop every exists filter find first flatMap forEach has join keep last map mapTo nth prepend reject set slice some take uniq valueOf without xs

Methods

clone entry isAddress key setKey setValue value create from fromAddress fromId fromIdentifier fromPubkey fromTopic

Constructors

constructor

  • new Tag(...args: [xs: string[]]): Tag

  • Parameters

    • ...args: [xs: string[]]

    Returns Tag

Properties

append

append: (x: string) => this

concat

concat: (xs: string[]) => this

count

count: () => number

drop

drop: (n: number) => this

every

every: (f: (t: string) => boolean) => boolean

exists

exists: () => boolean

filter

filter: (f: (t: string) => boolean) => this

find

find: (f: (t: string) => boolean) => undefined | string

first

first: () => string

flatMap

flatMap: <U>(f: (t: string) => U[]) => Fluent<U>

forEach

forEach: (f: (t: string, i: number) => void) => void

has

has: (v: string) => boolean

join

join: (s: string) => string

keep

keep: (xs: string[]) => this

last

last: () => string

map

map: (f: (t: string) => string) => this

mapTo

mapTo: <U>(f: (t: string) => U) => Fluent<U>

nth

nth: (i: number) => string

prepend

prepend: (x: string) => this

reject

reject: (f: (t: string) => boolean) => this

set

set: (i: number, x: string) => this

slice

slice: (a: number, b?: number) => this

some

some: (f: (t: string) => boolean) => boolean

take

take: (n: number) => this

uniq

uniq: () => this

valueOf

valueOf: () => string[]

without

without: (xs: string[]) => this

Readonlyxs

xs: string[]

Methods

clone

  • clone<K extends Fluent<string>>(this: K, xs: string[]): K

  • Type Parameters

    Parameters

    • this: K
    • xs: string[]

    Returns K

entry

isAddress

key

setKey

setValue

value

Staticcreate

Staticfrom

StaticfromAddress

StaticfromId

StaticfromIdentifier

StaticfromPubkey

StaticfromTopic

Settings

Member Visibility

On This Page

Constructors
Properties
Methods