vega-lite

Variables

• duplicate
• entries
• keys
• vals
• version

Functions

• accessPathDepth()
• accessPathWithDatum()
• accessWithDatumToUnescapedPath()
• compile()
• contains()
• deepEqual()
• deleteNestedProperty()
• every()
• fieldIntersection()
• flatAccessWithDatum()
• getFirstDefined()
• hash()
• hasIntersection()
• hasProperty()
• internalField()
• isBoolean()
• isEmpty()
• isEqual()
• isInternalField()
• isNullOrFalse()
• isNumeric()
• logicalExpr()
• mergeDeep()
• never()
• normalize()
• normalizeAngle()
• omit()
• pick()
• prefixGenerator()
• removePathFromField()
• replaceAll()
• replacePathInField()
• resetIdCounter()
• setEqual()
• some()
• stringify()
• titleCase()
• unique()
• uniqueId()
• varName()

Interfaces

• Config

  • aria
  • legend
  • lineBreak
  • locale
  • projection
  • range
  • signals
  • style
  • title

Type Aliases

• DeepPartial
• Dict
• Flag
• TopLevelSpec

variable duplicate

const duplicate: (value: any, options?: StructuredSerializeOptions) => any;

variable entries

const entries: <T>(obj: T) => [keyof T, T[keyof T]][];

variable keys

const keys: <T>(o: T) => Extract<keyof T, string>[];

variable vals

const vals: <T>(obj: T) => T[keyof T][];

variable version

const version: any;

function accessPathDepth

accessPathDepth: (path: string) => any;

• Count the depth of the path. Returns 1 for fields that are not nested.

function accessPathWithDatum

accessPathWithDatum: (path: string, datum?: string) => string;

• Converts a path to an access path with datum.

  Parameter path

  The field name.

  Parameter datum

  The string to use for datum.

function accessWithDatumToUnescapedPath

accessWithDatumToUnescapedPath: (unescapedPath: string) => string;

• Return access with datum to **an unescaped path**.

  console.log(accessWithDatumToUnescapedPath("vega's favorite"))
  // "datum['vega\\'s favorite']"

  Parameter path

  The unescaped path name. E.g., "a.b", "vega's favorite". (Note that the field defs take escaped strings like "a\\.b", "vega\\'s favorite", but this function is for the unescaped field/path)

function compile

compile: (
    inputSpec: TopLevelSpec,
    opt?: CompileOptions
) => { spec: VgSpec; normalized: TopLevel<NormalizedSpec> & LayoutSizeMixins };

• Vega-Lite's main function, for compiling Vega-Lite spec into Vega spec.

  At a high-level, we make the following transformations in different phases:

  Input spec | | (Normalization) v Normalized Spec (Row/Column channels in single-view specs becomes faceted specs, composite marks becomes layered specs.) | | (Build Model) v A model tree of the spec | | (Parse) v A model tree with parsed components (intermediate structure of visualization primitives in a format that can be easily merged) | | (Optimize) v A model tree with parsed components with the data component optimized | | (Assemble) v Vega spec

  Parameter inputSpec

  The Vega-Lite specification.

  Parameter opt

  Optional arguments passed to the Vega-Lite compiler.

  Returns

  An object containing the compiled Vega spec and normalized Vega-Lite spec.

function contains

contains: <T>(array: readonly T[], item: T) => boolean;

function deepEqual

deepEqual: (a: any, b: any) => boolean;

• Compares two values for equality, including arrays and objects.

  Adapted from https://github.com/epoberezkin/fast-deep-equal.

function deleteNestedProperty

deleteNestedProperty: (obj: any, orderedProps: string[]) => boolean;

• Delete nested property of an object, and delete the ancestors of the property if they become empty.

function every

every: <T>(arr: readonly T[], f: (d: T, k?: any, i?: any) => boolean) => boolean;

• Returns true if all items return true.

function fieldIntersection

fieldIntersection: (a: ReadonlySet<string>, b: ReadonlySet<string>) => boolean;

• Returns true if a and b have an intersection. Also return true if a or b are undefined since this means we don't know what fields a node produces or depends on.

function flatAccessWithDatum

flatAccessWithDatum: (
    path: string,
    datum?: 'datum' | 'parent' | 'datum.datum'
) => string;

• Return access with datum to the flattened field.

  Parameter path

  The field name.

  Parameter datum

  The string to use for datum.

function getFirstDefined

getFirstDefined: <T>(...args: readonly T[]) => T | undefined;

• This is a replacement for chained || for numeric properties or properties that respect null so that 0 will be included.

function hash

hash: (a: any) => string | number;

• Converts any object to a string of limited size, or a number.

