@ggts-sh/svelte 0.43.0

package/dist/chrome/chrome-state.svelte.js

@@ -0,0 +1,158 @@
+import { INTERACTION_DIAGNOSTIC_CATALOG, } from "../interaction/interaction.js";
+import { bandChannelsForZoom, canPublishPointSelection as canPublishPointSelectionFromSelect, capabilityStatusText, isEmptyPlotScene, legendFocusDiscreteOnlyDiagnostics, resolveFilteredAvailableTools, shouldShowToolRail, zoomScaleDiagnosticsFromChannels, zoomSupportsChannel, } from "../interaction/capability.js";
+import { datumLabel as datumLabelFor, labelFromFields, markLabel as markLabelFor, uniqueMappedFields, } from "../assembly/labels.js";
+import { isContainerWidthProp, plotRootInlineStyle } from "../assembly/layout.js";
+import { themeTokensToCss } from "./theme-css.js";
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create the plot chrome controller. All deriveds are construction-time —
+ * every dep is earlier-declared at the host factory position. No $state,
+ * handlers, or effects.
+ */
+export function createPlotChromeState(deps) {
+    const zoomHasSupportedChannel = $derived.by(() => {
+        const zoom = deps.zoomConfig();
+        const model = deps.model();
+        if (zoom === null || model === null)
+            return true;
+        return zoomSupportsChannel(zoom.mode, model.scales);
+    });
+    const availableTools = $derived(resolveFilteredAvailableTools(deps.configuredAvailableTools(), deps.zoomConfig(), deps.model()?.scales ?? null));
+    const canPublishPointSelection = $derived(canPublishPointSelectionFromSelect(deps.selectConfig()));
+    // Shared by tool-rail visibility and ToolRail recovery props (avoid dual calc).
+    const hasPointSelection = $derived(canPublishPointSelection && deps.effectiveSelectedKeys().length > 0);
+    // R3: interval presence covers dormant panel intervals, not just the
+    // committed one (effectiveIntervals), so recovery controls stay reachable.
+    const hasIntervalSelection = $derived(deps.effectiveIntervals().length > 0);
+    const hasZoomDomains = $derived(deps.effectiveZoomDomains() !== null);
+    const showToolRail = $derived(shouldShowToolRail({
+        interactive: deps.interactive(),
+        availableToolCount: availableTools.length,
+        canPublishPointSelection,
+        selectedKeyCount: deps.effectiveSelectedKeys().length,
+        hasIntervalSelection,
+        hasZoomDomains,
+    }));
+    const emptyPlot = $derived.by(() => {
+        const model = deps.model();
+        return model !== null && isEmptyPlotScene(model.scene.batches);
+    });
+    const preciseIntervalAxes = $derived.by(() => {
+        const selectOptions = deps.selectConfig();
+        if (selectOptions === null || selectOptions.type !== "interval")
+            return [];
+        return ["x", "y"].filter((axis) => selectOptions.mode === "xy" || selectOptions.mode === axis);
+    });
+    const preciseZoomAxes = $derived.by(() => {
+        const zoom = deps.zoomConfig();
+        const model = deps.model();
+        if (zoom === null || model === null)
+            return [];
+        return ["x", "y"].filter((axis) => (zoom.mode === "xy" || zoom.mode === axis) && model.scales[axis].type !== "band");
+    });
+    const areaScaleDiagnostics = $derived.by(() => {
+        const model = deps.model();
+        const zoom = deps.zoomConfig();
+        if (model === null || zoom === null)
+            return [];
+        return zoomScaleDiagnosticsFromChannels(bandChannelsForZoom(zoom.mode, model.scales), INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_INTERVAL_SCALE_UNSUPPORTED);
+    });
+    const legendDiagnostics = $derived.by(() => {
+        const model = deps.model();
+        if (model === null)
+            return [];
+        return legendFocusDiscreteOnlyDiagnostics(deps.legendFocusEnabled(), model.scene.legends);
+    });
+    const capabilityStatus = $derived.by(() => {
+        const unavailable = deps
+            .interactionDiagnostics()
+            .find((diagnostic) => diagnostic.code === "INTERACTION_INTERVAL_FACET_UNSUPPORTED");
+        const model = deps.model();
+        return capabilityStatusText({
+            ...(unavailable !== undefined && {
+                facetUnavailableMessage: unavailable.message,
+            }),
+            areaDiagnostics: areaScaleDiagnostics,
+            zoomSupported: zoomHasSupportedChannel,
+            interactive: deps.interactive(),
+            emptyPlot,
+            candidateCount: model === null ? null : model.candidates.size,
+        });
+    });
+    const themeStyle = $derived.by(() => {
+        const model = deps.model();
+        return model === null ? "" : themeTokensToCss(model.scene.theme);
+    });
+    const rootStyle = $derived(plotRootInlineStyle({
+        needsSizedBox: deps.hasCanvas() ||
+            deps.interactive() ||
+            deps.effectiveEmphasisKeys().length > 0 ||
+            deps.effectiveSelectedKeys().length > 0,
+        containerWidth: isContainerWidthProp(deps.width()),
+        sceneWidth: deps.model()?.scene.width ?? deps.resolvedWidth(),
+        sceneHeight: deps.model()?.scene.height ?? deps.resolvedHeight(),
+        themeStyle,
+    }));
+    // Stable SceneView callback identity when model is unchanged. Unique field
+    // list is built once per model so per-mark labels do not re-flatten
+    // layerFields (#1329).
+    const markLabel = $derived.by(() => {
+        const model = deps.model();
+        if (model === null)
+            return (row) => markLabelFor(null, row);
+        const fields = uniqueMappedFields(model);
+        return (row) => {
+            const values = model.row(row);
+            if (values === null)
+                return `data point ${row + 1}`;
+            return labelFromFields(fields, values, `data point ${row + 1}`);
+        };
+    });
+    function datumLabel(values) {
+        return datumLabelFor(deps.model(), values);
+    }
+    return {
+        get availableTools() {
+            return availableTools;
+        },
+        get canPublishPointSelection() {
+            return canPublishPointSelection;
+        },
+        get hasPointSelection() {
+            return hasPointSelection;
+        },
+        get hasIntervalSelection() {
+            return hasIntervalSelection;
+        },
+        get showToolRail() {
+            return showToolRail;
+        },
+        get emptyPlot() {
+            return emptyPlot;
+        },
+        get preciseIntervalAxes() {
+            return preciseIntervalAxes;
+        },
+        get preciseZoomAxes() {
+            return preciseZoomAxes;
+        },
+        get areaScaleDiagnostics() {
+            return areaScaleDiagnostics;
+        },
+        get legendDiagnostics() {
+            return legendDiagnostics;
+        },
+        get capabilityStatus() {
+            return capabilityStatus;
+        },
+        get rootStyle() {
+            return rootStyle;
+        },
+        get markLabel() {
+            return markLabel;
+        },
+        datumLabel,
+    };
+}

