UpSet.js Model - v1.11.0

Index

Type aliases

Variables

SET_JOINERS

Type aliases

ISetCombination

ISetCombination<T>: ISetIntersection<T> | ISetUnion<T> | ISetComposite<T> | IDistinctSetIntersection<T>

union of all set combination types

Type parameters

T = any

ISetCombinations

ISetCombinations<T>: readonly ISetCombination<T>[]

readonly array of set combinations

Type parameters

T = any

ISetLike

ISetLike<T>: ISet<T> | ISetCombination<T>

union of a set or a set combination

Type parameters

T = any

ISetLikes

ISetLikes<T>: readonly ISetLike<T>[]

readonly array of set like objects

Type parameters

T = any

ISets

ISets<T>: readonly ISet<T>[]

readonly array of sets

Type parameters

T = any

NumericScaleTick

NumericScaleTick: { label?: string; value: number }

Type declaration

Optional label?: string
value: number

SetCombinationType

SetCombinationType: "intersection" | "union" | "composite" | "distinctIntersection"

UpSetCompressedIndices

UpSetCompressedIndices: readonly number[] | string

UpSetQueries

UpSetQueries<T>: readonly UpSetQuery<T>[]

Type parameters

T = any

UpSetQuery

UpSetQuery<T>: UpSetElemQuery<T> | UpSetCalcQuery<T> | UpSetSetQuery<T>

Type parameters

T = any

Variables

SET_JOINERS

SET_JOINERS: { composite: string; distinctIntersection: string; intersection: string; union: string } = ...

upsetjs/model

https://github.com/upsetjs/upsetjs

Type declaration

composite: string
distinctIntersection: string
intersection: string
union: string

Functions

asCombination

asCombination<T, S>(set: S, type: SetCombinationType, toSets: (s: S) => ISets<T>): S & ISetCombination<T>

- Defined in data/asCombinations.ts:109
helper to create a proper data structures for UpSet.js sets by adding extra properties

Type parameters
- T
- S: { elems: readonly T[]; name: string }
Parameters
- set: S
- type: SetCombinationType
- toSets: (s: S) => ISets<T>
  - - (s: S): ISets<T>
    - Parameters
      - s: S
      Returns ISets<T>
Returns S & ISetCombination<T>

asCombinations

asCombinations<T, S>(sets: readonly S[], type: SetCombinationType, toSets: (s: S) => ISets<T>): (S & ISetCombination<T>)[]

- Defined in data/asCombinations.ts:132
helper to create a proper data structures for UpSet.js sets by adding extra properties

Type parameters
- T
- S: { elems: readonly T[]; name: string }
Parameters
- sets: readonly S[]
  
  set like structures
- type: SetCombinationType
  
  hint for the type of combinations
- toSets: (s: S) => ISets<T>
  
  resolver of the contained sets
  - - (s: S): ISets<T>
    - Parameters
      - s: S
      Returns ISets<T>
Returns (S & ISetCombination<T>)[]

asSet

asSet<T, S>(set: S): S & ISet<T>

- Defined in data/asSets.ts:15
helper method to create proper UpSet.js structures by adding extra properties

Type parameters
- T
- S: { elems: readonly T[]; name: string }
Parameters
- set: S
  
  the set to complete
Returns S & ISet<T>

asSets

asSets<T, S>(sets: readonly S[], options?: PostprocessSetOptions): (S & ISet<T>)[]

- Defined in data/asSets.ts:78
helper to create a proper data structures for UpSet.js sets by adding extra properties

Type parameters
- T
- S: { elems: readonly T[]; name: string }
Parameters
- sets: readonly S[]
  
  set like structures
- options: PostprocessSetOptions = {}
  
  additional postprocessing options
Returns (S & ISet<T>)[]

Const bandScale

bandScale(domain: string[], size: number, padding: number): BandScaleLike

- Defined in scales/band.ts:17
Parameters
- domain: string[]
- size: number
- padding: number
Returns BandScaleLike

extractCombinations

extractCombinations<T>(elements: readonly T[], acc: (elem: T) => string[], options?: ExtractCombinationsOptions<T>): { combinations: ISetCombinations<T>; sets: ISets<T> }
extractCombinations<T>(elements: readonly T[], options?: ExtractCombinationsOptions<T>): { combinations: ISetCombinations<T>; sets: ISets<T> }

