@ggts-sh/svelte 0.43.0

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

@@ -0,0 +1,161 @@
+import { createInteractionReducer } from "../interaction/reducer.js";
+import { resolveChooseToolAction, resolveEffectiveTool } from "../interaction/capability.js";
+import { shouldClosePinnedOnOutsidePointer } from "../inspection/teardown.js";
+import { buildSurfaceDescription } from "./surface-description.js";
+import { isAreaAwaitingSecond, isAreaBrushing } from "./pointer.js";
+import { createSurfaceHandlers } from "./surface-handlers.svelte.js";
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create the surface controller. Construction registers deriveds and
+ * window-teardown + tool-sync effects.
+ *
+ * Construction-order note: deps must not be invoked during construction —
+ * construction-read discipline enforced by the armed-getter suite.
+ */
+export function createSurfaceState(context, options) {
+    let reducerRevision = $state(0);
+    let brushRect = $state(null);
+    // Handlers are created first and receive the reducer via a thunk — the
+    // reducer's onPointerFrame calls back into handlers.applyAreaMove (the
+    // module boundary replaces the original hoisted function declaration).
+    const handlers = createSurfaceHandlers({
+        context,
+        reducer: () => reducer,
+        activeTool: () => activeTool,
+        brushing: () => brushing,
+        areaAwaitingSecond: () => areaAwaitingSecond,
+        getBrushRect: () => brushRect,
+        setBrushRect: (rect) => {
+            brushRect = rect;
+        },
+        chooseTool,
+        inspection: options.inspection,
+        interval: options.interval,
+        zoom: options.zoom,
+        emitSelection: options.emitSelection,
+        togglePointKeys: options.togglePointKeys,
+        pointSelectEnabled: options.pointSelectEnabled,
+    });
+    // Reducer is created INSIDE the factory (original host position ~516).
+    const reducer = createInteractionReducer({
+        onChange: () => {
+            reducerRevision += 1;
+        },
+        scheduleFrame: (callback) => requestAnimationFrame(callback),
+        cancelFrame: (handle) => {
+            cancelAnimationFrame(handle);
+        },
+        onPointerFrame: (action) => {
+            if (action.type === "move-area") {
+                handlers.applyAreaMove(action.point);
+                return true;
+            }
+            return options.inspection().onInspectPointerFrame(action);
+        },
+    });
+    // Construction-safe: own state + inspectConfig only.
+    const activeTool = $derived.by(() => {
+        void reducerRevision;
+        return reducer.state.tool;
+    });
+    // Lazy pin read: only consult inspectConfig on the inspect tool branch so
+    // non-inspect tools do not subscribe to inspect config (dependency tracking).
+    const surfaceDescription = $derived.by(() => buildSurfaceDescription(activeTool, activeTool === "inspect" && context.inspectConfig()?.pin === true));
+    // Private — no remaining host consumer after extraction (codex P2-7).
+    const brushing = $derived.by(() => {
+        void reducerRevision;
+        return isAreaBrushing(reducer.state.area.kind);
+    });
+    const areaAwaitingSecond = $derived.by(() => {
+        void reducerRevision;
+        return isAreaAwaitingSecond(reducer.state.area.kind);
+    });
+    function clearBrush() {
+        brushRect = null;
+    }
+    function chooseTool(next) {
+        // Decision table is pure (interaction/capability); this switch owns side effects.
+        const action = resolveChooseToolAction({
+            next,
+            available: options.availableTools(),
+            isControlled: options.toolProp() !== undefined,
+        });
+        switch (action.type) {
+            case "ignore":
+                return;
+            case "request":
+                context.ontoolchange()?.(next);
+                return;
+            case "apply":
+                reducer.dispatch({ type: "set-tool", tool: next });
+                brushRect = null;
+                // set-tool already full-cancels the schedule; clear inspect payload only
+                // (preserve pinned stash — matches prior clearQueuedPointer-only path).
+                options.inspection().cancelPointerInspect({ pendingPinned: "preserve" });
+                context.ontoolchange()?.(next);
+                break;
+        }
+    }
+    // Window outside-pointer / blur teardown + tool-sync (formerly host-phased
+    // registerSurfaceEffects — registered at construction, #627).
+    $effect(() => {
+        // No-op cleanup keeps every code path returning a teardown (consistent-return).
+        if (!options.surfaceInteractive())
+            return () => { };
+        const onOutsidePointer = (event) => {
+            if (!shouldClosePinnedOnOutsidePointer({
+                inspectionState: options.inspection().inspection?.state,
+                targetInsideRoot: context.root()?.contains(event.target) === true,
+            }))
+                return;
+            options.inspection().closeInspection("pointer", false);
+        };
+        const cancelDraft = () => {
+            brushRect = null;
+            options.inspection().cancelPointerInspect({ pendingPinned: "preserve" });
+            handlers.clearTouchInspect();
+            reducer.cancelScheduledPointer();
+            reducer.dispatch({ type: "cancel-area" });
+        };
+        window.addEventListener("pointerdown", onOutsidePointer);
+        window.addEventListener("blur", cancelDraft);
+        return () => {
+            window.removeEventListener("pointerdown", onOutsidePointer);
+            window.removeEventListener("blur", cancelDraft);
+        };
+    });
+    $effect(() => {
+        const next = resolveEffectiveTool(options.toolProp() ?? options.initialTool(), options.availableTools());
+        reducer.dispatch({ type: "set-tool", tool: next });
+    });
+    return {
+        get reducer() {
+            return reducer;
+        },
+        get activeTool() {
+            return activeTool;
+        },
+        get surfaceDescription() {
+            return surfaceDescription;
+        },
+        get brushRect() {
+            return brushRect;
+        },
+        get areaAwaitingSecond() {
+            return areaAwaitingSecond;
+        },
+        clearBrush,
+        chooseTool,
+        onPointerMove: handlers.onPointerMove,
+        onPointerDown: handlers.onPointerDown,
+        onPointerUp: handlers.onPointerUp,
+        onPointerLeave: handlers.onPointerLeave,
+        onPointerCancel: handlers.onPointerCancel,
+        onLostPointerCapture: handlers.onLostPointerCapture,
+        onCaptureClick: handlers.onCaptureClick,
+        onSurfaceKeyDown: handlers.onSurfaceKeyDown,
+        onSurfaceBlur: handlers.onSurfaceBlur,
+    };
+}

