@ggts-sh/svelte 0.43.0

package/dist/runtime/semantic-keys-resolve.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Pure resolveSemanticKeys: durable row keys + interaction diagnostics.
+ * Source identity / epoch tokens: semantic-source-identity.ts,
+ * semantic-data-identity.ts. Projection cache: semantic-keys-projection.ts.
+ */
+import type { CellValue } from "@ggts-sh/core";
+import type { InteractionDiagnostic } from "../interaction/interaction.js";
+export type SemanticKeyCandidate = {
+    readonly id: number;
+    readonly rowIndex: number | null;
+    readonly layerIndex: number;
+    readonly lineage: number;
+};
+type SemanticKeyLayer = {
+    readonly geom: string;
+    readonly params?: Record<string, unknown> | undefined;
+};
+/** Narrow model surface needed for key resolution (no RenderModel import). */
+export type SemanticKeyModelView = {
+    readonly candidateCount: number;
+    candidate(id: number): SemanticKeyCandidate | null;
+    lineageKeys(lineageId: number): Iterable<number>;
+    row(rowIndex: number): Record<string, CellValue> | null;
+    readonly layers: readonly SemanticKeyLayer[];
+};
+export type ResolveSemanticKeysInput = {
+    readonly model: SemanticKeyModelView;
+    readonly datumKey: string | number | symbol | ((row: never, index: number) => PropertyKey) | undefined;
+    /**
+     * Mutable per-component map of rowIdentity → last key. Caller owns lifetime;
+     * this function mutates it in place (same as GGPlot historically).
+     */
+    readonly priorKeys: Map<string, PropertyKey>;
+    /** Stable identity for a source row within the current data/spec epoch. */
+    readonly rowIdentity: (rowIndex: number) => string;
+};
+export type ResolveSemanticKeysResult = {
+    readonly keys: Map<number, PropertyKey | null>;
+    readonly diagnostics: InteractionDiagnostic[];
+};
+export type SemanticKeysPlotModel = {
+    readonly candidates: {
+        readonly size: number;
+        candidate(id: number): SemanticKeyCandidate | null;
+    };
+    readonly lineage: {
+        keys(lineageId: number): Iterable<number>;
+    };
+    row(rowIndex: number): Record<string, CellValue> | null;
+};
+/**
+ * Resolve semantic keys for a GGPlot host: null model → empty bag; else adapt
+ * the render model into `SemanticKeyModelView` and call `resolveSemanticKeys`.
+ */
+export declare function resolveSemanticKeysForPlot(input: {
+    readonly model: SemanticKeysPlotModel | null;
+    readonly layers: readonly SemanticKeyLayer[];
+    readonly datumKey: ResolveSemanticKeysInput["datumKey"];
+    readonly priorKeys: Map<string, PropertyKey>;
+    readonly dataToken: string;
+    readonly specToken: string;
+}): ResolveSemanticKeysResult;
+/**
+ * Resolve durable semantic keys for interaction, emitting diagnostics in
+ * encounter order: synthetic-rule missing lineage, per-candidate missing
+ * lineage, then per-row invalid / unstable / duplicate key diagnostics.
+ */
+export declare function resolveSemanticKeys(input: ResolveSemanticKeysInput): ResolveSemanticKeysResult;
+export {};

package/dist/runtime/semantic-keys-resolve.js