package/dist/chrome/theme-css.d.ts

@@ -0,0 +1,16 @@
+/** Interaction theme roles exposed as CSS custom properties on the plot root.
+ *  Values may be color strings or numeric opacities (e.g. interactionMuted). */
+export type PlotThemeCssTokens = {
+    readonly interactionInk: string | number;
+    readonly interactionMuted: string | number;
+    readonly focusRing: string | number;
+    readonly crosshair: string | number;
+    readonly selectionFill: string | number;
+    readonly selectionStroke: string | number;
+    readonly tooltipPaper: string | number;
+    readonly tooltipInk: string | number;
+    readonly tooltipBorder: string | number;
+    readonly toolActive: string | number;
+};
+/** Stable role-order CSS custom property string for interaction chrome. */
+export declare function themeTokensToCss(tokens: PlotThemeCssTokens): string;

package/dist/chrome/theme-css.js

@@ -0,0 +1,16 @@
+const THEME_ROLES = [
+    "interactionInk",
+    "interactionMuted",
+    "focusRing",
+    "crosshair",
+    "selectionFill",
+    "selectionStroke",
+    "tooltipPaper",
+    "tooltipInk",
+    "tooltipBorder",
+    "toolActive",
+];
+/** Stable role-order CSS custom property string for interaction chrome. */
+export function themeTokensToCss(tokens) {
+    return THEME_ROLES.map((role) => `--gg-theme-${role}:${tokens[role]}`).join(";");
+}

package/dist/codemod/cli.d.ts

@@ -0,0 +1,16 @@
+/** Filesystem and streams, injected so the command stays pure. */
+export interface CodemodIO {
+    /** Every .svelte file at `path`, which may be a file or a directory. */
+    listSvelteFiles: (path: string) => string[];
+    readFile: (path: string) => string;
+    writeFile: (path: string, content: string) => void;
+    writeOut: (line: string) => void;
+    writeErr: (line: string) => void;
+}
+/**
+ * Run the codemod.
+ *
+ * Parses every file before writing any of them: a parse failure halfway
+ * through a directory must not leave a half-migrated tree behind.
+ */
+export declare function runCodemodCLI(argv: readonly string[], io: CodemodIO): number;