- Defined in data/extractCombinations.ts:71
extract sets out of a given element array, where an accessor is used to specify the set names

Type parameters
- T
Parameters
- elements: readonly T[]
  
  list of elements
- acc: (elem: T) => string[]
  
  accessor to get the list of sets the element belong to
  - - (elem: T): string[]
    - Parameters
      - elem: T
      Returns string[]
- Optional options: ExtractCombinationsOptions<T>
  
  postprocess options
Returns { combinations: ISetCombinations<T>; sets: ISets<T> }
- combinations: ISetCombinations<T>
- sets: ISets<T>
- Defined in data/extractCombinations.ts:82
extract sets out of a given element array which have a .sets property

Type parameters
- T: { sets: string[] }
Parameters
- elements: readonly T[]
- Optional options: ExtractCombinationsOptions<T>
  
  postprocess options
Returns { combinations: ISetCombinations<T>; sets: ISets<T> }
- combinations: ISetCombinations<T>
- sets: ISets<T>

extractFromExpression

extractFromExpression<T>(combinations: readonly T[], accessor: (elem: T) => string[], options?: ExtractFromExpressionOptions): { combinations: readonly (T & ISetCombination<unknown>)[]; sets: ISets<unknown> }
extractFromExpression<T>(combinations: readonly T[], options?: ExtractFromExpressionOptions): { combinations: readonly (T & ISetCombination<unknown>)[]; sets: ISets<unknown> }

- Defined in data/extractFromExpression.ts:35
extract sets and combinations out of a given list of static combination information. In addition an accessor is used to specify the set names

Type parameters
- T: { cardinality: number }
Parameters
- combinations: readonly T[]
  
  list of combinations
- accessor: (elem: T) => string[]
  
  accessor to get the list of sets the combination belong to
  - - (elem: T): string[]
    - Parameters
      - elem: T
      Returns string[]
- Optional options: ExtractFromExpressionOptions
  
  hints about the given combinations
Returns { combinations: readonly (T & ISetCombination<unknown>)[]; sets: ISets<unknown> }
- combinations: readonly (T & ISetCombination<unknown>)[]
- sets: ISets<unknown>
- Defined in data/extractFromExpression.ts:46
extract sets out of a given element array which have a .sets property

Type parameters
- T: { cardinality: number; sets: string[] }
Parameters
- combinations: readonly T[]
- Optional options: ExtractFromExpressionOptions
  
  hints about the given combinations
Returns { combinations: readonly (T & ISetCombination<unknown>)[]; sets: ISets<unknown> }
- combinations: readonly (T & ISetCombination<unknown>)[]
- sets: ISets<unknown>

extractSets

extractSets<T>(elements: readonly T[], acc: (elem: T) => string[], options?: PostprocessSetOptions): ISets<T>
extractSets<T>(elements: readonly T[], options?: PostprocessSetOptions): ISets<T>

- Defined in data/extractSets.ts:17
extract sets out of a given element array, where an accessor is used to specify the set names

Type parameters
- T
Parameters
- elements: readonly T[]
  
  list of elements
- acc: (elem: T) => string[]
  
  accessor to get the list of sets the element belong to
  - - (elem: T): string[]
    - Parameters
      - elem: T
      Returns string[]
- Optional options: PostprocessSetOptions
  
  postprocess options
Returns ISets<T>
- Defined in data/extractSets.ts:28
extract sets out of a given element array which have a .sets property

Type parameters
- T: { sets: string[] }
Parameters
- elements: readonly T[]
- Optional options: PostprocessSetOptions
  
  postprocess options
Returns ISets<T>

fromDump

fromDump<T>(dump: IUpSetDump, elems: readonly T[], options?: IUpSetFromDumpConfig<T>): { combinations: ISetCombinations<T>; queries: ReadonlyArray<UpSetElemQuery<T> | UpSetSetQuery<T>>; selection?: ISetLike<T> | readonly T[]; sets: ISets<T> }

- Defined in dump/dump.ts:19
Type parameters
- T
Parameters
- dump: IUpSetDump
- elems: readonly T[]
- options: IUpSetFromDumpConfig<T> = {}
Returns { combinations: ISetCombinations<T>; queries: ReadonlyArray<UpSetElemQuery<T> | UpSetSetQuery<T>>; selection?: ISetLike<T> | readonly T[]; sets: ISets<T> }
- combinations: ISetCombinations<T>
- queries: ReadonlyArray<UpSetElemQuery<T> | UpSetSetQuery<T>>
- Optional selection?: ISetLike<T> | readonly T[]
- sets: ISets<T>

