@uwdata/mosaic-spec 0.7.0 → 0.8.0

package/dist/types/ast/ASTNode.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Abstract base class for Mosaic spec AST nodes.
+ */
+export class ASTNode {
+    constructor(type: any, children?: any);
+    /** @type {string} */
+    type: string;
+    /** @type {ASTNode[] | null} */
+    children: ASTNode[] | null;
+    /**
+     * Instantiate this AST node to use in a live web application.
+     * @param {import('../ast-to-dom.js').InstantiateContext} ctx The instantiation context.
+     * @returns {*} The instantiated value of this node.
+     */
+    instantiate(ctx: import('../ast-to-dom.js').InstantiateContext): any;
+    /**
+     * Generate ESM code for this AST node.
+     * @param {import('../ast-to-esm.js').CodegenContext} ctx The code generator context.
+     * @returns {string|void} The generated ESM code for the node.
+     */
+    codegen(ctx: import('../ast-to-esm.js').CodegenContext): string | void;
+    /**
+     * @returns {*} This AST node in JSON specification format.
+     */
+    toJSON(): any;
+}

package/dist/types/ast/DataNode.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Parse a data definition spec.
+ * @param {string} name The name of the dataset
+ * @param {import('../spec/Data.js').DataDefinition} spec The data definition spec.
+ * @param {import('../parse-spec.js').ParseContext} ctx The parser context.
+ * @returns {DataNode} a parsed data definition AST node
+ */
+export function parseData(name: string, spec: import('../spec/Data.js').DataDefinition, ctx: import('../parse-spec.js').ParseContext): DataNode;
+export const TABLE_DATA: "table";
+export const PARQUET_DATA: "parquet";
+export const CSV_DATA: "csv";
+export const JSON_DATA: "json";
+export const SPATIAL_DATA: "spatial";
+export class DataNode extends ASTNode {
+    name: any;
+    format: any;
+}
+export class QueryDataNode extends DataNode {
+    /**
+     * Instantiate a table creation query.
+     * @param {import('../ast-to-dom.js').InstantiateContext} ctx The instantiation context.
+     * @returns {string|void} The instantiated query.
+     */
+    instantiateQuery(ctx: import('../ast-to-dom.js').InstantiateContext): string | void;
+    /**
+     * Code generate a table creation query.
+     * @param {import('../ast-to-esm.js').CodegenContext} ctx The code generator context.
+     * @returns {string|void} The generated query code.
+     */
+    codegenQuery(ctx: import('../ast-to-esm.js').CodegenContext): string | void;
+}
+export class TableDataNode extends QueryDataNode {
+    constructor(name: any, query: any, options: any);
+    query: any;
+    options: any;
+}
+export class FileDataNode extends QueryDataNode {
+    constructor(name: any, format: any, method: any, file: any, options: any);
+    file: any;
+    method: any;
+    options: any;
+}
+export class SpatialDataNode extends FileDataNode {
+    constructor(name: any, file: any, options: any);
+}
+export class ParquetDataNode extends FileDataNode {
+    constructor(name: any, file: any, options: any);
+}
+export class CSVDataNode extends FileDataNode {
+    constructor(name: any, file: any, options: any);
+}
+export class JSONDataNode extends FileDataNode {
+    constructor(name: any, file: any, options: any);
+}
+export class LiteralJSONDataNode extends QueryDataNode {
+    constructor(name: any, data: any, options: any);
+    data: any;
+    options: any;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/ExpressionNode.d.ts

@@ -0,0 +1,15 @@
+export function parseExpression(spec: any, ctx: any): ExpressionNode;
+export class ExpressionNode extends ASTNode {
+    constructor(value: any, spans: any, params: any, label: any, aggregate: any);
+    value: any;
+    spans: any;
+    params: any;
+    label: any;
+    aggregate: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): {
+        [x: string]: any;
+    };
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/HConcatNode.d.ts

@@ -0,0 +1,10 @@
+export function parseHConcat(spec: any, ctx: any): HConcatNode;
+export class HConcatNode extends ASTNode {
+    constructor(children: any);
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): {
+        [x: string]: any[];
+    };
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/HSpaceNode.d.ts

@@ -0,0 +1,11 @@
+export function parseHSpace(spec: any): HSpaceNode;
+export class HSpaceNode extends ASTNode {
+    constructor(value: any);
+    value: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): {
+        [x: string]: any;
+    };
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/InputNode.d.ts

@@ -0,0 +1,8 @@
+export function parseInput(spec: any, ctx: any): InputNode;
+export class InputNode extends ASTNode {
+    name: any;
+    options: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/LiteralNode.d.ts

@@ -0,0 +1,7 @@
+export class LiteralNode extends ASTNode {
+    constructor(value: any);
+    value: any;
+    instantiate(): any;
+    codegen(ctx: any): any;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/OptionsNode.d.ts

@@ -0,0 +1,10 @@
+export function parseOptions(spec: any, ctx: any): OptionsNode;
+export class OptionsNode extends ASTNode {
+    constructor(options: any);
+    options: any;
+    filter(predicate: any): OptionsNode;
+    instantiate(ctx: any): {};
+    codegen(ctx: any): string;
+    toJSON(): {};
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/ParamNode.d.ts

@@ -0,0 +1,9 @@
+export function parseParam(spec: any, ctx: any): SelectionNode | ParamNode;
+export class ParamNode extends ASTNode {
+    value: any;
+    date: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+}
+import { SelectionNode } from './SelectionNode.js';
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/ParamRefNode.d.ts

@@ -0,0 +1,8 @@
+export class ParamRefNode extends ASTNode {
+    constructor(name: any);
+    name: any;
+    instantiate(ctx: any): any;
+    codegen(): string;
+    toJSON(): string;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/PlotAttributeNode.d.ts

@@ -0,0 +1,18 @@
+export function parseAttribute(key: any, value: any, ctx: any): PlotAttributeNode;
+export class PlotAttributeNode extends ASTNode {
+    name: any;
+    value: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): {
+        [x: number]: any;
+    };
+}
+export class PlotFixedNode extends ASTNode {
+    constructor();
+    value: string;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): string;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/PlotFromNode.d.ts

@@ -0,0 +1,9 @@
+export function parseMarkData(spec: any, ctx: any): LiteralNode | PlotFromNode;
+export class PlotFromNode extends ASTNode {
+    table: any;
+    options: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+}
+import { LiteralNode } from './LiteralNode.js';
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/PlotInteractorNode.d.ts

@@ -0,0 +1,8 @@
+export function parseInteractor(spec: any, ctx: any): PlotInteractorNode;
+export class PlotInteractorNode extends ASTNode {
+    name: any;
+    options: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/PlotLegendNode.d.ts

@@ -0,0 +1,10 @@
+export function parseLegend(spec: any, ctx: any): PlotLegendNode;
+export class PlotLegendNode extends ASTNode {
+    constructor(key: any, name: any, options: any);
+    key: any;
+    name: any;
+    options: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/PlotMarkNode.d.ts

@@ -0,0 +1,10 @@
+export function parseMark(spec: any, ctx: any): PlotMarkNode;
+export class PlotMarkNode extends ASTNode {
+    constructor(name: any, data: any, options: any);
+    name: any;
+    data: any;
+    options: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/PlotNode.d.ts

@@ -0,0 +1,11 @@
+export function parseTopLevelMark(spec: any, ctx: any): PlotNode;
+export function parsePlot(spec: any, ctx: any): PlotNode;
+export class PlotNode extends ASTNode {
+    attributes: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): {
+        [x: string]: any[];
+    };
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/SelectionNode.d.ts

@@ -0,0 +1,12 @@
+export class SelectionNode extends ASTNode {
+    constructor(select: string, cross: any);
+    select: string;
+    cross: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): {
+        select: string;
+        cross: any;
+    };
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/SpecNode.d.ts

@@ -0,0 +1,10 @@
+export class SpecNode extends ASTNode {
+    constructor(root: any, meta: any, config: any, data: any, params: any, plotDefaults: any);
+    root: any;
+    meta: any;
+    config: any;
+    data: any;
+    params: any;
+    plotDefaults: any;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/TransformNode.d.ts

@@ -0,0 +1,13 @@
+export function parseTransform(spec: any, ctx: any): TransformNode;
+export class TransformNode extends ASTNode {
+    constructor(name: any, args: any, options: any);
+    name: any;
+    args: any;
+    options: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): {
+        [x: number]: any;
+    };
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/VConcatNode.d.ts

@@ -0,0 +1,10 @@
+export function parseVConcat(spec: any, ctx: any): VConcatNode;
+export class VConcatNode extends ASTNode {
+    constructor(children: any);
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): {
+        [x: string]: any[];
+    };
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/VSpaceNode.d.ts

@@ -0,0 +1,11 @@
+export function parseVSpace(spec: any): VSpaceNode;
+export class VSpaceNode extends ASTNode {
+    constructor(value: any);
+    value: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): {
+        [x: string]: any;
+    };
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast-to-dom.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Generate a running web application (DOM content) for a Mosaic spec AST.
+ * @param {SpecNode} ast Mosaic AST root node.
+ * @param {object} [options] Instantiation options.
+ * @param {string} [options.baseURL] The base URL for loading data files.
+ * @param {any[]} [options.plotDefaults] Array of default plot attributes.
+ * @param {Map<string, Param>} [options.params] A map of predefined Params/Selections.
+ * @returns {Promise<{
+ *   element: HTMLElement | SVGSVGElement;
+*    params: Map<string, Param | Selection>;
+*  }>} A Promise to an object with the resulting
+ *  DOM element, and a map of named parameters (Param and Selection instances).
+ */
+export function astToDOM(ast: SpecNode, options?: {
+    baseURL?: string;
+    plotDefaults?: any[];
+    params?: Map<string, Param>;
+}): Promise<{
+    element: HTMLElement | SVGSVGElement;
+    params: Map<string, Param | Selection>;
+}>;
+export class InstantiateContext {
+    constructor({ api, plotDefaults, params, baseURL }?: {
+        api?: any;
+        plotDefaults?: any[];
+        params?: Map<any, any>;
+        baseURL?: any;
+    });
+    api: any;
+    plotDefaults: any[];
+    activeParams: Map<any, any>;
+    baseURL: any;
+    coordinator: any;
+    error(message: any, data: any): void;
+}
+import { SpecNode } from './ast/SpecNode.js';
+import { Param } from '@uwdata/mosaic-core';
+import { Selection } from '@uwdata/mosaic-core';

package/dist/types/ast-to-esm.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Generate ESM code for a Mosaic spec AST.
+ * @param {SpecNode} ast Mosaic AST root node.
+ * @param {object} [options] Code generation options.
+ * @param {string} [options.baseURL] The base URL for loading data files.
+ * @param {string} [options.connector] A database connector to initialize.
+ *  Valid values are 'wasm', 'socket', and 'rest'.
+ *  If undefined, no connector code is generated.
+ * @param {string} [options.namespace='vg'] The vgplot API namespace object.
+ * @param {number} [options.depth=0] The starting indentation depth.
+ * @param {Map<string,string|string[]>} [options.imports] A Map of ESM
+ *  imports to include in generated code. Keys are packages (e.g.,
+ *  '@uwdata/vgplot') and values indicate what to import (e.g., '* as vg').
+ * @param {string|string[]} [options.preamble] Code to include after imports.
+ * @returns {string} Generated ESM code using the vgplot API.
+ */
+export function astToESM(ast: SpecNode, options?: {
+    baseURL?: string;
+    connector?: string;
+    namespace?: string;
+    depth?: number;
+    imports?: Map<string, string | string[]>;
+    preamble?: string | string[];
+}): string;
+export class CodegenContext {
+    /**
+     * Create a new code generator context.
+     * @param {object} [options] Code generation options.
+     * @param {*} [options.plotDefaults] Default attributes to apply to all plots.
+     * @param {string} [options.baseURL] The base URL for loading data files.
+     * @param {string} [options.connector] A database connector to initialize.
+     *  Valid values are 'wasm', 'socket', and 'rest'.
+     *  If undefined, no connector code is generated.
+     * @param {string} [options.namespace='vg'] The vgplot API namespace object.
+     * @param {number} [options.depth=0] The starting indentation depth.
+     * @param {Map<string,string|string[]>} [options.imports] A Map of ESM
+     *  imports to include in generated code. Keys are packages (e.g.,
+     *  '@uwdata/vgplot') and values indicate what to import (e.g., '* as vg').
+     */
+    constructor({ plotDefaults, namespace, connector, imports, baseURL, depth }?: {
+        plotDefaults?: any;
+        baseURL?: string;
+        connector?: string;
+        namespace?: string;
+        depth?: number;
+        imports?: Map<string, string | string[]>;
+    });
+    plotDefaults: any;
+    namespace: string;
+    connector: string;
+    imports: Map<string, string | string[]>;
+    baseURL: string;
+    depth: number;
+    addImport(pkg: any, method: any): void;
+    setImports(pkg: any, all: any): void;
+    ns(): string;
+    indent(): void;
+    undent(): void;
+    tab(): string;
+    stringify(value: any): any;
+    maybeLineWrap(spans: any): any;
+    error(message: any, data: any): void;
+}
+import { SpecNode } from './ast/SpecNode.js';

package/dist/types/config/components.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Map of specification keys to component parsers.
+ */
+export function componentMap(overrides?: any[]): Map<any, any>;

package/dist/types/config/extensions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Construct a set of database extensions to load.
+ * Automatically adds the spatial extension if a
+ * dataset with format "spatial" is loaded.
+ * @param {SpecNode} ast Mosaic AST root node.
+ * @returns {Set<string>} A set of extension names.
+ */
+export function resolveExtensions(ast: SpecNode): Set<string>;
+import { SpecNode } from '../ast/SpecNode.js';

package/dist/types/config/inputs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Set of input widget type names.
+ * @returns {Set<string>}
+ */
+export function inputNames(overrides?: any[]): Set<string>;

package/dist/types/config/plots.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Generate an object of lookup maps for vgplot components.
+ */
+export function plotNames({ attributes, interactors, legends, marks }?: {
+    attributes?: Set<string>;
+    interactors?: Set<string>;
+    legends?: Set<string>;
+    marks?: Set<string>;
+}): {
+    attributes: Set<string>;
+    interactors: Set<string>;
+    legends: Set<string>;
+    marks: Set<string>;
+};
+/**
+ * Names of attribute directive functions.
+ * @returns {Set<string>}
+ */
+export function plotAttributeNames(overrides?: any[]): Set<string>;
+/**
+ * Names interactor directive functions.
+ * @returns {Set<string>}
+ */
+export function plotInteractorNames(overrides?: any[]): Set<string>;
+/**
+ * Names of legend directive functions.
+ * @returns {Set<string>}
+ */
+export function plotLegendNames(overrides?: any[]): Set<string>;
+/**
+ * Names of mark directive functions.
+ * @returns {Set<string>}
+ */
+export function plotMarkNames(overrides?: any[]): Set<string>;

package/dist/types/config/transforms.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Valid transform method names.
+ */
+export function transformNames(overrides?: any[]): Set<any>;

package/dist/types/constants.d.ts

@@ -0,0 +1,30 @@
+export const SPEC: "spec";
+export const LITERAL: "literal";
+export const DATAREF: "dataref";
+export const OPTIONS: "options";
+export const SELECTION: "selection";
+export const PARAMREF: "paramref";
+export const PARAM: "param";
+export const SELECT: "select";
+export const VALUE: "value";
+export const CROSSFILTER: "crossfilter";
+export const INTERSECT: "intersect";
+export const UNION: "union";
+export const SINGLE: "single";
+export const DATA: "data";
+export const EXPRESSION: "expression";
+export const SQL: "sql";
+export const AGG: "agg";
+export const INPUT: "input";
+export const HCONCAT: "hconcat";
+export const VCONCAT: "vconcat";
+export const HSPACE: "hspace";
+export const VSPACE: "vspace";
+export const MARK: "mark";
+export const FROM: "from";
+export const PLOT: "plot";
+export const LEGEND: "legend";
+export const ATTRIBUTE: "attribute";
+export const TRANSFORM: "transform";
+export const INTERACTOR: "interactor";
+export const FIXED: "Fixed";

package/dist/types/index.d.ts

@@ -0,0 +1,29 @@
+export { parseSpec } from "./parse-spec.js";
+export * from "./constants.js";
+export { ASTNode } from "./ast/ASTNode.js";
+export { ExpressionNode } from "./ast/ExpressionNode.js";
+export { HConcatNode } from "./ast/HConcatNode.js";
+export { HSpaceNode } from "./ast/HSpaceNode.js";
+export { InputNode } from "./ast/InputNode.js";
+export { LiteralNode } from "./ast/LiteralNode.js";
+export { OptionsNode } from "./ast/OptionsNode.js";
+export { ParamNode } from "./ast/ParamNode.js";
+export { ParamRefNode } from "./ast/ParamRefNode.js";
+export { PlotFromNode } from "./ast/PlotFromNode.js";
+export { PlotInteractorNode } from "./ast/PlotInteractorNode.js";
+export { PlotLegendNode } from "./ast/PlotLegendNode.js";
+export { PlotMarkNode } from "./ast/PlotMarkNode.js";
+export { PlotNode } from "./ast/PlotNode.js";
+export { SelectionNode } from "./ast/SelectionNode.js";
+export { SpecNode } from "./ast/SpecNode.js";
+export { TransformNode } from "./ast/TransformNode.js";
+export { VConcatNode } from "./ast/VConcatNode.js";
+export { VSpaceNode } from "./ast/VSpaceNode.js";
+/**
+ * A Mosaic declarative specification.
+ */
+export type Spec = import('./spec/Spec.js').Spec;
+export { astToDOM, InstantiateContext } from "./ast-to-dom.js";
+export { astToESM, CodegenContext } from "./ast-to-esm.js";
+export { DataNode, QueryDataNode, TableDataNode, FileDataNode, CSVDataNode, JSONDataNode, ParquetDataNode, SpatialDataNode, LiteralJSONDataNode } from "./ast/DataNode.js";
+export { PlotAttributeNode, PlotFixedNode } from "./ast/PlotAttributeNode.js";

package/dist/types/parse-spec.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @typedef {{
+ *   attributes: Set<string>;
+ *   interactors: Set<string>;
+ *   legends: Set<string>;
+ *   marks: Set<string>;
+ * }} PlotNames names for supported plot elements
+ */
+/**
+ * Parse a Mosaic specification to an AST (abstract syntax tree).
+ * @param {import('./spec/Spec.js').Spec} spec The input specification.
+ * @param {object} [options] Optional parse options object.
+ * @param {Map<string, Function>} [options.components] Map of component names to parse functions.
+ * @param {Set<string>} [options.transforms] The names of allowed transform functions.
+ * @param {Set<string>} [options.inputs] The names of supported input widgets.
+ * @param {PlotNames} [options.plot] The names of supported plot elements.
+ * @param {any[]} [options.params] An array of [name, node] pairs of pre-parsed
+ *  Param or Selection AST nodes.
+ * @param {any[]} [options.datasets] An array of [name, node] pairs of pre-parsed
+ *  dataset definition AST nodes.
+ * @returns {SpecNode} The top-level AST spec node.
+ */
+export function parseSpec(spec: import('./spec/Spec.js').Spec, options?: {
+    components?: Map<string, Function>;
+    transforms?: Set<string>;
+    inputs?: Set<string>;
+    plot?: PlotNames;
+    params?: any[];
+    datasets?: any[];
+}): SpecNode;
+export class ParseContext {
+    /**
+     * Create a new parser context.
+     * @param {object} [options]
+     * @param {Map<string, Function>} [options.components] Map of component names to parse functions.
+     * @param {Set<string>} [options.transforms] The names of allowed transform functions.
+     * @param {Set<string>} [options.inputs] The names of supported input widgets.
+     * @param {PlotNames} [options.plot] The names of supported plot elements.
+     * @param {any[]} [options.params] An array of [name, node] pairs of pre-parsed
+     *  Param or Selection AST nodes.
+     * @param {any[]} [options.datasets] An array of [name, node] pairs of pre-parsed
+     *  dataset definition AST nodes.
+     */
+    constructor({ components, transforms, inputs, plot, params, datasets }?: {
+        components?: Map<string, Function>;
+        transforms?: Set<string>;
+        inputs?: Set<string>;
+        plot?: PlotNames;
+        params?: any[];
+        datasets?: any[];
+    });
+    components: Map<string, Function>;
+    transforms: Set<string>;
+    inputs: Set<string>;
+    plot: PlotNames;
+    params: Map<any, any>;
+    datasets: Map<any, any>;
+    parse(spec: any): SpecNode;
+    plotDefaults: import("./ast/PlotAttributeNode.js").PlotAttributeNode[];
+    parseComponent(spec: any): any;
+    /**
+     * Test if a value is param reference, if so, generate a paramter definition
+     * as needed and return a new ParamRefNode. Otherwise, return a LiteralNode.
+     * @param {*} value The value to test.
+     * @param {() => ParamNode | SelectionNode} [makeNode] A Param of Selection AST
+     *  node constructor.
+     * @returns {ParamRefNode|LiteralNode} An AST node for the input value.
+     */
+    maybeParam(value: any, makeNode?: () => ParamNode | SelectionNode): ParamRefNode | LiteralNode;
+    maybeSelection(value: any): LiteralNode | ParamRefNode;
+    error(message: any, data: any): void;
+}
+/**
+ * names for supported plot elements
+ */
+export type PlotNames = {
+    attributes: Set<string>;
+    interactors: Set<string>;
+    legends: Set<string>;
+    marks: Set<string>;
+};
+import { SpecNode } from './ast/SpecNode.js';
+import { ParamNode } from './ast/ParamNode.js';
+import { SelectionNode } from './ast/SelectionNode.js';
+import { ParamRefNode } from './ast/ParamRefNode.js';
+import { LiteralNode } from './ast/LiteralNode.js';

package/dist/types/spec/CSSStyles.d.ts

@@ -0,0 +1,3 @@
+type OmittedProperties = 'parentRule' | 'getPropertyPriority' | 'getPropertyValue' | 'item' | 'removeProperty' | 'setProperty';
+export type CSSStyles = Partial<Omit<CSSStyleDeclaration, OmittedProperties>>;
+export {};