package/dist/codemod/cli.js

@@ -0,0 +1,150 @@
+/**
+ * `ggts-codemod` — opt-in migration of deprecated <GGPlot> grammar props
+ * to child layers (#659 slice 7, closes #290).
+ *
+ * Pure entry point: all I/O is injected through {@link CodemodIO}, so the whole
+ * command is testable without touching a disk. bin/ggts-codemod.js wires
+ * process streams and the exit code, exactly as @ggts-sh/cli's
+ * bin/ggts.js does.
+ *
+ * ADR 0013: dry-run by default, writes only behind an explicit `--write`, and
+ * anything the transform refuses to guess at is reported with the guide anchor
+ * for the manual change rather than half-migrated.
+ *
+ * Exit codes: 0 ok · 1 a file failed to parse · 2 usage error.
+ */
+import { migratePlotProps } from "./migrate-plot-props.js";
+const USAGE = [
+    "usage: ggts-codemod [--write] <path…>",
+    "",
+    "Migrate deprecated <GGPlot> grammar props (facet, coord, scales, guides,",
+    "legend, theme, labs) to declaration-only child layers.",
+    "",
+    "  --write     apply the changes (default: print a diff and write nothing)",
+    "  --source=S  also treat module specifier S as ggts (repeatable)",
+    "  --help      show this message",
+    "",
+    "Shapes the codemod will not guess at are reported with the guide anchor",
+    "for the manual change: https://ggts.sh/guide/upgrading",
+].join("\n");
+function parseArgs(argv) {
+    const sources = [];
+    const paths = [];
+    let write = false;
+    for (const arg of argv) {
+        if (arg === "--write")
+            write = true;
+        else if (arg.startsWith("--source="))
+            sources.push(arg.slice("--source=".length));
+        else if (arg.startsWith("-"))
+            return { error: `unknown option: ${arg}` };
+        else
+            paths.push(arg);
+    }
+    if (paths.length === 0)
+        return { error: "no paths given" };
+    return { write, sources, paths };
+}
+/**
+ * A unified-ish diff of the changed lines.
+ *
+ * Deliberately line-based and dependency-free: the point is to let a human see
+ * what `--write` would do, not to produce a patch another tool can apply.
+ */
+function diff(path, before, after) {
+    const beforeLines = before.split("\n");
+    const afterLines = after.split("\n");
+    const lines = [`--- ${path}`, `+++ ${path}`];
+    let b = 0;
+    let a = 0;
+    while (b < beforeLines.length || a < afterLines.length) {
+        if (b < beforeLines.length && a < afterLines.length && beforeLines[b] === afterLines[a]) {
+            b += 1;
+            a += 1;
+            continue;
+        }
+        // `before` exhausted: everything left is appended. Handled ahead of the
+        // resync scan because that scan can only advance `a` as far as a line the
+        // two sides still share, and there is none left — which advanced neither
+        // index and spun forever on a file with no trailing newline.
+        if (b >= beforeLines.length) {
+            lines.push(`+${afterLines[a]}`);
+            a += 1;
+            continue;
+        }
+        // Resynchronize on the next line the two sides share, so an insertion
+        // shows as added lines rather than rewriting the whole tail. indexOf
+        // searches from `a` and an exact hit at `a` was consumed above, so a
+        // successful resync always sits strictly ahead and always advances `a`.
+        const resync = afterLines.indexOf(beforeLines[b], a);
+        if (resync === -1) {
+            lines.push(`-${beforeLines[b]}`);
+            b += 1;
+            continue;
+        }
+        while (a < resync) {
+            lines.push(`+${afterLines[a]}`);
+            a += 1;
+        }
+    }
+    return lines;
+}
+function reportSkips(io, path, skips) {
+    for (const skip of skips) {
+        io.writeErr(`manual change required: ${path}:${String(skip.line)} — ${skip.prop} (${skip.reason})`);
+        io.writeErr(`  see ${skip.docUrl}`);
+    }
+}
+/**
+ * Run the codemod.
+ *
+ * Parses every file before writing any of them: a parse failure halfway
+ * through a directory must not leave a half-migrated tree behind.
+ */
+export function runCodemodCLI(argv, io) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        io.writeOut(USAGE);
+        return 0;
+    }
+    const options = parseArgs(argv);
+    if ("error" in options) {
+        io.writeErr(options.error);
+        io.writeErr(USAGE);
+        return 2;
+    }
+    const files = options.paths.flatMap((path) => io.listSvelteFiles(path));
+    const pending = [];
+    let failed = false;
+    for (const path of files) {
+        if (!path.endsWith(".svelte"))
+            continue;
+        const before = io.readFile(path);
+        let result;
+        try {
+            result = migratePlotProps(before, { sources: options.sources });
+        }
+        catch (error) {
+            io.writeErr(`${path}: ${error instanceof Error ? error.message : String(error)}`);
+            failed = true;
+            continue;
+        }
+        reportSkips(io, path, result.skipped);
+        if (result.changes.length > 0)
+            pending.push({ path, before, after: result.code });
+    }
+    if (failed)
+        return 1;
+    for (const change of pending) {
+        if (options.write)
+            io.writeFile(change.path, change.after);
+        else
+            for (const line of diff(change.path, change.before, change.after))
+                io.writeOut(line);
+    }
+    const count = pending.length;
+    const noun = count === 1 ? "file" : "files";
+    io.writeOut(options.write
+        ? `${String(count)} ${noun} changed`
+        : `${String(count)} ${noun} would change (run again with --write to apply)`);
+    return 0;
+}

