@ggts-sh/svelte 0.43.0

package/dist/codemod/migrate-plot-props-rewrite.js

@@ -0,0 +1,228 @@
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+/**
+ * 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 function childObjects(value) {
+    if (!isRecord(value))
+        return [];
+    const out = [];
+    for (const child of Object.values(value)) {
+        if (Array.isArray(child))
+            out.push(...child.filter((item) => isRecord(item)));
+        else if (isRecord(child))
+            out.push(child);
+    }
+    return out;
+}
+export function isNode(value) {
+    return (isRecord(value) &&
+        typeof value["type"] === "string" &&
+        typeof value["start"] === "number" &&
+        typeof value["end"] === "number");
+}
+// ---------------------------------------------------------------------------
+// Source helpers
+// ---------------------------------------------------------------------------
+export function lineOf(source, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < source.length; i += 1) {
+        if (source[i] === "\n")
+            line += 1;
+    }
+    return line;
+}
+/** Leading whitespace of the line `offset` sits on, or "" if code precedes it. */
+export function indentAt(source, offset) {
+    const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+    const prefix = source.slice(lineStart, offset);
+    return /^[\t ]*$/.test(prefix) ? prefix : "";
+}
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/** A double-quoted string literal with nothing an attribute value must escape. */
+function plainDoubleQuoted(raw) {
+    return raw !== undefined && /^"[^"\\\n]*"$/.test(raw);
+}
+// ---------------------------------------------------------------------------
+// Attribute → child element
+// ---------------------------------------------------------------------------
+/** The `{ … }` expression tag of an attribute, or undefined for other shapes. */
+function expressionTag(attribute) {
+    const value = attribute["value"];
+    const nodes = Array.isArray(value) ? value : [value];
+    if (nodes.length !== 1)
+        return undefined;
+    const only = nodes[0];
+    return isNode(only) && only.type === "ExpressionTag" ? only : undefined;
+}
+/** The single quoted-text value of an attribute, or undefined. */
+function textValue(attribute) {
+    const value = attribute["value"];
+    if (!Array.isArray(value) || value.length !== 1)
+        return undefined;
+    const only = value[0];
+    return isNode(only) && only.type === "Text" ? only : undefined;
+}
+/**
+ * Attributes for a flat prop bag whose value is an object literal made only of
+ * plain `key: value` properties.
+ *
+ * Anything else — shorthand, spread, computed keys, methods, getters, a
+ * non-identifier key — falls back to `{...expr}` rather than being partially
+ * expanded. Both forms are correct; expansion only exists so the common
+ * `labs={{ title: "Sales" }}` migrates to code a human would have written.
+ */
+function expandObjectLiteral(source, expression) {
+    if (!isRecord(expression) || expression["type"] !== "ObjectExpression")
+        return undefined;
+    const properties = expression["properties"];
+    if (!Array.isArray(properties) || properties.length === 0)
+        return undefined;
+    const parts = [];
+    for (const raw of properties) {
+        if (!isRecord(raw) || raw["type"] !== "Property")
+            return undefined;
+        const property = raw;
+        if (property.kind !== "init" || property.computed || property.method || property.shorthand) {
+            return undefined;
+        }
+        const key = property.key.type === "Identifier"
+            ? property.key.name
+            : property.key.type === "Literal" && typeof property.key.value === "string"
+                ? property.key.value
+                : undefined;
+        if (key === undefined || !IDENTIFIER.test(key))
+            return undefined;
+        const valueSource = source.slice(property.value.start, property.value.end);
+        parts.push(property.value.type === "Literal" && plainDoubleQuoted(property.value.raw)
+            ? `${key}=${valueSource}`
+            : `${key}={${valueSource}}`);
+    }
+    return parts.join(" ");
+}
+/**
+ * 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 function childFor(source, prop, rule, attribute) {
+    const tag = expressionTag(attribute);
+    const text = textValue(attribute);
+    if (rule.form === "theme") {
+        if (text !== undefined) {
+            return { element: `<Theme name="${source.slice(text.start, text.end)}" />` };
+        }
+        if (tag !== undefined) {
+            const expression = tag["expression"];
+            if (isRecord(expression) &&
+                expression["type"] === "Literal" &&
+                typeof expression["value"] === "string") {
+                return { element: `<Theme name="${expression["value"]}" />` };
+            }
+        }
+        return {
+            skip: "theme is ThemeName | ThemeSpec and <Theme> has no `value` hatch, so only a string literal can be rewritten mechanically",
+        };
+    }
+    if (text !== undefined) {
+        const quoted = `"${source.slice(text.start, text.end)}"`;
+        return rule.form === "value"
+            ? { element: `<${rule.component} value=${quoted} />` }
+            : { skip: `${prop} is an object-valued prop, so a quoted string is not a shape it can hold` };
+    }
+    if (tag === undefined) {
+        return { skip: `${prop} has no single expression value to move onto <${rule.component}>` };
+    }
+    const inner = source.slice(tag.start + 1, tag.end - 1);
+    if (rule.form === "value") {
+        return { element: `<${rule.component} value={${inner}} />` };
+    }
+    const expanded = expandObjectLiteral(source, tag["expression"]);
+    return {
+        element: expanded === undefined
+            ? `<${rule.component} {...${inner}} />`
+            : `<${rule.component} ${expanded} />`,
+    };
+}
+/**
+ * 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 function findGGPlotImport(program, sources) {
+    if (!isRecord(program))
+        return undefined;
+    const body = program["body"];
+    if (!Array.isArray(body))
+        return undefined;
+    for (const statement of body) {
+        if (!isRecord(statement) || statement["type"] !== "ImportDeclaration")
+            continue;
+        const source = statement["source"];
+        if (!isRecord(source) || typeof source["value"] !== "string")
+            continue;
+        if (!sources.includes(source["value"]))
+            continue;
+        const rawSpecifiers = statement["specifiers"];
+        if (!Array.isArray(rawSpecifiers))
+            continue;
+        const specifiers = [];
+        let hasGGPlot = false;
+        for (const specifier of rawSpecifiers) {
+            if (!isRecord(specifier) || specifier["type"] !== "ImportSpecifier")
+                continue;
+            const local = specifier["local"];
+            const imported = specifier["imported"];
+            if (!isNode(specifier) || !isRecord(local) || typeof local["name"] !== "string")
+                continue;
+            if (isRecord(imported) && imported["name"] === "GGPlot")
+                hasGGPlot = true;
+            specifiers.push({ local: local["name"], start: specifier.start, end: specifier.end });
+        }
+        if (hasGGPlot && specifiers.length > 0)
+            return { specifiers };
+    }
+    return undefined;
+}
+function isSortedCaseInsensitive(names) {
+    for (let i = 1; i < names.length; i += 1) {
+        if (names[i - 1].toLowerCase() > names[i].toLowerCase())
+            return false;
+    }
+    return true;
+}
+/**
+ * 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 function importEdits(site, additions) {
+    const existing = site.specifiers.map((specifier) => specifier.local);
+    const missing = additions.filter((name) => !existing.includes(name));
+    if (missing.length === 0)
+        return [];
+    const last = site.specifiers.at(-1);
+    if (!isSortedCaseInsensitive(existing)) {
+        return [{ start: last.end, end: last.end, text: missing.map((n) => `, ${n}`).join("") }];
+    }
+    const edits = [];
+    for (const name of missing) {
+        const before = site.specifiers.find((specifier) => specifier.local.toLowerCase() > name.toLowerCase());
+        edits.push(before === undefined
+            ? { start: last.end, end: last.end, text: `, ${name}` }
+            : { start: before.start, end: before.start, text: `${name}, ` });
+    }
+    return edits;
+}

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

@@ -0,0 +1,38 @@
+/** A prop this run rewrote. */
+export interface PropChange {
+    readonly prop: string;
+    readonly component: string;
+    readonly line: number;
+}
+/** A prop this run deliberately left alone, with the manual-change pointer. */
+export interface PropSkip {
+    readonly prop: string;
+    readonly line: number;
+    readonly reason: string;
+    readonly docUrl: string;
+}
+/** The module specifier a consumer imports `GGPlot` from. */
+export declare const PACKAGE_SPECIFIER = "@ggts-sh/svelte";
+export interface MigrateOptions {
+    /**
+     * Extra module specifiers that also count as ggts, on top of
+     * {@link PACKAGE_SPECIFIER}. Exists for this repo's own sources, which
+     * import through relative paths; consumers never need it.
+     */
+    readonly sources?: readonly string[];
+}
+export interface MigrationResult {
+    /** Migrated source. Byte-identical to the input when nothing was rewritten. */
+    readonly code: string;
+    readonly changes: readonly PropChange[];
+    readonly skipped: readonly PropSkip[];
+}
+/**
+ * Rewrite deprecated `<GGPlot>` grammar props into child layers.
+ *
+ * Returns the source unchanged (and no changes) when the file imports no
+ * `GGPlot`, uses none of the deprecated props, or only uses shapes the
+ * codemod refuses to guess at — the second run of any file is therefore a
+ * no-op, which is ADR 0013's idempotence criterion.
+ */
+export declare function migratePlotProps(source: string, options?: MigrateOptions): MigrationResult;