fromIndicesArray

fromIndicesArray<T>(indices: string | readonly number[], elements: readonly T[]): readonly T[]

- Defined in array.ts:88
reverse operation of toIndicesArray by supporting compressed indices notation

Type parameters
- T
Parameters
- indices: string | readonly number[]
  
  the (compressed) indices
- elements: readonly T[]
  
  the elements to refer by index
Returns readonly T[]

fromSetName

fromSetName<T>(sets: ISets<T>, symbol?: RegExp): (s: { name: string }) => ISet<T>[]

- Defined in data/asCombinations.ts:17
helper method to extract the sets in a set combination from its name, e.g. S1&S2 => S1,S2

Type parameters
- T
Parameters
- sets: ISets<T>
  
  the list of possible sets
- symbol: RegExp = ...
  
  the regex to split a name
Returns (s: { name: string }) => ISet<T>[]
- - (s: { name: string }): ISet<T>[]
  - Parameters
    - s: { name: string }
      - name: string
    Returns ISet<T>[]

fromStaticDump

fromStaticDump(dump: IUpSetStaticDump, config?: IUpSetFromStaticDumpConfig<never>): { combinations: ISetCombinations<never>; queries: ReadonlyArray<UpSetCalcQuery<never> | UpSetSetQuery<never>>; selection?: ISetLike<never> | ((v: ISetLike<never>) => number); sets: ISets<never> }

- Defined in dump/staticDump.ts:202
Parameters
- dump: IUpSetStaticDump
- config: IUpSetFromStaticDumpConfig<never> = {}
Returns { combinations: ISetCombinations<never>; queries: ReadonlyArray<UpSetCalcQuery<never> | UpSetSetQuery<never>>; selection?: ISetLike<never> | ((v: ISetLike<never>) => number); sets: ISets<never> }
- combinations: ISetCombinations<never>
- queries: ReadonlyArray<UpSetCalcQuery<never> | UpSetSetQuery<never>>
- Optional selection?: ISetLike<never> | ((v: ISetLike<never>) => number)
- sets: ISets<never>

generateCombinations

generateCombinations<T>(sets: ISets<T>, options?: GenerateSetCombinationsOptions<T>): ISetCombinations<T>

- Defined in data/generateCombinations.ts:218
generate set intersection/unions for a given list of sets

Type parameters
- T = any
Parameters
- sets: ISets<T>
  
  the sets with their elements
- options: GenerateSetCombinationsOptions<T> = {}
  
  additional customization options
Returns ISetCombinations<T>

generateDistinctOverlapFunction

generateDistinctOverlapFunction<T>(combinations: ISetCombinations<T>, fallback: ISetOverlapFunction<T>, toKey?: (s: ISetLike<T>) => string): ISetOverlapFunction<T>

- Defined in data/generateOverlapFunction.ts:118
Type parameters
- T
Parameters
- combinations: ISetCombinations<T>
- fallback: ISetOverlapFunction<T>
- toKey: (s: ISetLike<T>) => string = toDefaultKey
  - - (s: ISetLike<T>): string
    - Parameters
      - s: ISetLike<T>
      Returns string
Returns ISetOverlapFunction<T>

generateIntersectionOverlapFunction

generateIntersectionOverlapFunction<T>(combinations: ISetCombinations<T>, fallback: ISetOverlapFunction<T>, toKey?: (s: ISetLike<T>) => string): ISetOverlapFunction<T>

- Defined in data/generateOverlapFunction.ts:165
Type parameters
- T
Parameters
- combinations: ISetCombinations<T>
- fallback: ISetOverlapFunction<T>
- toKey: (s: ISetLike<T>) => string = toDefaultKey
  - - (s: ISetLike<T>): string
    - Parameters
      - s: ISetLike<T>
      Returns string
Returns ISetOverlapFunction<T>

generateOverlapFunction

generateOverlapFunction<T>(combinations: ISetCombinations<T>, fallback: ISetOverlapFunction<T>, toKey?: (s: ISetLike<T>) => string): ISetOverlapFunction<T>