package/dist/codemod/edits.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Positional source edits (#659 slice 7).
+ *
+ * ADR 0013 named `magic-string` as the starting-point stack and told the first
+ * real codemod to revisit it. This transform only ever removes attribute
+ * ranges and inserts child elements, so the whole requirement is "apply
+ * non-overlapping [start, end) replacements to the original string" — 20 lines
+ * that keep `@ggts-sh/svelte` free of a runtime dependency consumers would
+ * install forever to run a tool once.
+ *
+ * Applying right-to-left is what makes earlier offsets stay valid, which is
+ * why every offset in the caller can come straight from the parse tree.
+ */
+/** A replacement of `source[start, end)` with `text`. Insert ⇒ start === end. */
+export interface Edit {
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+}
+/**
+ * Apply non-overlapping edits to `source`.
+ *
+ * @throws if two edits overlap — a codemod bug that would otherwise corrupt
+ * output silently, which is exactly the "wrong rewrite" blast radius ADR 0013
+ * weighs. Insertions at the same offset are not overlaps and keep their
+ * relative order.
+ */
+export declare function applyEdits(source: string, edits: readonly Edit[]): string;

package/dist/codemod/edits.js

@@ -0,0 +1,36 @@
+/**
+ * Positional source edits (#659 slice 7).
+ *
+ * ADR 0013 named `magic-string` as the starting-point stack and told the first
+ * real codemod to revisit it. This transform only ever removes attribute
+ * ranges and inserts child elements, so the whole requirement is "apply
+ * non-overlapping [start, end) replacements to the original string" — 20 lines
+ * that keep `@ggts-sh/svelte` free of a runtime dependency consumers would
+ * install forever to run a tool once.
+ *
+ * Applying right-to-left is what makes earlier offsets stay valid, which is
+ * why every offset in the caller can come straight from the parse tree.
+ */
+/**
+ * Apply non-overlapping edits to `source`.
+ *
+ * @throws if two edits overlap — a codemod bug that would otherwise corrupt
+ * output silently, which is exactly the "wrong rewrite" blast radius ADR 0013
+ * weighs. Insertions at the same offset are not overlaps and keep their
+ * relative order.
+ */
+export function applyEdits(source, edits) {
+    const ordered = edits
+        .map((edit, index) => ({ edit, index }))
+        .toSorted((a, b) => b.edit.start - a.edit.start || b.index - a.index);
+    let out = source;
+    let lowestApplied = source.length;
+    for (const { edit } of ordered) {
+        if (edit.end > lowestApplied) {
+            throw new Error(`codemod: overlapping edits at [${String(edit.start)}, ${String(edit.end)})`);
+        }
+        out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+        lowestApplied = edit.start;
+    }
+    return out;
+}

package/dist/codemod/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Codemod entry point (#659 slice 7, closes #290).
+ *
+ * Consumed by bin/ggts-codemod.js. Not re-exported from the package root:
+ * a one-shot migration tool is not part of the charting API, and pulling
+ * `svelte/compiler` into the main entry would drag the compiler into every
+ * consumer bundle that imports a component.
+ */
+export { runCodemodCLI, type CodemodIO } from "./cli.js";
+export { migratePlotProps, PACKAGE_SPECIFIER, type MigrateOptions, type MigrationResult, type PropChange, type PropSkip, } from "./migrate-plot-props.js";

package/dist/codemod/index.js

@@ -0,0 +1,10 @@
+/**
+ * Codemod entry point (#659 slice 7, closes #290).
+ *
+ * Consumed by bin/ggts-codemod.js. Not re-exported from the package root:
+ * a one-shot migration tool is not part of the charting API, and pulling
+ * `svelte/compiler` into the main entry would drag the compiler into every
+ * consumer bundle that imports a component.
+ */
+export { runCodemodCLI } from "./cli.js";
+export { migratePlotProps, PACKAGE_SPECIFIER, } from "./migrate-plot-props.js";

package/dist/codemod/migrate-plot-props-rewrite.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Pure rewrite helpers for the plot-props codemod (AST walk, attribute→child
+ * emission, import edits). The public transform is migrate-plot-props.ts.
+ *
+ * Semantic confidence (ADR 0013): only meaning-preserving rewrites are
+ * performed. Each target component's props type is the prop's own type, so the
+ * rewrite cannot change the assembled PortableSpec:
+ *
+ *   coord / scales / guides  →  <Coord|Scale|Guides value={…}/>   (`value` IS the prop type)
+ *   facet / legend / labs    →  <Facet|Legend|Labs {...…}/>       (flat prop bags)
+ *   theme (string literal)   →  <Theme name="…"/>
+ *
+ * `theme={expr}` is NOT rewritten: `theme` is `ThemeName | ThemeSpec`, and
+ * `<Theme>` takes `name` plus role overrides with no `value` hatch, so an
+ * object-valued expression cannot be routed without judgment.
+ *
+ * Named shells (`<ThemeDark/>`, `<ScaleColorDiscrete scheme="…"/>`) are what
+ * the guide recommends by hand, but the codemod never produces them: mapping a
+ * value onto a helper is a style choice, and for scales it is not even
+ * byte-identity-preserving (D8 — `normalize()` does not infer scale `type`).
+ */
+import type { GrammarCodemodForm } from "../layers/grammar-families.js";
+import type { Edit } from "./edits.js";
+/** How a deprecated prop's value is handed to its replacement component. */
+type Form = GrammarCodemodForm;
+export interface PropRule {
+    readonly component: string;
+    readonly form: Form;
+    readonly docUrl: string;
+}
+export interface Node {
+    readonly type: string;
+    readonly start: number;
+    readonly end: number;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Every object reachable one step down, arrays flattened.
+ *
+ * Deliberately not filtered to {@link isNode}: `Fragment` carries the children
+ * of an element but has no start/end, so a node-only walk stops at the first
+ * `<div>` and silently skips every plot nested inside one.
+ */
+export declare function childObjects(value: unknown): unknown[];
+export declare function isNode(value: unknown): value is Node;
+export declare function lineOf(source: string, offset: number): number;
+/** Leading whitespace of the line `offset` sits on, or "" if code precedes it. */
+export declare function indentAt(source: string, offset: number): string;
+/**
+ * Build the replacement child for one deprecated attribute.
+ *
+ * @returns the element source, or a skip reason when the shape is one the
+ * codemod refuses to guess at.
+ */
+export declare function childFor(source: string, prop: string, rule: PropRule, attribute: Record<string, unknown>): {
+    element: string;
+} | {
+    skip: string;
+};
+export interface ImportSite {
+    /** Named specifiers, in source order. */
+    readonly specifiers: {
+        readonly local: string;
+        readonly start: number;
+        readonly end: number;
+    }[];
+}
+/**
+ * The named-import statement that brought ggts's `GGPlot` into scope.
+ *
+ * Scoped by module specifier on purpose: a `GGPlot` imported from a consumer's
+ * own `./local.js` is somebody else's component, and rewriting its props would
+ * be exactly the wrong-rewrite blast radius ADR 0013 weighs. `sources` exists
+ * so this repo can still migrate its own files, which import the package
+ * through relative paths because the workspace has no self-link.
+ */
+export declare function findGGPlotImport(program: unknown, sources: readonly string[]): ImportSite | undefined;
+/**
+ * Edits that add `additions` to an existing named-import list.
+ *
+ * Sorted lists stay sorted (case-insensitively — the repo's own convention,
+ * e.g. `{ coordFixed, GGPlot, GeomLine }`); an unsorted list is appended to,
+ * so the codemod never reorders a line the author arranged deliberately.
+ */
+export declare function importEdits(site: ImportSite, additions: readonly string[]): Edit[];
+export {};