UpSet.js Bundle

Index

Namespaces

propValidators

Interfaces

Variables

SET_JOINERS

Functions

Type aliases

ICategories

ICategories: readonly ICategory[]

ICategoryBins

ICategoryBins: readonly ICategoryBin[]

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

KarnaughMapFullProps

KarnaughMapFullProps<T>: KarnaughMapFullPropsG<T, CSSStyleDeclaration, UpSetReactElement, string>

Type parameters

T = any

KarnaughMapProps

KarnaughMapProps<T>: KarnaughMapPropsG<T, CSSStyleDeclaration, UpSetReactElement, string>

Type parameters

T = any

NumericScaleTick

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

Type declaration

Optional label?: string
value: number

QuantilesMethod

SetCombinationType

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

UpSetAddon

UpSetAddon<T>: UpSetAddonImpl<ISetLike<T>, T, UpSetReactElement>

Type parameters

UpSetAddonHandlerInfos

UpSetAddonHandlerInfos: readonly (UpSetAddonHandlerInfo | null)[]

UpSetAddons

UpSetAddons<T>: readonly UpSetAddon<T>[]

Type parameters

UpSetCompressedIndices

UpSetCompressedIndices: readonly number[] | string

UpSetFullProps

UpSetFullProps<T>: UpSetFullPropsG<T, CSSStyleDeclaration, UpSetReactElement, string>

Type parameters

T = any

UpSetProps

UpSetProps<T>: UpSetPropsG<T, CSSStyleDeclaration, UpSetReactElement, string>

Type parameters

T = any

UpSetQueries

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

Type parameters

T = any

UpSetQuery

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

Type parameters

T = any

UpSetReactElement

UpSetReactElement: any

UpSetReactElementComponentChild

UpSetReactElementComponentChildren

UpSetReactElementComponentChildren: UpSetReactElementComponentChild[] | UpSetReactElementComponentChild

UpSetStyleClassNames

UpSetStyleClassNames: UpSetMultiStyle<string>

UpSetThemes

UpSetThemes: "light" | "dark" | "vega"

VennDiagramFullProps

VennDiagramFullProps<T>: VennDiagramFullPropsG<T, CSSStyleDeclaration, UpSetReactElement, string>

Type parameters

T = any

VennDiagramProps

VennDiagramProps<T>: VennDiagramPropsG<T, CSSStyleDeclaration, UpSetReactElement, string>

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 packages/model/dist/index.d.ts:170
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 packages/model/dist/index.d.ts:180
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 packages/model/dist/index.d.ts:115
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 packages/model/dist/index.d.ts:138
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
- Optional options: PostprocessSetOptions
  
  additional postprocessing options
Returns (S & ISet<T>)[]

Const bandScale

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

- Defined in packages/model/dist/index.d.ts:526
Parameters
- domain: string[]
- size: number
- padding: number
Returns BandScaleLike

boxplot

boxplot(data: readonly number[] | Float32Array | Float64Array, options?: BoxplotStatsOptions): _sgratzl_boxplots.IBoxPlot

- Defined in packages/math/dist/index.d.ts:43
Parameters
- data: readonly number[] | Float32Array | Float64Array
- Optional options: BoxplotStatsOptions
Returns _sgratzl_boxplots.IBoxPlot

boxplotAddon

boxplotAddon<T>(prop: keyof T | ((v: T) => number), elems: readonly T[] | { max: number; min: number }, options?: Partial<Pick<UpSetAddon<T>, "size" | "position" | "name">> & IBoxplotStyleProps): UpSetAddon<T>

- Defined in packages/bundle/src/addons/boxplot.ts:39
generates a boxplot addon to render box plots as UpSet.js addon for aggregated set data

Type parameters
- T
Parameters
- prop: keyof T | ((v: T) => number)
  
  accessor or name of the property within the element
- elems: readonly T[] | { max: number; min: number }
  
  list of elements or their minimum / maximum value for specifying the data domain
- options: Partial<Pick<UpSetAddon<T>, "size" | "position" | "name">> & IBoxplotStyleProps = {}
  
  additional options
Returns UpSetAddon<T>

boxplotAggregatedAddon

boxplotAggregatedAddon<T>(acc: (v: readonly T[]) => IBoxPlot, domain: { max: number; min: number }, options?: Partial<Pick<UpSetAddon<T>, "size" | "position" | "name">> & IBoxplotStyleProps): UpSetAddon<T>

- Defined in packages/bundle/src/addons/boxplot.ts:58
generates a boxplot addon to render box plots as UpSet.js addon for aggregated set data