@@ -0,0 +1,122 @@
+import { INTERACTION_DIAGNOSTIC_CATALOG } from "../interaction/interaction.js";
+/** Empty semantic-key bag when there is no render model. */
+function emptySemanticKeysResult() {
+    return {
+        keys: new Map(),
+        diagnostics: [],
+    };
+}
+/**
+ * Resolve semantic keys for a GGPlot host: null model → empty bag; else adapt
+ * the render model into `SemanticKeyModelView` and call `resolveSemanticKeys`.
+ */
+export function resolveSemanticKeysForPlot(input) {
+    if (input.model === null)
+        return emptySemanticKeysResult();
+    const model = input.model;
+    return resolveSemanticKeys({
+        model: {
+            candidateCount: model.candidates.size,
+            candidate: (id) => model.candidates.candidate(id),
+            lineageKeys: (lineageId) => model.lineage.keys(lineageId),
+            row: (rowIndex) => model.row(rowIndex),
+            layers: input.layers,
+        },
+        datumKey: input.datumKey,
+        priorKeys: input.priorKeys,
+        rowIdentity: (rowIndex) => `${input.dataToken}:${input.specToken}:${rowIndex}`,
+    });
+}
+function sourceRowsForSemanticKeys(model, diagnostics) {
+    const sourceRows = new Set();
+    if (model.candidateCount === 0 &&
+        model.layers.some((layer) => layer.geom === "rule" &&
+            (layer.params?.["xintercept"] !== undefined || layer.params?.["yintercept"] !== undefined)))
+        diagnostics.push({
+            ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_MISSING_LINEAGE,
+            actual: "synthetic rule has no source rows",
+        });
+    const lineageEmpty = new Map();
+    for (let id = 0; id < model.candidateCount; id++) {
+        const candidate = model.candidate(id);
+        if (candidate === null)
+            continue;
+        if (candidate.rowIndex !== null)
+            sourceRows.add(candidate.rowIndex);
+        const lineageId = candidate.lineage;
+        let empty = lineageEmpty.get(lineageId);
+        if (empty === undefined) {
+            empty = true;
+            for (const rowIndex of model.lineageKeys(lineageId)) {
+                empty = false;
+                sourceRows.add(rowIndex);
+            }
+            lineageEmpty.set(lineageId, empty);
+        }
+        if (candidate.rowIndex === null && empty)
+            diagnostics.push({
+                ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_MISSING_LINEAGE,
+                actual: { layerIndex: candidate.layerIndex, candidateId: candidate.id },
+            });
+    }
+    return sourceRows;
+}
+/**
+ * Resolve durable semantic keys for interaction, emitting diagnostics in
+ * encounter order: synthetic-rule missing lineage, per-candidate missing
+ * lineage, then per-row invalid / unstable / duplicate key diagnostics.
+ */
+export function resolveSemanticKeys(input) {
+    const keys = new Map();
+    const diagnostics = [];
+    const { model, datumKey, priorKeys, rowIdentity } = input;
+    if (datumKey === undefined)
+        return { keys, diagnostics };
+    const owners = new Map();
+    // Expand each lineage id once. Smooth / aggregate eval-grid marks share one
+    // membership array across C marks (#1140) — re-spreading was O(C·L).
+    const sourceRows = sourceRowsForSemanticKeys(model, diagnostics);
+    for (const rowIndex of sourceRows) {
+        const row = model.row(rowIndex);
+        const value = row === null
+            ? null
+            : typeof datumKey === "function"
+                ? datumKey(row, rowIndex)
+                : row[datumKey];
+        if (typeof value !== "string" && typeof value !== "number" && typeof value !== "symbol") {
+            keys.set(rowIndex, null);
+            diagnostics.push({
+                ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_INVALID_KEY,
+                actual: value,
+            });
+            continue;
+        }
+        if (row !== null) {
+            const identity = rowIdentity(rowIndex);
+            const priorKey = priorKeys.get(identity);
+            if (priorKey !== undefined && priorKey !== value) {
+                keys.set(rowIndex, null);
+                diagnostics.push({
+                    ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_UNSTABLE_KEY,
+                    actual: { previous: priorKey, current: value },
+                });
+                continue;
+            }
+            priorKeys.set(identity, value);
+        }
+        const prior = owners.get(value);
+        if (prior !== undefined && prior !== rowIndex) {
+            keys.set(prior, null);
+            keys.set(rowIndex, null);
+            diagnostics.push({
+                ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_DUPLICATE_KEY,
+                actual: value,
+            });
+        }
+        else {
+            owners.set(value, rowIndex);
+            keys.set(rowIndex, value);
+        }
+    }
+    return { keys, diagnostics };
+}