- Defined in data/generateOverlapFunction.ts:223
Type parameters
- T
Parameters
- combinations: ISetCombinations<T>
- fallback: ISetOverlapFunction<T>
- toKey: (s: ISetLike<T>) => string = toDefaultKey
  - - (s: ISetLike<T>): string
    - Parameters
      - s: ISetLike<T>
      Returns string
Returns ISetOverlapFunction<T>

generateOverlapLookup

generateOverlapLookup<T>(sets: ISets<T>, combinations: ISetCombinations<T>, options?: GenerateOverlapLookupOptions<T>): readonly readonly number[][] | string

- Defined in data/generateOverlapLookup.ts:105
generate a (compressed) overlap lookup matrix that can be dumped and later used to lookup overlaps

Type parameters
- T
Parameters
- sets: ISets<T>
  
  the sets of the plot
- combinations: ISetCombinations<T>
  
  the set combinations of the plot
- options: GenerateOverlapLookupOptions<T> = {}
  
  additional options
Returns readonly readonly number[][] | string

generateOverlapLookupFunction

generateOverlapLookupFunction<T>(matrix: string | readonly readonly number[][], sets: ISets<T>, combinations: ISetCombinations<T>, toKey?: (v: ISetLike<T>) => string): { combinationIndex: Map<string, number>; compute: ISetOverlapFunction<T>; setIndex: Map<string, number> }

- Defined in data/generateOverlapLookup.ts:155
uses the given overlap lookup function to generate a compute and indices functions

Type parameters
- T
Parameters
- matrix: string | readonly readonly number[][]
  
  the compressed overlap matrix
- sets: ISets<T>
  
  the sets of the plot
- combinations: ISetCombinations<T>
  
  the set combinations of the plot
- toKey: (v: ISetLike<T>) => string = toKeyImpl
  - - (v: ISetLike<T>): string
    - Parameters
      - v: ISetLike<T>
      Returns string
Returns { combinationIndex: Map<string, number>; compute: ISetOverlapFunction<T>; setIndex: Map<string, number> }
- combinationIndex: Map<string, number>
- compute: ISetOverlapFunction<T>
- setIndex: Map<string, number>

generateUnionOverlapFunction

generateUnionOverlapFunction<T>(combinations: ISetCombinations<T>, fallback: ISetOverlapFunction<T>, toKey?: (s: ISetLike<T>) => string): ISetOverlapFunction<T>

- Defined in data/generateOverlapFunction.ts:194
Type parameters
- T
Parameters
- combinations: ISetCombinations<T>
- fallback: ISetOverlapFunction<T>
- toKey: (s: ISetLike<T>) => string = toDefaultKey
  - - (s: ISetLike<T>): string
    - Parameters
      - s: ISetLike<T>
      Returns string
Returns ISetOverlapFunction<T>

isCalcQuery

isCalcQuery<T>(q: UpSetQuery<T>): q is UpSetCalcQuery<T>

- Defined in queries.ts:71
Type parameters
- T
Parameters
- q: UpSetQuery<T>
Returns q is UpSetCalcQuery<T>

isElemQuery

isElemQuery<T>(q: UpSetQuery<T>): q is UpSetElemQuery<T>

- Defined in queries.ts:67
Type parameters
- T
Parameters
- q: UpSetQuery<T>
Returns q is UpSetElemQuery<T>

isGenerateSetCombinationOptions

isGenerateSetCombinationOptions(v: any): v is GenerateSetCombinationsOptions<any>

- Defined in validators.ts:35
Parameters
- v: any
Returns v is GenerateSetCombinationsOptions<any>

isSet

isSet(v: any): v is ISet<any>

- Defined in validators.ts:17
Parameters
- v: any
Returns v is ISet<any>

isSetCombination

isSetCombination(v: any): v is ISetCombination<any>

- Defined in validators.ts:21
Parameters
- v: any
Returns v is ISetCombination<any>

isSetLike

isSetLike(v: any): v is ISetLike<any>

- Defined in validators.ts:31
Parameters
- v: any
Returns v is ISetLike<any>

isSetQuery

isSetQuery<T>(q: UpSetQuery<T>): q is UpSetSetQuery<T>

- Defined in queries.ts:75
Type parameters
- T
Parameters
- q: UpSetQuery<T>
Returns q is UpSetSetQuery<T>

isUpSetQuery

isUpSetQuery(v: any): v is UpSetQuery<any>

