UpSet.js React - v1.11.0

Index

References

default

Namespaces

propValidators

Interfaces

Properties

Variables

Functions

References

default

Renames and re-exports UpSetJS

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

KarnaughMapFullProps

KarnaughMapFullProps<T>: KarnaughMapFullPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>

Type parameters

T = any

KarnaughMapProps

KarnaughMapProps<T>: KarnaughMapPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>

Type parameters

T = any

NumericScaleTick

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

Type declaration

Optional label?: string
value: number

SetCombinationType

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

UpSetAddonHandlerInfos

UpSetAddonHandlerInfos: readonly (UpSetAddonHandlerInfo | null)[]

UpSetAddons

UpSetAddons<S, T, N>: readonly UpSetAddon<S, T, N>[]

Type parameters

S: ISetLike<T>
T
N

UpSetCompressedIndices

UpSetCompressedIndices: readonly number[] | string

UpSetExtraTheme

UpSetExtraTheme: { backgroundColor: string }

Type declaration

backgroundColor: string

UpSetFullProps

UpSetFullProps<T>: UpSetFullPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>

Type parameters

T = any

UpSetProps

UpSetProps<T>: UpSetPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>

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

UpSetSelection

UpSetSelection<T>: ISetLike<T> | null | readonly T[] | ((s: ISetLike<T>) => number)

Type parameters

UpSetStyleClassNames

UpSetStyleClassNames: UpSetMultiStyle<string>

UpSetThemes

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

VennDiagramFullProps

VennDiagramFullProps<T>: VennDiagramFullPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>

Type parameters

T = any

VennDiagramProps

VennDiagramProps<T>: VennDiagramPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>

Type parameters

T = any

Properties

KarnaughMap

KarnaughMap: <T>(p: KarnaughMapProps<T> & RefAttributes<SVGSVGElement>) => ReactElement<any, string | JSXElementConstructor<any>>

Type declaration

- <T>(p: KarnaughMapProps<T> & RefAttributes<SVGSVGElement>): ReactElement<any, string | JSXElementConstructor<any>>
- Type parameters
  - T
  Parameters
  - p: KarnaughMapProps<T> & RefAttributes<SVGSVGElement>
  Returns ReactElement<any, string | JSXElementConstructor<any>>

UpSetJS

UpSetJS: <T>(p: UpSetProps<T> & RefAttributes<SVGSVGElement>) => ReactElement<any, string | JSXElementConstructor<any>>

Type declaration

- <T>(p: UpSetProps<T> & RefAttributes<SVGSVGElement>): ReactElement<any, string | JSXElementConstructor<any>>
- upsetjs/react
  https://github.com/upsetjs/upsetjs
  
  Copyright (c) 2021 Samuel Gratzl sam@sgratzl.com
  
  Type parameters
  - T
  Parameters
  - p: UpSetProps<T> & RefAttributes<SVGSVGElement>
  Returns ReactElement<any, string | JSXElementConstructor<any>>

VennDiagram

VennDiagram: <T>(p: VennDiagramProps<T> & RefAttributes<SVGSVGElement>) => ReactElement<any, string | JSXElementConstructor<any>>

Type declaration

- <T>(p: VennDiagramProps<T> & RefAttributes<SVGSVGElement>): ReactElement<any, string | JSXElementConstructor<any>>
- Type parameters
  - T
  Parameters
  - p: VennDiagramProps<T> & RefAttributes<SVGSVGElement>
  Returns ReactElement<any, string | JSXElementConstructor<any>>

Variables

KarnaughMapSkeleton

KarnaughMapSkeleton: FC<UpSetJSSkeletonProps & RefAttributes<SVGSVGElement>> = ...

KV Diagram Skeleton a simple KarnaughMap skeleton

with React.forwardRef support to specify a reference to the SVG element

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

UpSetJSSkeleton

UpSetJSSkeleton: FC<UpSetJSSkeletonProps & RefAttributes<SVGSVGElement>> = ...

UpSetJS Skeleton a simple UpSetJS skeleton

with React.forwardRef support to specify a reference to the SVG element

VennDiagramSkeleton

VennDiagramSkeleton: FC<UpSetJSSkeletonProps & RefAttributes<SVGSVGElement>> = ...

VennDiagram Skeleton a simple VennDiagram skeleton

with React.forwardRef support to specify a reference to the SVG element

Functions

asCombination

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

- Defined in 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 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 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 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 model/dist/index.d.ts:526
Parameters
- domain: string[]
- size: number
- padding: number
Returns BandScaleLike

createVennJSAdapter

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

- Defined in react/src/venn/layout/vennjsAdapter.ts:53
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 react/src/exporter/exportSVG.ts:73
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 react/src/exporter/exportSVG.ts:27
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>

exportVegaLite

exportVegaLite(svg: SVGSVGElement, __namedParameters?: { title?: string }): void

- Defined in react/src/exporter/exportVegaLite.ts:396
Parameters
- svg: SVGSVGElement
- __namedParameters: { title?: string } = {}
  - Optional title?: string