package/dist/runtime/semantic-keys.svelte.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Reactive semantic-key service for GGPlot.
+ *
+ * Owns priorKeys, derived key resolution, candidate key cache, and diagnostics
+ * delivery. Pure helpers: semantic-keys-resolve.ts, semantic-keys-projection.ts,
+ * semantic-data-identity.ts, semantic-source-identity.ts.
+ */
+import type { CandidateFacts, CellValue, RenderModel } from "@ggts-sh/core";
+import type { PortableSpec } from "@ggts-sh/spec";
+import type { InteractionDiagnostic } from "../interaction/interaction.js";
+export type SemanticKeyServiceDeps = {
+    model: () => RenderModel | null;
+    assembled: () => PortableSpec | null;
+    datumKey: () => string | number | symbol | ((row: never, index: number) => PropertyKey) | undefined;
+    data: () => unknown;
+    spec: () => unknown;
+    sourceIdentity: (value: unknown) => string;
+    deliverDiagnostic: (diagnostic: InteractionDiagnostic) => void;
+};
+export type SemanticKeyService = {
+    semanticKey(row: Record<string, CellValue> | null, index: number | null): PropertyKey | null;
+    candidateSemanticKeys(candidate: CandidateFacts): PropertyKey[];
+    /** Direct map lookup (inspection coordinator / mask paths). */
+    keyAt(index: number): PropertyKey | null;
+};
+/**
+ * Owns priorKeys, semantic key resolution, and diagnostics delivery.
+ * Diagnostics `$effect` registers at construction (#627).
+ */
+export declare function createSemanticKeyService(deps: SemanticKeyServiceDeps): SemanticKeyService;

package/dist/runtime/semantic-keys.svelte.js

@@ -0,0 +1,69 @@
+import { candidateSemanticKeysFromCache, createCandidateKeysProjectionCache, } from "./semantic-keys-projection.js";
+import { resolveSemanticKeysForPlot } from "./semantic-keys-resolve.js";
+/**
+ * Owns priorKeys, semantic key resolution, and diagnostics delivery.
+ * Diagnostics `$effect` registers at construction (#627).
+ */
+export function createSemanticKeyService(deps) {
+    // Owned for the component lifetime; resolveSemanticKeys mutates in place.
+    const priorKeys = new Map();
+    const semanticKeys = $derived.by(() => {
+        const model = deps.model();
+        return resolveSemanticKeysForPlot({
+            model: model === null
+                ? null
+                : {
+                    candidates: model.candidates,
+                    lineage: model.lineage,
+                    row: (rowIndex) => model.row(rowIndex),
+                },
+            layers: deps.assembled()?.layers ?? [],
+            datumKey: deps.datumKey(),
+            priorKeys,
+            dataToken: deps.sourceIdentity(deps.data()),
+            specToken: deps.sourceIdentity(deps.spec()),
+        });
+    });
+    $effect(() => {
+        for (const diagnostic of semanticKeys.diagnostics)
+            deps.deliverDiagnostic(diagnostic);
+    });
+    function semanticKey(row, index) {
+        if (row === null || index === null || deps.datumKey() === undefined)
+            return null;
+        return semanticKeys.keys.get(index) ?? null;
+    }
+    /**
+     * Shared candidate→semantic-keys cache for the current model/key epoch.
+     * Interval, selection anchors, and interaction masks all used to re-walk
+     * lineage independently (~3× O(C×L) per reactive turn). Entries fill lazily
+     * on first lookup so single-candidate paths (point toggle) stay O(L); full
+     * store consumers share one projection after the first walk. Smooth
+     * eval-grid marks that share a lineage expand membership once, not once
+     * per mark. Cache bags are mutated after the derived produces them —
+     * intentional memoization, not reactive state. Fresh bag when model/keys change.
+     */
+    const candidateKeysEpoch = $derived.by(() => {
+        const model = deps.model();
+        // Depend on the row-key bag so key invalidation clears the cache.
+        const rowKeys = semanticKeys.keys;
+        return {
+            model,
+            rowKeys,
+            cache: createCandidateKeysProjectionCache(),
+        };
+    });
+    function candidateSemanticKeys(candidate) {
+        const { model, rowKeys, cache } = candidateKeysEpoch;
+        if (model === null)
+            return [];
+        return candidateSemanticKeysFromCache(candidate, cache, (lineageId) => model.lineage.keys(lineageId), (rowIndex) => rowKeys.get(rowIndex) ?? null);
+    }
+    return {
+        semanticKey,
+        candidateSemanticKeys,
+        keyAt(index) {
+            return semanticKeys.keys.get(index) ?? null;
+        },
+    };
+}

package/dist/runtime/semantic-source-identity.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Source-identity tracker owned by one GGPlot instance for the component
+ * lifetime. Do not clear: clearing would silently reset dataIdentityEpoch and
+ * break unstable-key detection across respecs.
+ */
+export type SourceIdentityTracker = {
+    sourceIdentity(value: unknown): string;
+};
+export declare function createSourceIdentityTracker(): SourceIdentityTracker;