Type parameters
- T
Parameters
- acc: (v: readonly T[]) => IBoxPlot
  
  accessor
  - - (v: readonly T[]): IBoxPlot
    - Parameters
      - v: readonly T[]
      Returns IBoxPlot
- domain: { max: number; min: number }
  - max: number
  - min: number
- options: Partial<Pick<UpSetAddon<T>, "size" | "position" | "name">> & IBoxplotStyleProps = {}
  
  additional options
Returns UpSetAddon<T>

categoricalAddon

categoricalAddon<T>(prop: keyof T | ((v: T) => string), elems: readonly T[] | { categories: readonly (string | ICategory)[] }, options?: Partial<Pick<UpSetAddon<T>, "size" | "position" | "name">> & ICategoricalStyleProps): UpSetAddon<T>

- Defined in packages/bundle/src/addons/categorical.ts:26
generates a categorical addon to render categorical distribution as UpSet.js addon for aggregated set data

Type parameters
- T
Parameters
- prop: keyof T | ((v: T) => string)
  
  accessor or name of the property within the element
- elems: readonly T[] | { categories: readonly (string | ICategory)[] }
  
  list of elements or their minimum / maximum value for specifying the data domain
- options: Partial<Pick<UpSetAddon<T>, "size" | "position" | "name">> & ICategoricalStyleProps = {}
  
  additional options
Returns UpSetAddon<T>

categoricalAggregatedAddon

categoricalAggregatedAddon<T>(acc: (v: readonly T[]) => ICategoryBins, options?: Partial<Pick<UpSetAddon<T>, "size" | "position" | "name">> & ICategoricalStyleProps): UpSetAddon<T>

- Defined in packages/bundle/src/addons/categorical.ts:40
generates a categorical addon to render categorical distribution as UpSet.js addon for aggregated set data

Type parameters
- T
Parameters
- acc: (v: readonly T[]) => ICategoryBins
  - - (v: readonly T[]): ICategoryBins
    - Parameters
      - v: readonly T[]
      Returns ICategoryBins
- options: Partial<Pick<UpSetAddon<T>, "size" | "position" | "name">> & ICategoricalStyleProps = {}
  
  additional options
Returns UpSetAddon<T>

categoricalHistogram

categoricalHistogram(values: readonly string[], categories: readonly (string | ICategory)[], base?: readonly string[], dark?: boolean): readonly ICategoryBin[]

- Defined in packages/math/dist/index.d.ts:77
Parameters
- values: readonly string[]
- categories: readonly (string | ICategory)[]
- Optional base: readonly string[]
- Optional dark: boolean
Returns readonly ICategoryBin[]

createElement

createElement(type: string, props: null | Record<string, any>, ...children: any[]): UpSetReactElement

- Defined in packages/bundle/src/index.ts:296
Parameters
- type: string
- props: null | Record<string, any>
- Rest ...children: any[]
Returns UpSetReactElement

createVennJSAdapter

createVennJSAdapter<O>(layout: IVennJSLayoutFunction<O>, options?: O): IVennDiagramLayoutGenerator

- Defined in .yarn/__virtual__/@upsetjs-react-virtual-06be4ef03d/1/packages/react/dist/index.d.ts:912
Type parameters
- O: { height?: number; width?: number }
Parameters
- layout: IVennJSLayoutFunction<O>
- Optional options: O
Returns IVennDiagramLayoutGenerator

downloadUrl

downloadUrl(url: string, title: string, doc: Document): void

- Defined in packages/bundle/src/index.ts:262
helper method to download a given url in the browser

Parameters
- url: string
  
  the url to download
- title: string
  
  the desired file name
- doc: Document
  
  the root document
Returns void

exportSVG

exportSVG(node: SVGSVGElement, options: { title?: string; toRemove?: string; type?: "png" | "svg" }): Promise<void>

- Defined in packages/bundle/src/index.ts:249
helper method to export an download an SVG image

Parameters
- node: SVGSVGElement
  
  the SVG element to download
- options: { title?: string; toRemove?: string; type?: "png" | "svg" }
  
  additional options
  - Optional title?: string
  - Optional toRemove?: string
  - Optional type?: "png" | "svg"
Returns Promise<void>

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 packages/model/dist/index.d.ts:305
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 packages/model/dist/index.d.ts:314
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 packages/model/dist/index.d.ts:264
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 packages/model/dist/index.d.ts:275
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 packages/model/dist/index.d.ts:334
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 packages/model/dist/index.d.ts:340
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>

fillDefaults

fillDefaults<T>(props: UpSetProps<T>): UpSetFullProps<T>