package/dist/codemod/migrate-plot-props.js

@@ -0,0 +1,159 @@
+/**
+ * Codemod: deprecated <GGPlot> grammar props → declaration-only child layers
+ * (#659 slice 7, closes #290).
+ *
+ * Rewrites the seven props deprecated in 0.11.0 — facet, coord, scales,
+ * guides, legend, theme, labs — into the child components that replace them,
+ * and adds the components to whichever import statement already provided
+ * `GGPlot`.
+ *
+ * ## Why children go first
+ *
+ * D2: assemblePortableSpec applies props first, then child plotLayers in
+ * registration order. A prop that becomes a child must therefore register
+ * BEFORE any child the file already had, or a pre-existing `<ScaleColorDiscrete/>`
+ * would stop winning over the migrated `scales` prop. Inserting immediately
+ * after the open tag preserves the old precedence exactly.
+ *
+ * Attribute rewrite and import edits live in migrate-plot-props-rewrite.ts.
+ */
+import { parse } from "svelte/compiler";
+import { grammarCodemodRules } from "../layers/grammar-families.js";
+import { applyEdits } from "./edits.js";
+import { childFor, childObjects, findGGPlotImport, importEdits, indentAt, isNode, isRecord, lineOf, } from "./migrate-plot-props-rewrite.js";
+/** The module specifier a consumer imports `GGPlot` from. */
+export const PACKAGE_SPECIFIER = "@ggts-sh/svelte";
+/**
+ * The seven props deprecated in 0.11.0, in GGPlotProps declaration order.
+ * Built from GRAMMAR_FAMILIES / GGPLOT_PROP_ORDER (#785) so codemod rules
+ * cannot drift from deprecation metadata.
+ */
+const RULES = grammarCodemodRules();
+function migrateElement(source, plotName, element, output) {
+    const attributes = Array.isArray(element["attributes"]) ? element["attributes"] : [];
+    const elementStart = element.start;
+    const elementEnd = element.end;
+    const children = [];
+    let previousEnd = elementStart + 1 + plotName.length;
+    for (const raw of attributes) {
+        if (!isRecord(raw) || !isNode(raw))
+            continue;
+        const attributeEnd = raw.end;
+        const attributeStart = raw.start;
+        const name = raw["name"];
+        if (raw["type"] !== "Attribute" || typeof name !== "string") {
+            previousEnd = attributeEnd;
+            continue;
+        }
+        const rule = Object.hasOwn(RULES, name) ? RULES[name] : undefined;
+        if (rule === undefined) {
+            previousEnd = attributeEnd;
+            continue;
+        }
+        const built = childFor(source, name, rule, raw);
+        if ("skip" in built) {
+            output.skipped.push({
+                prop: name,
+                line: lineOf(source, attributeStart),
+                reason: built.skip,
+                docUrl: rule.docUrl,
+            });
+            previousEnd = attributeEnd;
+            continue;
+        }
+        children.push(built.element);
+        output.needed.add(rule.component);
+        output.changes.push({
+            prop: name,
+            component: rule.component,
+            line: lineOf(source, attributeStart),
+        });
+        output.edits.push({ start: previousEnd, end: attributeEnd, text: "" });
+        previousEnd = attributeEnd;
+    }
+    if (children.length === 0)
+        return;
+    const fragment = element["fragment"];
+    const fragmentNodes = !Array.isArray(fragment) && isRecord(fragment) && Array.isArray(fragment["nodes"])
+        ? fragment["nodes"]
+        : [];
+    const firstChild = fragmentNodes.find((node) => isNode(node));
+    const elementIndent = indentAt(source, elementStart);
+    const childIndent = `${elementIndent}  `;
+    const block = children.map((child) => `\n${childIndent}${child}`).join("");
+    if (firstChild === undefined) {
+        output.edits.push({
+            start: previousEnd,
+            end: elementEnd,
+            text: `>${block}\n${elementIndent}</${plotName}>`,
+        });
+    }
+    else {
+        output.edits.push({
+            start: firstChild.start,
+            end: firstChild.start,
+            text: block,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Transform
+// ---------------------------------------------------------------------------
+/**
+ * Rewrite deprecated `<GGPlot>` grammar props into child layers.
+ *
+ * Returns the source unchanged (and no changes) when the file imports no
+ * `GGPlot`, uses none of the deprecated props, or only uses shapes the
+ * codemod refuses to guess at — the second run of any file is therefore a
+ * no-op, which is ADR 0013's idempotence criterion.
+ */
+export function migratePlotProps(source, options = {}) {
+    const sources = [PACKAGE_SPECIFIER, ...(options.sources ?? [])];
+    const ast = parse(source, { modern: true });
+    const importSite = findGGPlotImport(isRecord(ast.instance) ? ast.instance["content"] : undefined, sources) ??
+        findGGPlotImport(isRecord(ast.module) ? ast.module["content"] : undefined, sources);
+    if (importSite === undefined)
+        return { code: source, changes: [], skipped: [] };
+    const localName = importSite.specifiers.find((specifier) => {
+        // The local name for the GGPlot binding: re-derived here so `import
+        // { GGPlot as Plot }` rewrites <Plot> rather than silently doing nothing.
+        return specifier.local === "GGPlot";
+    })?.local;
+    const plotName = localName ?? aliasedGGPlotName(source, importSite);
+    if (plotName === undefined)
+        return { code: source, changes: [], skipped: [] };
+    const edits = [];
+    const changes = [];
+    const skipped = [];
+    const needed = new Set();
+    const output = { edits, changes, skipped, needed };
+    for (const element of collectComponents(ast.fragment, plotName))
+        migrateElement(source, plotName, element, output);
+    if (changes.length === 0)
+        return { code: source, changes: [], skipped };
+    edits.push(...importEdits(importSite, [...needed].toSorted()));
+    return { code: applyEdits(source, edits), changes, skipped };
+}
+/** Local name of an aliased `import { GGPlot as X }`, read back from source. */
+function aliasedGGPlotName(source, site) {
+    for (const specifier of site.specifiers) {
+        const text = source.slice(specifier.start, specifier.end);
+        if (/^GGPlot\s+as\s+/.test(text))
+            return specifier.local;
+    }
+    return undefined;
+}
+/** Every `<plotName>` component in the template, including nested ones. */
+function collectComponents(fragment, plotName) {
+    const found = [];
+    const walk = (node) => {
+        if (!isRecord(node))
+            return;
+        if (node["type"] === "Component" && node["name"] === plotName)
+            found.push(node);
+        for (const child of childObjects(node))
+            walk(child);
+    };
+    walk(fragment);
+    return found;
+}

package/dist/coord/Coord.svelte

@@ -0,0 +1,21 @@
+<script lang="ts">
+  /**
+   * <Coord> — declaration-only coordinate layer for <GGPlot> (#659 slice 5).
+   * Escape hatch: pass a whole `CoordSpec | "flip"` via `value`. Named shells
+   * (<CoordFlip/>, <CoordFixed/>, …) are preferred when the form is known at
+   * authoring time; use this for computed fragments or variable references.
+   *
+   * Emits NO markup; registers a live coord layer during component init and
+   * unregisters on destroy. Inert without a <GGPlot> ancestor.
+   */
+  import type { CoordSpec } from "@ggts-sh/spec";
+
+  import { createPlotLayer } from "../layers/plot-layer.svelte.js";
+
+  type Props = {
+    value: CoordSpec | "flip";
+  };
+
+  const props: Props = $props();
+  createPlotLayer("coord", () => props.value);
+</script>

package/dist/coord/Coord.svelte.d.ts

@@ -0,0 +1,16 @@
+/**
+   * <Coord> — declaration-only coordinate layer for <GGPlot> (#659 slice 5).
+   * Escape hatch: pass a whole `CoordSpec | "flip"` via `value`. Named shells
+   * (<CoordFlip/>, <CoordFixed/>, …) are preferred when the form is known at
+   * authoring time; use this for computed fragments or variable references.
+   *
+   * Emits NO markup; registers a live coord layer during component init and
+   * unregisters on destroy. Inert without a <GGPlot> ancestor.
+   */
+import type { CoordSpec } from "@ggts-sh/spec";
+type Props = {
+    value: CoordSpec | "flip";
+};
+declare const Coord: import("svelte").Component<Props, {}, "">;
+type Coord = ReturnType<typeof Coord>;
+export default Coord;

package/dist/coord/CoordCartesian.svelte

@@ -0,0 +1,11 @@
+<script lang="ts">
+  /**
+   * <CoordCartesian> — declaration-only default Cartesian layer for <GGPlot>
+   * (#659 slice 5). Registers `{ type: "cartesian" }`, which normalize() drops
+   * when bare (no other keys). Useful mid-migration under REPLACE so a child
+   * can clear a prior `coord="flip"` prop. Emits NO markup.
+   */
+  import { createPlotLayer } from "../layers/plot-layer.svelte.js";
+
+  createPlotLayer("coord", () => ({ type: "cartesian" }));
+</script>

package/dist/coord/CoordCartesian.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const CoordCartesian: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type CoordCartesian = InstanceType<typeof CoordCartesian>;
+export default CoordCartesian;

package/dist/coord/CoordFixed.svelte

@@ -0,0 +1,17 @@
+<script lang="ts">
+  /**
+   * <CoordFixed> — declaration-only fixed-aspect coordinate layer for
+   * <GGPlot> (#659 slice 5). Accepts the same options as `coordFixed(…)`.
+   * Also exported as `CoordEqual` (alias of `coordEqual = coordFixed`).
+   * Emits NO markup.
+   */
+  import { coordFixed, type CoordFixedOptions } from "@ggts-sh/spec";
+
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: CoordFixedOptions = $props();
+  createPlotLayer("coord", () => coordFixed(definedProps(props)));
+</script>

package/dist/coord/CoordFixed.svelte.d.ts

@@ -0,0 +1,10 @@
+/**
+   * <CoordFixed> — declaration-only fixed-aspect coordinate layer for
+   * <GGPlot> (#659 slice 5). Accepts the same options as `coordFixed(…)`.
+   * Also exported as `CoordEqual` (alias of `coordEqual = coordFixed`).
+   * Emits NO markup.
+   */
+import { type CoordFixedOptions } from "@ggts-sh/spec";
+declare const CoordFixed: import("svelte").Component<CoordFixedOptions, {}, "">;
+type CoordFixed = ReturnType<typeof CoordFixed>;
+export default CoordFixed;

package/dist/coord/CoordFlip.svelte

@@ -0,0 +1,11 @@
+<script lang="ts">
+  /**
+   * <CoordFlip> — declaration-only flipped Cartesian layer for <GGPlot>
+   * (#659 slice 5). Registers the canonical `{ type: "flip" }` object (not the
+   * bare string), matching `builder.coord("flip")` / `coordFlip()`.
+   * Emits NO markup.
+   */
+  import { createPlotLayer } from "../layers/plot-layer.svelte.js";
+
+  createPlotLayer("coord", () => ({ type: "flip" }));
+</script>

package/dist/coord/CoordFlip.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const CoordFlip: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type CoordFlip = InstanceType<typeof CoordFlip>;
+export default CoordFlip;

package/dist/coord/CoordPolar.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+  /**
+   * <CoordPolar> — ggplot2 coord_polar alias for polar coordinates.
+   * Emits `{ type: "radial", clip: true, … }` via `coordPolar(…)`.
+   * Prefer <CoordRadial> for new work (partial arcs, inner radius, reverse).
+   */
+  import { coordPolar, type CoordPolarOptions } from "@ggts-sh/spec";
+
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: CoordPolarOptions = $props();
+  createPlotLayer("coord", () => coordPolar(definedProps(props)));
+</script>

package/dist/coord/CoordPolar.svelte.d.ts

@@ -0,0 +1,9 @@
+/**
+   * <CoordPolar> — ggplot2 coord_polar alias for polar coordinates.
+   * Emits `{ type: "radial", clip: true, … }` via `coordPolar(…)`.
+   * Prefer <CoordRadial> for new work (partial arcs, inner radius, reverse).
+   */
+import { type CoordPolarOptions } from "@ggts-sh/spec";
+declare const CoordPolar: import("svelte").Component<CoordPolarOptions, {}, "">;
+type CoordPolar = ReturnType<typeof CoordPolar>;
+export default CoordPolar;

package/dist/coord/CoordRadial.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+  /**
+   * <CoordRadial> — declaration-only polar/radial coordinate layer for
+   * <GGPlot>. Accepts the same options as `coordRadial(…)`. Emits NO markup.
+   * Also exported as `CoordPolar` (ggplot2 coord_polar alias shell).
+   */
+  import { coordRadial, type CoordRadialOptions } from "@ggts-sh/spec";
+
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: CoordRadialOptions = $props();
+  createPlotLayer("coord", () => coordRadial(definedProps(props)));
+</script>

package/dist/coord/CoordRadial.svelte.d.ts

@@ -0,0 +1,9 @@
+/**
+   * <CoordRadial> — declaration-only polar/radial coordinate layer for
+   * <GGPlot>. Accepts the same options as `coordRadial(…)`. Emits NO markup.
+   * Also exported as `CoordPolar` (ggplot2 coord_polar alias shell).
+   */
+import { type CoordRadialOptions } from "@ggts-sh/spec";
+declare const CoordRadial: import("svelte").Component<CoordRadialOptions, {}, "">;
+type CoordRadial = ReturnType<typeof CoordRadial>;
+export default CoordRadial;

package/dist/coord/CoordSf.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+  /**
+   * <CoordSf> — declaration-only simple-features fixed-aspect coordinate layer
+   * for <GGPlot> (#809 phase 8). Accepts the same options as `coordSf(…)`.
+   * Already-projected data only (no CRS reproject in v1). Emits NO markup.
+   */
+  import { coordSf, type CoordSfOptions } from "@ggts-sh/spec";
+
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: CoordSfOptions = $props();
+  createPlotLayer("coord", () => coordSf(definedProps(props)));
+</script>

package/dist/coord/CoordSf.svelte.d.ts

@@ -0,0 +1,9 @@
+/**
+   * <CoordSf> — declaration-only simple-features fixed-aspect coordinate layer
+   * for <GGPlot> (#809 phase 8). Accepts the same options as `coordSf(…)`.
+   * Already-projected data only (no CRS reproject in v1). Emits NO markup.
+   */
+import { type CoordSfOptions } from "@ggts-sh/spec";
+declare const CoordSf: import("svelte").Component<CoordSfOptions, {}, "">;
+type CoordSf = ReturnType<typeof CoordSf>;
+export default CoordSf;

package/dist/coord/CoordTransform.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+  /**
+   * <CoordTransform> — declaration-only post-stat coordinate transform for
+   * <GGPlot> (#659 slice 5). Accepts the same options as `coordTransform(…)`.
+   * Emits NO markup.
+   */
+  import { coordTransform, type CoordTransformOptions } from "@ggts-sh/spec";
+
+  import {
+    createPlotLayer,
+    definedProps,
+  } from "../layers/plot-layer.svelte.js";
+
+  const props: CoordTransformOptions = $props();
+  createPlotLayer("coord", () => coordTransform(definedProps(props)));
+</script>