Returns 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 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 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 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 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 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 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 react/src/fillDefaults.tsx:181
Type parameters
- T = any
Parameters
- props: UpSetProps<T>
Returns UpSetFullProps<T>

fillDefaultsG

fillDefaultsG<T, C, N, L>(props: UpSetPropsG<T, C, N, L>): UpSetFullPropsG<T, C, N, L>

- Defined in react/src/fillDefaults.tsx:147
helper methods to fill up partial UpSet.js properties with their default values

Type parameters
- T
- C
- N
- L = N
Parameters
- props: UpSetPropsG<T, C, N, L>
Returns UpSetFullPropsG<T, C, N, L>

fillKarnaughMapDefaults

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

- Defined in react/src/fillDefaults.tsx:235
Type parameters
- T = any
Parameters
- props: KarnaughMapProps<T>
Returns KarnaughMapFullProps<T>

fillKarnaughMapDefaultsG

fillKarnaughMapDefaultsG<T, C, N, L>(props: KarnaughMapPropsG<T, C, N, L>): KarnaughMapFullPropsG<T, C, N, L>

- Defined in react/src/fillDefaults.tsx:214
helper methods to fill up partial UpSet.js properties with their default values

Type parameters
- T
- C
- N
- L = N
Parameters
- props: KarnaughMapPropsG<T, C, N, L>
Returns KarnaughMapFullPropsG<T, C, N, L>

fillVennDiagramDefaults

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

- Defined in react/src/fillDefaults.tsx:207
Type parameters
- T = any
Parameters
- props: VennDiagramProps<T>
Returns VennDiagramFullProps<T>

fillVennDiagramDefaultsG

fillVennDiagramDefaultsG<T, C, N, L>(props: VennDiagramPropsG<T, C, N, L>): VennDiagramFullPropsG<T, C, N, L>

- Defined in react/src/fillDefaults.tsx:188
helper methods to fill up partial UpSet.js properties with their default values

Type parameters
- T
- C
- N
- L = N
Parameters
- props: VennDiagramPropsG<T, C, N, L>
Returns VennDiagramFullPropsG<T, C, N, L>

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 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 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 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 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 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 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 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 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 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 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 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 react/src/fillDefaults.tsx:89
Parameters
- Optional theme: UpSetThemes
Returns Readonly<Required<UpSetThemeProps & VennDiagramThemeProps & UpSetExtraTheme>>

isCalcQuery

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

- Defined in 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 model/dist/index.d.ts:482
Type parameters
- T
Parameters
- q: UpSetQuery<T>
Returns q is UpSetElemQuery<T>

isEllipse

isEllipse(d: ICircle | IEllipse): d is IEllipse

- Defined in react/src/venn/layout/interfaces.ts:75
Parameters
- d: ICircle | IEllipse
Returns d is IEllipse

isGenerateSetCombinationOptions

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

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

isSet

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

- Defined in 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 model/dist/index.d.ts:508
Parameters
- v: any
Returns v is ISetCombination<any>

isSetLike

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

- Defined in 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 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 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 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 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 model/dist/index.d.ts:709
Parameters
- colors: readonly (undefined | string)[]
Returns string | undefined

parseColor

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

- Defined in 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 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 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

setElemIntersectionFactory

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

- Defined in 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 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 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 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 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 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 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 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 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> & VennDiagramProps<any> & KarnaughMapProps<any>>, author?: string, mode?: "venn" | "kmap" | "upset"): IUpSetJSDump

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

toUpSetJSStaticDump

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

- Defined in react/src/dump/index.ts:165
Parameters
- dump: IUpSetStaticDump
- props: Partial<UpSetProps<any> & VennDiagramProps<any> & KarnaughMapProps<any>>
- Optional author: string
- Optional mode: "venn" | "kmap" | "upset"
Returns IUpSetJSStaticDump

Index

References

Namespaces

Interfaces

Type aliases

Properties

Variables

Functions

References

default

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

KarnaughMapFullProps

Type parameters

T = any

KarnaughMapProps

Type parameters

T = any

NumericScaleTick

Type declaration

Optional label?: string

value: number

SetCombinationType

UpSetAddonHandlerInfos

UpSetAddons

Type parameters

S: ISetLike<T>

T

N

UpSetCompressedIndices

UpSetExtraTheme

Type declaration

backgroundColor: string

UpSetFullProps

Type parameters

T = any

UpSetProps

Type parameters

T = any

UpSetQueries

Type parameters

T = any

UpSetQuery

Type parameters

T = any

UpSetSelection

Type parameters

T

UpSetStyleClassNames

UpSetThemes

VennDiagramFullProps

Type parameters

T = any

VennDiagramProps

Type parameters

T = any

Properties

KarnaughMap

Type declaration

Type parameters

T

Parameters

p: KarnaughMapProps<T> & RefAttributes<SVGSVGElement>

Returns ReactElement<any, string | JSXElementConstructor<any>>

UpSetJS

Type declaration