- Defined in validators.ts:40
Parameters
- v: any
Returns v is UpSetQuery<any>

Const linearScale

linearScale(max: number, range: [number, number], options: TickOptions): NumericScaleLike

- Defined in scales/linear.ts:62
Parameters
- max: number
- range: [number, number]
- options: TickOptions
Returns NumericScaleLike

Const logScale

logScale(max: number, range: [number, number], options: TickOptions): NumericScaleLike

- Defined in scales/log.ts:65
Parameters
- max: number
- range: [number, number]
- options: TickOptions
Returns NumericScaleLike

mergeColors

mergeColors(colors: readonly (undefined | string)[]): string | undefined

- Defined in colors.ts:16
Parameters
- colors: readonly (undefined | string)[]
Returns string | undefined

parseColor

parseColor(color?: string): [number, number, number]

- Defined in colors.ts:1
Parameters
- Optional color: string
Returns [number, number, number]

queryElemOverlap

queryElemOverlap<T>(query: UpSetQuery<T>, what: keyof SetElemOverlap<T>, toElemKey?: (e: T) => string): (s: ISetLike<T>) => readonly T[] | null

- Defined in queries.ts:110
helper method to create an overlap function of elements for a given query

Type parameters
- T
Parameters
- query: UpSetQuery<T>
  
  the query
- what: keyof SetElemOverlap<T>
  
  type of overlap
- Optional toElemKey: (e: T) => string
  
  optional key function
  - - (e: T): string
    - Parameters
      - e: T
      Returns string
Returns (s: ISetLike<T>) => readonly T[] | null
- - (s: ISetLike<T>): readonly T[] | null
  - helper method to create an overlap function of elements for a given query
    
    Parameters
    - s: ISetLike<T>
    Returns readonly T[] | null

queryOverlap

queryOverlap<T>(query: UpSetQuery<T>, what: keyof SetOverlap, toElemKey?: (e: T) => string): (s: ISetLike<T> | readonly T[]) => number

- Defined in queries.ts:85
helper method to create an overlap function for a given query

Type parameters
- T
Parameters
- query: UpSetQuery<T>
  
  the query
- what: keyof SetOverlap
  
  type of overlap
- Optional toElemKey: (e: T) => string
  
  optional key function
  - - (e: T): string
    - Parameters
      - e: T
      Returns string
Returns (s: ISetLike<T> | readonly T[]) => number
- - (s: ISetLike<T> | readonly T[]): number
  - computes the overlap of the given set to this query
    
    Parameters
    - s: ISetLike<T> | readonly T[]
      
      the current set to evaluate
    Returns number
    at most s.cardinality

setElemIntersectionFactory

setElemIntersectionFactory<T>(a: Set<T> | readonly T[], toElemKey?: (e: T) => string): (b: Set<T> | readonly T[]) => readonly T[]

- Defined in data/setOverlap.ts:130
Type parameters
- T
Parameters
- a: Set<T> | readonly T[]
- Optional toElemKey: (e: T) => string
  - - (e: T): string
    - Parameters
      - e: T
      Returns string
Returns (b: Set<T> | readonly T[]) => readonly T[]
- - (b: Set<T> | readonly T[]): readonly T[]
  - Parameters
    - b: Set<T> | readonly T[]
    Returns readonly T[]

setElemOverlap

setElemOverlap<T>(a: Set<T> | readonly T[], b: Set<T> | readonly T[], toElemKey?: (e: T) => string): SetElemOverlap<T>

- Defined in data/setOverlap.ts:118
Type parameters
- T
Parameters
- a: Set<T> | readonly T[]
- b: Set<T> | readonly T[]
- Optional toElemKey: (e: T) => string
  - - (e: T): string
    - Parameters
      - e: T
      Returns string
Returns SetElemOverlap<T>

setElemOverlapFactory

setElemOverlapFactory<T>(a: Set<T> | readonly T[], toElemKey?: (e: T) => string): (b: Set<T> | readonly T[]) => SetElemOverlap<T>

- Defined in data/setOverlap.ts:82
Type parameters
- T
Parameters
- a: Set<T> | readonly T[]
- Optional toElemKey: (e: T) => string
  - - (e: T): string
    - Parameters
      - e: T
      Returns string
Returns (b: Set<T> | readonly T[]) => SetElemOverlap<T>
- - (b: Set<T> | readonly T[]): SetElemOverlap<T>
  - Parameters
    - b: Set<T> | readonly T[]
    Returns SetElemOverlap<T>