- Defined in packages/bundle/src/index.ts:89
helper methods to fill up partial UpSet.js properties with their default values

Type parameters
- T = any
Parameters
- props: UpSetProps<T>
Returns UpSetFullProps<T>

fillKarnaughMapDefaults

fillKarnaughMapDefaults<T>(props: KarnaughMapProps<T>): KarnaughMapFullProps<T>

- Defined in packages/bundle/src/index.ts:104
helper methods to fill up partial UpSet.js properties with their default values

Type parameters
- T = any
Parameters
- props: KarnaughMapProps<T>
Returns KarnaughMapFullProps<T>

fillVennDiagramDefaults

fillVennDiagramDefaults<T>(props: VennDiagramProps<T>): VennDiagramFullProps<T>

- Defined in packages/bundle/src/index.ts:97
helper methods to fill up partial UpSet.js properties with their default values

Type parameters
- T = any
Parameters
- props: VennDiagramProps<T>
Returns VennDiagramFullProps<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 packages/model/dist/index.d.ts:600
Type parameters
- T
Parameters
- dump: IUpSetDump
- elems: readonly T[]
- Optional 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 packages/model/dist/index.d.ts:583
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 packages/model/dist/index.d.ts:148
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
- Optional symbol: RegExp
  
  the regex to split a name
Returns (s: { name: string }) => ISet<T>[]
- - (s: { name: string }): ISet<T>[]
  - helper method to extract the sets in a set combination from its name, e.g. S1&S2 => S1,S2
    
    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 packages/model/dist/index.d.ts:701
Parameters
- dump: IUpSetStaticDump
- Optional 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 packages/model/dist/index.d.ts:237
generate set intersection/unions for a given list of sets

Type parameters
- T = any
Parameters
- sets: ISets<T>
  
  the sets with their elements
- Optional 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 packages/model/dist/index.d.ts:379
upsetjs/model
https://github.com/upsetjs/upsetjs

Copyright (c) 2021 Samuel Gratzl sam@sgratzl.com