package/dist/theme/Theme.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+  /**
+   * <Theme> — declaration-only theme layer for <GGPlot> (#659).
+   * Generic escape hatch: pass `name` and/or role overrides. Named shells
+   * (<ThemeDark/>, …) are preferred when the base theme is known at authoring
+   * time; use this form for reactive/dynamic names
+   * (`<Theme name={currentTheme}/>`).
+   *
+   * Emits NO markup; registers a live theme layer during component init and
+   * unregisters on destroy. Inert without a <GGPlot> ancestor.
+   *
+   * Canonical PortableSpec form: no role overrides → ThemeName string; any
+   * role override → ThemeSpec object with only defined keys.
+   */
+  import type { ThemeName, ThemeSpec } from "@ggts-sh/spec";
+
+  import { createThemeLayer, type ThemeRoleKey } from "./factory.svelte.js";
+
+  type Props = {
+    name?: ThemeName;
+  } & {
+    [K in ThemeRoleKey]?: ThemeSpec[K];
+  };
+
+  const props: Props = $props();
+  createThemeLayer(() => props);
+</script>

package/dist/theme/Theme.svelte.d.ts

@@ -0,0 +1,23 @@
+/**
+   * <Theme> — declaration-only theme layer for <GGPlot> (#659).
+   * Generic escape hatch: pass `name` and/or role overrides. Named shells
+   * (<ThemeDark/>, …) are preferred when the base theme is known at authoring
+   * time; use this form for reactive/dynamic names
+   * (`<Theme name={currentTheme}/>`).
+   *
+   * Emits NO markup; registers a live theme layer during component init and
+   * unregisters on destroy. Inert without a <GGPlot> ancestor.
+   *
+   * Canonical PortableSpec form: no role overrides → ThemeName string; any
+   * role override → ThemeSpec object with only defined keys.
+   */
+import type { ThemeName, ThemeSpec } from "@ggts-sh/spec";
+import { type ThemeRoleKey } from "./factory.svelte.js";
+type Props = {
+    name?: ThemeName;
+} & {
+    [K in ThemeRoleKey]?: ThemeSpec[K];
+};
+declare const Theme: import("svelte").Component<Props, {}, "">;
+type Theme = ReturnType<typeof Theme>;
+export default Theme;