function hasIntersection

hasIntersection: <T>(a: ReadonlySet<T>, b: ReadonlySet<T>) => boolean;

function hasProperty

hasProperty: <T>(obj: T, key: string | number | symbol) => key is keyof T;

• Check if the input object has the property and it's not undefined.

  Parameter object

  the object

  Parameter property

  the property to search

  Returns

  if the object has the property and it's not undefined.

function internalField

internalField: (name: string) => string;

function isBoolean

isBoolean: (b: any) => b is boolean;

function isEmpty

isEmpty: (obj: object) => boolean;

function isEqual

isEqual: <T>(dict: Dict<T>, other: Dict<T>) => boolean;

• Returns true if the two dictionaries agree. Applies only to defined values.

function isInternalField

isInternalField: (name: string) => boolean;

function isNullOrFalse

isNullOrFalse: (x: any) => x is false;

function isNumeric

isNumeric: (value: number | string) => boolean;

• Returns whether the passed in value is a valid number.

function logicalExpr

logicalExpr: <T>(
    op: LogicalComposition<T>,
    cb: (...args: readonly any[]) => string
) => string;

function mergeDeep

mergeDeep: <T>(dest: T, ...src: readonly DeepPartial<T>[]) => T;

• recursively merges src into dest

function never

never: (message: string) => never;

function normalize

normalize: (
    spec: TopLevelSpec & LayoutSizeMixins,
    config?: Config<SignalRef>
) => TopLevel<NormalizedSpec> & LayoutSizeMixins;

function normalizeAngle

normalizeAngle: (angle: number) => number;

• Normalize angle to be within [0,360).

function omit

omit: <T extends object, K extends keyof T>(
    obj: T,
    props: readonly K[]
) => Omit<T, K>;

• The opposite of _.pick; this method creates an object composed of the own and inherited enumerable string keyed properties of object that are not omitted.

function pick

pick: <T extends object, K extends keyof T>(
    obj: T,
    props: readonly K[]
) => Pick<T, K>;

• Creates an object composed of the picked object properties.

  var object = {'a': 1, 'b': '2', 'c': 3}; pick(object, ['a', 'c']); // → {'a': 1, 'c': 3}

function prefixGenerator

prefixGenerator: (a: ReadonlySet<string>) => ReadonlySet<string>;

function removePathFromField

removePathFromField: (path: string) => string;

• Remove path accesses with access from field. For example, foo["bar"].baz becomes foo.bar.baz.

function replaceAll

replaceAll: (string: string, find: string, replacement: string) => string;

• Replace all occurrences of a string with another string.

  Parameter string

  the string to replace in

  Parameter find

  the string to replace

  Parameter replacement

  the replacement

function replacePathInField

replacePathInField: (path: string) => string;

• Replaces path accesses with access to non-nested field. For example, foo["bar"].baz becomes foo\\.bar\\.baz.

function resetIdCounter

resetIdCounter: () => void;

• Resets the id counter used in uniqueId. This can be useful for testing.

function setEqual

setEqual: <T>(a: Set<T>, b: Set<T>) => boolean;

function some

some: <T>(arr: readonly T[], f: (d: T, k?: any, i?: any) => boolean) => boolean;

• Returns true if any item returns true.

function stringify

stringify: (data: any) => string;

• Converts any object to a string representation that can be consumed by humans.

  Adapted from https://github.com/epoberezkin/fast-json-stable-stringify

function titleCase

titleCase: (s: string) => string;

function unique

unique: <T>(values: readonly T[], f: (item: T) => string | number) => T[];

function uniqueId

uniqueId: (prefix?: string) => string | number;

• Returns a new random id every time it gets called.

  Has side effect!

function varName

varName: (s: string) => string;

• Convert a string into a valid variable name

type DeepPartial

type DeepPartial<T> = { [P in keyof T]?: DeepPartial<T[P]> };

• Like TS Partial but applies recursively to all properties.

type Dict

type Dict<T> = Record<string, T>;

type Flag

type Flag<S extends string> = { [K in S]: 1 };

type TopLevelSpec

type TopLevelSpec =
    | TopLevelUnitSpec<Field>
    | TopLevelFacetSpec
    | TopLevel<LayerSpec<Field>>
    | TopLevel<RepeatSpec>
    | TopLevel<GenericConcatSpec<NonNormalizedSpec>>
    | TopLevel<GenericVConcatSpec<NonNormalizedSpec>>
    | TopLevel<GenericHConcatSpec<NonNormalizedSpec>>;

• A Vega-Lite top-level specification. This is the root class for all Vega-Lite specifications. (The json schema is generated from this type.)