Type parameters
- T
Parameters
- combinations: ISetCombinations<T>
- fallback: ISetOverlapFunction<T>
- Optional toKey: (s: ISetLike<T>) => string
  - - (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 packages/model/dist/index.d.ts:380
Type parameters
- T
Parameters
- combinations: ISetCombinations<T>
- fallback: ISetOverlapFunction<T>
- Optional toKey: (s: ISetLike<T>) => string
  - - (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 packages/model/dist/index.d.ts:382
Type parameters
- T
Parameters
- combinations: ISetCombinations<T>
- fallback: ISetOverlapFunction<T>
- Optional toKey: (s: ISetLike<T>) => string
  - - (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 packages/model/dist/index.d.ts:402
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
- Optional 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 packages/model/dist/index.d.ts:410
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
- Optional toKey: (v: ISetLike<T>) => string
  - - (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 packages/model/dist/index.d.ts:381
Type parameters
- T
Parameters
- combinations: ISetCombinations<T>
- fallback: ISetOverlapFunction<T>
- Optional toKey: (s: ISetLike<T>) => string
  - - (s: ISetLike<T>): string
    - Parameters
      - s: ISetLike<T>
      Returns string
Returns ISetOverlapFunction<T>

getDefaultTheme

getDefaultTheme(theme?: UpSetThemes): Readonly<Required<UpSetThemeProps & VennDiagramThemeProps & UpSetExtraTheme>>

- Defined in .yarn/__virtual__/@upsetjs-react-virtual-06be4ef03d/1/packages/react/dist/index.d.ts:765
Parameters
- Optional theme: UpSetThemes
Returns Readonly<Required<UpSetThemeProps & VennDiagramThemeProps & UpSetExtraTheme>>

hydrate

hydrate<T>(node: HTMLElement, props: UpSetProps<T>): void

- Defined in packages/bundle/src/index.ts:183
hydrates the UpSetJS component when applied on a server rendered version

Type parameters
- T = any
Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetProps<T>
  
  the properties of the component
Returns void

hydrateKarnaughMap

hydrateKarnaughMap<T>(node: HTMLElement, props: KarnaughMapProps<T>): void

- Defined in packages/bundle/src/index.ts:202
hydrates the KarnaughMap component when applied on a server rendered version

Type parameters
- T = any
Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: KarnaughMapProps<T>
  
  the properties of the component
Returns void

hydrateKarnaughMapSkeleton

hydrateKarnaughMapSkeleton(node: HTMLElement, props: UpSetJSSkeletonProps): void

- Defined in packages/bundle/src/index.ts:232
hydrates the KarnaughMap Skeleton component when applied on a server rendered version

Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetJSSkeletonProps
  
  the properties of the component
Returns void

hydrateSkeleton

hydrateSkeleton(node: HTMLElement, props: UpSetJSSkeletonProps): void

- Defined in packages/bundle/src/index.ts:212
hydrates the UpSetJS Skeleton component when applied on a server rendered version

Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetJSSkeletonProps
  
  the properties of the component
Returns void

Const hydrateUpSet

hydrateUpSet<T>(node: HTMLElement, props: UpSetProps<T>): void

- Defined in packages/bundle/src/index.ts:242
hydrates the UpSetJS component when applied on a server rendered version

Type parameters
- T = any
Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetProps<T>
  
  the properties of the component
Returns void

hydrateVennDiagram

hydrateVennDiagram<T>(node: HTMLElement, props: VennDiagramProps<T>): void

- Defined in packages/bundle/src/index.ts:193
hydrates the VennDiagram component when applied on a server rendered version

Type parameters
- T = any
Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: VennDiagramProps<T>
  
  the properties of the component
Returns void

hydrateVennDiagramSkeleton

hydrateVennDiagramSkeleton(node: HTMLElement, props: UpSetJSSkeletonProps): void

- Defined in packages/bundle/src/index.ts:222
hydrates the VennDiagram Skeleton component when applied on a server rendered version

Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetJSSkeletonProps
  
  the properties of the component
Returns void

isCalcQuery

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

- Defined in packages/model/dist/index.d.ts:483
Type parameters
- T
Parameters
- q: UpSetQuery<T>
Returns q is UpSetCalcQuery<T>

isElemQuery

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

- Defined in packages/model/dist/index.d.ts:482
Type parameters
- T
Parameters
- q: UpSetQuery<T>
Returns q is UpSetElemQuery<T>

isGenerateSetCombinationOptions

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

- Defined in packages/model/dist/index.d.ts:510
Parameters
- v: any
Returns v is GenerateSetCombinationsOptions<any>

isSet

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

- Defined in packages/model/dist/index.d.ts:507
upsetjs/model
https://github.com/upsetjs/upsetjs

Copyright (c) 2021 Samuel Gratzl sam@sgratzl.com

Parameters
- v: any
Returns v is ISet<any>

isSetCombination

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

- Defined in packages/model/dist/index.d.ts:508
Parameters
- v: any
Returns v is ISetCombination<any>

isSetLike

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

- Defined in packages/model/dist/index.d.ts:509
Parameters
- v: any
Returns v is ISetLike<any>

isSetQuery

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

- Defined in packages/model/dist/index.d.ts:484
Type parameters
- T
Parameters
- q: UpSetQuery<T>
Returns q is UpSetSetQuery<T>

isUpSetQuery

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

- Defined in packages/model/dist/index.d.ts:511
Parameters
- v: any
Returns v is UpSetQuery<any>

Const linearScale

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

- Defined in packages/model/dist/index.d.ts:558
upsetjs/model
https://github.com/upsetjs/upsetjs

Copyright (c) 2021 Samuel Gratzl sam@sgratzl.com

Parameters
- max: number
- range: [number, number]
- options: TickOptions
Returns NumericScaleLike

Const logScale

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

- Defined in packages/model/dist/index.d.ts:567
upsetjs/model
https://github.com/upsetjs/upsetjs

Copyright (c) 2021 Samuel Gratzl sam@sgratzl.com

Parameters
- max: number
- range: [number, number]
- options: TickOptions
Returns NumericScaleLike

mergeColors

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

- Defined in packages/model/dist/index.d.ts:709
Parameters
- colors: readonly (undefined | string)[]
Returns string | undefined

parseColor

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

- Defined in packages/model/dist/index.d.ts:708
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 packages/model/dist/index.d.ts:498
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 packages/model/dist/index.d.ts:491
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
  - helper method to create an overlap function for a given query
    
    Parameters
    - s: ISetLike<T> | readonly T[]
    Returns number

render

render<T>(node: HTMLElement, props: UpSetProps<T>): void

- Defined in packages/bundle/src/index.ts:114
renders the UpSetJS component

Type parameters
- T = any
Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetProps<T>
  
  the properties of the component
Returns void

renderKarnaughMap

renderKarnaughMap<T>(node: HTMLElement, props: KarnaughMapProps<T>): void

- Defined in packages/bundle/src/index.ts:143
renders the KarnaughMap component

Type parameters
- T = any
Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: KarnaughMapProps<T>
  
  the properties of the component
Returns void

renderKarnaughMapSkeleton

renderKarnaughMapSkeleton(node: HTMLElement, props: UpSetJSSkeletonProps): void

- Defined in packages/bundle/src/index.ts:173
renders the KarnaughMap skeleton component

Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetJSSkeletonProps
  
  the properties of the component
Returns void

renderSkeleton

renderSkeleton(node: HTMLElement, props: UpSetJSSkeletonProps): void

- Defined in packages/bundle/src/index.ts:153
renders the UpSetJS skeleton component

Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetJSSkeletonProps
  
  the properties of the component
Returns void

renderUpSet

renderUpSet<T>(node: HTMLElement, props: UpSetProps<T>): void

- Defined in packages/bundle/src/index.ts:124
renders the UpSetJS component

Type parameters
- T = any
Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetProps<T>
  
  the properties of the component
Returns void

renderVennDiagram

renderVennDiagram<T>(node: HTMLElement, props: VennDiagramProps<T>): void

- Defined in packages/bundle/src/index.ts:134
renders the VennDiagram component

Type parameters
- T = any
Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: VennDiagramProps<T>
  
  the properties of the component
Returns void

renderVennDiagramSkeleton

renderVennDiagramSkeleton(node: HTMLElement, props: UpSetJSSkeletonProps): void

- Defined in packages/bundle/src/index.ts:163
renders the VennDiagram skeleton component

Parameters
- node: HTMLElement
  
  the DOM node to render the component into
- props: UpSetJSSkeletonProps
  
  the properties of the component
Returns void

setElemIntersectionFactory

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

- Defined in packages/model/dist/index.d.ts:370
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 packages/model/dist/index.d.ts:369
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 packages/model/dist/index.d.ts:368
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 packages/model/dist/index.d.ts:367
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 packages/model/dist/index.d.ts:366
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 packages/model/dist/index.d.ts:644
Type parameters
- T
Parameters
- data: IUpSetDumpData<T>
- Optional config: IUpSetToDumpConfig<T>
Returns IUpSetDump

toIndicesArray

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

- Defined in packages/model/dist/index.d.ts:574
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
- Optional __namedParameters: { compress?: "auto" | "no" | "yes"; sortAble?: boolean }
  - Optional compress?: "auto" | "no" | "yes"
  - Optional sortAble?: boolean
Returns string | readonly number[]

toKey

toKey(s: ISetLike<any>): string

- Defined in packages/model/dist/index.d.ts:102
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 packages/model/dist/index.d.ts:697
Type parameters
- T
Parameters
- data: IUpSetStaticDumpData<T>
- Optional config: IUpSetToStaticDumpConfig<T>
Returns IUpSetStaticDump

toUpSetJSDump

toUpSetJSDump(dump: IUpSetDump, elements: readonly any[], props: Partial<UpSetProps<any>>, author?: string, mode?: "upset" | "venn" | "kmap"): IUpSetJSDump

- Defined in packages/bundle/src/index.ts:266
Parameters
- dump: IUpSetDump
- elements: readonly any[]
- props: Partial<UpSetProps<any>>
- Optional author: string
- Optional mode: "upset" | "venn" | "kmap"
Returns IUpSetJSDump

toUpSetJSStaticDump

toUpSetJSStaticDump(dump: IUpSetStaticDump, props: Partial<UpSetProps<any>>, author?: string, mode?: "upset" | "venn" | "kmap"): IUpSetJSStaticDump

- Defined in packages/bundle/src/index.ts:282
Parameters
- dump: IUpSetStaticDump
- props: Partial<UpSetProps<any>>
- Optional author: string
- Optional mode: "upset" | "venn" | "kmap"
Returns IUpSetJSStaticDump

Index

Namespaces

Interfaces

Type aliases

Variables

Functions

Type aliases

ICategories

ICategoryBins

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

KarnaughMapFullProps

Type parameters

T = any

KarnaughMapProps

Type parameters

T = any

NumericScaleTick

Type declaration

Optional label?: string

value: number

QuantilesMethod

SetCombinationType

UpSetAddon

Type parameters

T

UpSetAddonHandlerInfos

UpSetAddons

Type parameters

T

UpSetCompressedIndices

UpSetFullProps

Type parameters

T = any

UpSetProps

Type parameters

T = any

UpSetQueries

Type parameters

T = any

UpSetQuery

Type parameters

T = any

UpSetReactElement

UpSetReactElementComponentChild

UpSetReactElementComponentChildren

UpSetStyleClassNames

UpSetThemes

VennDiagramFullProps

Type parameters

T = any

VennDiagramProps

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