setOverlap

setOverlap<T>(a: Set<T> | readonly T[], b: Set<T> | readonly T[], toElemKey?: (e: T) => string): SetOverlap

- Defined in data/setOverlap.ts:66
Type parameters
- T
Parameters
- a: Set<T> | readonly T[]
- b: Set<T> | readonly T[]
- Optional toElemKey: (e: T) => string
  - - (e: T): string
    - Parameters
      - e: T
      Returns string
Returns SetOverlap

setOverlapFactory

setOverlapFactory<T>(a: Set<T> | readonly T[], toElemKey?: (e: T) => string): (b: Set<T> | readonly T[]) => SetOverlap

- Defined in data/setOverlap.ts:32
Type parameters
- T
Parameters
- a: Set<T> | readonly T[]
- Optional toElemKey: (e: T) => string
  - - (e: T): string
    - Parameters
      - e: T
      Returns string
Returns (b: Set<T> | readonly T[]) => SetOverlap
- - (b: Set<T> | readonly T[]): SetOverlap
  - Parameters
    - b: Set<T> | readonly T[]
    Returns SetOverlap

toDump

toDump<T>(data: IUpSetDumpData<T>, config?: IUpSetToDumpConfig<T>): IUpSetDump

- Defined in dump/dump.ts:107
Type parameters
- T
Parameters
- data: IUpSetDumpData<T>
- config: IUpSetToDumpConfig<T> = {}
Returns IUpSetDump

toIndicesArray

toIndicesArray<T>(arr: readonly T[], toIndex: (v: T) => number, __namedParameters?: { compress?: "no" | "yes" | "auto"; sortAble?: boolean }): string | readonly number[]

- Defined in array.ts:51
creates an (compressed) indices array for the given array of elements

Type parameters
- T
Parameters
- arr: readonly T[]
  
  the array to compress
- toIndex: (v: T) => number
  
  the element to index function
  - - (v: T): number
    - Parameters
      - v: T
      Returns number
- __namedParameters: { compress?: "no" | "yes" | "auto"; sortAble?: boolean } = {}
  - Optional compress?: "no" | "yes" | "auto"
  - Optional sortAble?: boolean
Returns string | readonly number[]

toKey

toKey(s: ISetLike<any>): string

- Defined in model.ts:110
helper method to generate a key for a given set

Parameters
- s: ISetLike<any>
  
  the set to compute the key for
Returns string

toStaticDump

toStaticDump<T>(data: IUpSetStaticDumpData<T>, config?: IUpSetToStaticDumpConfig<T>): IUpSetStaticDump

- Defined in dump/staticDump.ts:71
Type parameters
- T
Parameters
- data: IUpSetStaticDumpData<T>
- config: IUpSetToStaticDumpConfig<T> = {}
Returns IUpSetStaticDump

Index

Interfaces

Type aliases

Variables

Functions

Type aliases

ISetCombination

Type parameters

T = any

ISetCombinations

Type parameters

T = any

ISetLike

Type parameters

T = any

ISetLikes

Type parameters

T = any

ISets

Type parameters

T = any

NumericScaleTick

Type declaration

Optional label?: string

value: number

SetCombinationType

UpSetCompressedIndices

UpSetQueries

Type parameters

T = any

UpSetQuery

Type parameters

T = any

Variables

SET_JOINERS

Type declaration

composite: string

distinctIntersection: string

intersection: string

union: string

Functions

asCombination

Type parameters

T

S: { elems: readonly T[]; name: string }

Parameters

set: S

type: SetCombinationType

toSets: (s: S) => ISets<T>

Parameters

s: S

Returns ISets<T>

Returns S & ISetCombination<T>

asCombinations

Type parameters

T

S: { elems: readonly T[]; name: string }

Parameters

sets: readonly S[]

type: SetCombinationType

toSets: (s: S) => ISets<T>

Parameters

s: S

Returns ISets<T>

Returns (S & ISetCombination<T>)[]

asSet

Type parameters

T

S: { elems: readonly T[]; name: string }

Parameters

set: S

Returns S & ISet<T>

asSets

Type parameters

T

S: { elems: readonly T[]; name: string }

Parameters

sets: readonly S[]

options: PostprocessSetOptions = {}

Returns (S & ISet<T>)[]