package/dist/theme/ThemeBase.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeBase> — declaration-only "base" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("base", () => props);
+</script>

package/dist/theme/ThemeBase.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeBase> — declaration-only "base" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeBase: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeBase = ReturnType<typeof ThemeBase>;
+export default ThemeBase;

package/dist/theme/ThemeBw.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeBw> — declaration-only "bw" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("bw", () => props);
+</script>

package/dist/theme/ThemeBw.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeBw> — declaration-only "bw" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeBw: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeBw = ReturnType<typeof ThemeBw>;
+export default ThemeBw;

package/dist/theme/ThemeClassic.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeClassic> — declaration-only "classic" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("classic", () => props);
+</script>

package/dist/theme/ThemeClassic.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeClassic> — declaration-only "classic" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeClassic: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeClassic = ReturnType<typeof ThemeClassic>;
+export default ThemeClassic;

package/dist/theme/ThemeClean.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeClean> — declaration-only "clean" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("clean", () => props);
+</script>

package/dist/theme/ThemeClean.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeClean> — declaration-only "clean" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeClean: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeClean = ReturnType<typeof ThemeClean>;
+export default ThemeClean;

package/dist/theme/ThemeDark.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeDark> — declaration-only "dark" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("dark", () => props);
+</script>

package/dist/theme/ThemeDark.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeDark> — declaration-only "dark" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeDark: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeDark = ReturnType<typeof ThemeDark>;
+export default ThemeDark;

package/dist/theme/ThemeDefault.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeDefault> — declaration-only "default" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("default", () => props);
+</script>

package/dist/theme/ThemeDefault.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeDefault> — declaration-only "default" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeDefault: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeDefault = ReturnType<typeof ThemeDefault>;
+export default ThemeDefault;

package/dist/theme/ThemeEconomist.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeEconomist> — declaration-only "economist" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("economist", () => props);
+</script>

package/dist/theme/ThemeEconomist.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeEconomist> — declaration-only "economist" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeEconomist: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeEconomist = ReturnType<typeof ThemeEconomist>;
+export default ThemeEconomist;

package/dist/theme/ThemeEconomistwhite.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeEconomistwhite> — declaration-only "economist_white" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("economist_white", () => props);
+</script>

package/dist/theme/ThemeEconomistwhite.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeEconomistwhite> — declaration-only "economist_white" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeEconomistwhite: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeEconomistwhite = ReturnType<typeof ThemeEconomistwhite>;
+export default ThemeEconomistwhite;

package/dist/theme/ThemeFew.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeFew> — declaration-only "few" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("few", () => props);
+</script>

package/dist/theme/ThemeFew.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeFew> — declaration-only "few" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeFew: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeFew = ReturnType<typeof ThemeFew>;
+export default ThemeFew;

