@astryxdesign/vega 0.0.0-bootstrap.0 → 0.1.3-canary.e3beb97

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Meta Platforms, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,233 @@
 # @astryxdesign/vega
 
-This is a `0.0.0-bootstrap.0` placeholder published only to claim the npm name while configuring npm trusted publishing. Do not install it; it will be superseded by the first real release.
+Astryx Vega wrapper: chart and data visualization components.
+
+Renders [Vega](https://vega.github.io/vega/) and [Vega-Lite](https://vega.github.io/vega-lite/) specifications via the Vega runtime. The component inspects `$schema` to decide whether to compile (Vega-Lite) or render directly (Vega), validates the schema URL before doing either, and exposes the full Vega `parse()` and `View` construction APIs as props.
+
+> **Publishing status: canary only.** This package ships to npm **only under the `@canary` dist-tag** — there is no stable (`latest`) release yet. See [Publishing](#publishing) below for the canary model and the steps to graduate it to a public stable release.
+
+<!-- SYNC: When files in this directory change, update this document. -->
+
+## File Manifest
+
+| File                | Role      | Purpose                                                      |
+| ------------------- | --------- | ------------------------------------------------------------ |
+| `package.json`      | Config    | Package metadata, deps, build scripts                        |
+| `tsconfig.json`     | Config    | TypeScript compiler config (extends root)                    |
+| `tsup.config.ts`    | Config    | Build config: CJS + ESM + `.d.ts` outputs                    |
+| `src/index.ts`      | Barrel    | Public API surface                                           |
+| `src/VegaChart.tsx` | Component | Inspects `$schema`, compiles or renders, owns View lifecycle |
+| `src/schema.ts`     | Utility   | Parses and validates Vega/Vega-Lite `$schema` URLs           |
+| `src/types.ts`      | Types     | Shared TypeScript types for this package                     |
+
+## Installation
+
+Vega is published **only** under the `@canary` dist-tag, so you must request that tag explicitly. There is no `latest` version to install yet.
+
+```bash
+npm install @astryxdesign/vega@canary vega vega-lite
+```
+
+> Canary builds track the latest commit on `main` (`0.x.y-canary.<sha>`). They can break between any two versions — pin an exact version if you need stability.
+
+## Usage
+
+### Vega-Lite spec (compiled automatically)
+
+```tsx
+import {VegaChart} from '@astryxdesign/vega';
+
+<VegaChart
+  spec={{
+    $schema: 'https://vega.github.io/schema/vega-lite/v5.json',
+    mark: 'bar',
+    data: {
+      values: [
+        {a: 'A', b: 28},
+        {a: 'B', b: 55},
+      ],
+    },
+    encoding: {
+      x: {field: 'a', type: 'ordinal'},
+      y: {field: 'b', type: 'quantitative'},
+    },
+  }}
+/>;
+```
+
+### Vega spec (rendered directly, no compilation)
+
+```tsx
+<VegaChart
+  spec={{
+    $schema: 'https://vega.github.io/schema/vega/v5.json',
+    marks: [...],
+  }}
+/>
+```
+
+### Full configuration
+
+```tsx
+<VegaChart
+  spec={spec}
+  parseConfig={{background: '#1a1a1a'}}
+  parseOptions={{ast: true}}
+  viewOptions={{
+    renderer: 'canvas',
+    logLevel: 1,
+    tooltip: myTooltipHandler,
+    locale: myLocale,
+    loader: myLoader,
+  }}
+  onReady={view => {
+    view.addSignalListener('highlight', (name, value) => {
+      console.log('signal:', name, value);
+    });
+  }}
+  onError={err => console.error('Chart error:', err.message)}
+/>
+```
+
+## API
+
+### `<VegaChart>`
+
+| Prop             | Type                             | Default | Description                                                |
+| ---------------- | -------------------------------- | ------- | ---------------------------------------------------------- |
+| `spec`           | `AnySpec`                        | --      | Vega or Vega-Lite spec with `$schema` (required)           |
+| `data`           | `ViewData`                       | --      | Initial dataset values: `{datasetName: tuples[]}`          |
+| `compileOptions` | `CompileOptions`                 | --      | Options passed to `compile(spec, options)`, Vega-Lite only |
+| `parseConfig`    | `Config`                         | --      | Vega config passed to `parse(spec, config)`                |
+| `parseOptions`   | `ParseOptions`                   | --      | Options passed to `parse(spec, config, options)`           |
+| `viewOptions`    | `Omit<ViewOptions, 'container'>` | --      | Options passed to `new View(runtime, options)`             |
+| `className`      | `string`                         | --      | CSS class on the container div                             |
+| `style`          | `CSSProperties`                  | --      | Inline styles on the container div                         |
+| `onReady`        | `(view: View) => void`           | --      | Called with the live Vega View when ready                  |
+| `onError`        | `(err: Error) => void`           | --      | Called on schema error, compile failure, or render failure |
+
+`viewOptions` maps directly to [`ViewOptions`](https://vega.github.io/vega/docs/api/view/) with `container` omitted (always set by the component). Notable fields:
+
+| `viewOptions` field | Type                | Description                             |
+| ------------------- | ------------------- | --------------------------------------- |
+| `renderer`          | `'svg' \| 'canvas'` | Rendering backend (default: `'svg'`)    |
+| `hover`             | `boolean`           | Enable hover encoding (default: `true`) |
+| `logLevel`          | `number`            | Vega log verbosity                      |
+| `logger`            | `LoggerInterface`   | Custom logger                           |
+| `tooltip`           | `TooltipHandler`    | Custom tooltip handler                  |
+| `locale`            | `LocaleFormatters`  | Number and time format locale           |
+| `loader`            | `Loader`            | Custom data loader                      |
+| `background`        | `Color`             | Chart background color                  |
+
+`compileOptions` fields (Vega-Lite specs only, ignored otherwise):
+
+| `compileOptions` field | Type                           | Description                                         |
+| ---------------------- | ------------------------------ | --------------------------------------------------- |
+| `config`               | `VegaLiteConfig`               | Vega-Lite config merged on top of the spec's config |
+| `logger`               | `LoggerInterface`              | Custom logger used during compilation               |
+| `fieldTitle`           | `(fieldDef, config) => string` | Custom field title formatter                        |
+
+`parseOptions` fields:
+
+| `parseOptions` field | Type      | Description                                               |
+| -------------------- | --------- | --------------------------------------------------------- |
+| `ast`                | `boolean` | Retain expression AST in the runtime (useful for tooling) |
+
+### Data loading
+
+`data` maps dataset names to tuple arrays and is applied via `view.data(name, tuples)` during View initialization, before the first render. It is _not reactive_; changes after mount are ignored.
+
+To update data dynamically after render, use `onReady` to get the live View and drive it yourself:
+
+```tsx
+<VegaChart
+  spec={spec}
+  data={{
+    table: [
+      {category: 'A', value: 28},
+      {category: 'B', value: 55},
+    ],
+  }}
+  onReady={view => {
+    // Later, update data dynamically:
+    view.data('table', newRows);
+    view.runAsync();
+  }}
+/>
+```
+
+### `parseSchema(schema)` (exported utility)
+
+Parses and validates a Vega `$schema` URL. Returns:
+
+- `{ok: true, library: 'vega' | 'vega-lite', version: string}` on success
+- `{ok: false, error: string}` if the URL is missing, malformed, or names an unknown library
+
+## Schema validation
+
+`VegaChart` validates `spec.$schema` before doing any work. It will call `onError` (and render nothing) if:
+
+- `$schema` is missing or not a string
+- The URL doesn't match the expected format (`schema/{library}/{version}.json`)
+- The library name is not `vega` or `vega-lite`
+
+## Build
+
+```bash
+pnpm -F @astryxdesign/vega build
+```
+
+## Publishing
+
+### Canary (automatic, today)
+
+`package.json` keeps `"private": true` plus an `"astryx": { "canaryOnly": true }` marker. The release workflow (`.github/workflows/release.yml`) handles both dist-tags:
+
+- The **stable (`latest`) job** skips every package that is `private` **or** `canaryOnly`, so Vega can never be published as a stable release by accident.
+- The **canary job** runs on every push to `main`. In its ephemeral CI checkout only (never in git) it strips the `private` flag from `canaryOnly` packages and publishes them to the `@canary` dist-tag as `0.x.y-canary.<short-sha>`, with npm OIDC trusted publishing + provenance.
+
+The committed `private: true` is npm's hard guarantee that no stable publish can ever happen — **do not remove it until the graduation steps below are intentionally taken.**
+
+> **First canary won't publish until the package name is claimed on npm.** npm cannot register OIDC trust for a name that does not yet exist on the registry. An `@astryxdesign` npm org owner must bootstrap it once (this also applies before the first stable publish):
+>
+> ```bash
+> npm i -g npm@latest
+> npm login --registry https://registry.npmjs.org   # must be an @astryxdesign org owner
+> pnpm run setup-trusted-publishing                  # audit — shows what needs bootstrap/trust
+> pnpm run setup-trusted-publishing --bootstrap --setup-trust --workflow release.yml
+> ```
+>
+> This publishes a deprecated `0.0.0-bootstrap.0` stub to claim the name and registers `release.yml` as the trusted publisher. Until this is done, CI's canary publish for this package will fail.
+
+### Graduating to a public stable (`latest`) release
+
+When Vega is ready to be published publicly as a stable release, take these steps (in order). This mirrors how the other public `@astryxdesign/*` packages are released — see the wiki's **Release-Process** page for the authoritative flow.
+
+1. **Remove the canary-only gating** from `packages/vega/package.json`:
+   - Delete `"private": true`.
+   - Delete the `"astryx": { "canaryOnly": true }` block.
+
+2. **Join the versioning group.** Add `@astryxdesign/vega` to the `fixed` array in `.changeset/config.json` so it co-versions with the rest of the publishable packages (they all bump to the same version). Set `version` to match the current published version of the other packages.
+
+3. **Confirm the name is claimed + trusted on npm** (the bootstrap box above). An `@astryxdesign` org owner runs it once if it hasn't been done already — a stable publish fails for an unclaimed/untrusted name exactly like a canary does.
+
+4. **Add a changeset** so the release notes and version bump include Vega:
+
+   ```bash
+   pnpm changeset:new
+   ```
+
+5. **Land the change, then version + publish** through the normal release flow:
+   - Merge the PR that removes the gating (a canary publishes automatically on that push to `main`).
+   - Run the version-bump PR (`pnpm version-packages`, refresh the lockfile, merge) — this bumps versions on `main` but publishes nothing.
+   - Dispatch the stable Release workflow to publish the `latest` dist-tag:
+
+     ```bash
+     gh workflow run release.yml --ref main -f dry-run=true   # optional preview
+     gh workflow run release.yml --ref main                   # publish latest
+     gh run list --workflow=release.yml -L 3                   # watch
+     ```
+
+   Publishing is tokenless (npm OIDC trusted publishing) and version-gated/idempotent — re-running is safe. No manual `npm publish`, no npm tokens.
+
+After the stable publish, `npm install @astryxdesign/vega` (no tag) resolves to the stable release; the `@canary` tag continues to track `main`.

package/dist/VegaChart.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @file VegaChart.tsx
+ * @input A Vega or Vega-Lite spec (distinguished by $schema), parse config/options, view options, and data
+ * @output A React component that renders the spec via the Vega runtime
+ * @position Primary component in @astryxdesign/vega; owns the Vega View lifecycle
+ *
+ * SYNC: When modified, update /packages/vega/README.md
+ */
+import React from 'react';
+import type { VegaChartProps } from './types';
+/**
+ * `VegaChart` renders a Vega or Vega-Lite specification using the Vega runtime.
+ *
+ * The component inspects `spec.$schema` to determine how to handle the spec:
+ * - `vega-lite` schema -> compiled to Vega via `vega-lite`'s `compile()`, then rendered
+ * - `vega` schema -> rendered directly without compilation
+ * - Invalid / missing `$schema` -> calls `onError` and renders nothing
+ *
+ * Parse and view construction are fully configurable via `parseConfig`,
+ * `parseOptions`, and `viewOptions`, which map directly to the Vega API:
+ *
+ *   vega.parse(spec, parseConfig, parseOptions)
+ *   new vega.View(runtime, { ...viewOptions, container })
+ *
+ * Initial dataset values can be provided via `data`. They are loaded once
+ * during View initialization, before the first render, and are not reactive.
+ *
+ * It owns the full `View` lifecycle: creates the view on mount, re-creates
+ * it when `spec`, `parseConfig`, `parseOptions`, or `viewOptions` changes,
+ * and calls `view.finalize()` on cleanup to release all runtime resources.
+ *
+ * Callbacks (`onReady`, `onError`) are stable across renders via refs --
+ * you don't need to memoize them. Pass stable references (or `useMemo`)
+ * for `parseConfig`, `parseOptions`, `viewOptions`, and `data` to avoid
+ * unnecessary re-renders.
+ *
+ * Note: this component does not accept `xstyle` because `@astryxdesign/vega` does not
+ * depend on StyleX. Use `className` or `style` for layout overrides.
+ *
+ * @example
+ * ```
+ * import {VegaChart} from '@astryxdesign/vega';
+ *
+ * // Vega-Lite spec -- compiled automatically
+ * <VegaChart
+ *   spec={{
+ *     $schema: 'https://vega.github.io/schema/vega-lite/v5.json',
+ *     mark: 'bar',
+ *     data: {name: 'table'},
+ *     encoding: {
+ *       x: {field: 'a', type: 'ordinal'},
+ *       y: {field: 'b', type: 'quantitative'},
+ *     },
+ *   }}
+ *   data={{table: [{a: 'A', b: 28}, {a: 'B', b: 55}]}}
+ * />
+ *
+ * // Vega spec -- rendered directly
+ * <VegaChart
+ *   spec={{$schema: 'https://vega.github.io/schema/vega/v5.json', marks: []}}
+ *   parseConfig={{background: '#1a1a1a'}}
+ *   viewOptions={{logLevel: 1, tooltip: myTooltipHandler}}
+ * />
+ * ```
+ */
+export declare function VegaChart({ spec, data, compileOptions, parseConfig, parseOptions, viewOptions, className, style, ref, onReady, onError, ...props }: VegaChartProps): React.JSX.Element;
+export declare namespace VegaChart {
+    var displayName: string;
+}
+//# sourceMappingURL=VegaChart.d.ts.map

package/dist/VegaChart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VegaChart.d.ts","sourceRoot":"","sources":["../src/VegaChart.tsx"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,OAAO,KAA0B,MAAM,OAAO,CAAC;AAI/C,OAAO,KAAK,EAAC,cAAc,EAAyB,MAAM,SAAS,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,SAAS,CAAC,EACxB,IAAI,EACJ,IAAI,EACJ,cAAc,EACd,WAAW,EACX,YAAY,EACZ,WAAW,EACX,SAAS,EACT,KAAK,EACL,GAAG,EACH,OAAO,EACP,OAAO,EACP,GAAG,KAAK,EACT,EAAE,cAAc,qBA+FhB;yBA5Ge,SAAS"}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file index.ts
+ * @input All public exports for @astryxdesign/vega
+ * @output Public API surface for the Astryx Vega wrapper package
+ * @position Barrel export; entry point for consumers of @astryxdesign/vega
+ *
+ * SYNC: When modified, update /packages/vega/README.md
+ */
+/**
+ * @file index.ts
+ * @input All public exports for @astryxdesign/vega
+ * @output Public API surface for the Astryx Vega wrapper package
+ * @position Barrel export; entry point for consumers of @astryxdesign/vega
+ *
+ * SYNC: When modified, update /packages/vega/README.md
+ */
+export { VegaChart } from './VegaChart';
+export { parseSchema } from './schema';
+export { buildVegaLiteConfig, DEFAULT_STROKE_WIDTH, DEFAULT_POINT_SIZE, DEFAULT_LEGEND_ORIENT, LEGEND_OFFSET, TITLE_OFFSET, } from './vegaLiteConfig';
+export type { VegaChartProps, AnySpec, ViewData, VegaSpec, VegaLiteSpec, CompileOptions, ParseOptions, Config, ViewOptions, LoggerInterface, } from './types';
+export type { SchemaLibrary, SchemaResult } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH;;;;;;;GAOG;AAEH,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC;AACrC,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,YAAY,GACb,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,cAAc,EACd,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,MAAM,EACN,WAAW,EACX,eAAe,GAChB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAC,aAAa,EAAE,YAAY,EAAC,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,255 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/VegaChart.tsx
+var _react = require('react');
+var _vega = require('vega');
+var _vegalite = require('vega-lite');
+
+// src/schema.ts
+var SCHEMA_RE = /schema\/([\w-]+)\/([\w.-]+)\.json$/;
+function parseSchema(schema) {
+  if (schema === void 0 || schema === null) {
+    return { ok: false, error: 'Spec is missing a $schema field. Add "$schema": "https://vega.github.io/schema/vega/v5.json" or the vega-lite equivalent.' };
+  }
+  if (typeof schema !== "string") {
+    return { ok: false, error: `$schema must be a string, got ${typeof schema}.` };
+  }
+  const match = SCHEMA_RE.exec(schema);
+  if (!match) {
+    return {
+      ok: false,
+      error: `Unrecognized $schema URL: "${schema}". Expected format: https://vega.github.io/schema/{vega|vega-lite}/{version}.json`
+    };
+  }
+  const [, library, version] = match;
+  if (library !== "vega" && library !== "vega-lite") {
+    return {
+      ok: false,
+      error: `Unknown schema library "${library}". Must be "vega" or "vega-lite".`
+    };
+  }
+  return { ok: true, library, version };
+}
+
+// src/VegaChart.tsx
+var _jsxruntime = require('react/jsx-runtime');
+function VegaChart({
+  spec,
+  data,
+  compileOptions,
+  parseConfig,
+  parseOptions,
+  viewOptions,
+  className,
+  style,
+  ref,
+  onReady,
+  onError,
+  ...props
+}) {
+  const containerRef = _react.useRef.call(void 0, null);
+  const onReadyRef = _react.useRef.call(void 0, onReady);
+  const onErrorRef = _react.useRef.call(void 0, onError);
+  onReadyRef.current = onReady;
+  onErrorRef.current = onError;
+  _react.useEffect.call(void 0, () => {
+    const container = containerRef.current;
+    if (!container) {
+      return;
+    }
+    let cancelled = false;
+    let view = null;
+    const fail = (err) => {
+      if (!cancelled) {
+        _optionalChain([onErrorRef, 'access', _ => _.current, 'optionalCall', _2 => _2(
+          err instanceof Error ? err : new Error(String(err))
+        )]);
+      }
+    };
+    try {
+      const schemaResult = parseSchema(spec.$schema);
+      if (!schemaResult.ok) {
+        fail(new Error(schemaResult.error));
+        return;
+      }
+      const vegaSpec = schemaResult.library === "vega-lite" ? _vegalite.compile.call(void 0, spec, compileOptions).spec : spec;
+      const runtime = _vega.parse.call(void 0, vegaSpec, parseConfig, parseOptions);
+      view = new (0, _vega.View)(runtime, {
+        hover: true,
+        ...viewOptions,
+        container
+      });
+      if (data) {
+        for (const [name, tuples] of Object.entries(data)) {
+          view.data(name, tuples);
+        }
+      }
+      view.runAsync().then(() => {
+        if (cancelled) {
+          _optionalChain([view, 'optionalAccess', _3 => _3.finalize, 'call', _4 => _4()]);
+          return;
+        }
+        if (view) {
+          _optionalChain([onReadyRef, 'access', _5 => _5.current, 'optionalCall', _6 => _6(view)]);
+        }
+      }).catch(fail);
+    } catch (err) {
+      fail(err);
+    }
+    return () => {
+      cancelled = true;
+      _optionalChain([view, 'optionalAccess', _7 => _7.finalize, 'call', _8 => _8()]);
+    };
+  }, [spec, data, compileOptions, parseConfig, parseOptions, viewOptions]);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    "div",
+    {
+      ref: (node) => {
+        containerRef.current = node;
+        if (typeof ref === "function") {
+          ref(node);
+        } else if (ref) {
+          ref.current = node;
+        }
+      },
+      className,
+      style,
+      ...props
+    }
+  );
+}
+VegaChart.displayName = "VegaChart";
+
+// src/vegaLiteConfig.ts
+var DEFAULT_STROKE_WIDTH = 2;
+var DEFAULT_POINT_SIZE = 64;
+var DEFAULT_LEGEND_ORIENT = "right";
+var LEGEND_OFFSET = 16;
+var TITLE_OFFSET = 16;
+function buildVegaLiteConfig(token) {
+  return {
+    axis: {
+      domainColor: token("--color-icon-primary"),
+      domainWidth: 0.5,
+      gridColor: token("--color-background-muted"),
+      labelColor: token("--color-text-secondary"),
+      labelFont: token("--font-family-body"),
+      labelFontSize: 12,
+      labelLineHeight: 16,
+      labelPadding: 8,
+      tickCount: 5,
+      ticks: false,
+      title: null
+    },
+    axisX: {
+      grid: false
+    },
+    axisXQuantitative: {
+      domain: true
+    },
+    axisY: {
+      domain: false
+    },
+    axisYQuantitative: {
+      grid: true,
+      gridWidth: 0.5
+    },
+    background: token("--color-background-card"),
+    legend: {
+      labelColor: token("--color-text-secondary"),
+      labelFont: token("--font-family-body"),
+      labelFontSize: 12,
+      labelPadding: 8,
+      offset: LEGEND_OFFSET,
+      orient: DEFAULT_LEGEND_ORIENT,
+      rowPadding: 12,
+      title: null,
+      titleColor: token("--color-text-secondary"),
+      titleFont: token("--font-family-heading"),
+      titleFontSize: 16
+    },
+    line: {
+      strokeCap: "round",
+      strokeJoin: "round",
+      strokeWidth: DEFAULT_STROKE_WIDTH
+    },
+    padding: 16,
+    point: {
+      shape: "circle",
+      size: DEFAULT_POINT_SIZE,
+      fill: token("--color-background-card")
+    },
+    range: {
+      category: [
+        token("--color-data-categorical-blue"),
+        token("--color-data-categorical-orange"),
+        token("--color-data-categorical-purple"),
+        token("--color-data-categorical-green"),
+        token("--color-data-categorical-pink"),
+        token("--color-data-categorical-cyan"),
+        token("--color-data-categorical-red"),
+        token("--color-data-categorical-teal"),
+        token("--color-data-categorical-brown"),
+        token("--color-data-categorical-indigo")
+      ],
+      diverging: [
+        token("--color-data-blue-5"),
+        token("--color-data-blue-4"),
+        token("--color-data-blue-3"),
+        token("--color-data-blue-2"),
+        token("--color-data-blue-1"),
+        token("--color-data-gray-1"),
+        token("--color-data-red-1"),
+        token("--color-data-red-2"),
+        token("--color-data-red-3"),
+        token("--color-data-red-4"),
+        token("--color-data-red-5")
+      ],
+      heatmap: [
+        token("--color-data-blue-1"),
+        token("--color-data-blue-2"),
+        token("--color-data-blue-3"),
+        token("--color-data-blue-4"),
+        token("--color-data-blue-5")
+      ],
+      ordinal: [
+        token("--color-data-blue-5"),
+        token("--color-data-blue-4"),
+        token("--color-data-blue-3"),
+        token("--color-data-blue-2"),
+        token("--color-data-blue-1")
+      ],
+      ramp: [
+        token("--color-data-blue-1"),
+        token("--color-data-blue-2"),
+        token("--color-data-blue-3"),
+        token("--color-data-blue-4"),
+        token("--color-data-blue-5")
+      ]
+    },
+    scale: {
+      bandPaddingInner: 0.1
+    },
+    text: {
+      color: token("--color-text-primary")
+    },
+    title: {
+      anchor: "start",
+      color: token("--color-text-primary"),
+      subtitleFontWeight: "normal",
+      subtitleColor: token("--color-text-secondary"),
+      offset: TITLE_OFFSET
+    },
+    view: {
+      stroke: null
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_LEGEND_ORIENT = DEFAULT_LEGEND_ORIENT; exports.DEFAULT_POINT_SIZE = DEFAULT_POINT_SIZE; exports.DEFAULT_STROKE_WIDTH = DEFAULT_STROKE_WIDTH; exports.LEGEND_OFFSET = LEGEND_OFFSET; exports.TITLE_OFFSET = TITLE_OFFSET; exports.VegaChart = VegaChart; exports.buildVegaLiteConfig = buildVegaLiteConfig; exports.parseSchema = parseSchema;