package/dist/runtime/semantic-source-identity.js

@@ -0,0 +1,16 @@
+export function createSourceIdentityTracker() {
+    const sourceIdentities = new WeakMap();
+    let nextSourceIdentity = 1;
+    return {
+        sourceIdentity(value) {
+            if ((typeof value !== "object" && typeof value !== "function") || value === null)
+                return String(value);
+            let identity = sourceIdentities.get(value);
+            if (identity === undefined) {
+                identity = nextSourceIdentity++;
+                sourceIdentities.set(value, identity);
+            }
+            return String(identity);
+        },
+    };
+}

package/dist/scale/Scale.svelte

@@ -0,0 +1,26 @@
+<script lang="ts">
+  /**
+   * <Scale> — declaration-only scale layer for <GGPlot> (#659).
+   * Escape hatch: pass a whole `Scales` fragment via `value`. Named shells
+   * (<ScaleColorDiscrete/>, <ScaleXContinuous/>, <ScaleSizeContinuous/>, …)
+   * are preferred when the helper is known at authoring time; use this form
+   * for raw fragments, computed scales, and variable references.
+   *
+   * Emits NO markup; registers a live scale layer during component init and
+   * unregisters on destroy. Inert without a <GGPlot> ancestor.
+   *
+   * Byte-identity-preserving for raw fragments (D8): `value` is not routed
+   * through a helper, so migrating `scales={{color:{scheme:"x"}}}` →
+   * `<Scale value={{color:{scheme:"x"}}}/>` keeps PortableSpec bytes identical.
+   */
+  import type { Scales } from "@ggts-sh/spec";
+
+  import { createPlotLayer } from "../layers/plot-layer.svelte.js";
+
+  type Props = {
+    value: Scales;
+  };
+
+  const props: Props = $props();
+  createPlotLayer("scale", () => props.value);
+</script>

package/dist/scale/Scale.svelte.d.ts

@@ -0,0 +1,21 @@
+/**
+   * <Scale> — declaration-only scale layer for <GGPlot> (#659).
+   * Escape hatch: pass a whole `Scales` fragment via `value`. Named shells
+   * (<ScaleColorDiscrete/>, <ScaleXContinuous/>, <ScaleSizeContinuous/>, …)
+   * are preferred when the helper is known at authoring time; use this form
+   * for raw fragments, computed scales, and variable references.
+   *
+   * Emits NO markup; registers a live scale layer during component init and
+   * unregisters on destroy. Inert without a <GGPlot> ancestor.
+   *
+   * Byte-identity-preserving for raw fragments (D8): `value` is not routed
+   * through a helper, so migrating `scales={{color:{scheme:"x"}}}` →
+   * `<Scale value={{color:{scheme:"x"}}}/>` keeps PortableSpec bytes identical.
+   */
+import type { Scales } from "@ggts-sh/spec";
+type Props = {
+    value: Scales;
+};
+declare const Scale: import("svelte").Component<Props, {}, "">;
+type Scale = ReturnType<typeof Scale>;
+export default Scale;

package/dist/scale/ScaleAlphaBinned.svelte

@@ -0,0 +1,14 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleAlphaBinned,
+    type SequentialStyleScaleOptions,
+  } from "@ggts-sh/spec";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: SequentialStyleScaleOptions = $props();
+  createPlotLayer("scale", () => scaleAlphaBinned(definedProps(props)));
+</script>

package/dist/scale/ScaleAlphaBinned.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type SequentialStyleScaleOptions } from "@ggts-sh/spec";
+declare const ScaleAlphaBinned: import("svelte").Component<SequentialStyleScaleOptions, {}, "">;
+type ScaleAlphaBinned = ReturnType<typeof ScaleAlphaBinned>;
+export default ScaleAlphaBinned;

package/dist/scale/ScaleAlphaContinuous.svelte

@@ -0,0 +1,14 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleAlphaContinuous,
+    type SequentialStyleScaleOptions,
+  } from "@ggts-sh/spec";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: SequentialStyleScaleOptions = $props();
+  createPlotLayer("scale", () => scaleAlphaContinuous(definedProps(props)));
+</script>