package/dist/theme/ThemeFivethirtyeight.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+  /**
+   * <ThemeFivethirtyeight> — declaration-only "fivethirtyeight" theme layer
+   * for <GGPlot>. Accepts optional role overrides (`ink`, `paper`, …).
+   * Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("fivethirtyeight", () => props);
+</script>

package/dist/theme/ThemeFivethirtyeight.svelte.d.ts

@@ -0,0 +1,9 @@
+/**
+   * <ThemeFivethirtyeight> — declaration-only "fivethirtyeight" theme layer
+   * for <GGPlot>. Accepts optional role overrides (`ink`, `paper`, …).
+   * Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeFivethirtyeight: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeFivethirtyeight = ReturnType<typeof ThemeFivethirtyeight>;
+export default ThemeFivethirtyeight;

package/dist/theme/ThemeGgplot2.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeGgplot2> — declaration-only "ggplot2" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("ggplot2", () => props);
+</script>

package/dist/theme/ThemeGgplot2.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeGgplot2> — declaration-only "ggplot2" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeGgplot2: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeGgplot2 = ReturnType<typeof ThemeGgplot2>;
+export default ThemeGgplot2;

package/dist/theme/ThemeGray.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeGray> — declaration-only "gray" theme layer for <GGPlot>
+   * (US spelling; alias of the ggplot2 grey-panel look). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("gray", () => props);
+</script>

package/dist/theme/ThemeGray.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeGray> — declaration-only "gray" theme layer for <GGPlot>
+   * (US spelling; alias of the ggplot2 grey-panel look). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeGray: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeGray = ReturnType<typeof ThemeGray>;
+export default ThemeGray;

package/dist/theme/ThemeGrey.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeGrey> — declaration-only "grey" theme layer for <GGPlot>
+   * (UK spelling; alias of the ggplot2 grey-panel look). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("grey", () => props);
+</script>

package/dist/theme/ThemeGrey.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeGrey> — declaration-only "grey" theme layer for <GGPlot>
+   * (UK spelling; alias of the ggplot2 grey-panel look). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeGrey: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeGrey = ReturnType<typeof ThemeGrey>;
+export default ThemeGrey;

package/dist/theme/ThemeHc.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeHc> — declaration-only "hc" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("hc", () => props);
+</script>

package/dist/theme/ThemeHc.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeHc> — declaration-only "hc" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeHc: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeHc = ReturnType<typeof ThemeHc>;
+export default ThemeHc;

package/dist/theme/ThemeHcdark.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeHcdark> — declaration-only "hcdark" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("hcdark", () => props);
+</script>

package/dist/theme/ThemeHcdark.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeHcdark> — declaration-only "hcdark" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeHcdark: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeHcdark = ReturnType<typeof ThemeHcdark>;
+export default ThemeHcdark;

package/dist/theme/ThemeHrbr.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeHrbr> — declaration-only "hrbr" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("hrbr", () => props);
+</script>

package/dist/theme/ThemeHrbr.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeHrbr> — declaration-only "hrbr" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeHrbr: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeHrbr = ReturnType<typeof ThemeHrbr>;
+export default ThemeHrbr;

package/dist/theme/ThemeIgray.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeIgray> — declaration-only "igray" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("igray", () => props);
+</script>

package/dist/theme/ThemeIgray.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+   * <ThemeIgray> — declaration-only "igray" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+import { type NamedThemeLayerProps } from "./factory.svelte.js";
+declare const ThemeIgray: import("svelte").Component<NamedThemeLayerProps, {}, "">;
+type ThemeIgray = ReturnType<typeof ThemeIgray>;
+export default ThemeIgray;

package/dist/theme/ThemeLight.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  /**
+   * <ThemeLight> — declaration-only "light" theme layer for <GGPlot>.
+   * Accepts optional role overrides (`ink`, `paper`, …). Emits NO markup.
+   */
+  import {
+    createNamedThemeLayer,
+    type NamedThemeLayerProps,
+  } from "./factory.svelte.js";
+
+  const props: NamedThemeLayerProps = $props();
+  createNamedThemeLayer("light", () => props);
+</script>