package/dist/scale/ScaleAlphaContinuous.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type SequentialStyleScaleOptions } from "@ggts-sh/spec";
+declare const ScaleAlphaContinuous: import("svelte").Component<SequentialStyleScaleOptions, {}, "">;
+type ScaleAlphaContinuous = ReturnType<typeof ScaleAlphaContinuous>;
+export default ScaleAlphaContinuous;

package/dist/scale/ScaleAlphaDate.svelte

@@ -0,0 +1,15 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleAlphaDate,
+    type TemporalNumericStyleScaleOptions,
+  } from "@ggts-sh/spec";
+  import "@ggts-sh/core/temporal";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: TemporalNumericStyleScaleOptions = $props();
+  createPlotLayer("scale", () => scaleAlphaDate(definedProps(props)));
+</script>

package/dist/scale/ScaleAlphaDate.svelte.d.ts

@@ -0,0 +1,5 @@
+import { type TemporalNumericStyleScaleOptions } from "@ggts-sh/spec";
+import "@ggts-sh/core/temporal";
+declare const ScaleAlphaDate: import("svelte").Component<TemporalNumericStyleScaleOptions, {}, "">;
+type ScaleAlphaDate = ReturnType<typeof ScaleAlphaDate>;
+export default ScaleAlphaDate;

package/dist/scale/ScaleAlphaDatetime.svelte

@@ -0,0 +1,15 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleAlphaDatetime,
+    type TemporalNumericStyleScaleOptions,
+  } from "@ggts-sh/spec";
+  import "@ggts-sh/core/temporal";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: TemporalNumericStyleScaleOptions = $props();
+  createPlotLayer("scale", () => scaleAlphaDatetime(definedProps(props)));
+</script>

package/dist/scale/ScaleAlphaDatetime.svelte.d.ts

@@ -0,0 +1,5 @@
+import { type TemporalNumericStyleScaleOptions } from "@ggts-sh/spec";
+import "@ggts-sh/core/temporal";
+declare const ScaleAlphaDatetime: import("svelte").Component<TemporalNumericStyleScaleOptions, {}, "">;
+type ScaleAlphaDatetime = ReturnType<typeof ScaleAlphaDatetime>;
+export default ScaleAlphaDatetime;

package/dist/scale/ScaleAlphaDiscrete.svelte

@@ -0,0 +1,14 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleAlphaDiscrete,
+    type DiscreteNumericStyleScaleOptions,
+  } from "@ggts-sh/spec";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: DiscreteNumericStyleScaleOptions = $props();
+  createPlotLayer("scale", () => scaleAlphaDiscrete(definedProps(props)));
+</script>

package/dist/scale/ScaleAlphaDiscrete.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type DiscreteNumericStyleScaleOptions } from "@ggts-sh/spec";
+declare const ScaleAlphaDiscrete: import("svelte").Component<DiscreteNumericStyleScaleOptions, {}, "">;
+type ScaleAlphaDiscrete = ReturnType<typeof ScaleAlphaDiscrete>;
+export default ScaleAlphaDiscrete;

package/dist/scale/ScaleAlphaIdentity.svelte

@@ -0,0 +1,14 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleAlphaIdentity,
+    type IdentityNumericStyleScaleOptions,
+  } from "@ggts-sh/spec";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: IdentityNumericStyleScaleOptions = $props();
+  createPlotLayer("scale", () => scaleAlphaIdentity(definedProps(props)));
+</script>

package/dist/scale/ScaleAlphaIdentity.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type IdentityNumericStyleScaleOptions } from "@ggts-sh/spec";
+declare const ScaleAlphaIdentity: import("svelte").Component<IdentityNumericStyleScaleOptions, {}, "">;
+type ScaleAlphaIdentity = ReturnType<typeof ScaleAlphaIdentity>;
+export default ScaleAlphaIdentity;

package/dist/scale/ScaleAlphaManual.svelte

@@ -0,0 +1,14 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleAlphaManual,
+    type ManualNumericStyleScaleOptions,
+  } from "@ggts-sh/spec";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: ManualNumericStyleScaleOptions = $props();
+  createPlotLayer("scale", () => scaleAlphaManual(definedProps(props)));
+</script>

package/dist/scale/ScaleAlphaManual.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type ManualNumericStyleScaleOptions } from "@ggts-sh/spec";
+declare const ScaleAlphaManual: import("svelte").Component<ManualNumericStyleScaleOptions, {}, "">;
+type ScaleAlphaManual = ReturnType<typeof ScaleAlphaManual>;
+export default ScaleAlphaManual;

package/dist/scale/ScaleColorBinned.svelte

@@ -0,0 +1,14 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleColorBinned,
+    type BinnedColorScaleOptions,
+  } from "@ggts-sh/spec";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: BinnedColorScaleOptions = $props();
+  createPlotLayer("scale", () => scaleColorBinned(definedProps(props)));
+</script>

package/dist/scale/ScaleColorBinned.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const ScaleColorBinned: import("svelte").Component<import("@ggts-sh/spec").SequentialColorScaleOptions, {}, "">;
+type ScaleColorBinned = ReturnType<typeof ScaleColorBinned>;
+export default ScaleColorBinned;

package/dist/scale/ScaleColorBrewer.svelte

@@ -0,0 +1,14 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleColorBrewer,
+    type ColorBrewerScaleOptions,
+  } from "@ggts-sh/spec";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: ColorBrewerScaleOptions = $props();
+  createPlotLayer("scale", () => scaleColorBrewer(definedProps(props)));
+</script>

package/dist/scale/ScaleColorBrewer.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type ColorBrewerScaleOptions } from "@ggts-sh/spec";
+declare const ScaleColorBrewer: import("svelte").Component<ColorBrewerScaleOptions, {}, "">;
+type ScaleColorBrewer = ReturnType<typeof ScaleColorBrewer>;
+export default ScaleColorBrewer;

package/dist/scale/ScaleColorContinuous.svelte

@@ -0,0 +1,14 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleColorContinuous,
+    type SequentialColorScaleOptions,
+  } from "@ggts-sh/spec";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: SequentialColorScaleOptions = $props();
+  createPlotLayer("scale", () => scaleColorContinuous(definedProps(props)));
+</script>

package/dist/scale/ScaleColorContinuous.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type SequentialColorScaleOptions } from "@ggts-sh/spec";
+declare const ScaleColorContinuous: import("svelte").Component<SequentialColorScaleOptions, {}, "">;
+type ScaleColorContinuous = ReturnType<typeof ScaleColorContinuous>;
+export default ScaleColorContinuous;

package/dist/scale/ScaleColorDate.svelte

@@ -0,0 +1,15 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleColorDate,
+    type TemporalColorScaleOptions,
+  } from "@ggts-sh/spec";
+  import "@ggts-sh/core/temporal";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: TemporalColorScaleOptions = $props();
+  createPlotLayer("scale", () => scaleColorDate(definedProps(props)));
+</script>

package/dist/scale/ScaleColorDate.svelte.d.ts

@@ -0,0 +1,5 @@
+import { type TemporalColorScaleOptions } from "@ggts-sh/spec";
+import "@ggts-sh/core/temporal";
+declare const ScaleColorDate: import("svelte").Component<TemporalColorScaleOptions, {}, "">;
+type ScaleColorDate = ReturnType<typeof ScaleColorDate>;
+export default ScaleColorDate;

package/dist/scale/ScaleColorDatetime.svelte

@@ -0,0 +1,15 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleColorDatetime,
+    type TemporalColorScaleOptions,
+  } from "@ggts-sh/spec";
+  import "@ggts-sh/core/temporal";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: TemporalColorScaleOptions = $props();
+  createPlotLayer("scale", () => scaleColorDatetime(definedProps(props)));
+</script>

package/dist/scale/ScaleColorDatetime.svelte.d.ts

@@ -0,0 +1,5 @@
+import { type TemporalColorScaleOptions } from "@ggts-sh/spec";
+import "@ggts-sh/core/temporal";
+declare const ScaleColorDatetime: import("svelte").Component<TemporalColorScaleOptions, {}, "">;
+type ScaleColorDatetime = ReturnType<typeof ScaleColorDatetime>;
+export default ScaleColorDatetime;

package/dist/scale/ScaleColorDiscrete.svelte

@@ -0,0 +1,14 @@
+<!-- GENERATED by scripts/gen-scale-children.ts — do not edit. Run: bun run scale:children:gen -->
+<script lang="ts">
+  import {
+    scaleColorDiscrete,
+    type DiscreteColorScaleOptions,
+  } from "@ggts-sh/spec";
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: DiscreteColorScaleOptions = $props();
+  createPlotLayer("scale", () => scaleColorDiscrete(definedProps(props)));
+</script>