@peasant-labs/fairtrade 0.0.0

package/dist/lib/types/SignIn.stories.d.ts

@@ -0,0 +1,57 @@
+export default meta;
+export namespace SplitButton {
+    let name: string;
+    let decorators: Function[];
+    namespace args {
+        let onSignIn: import("storybook/test").Mock<(...args: any[]) => any>;
+    }
+    function render(args: any): any;
+    function play({ canvasElement, args }: {
+        canvasElement: any;
+        args: any;
+    }): Promise<void>;
+}
+export namespace HandleClaimStory {
+    let name_1: string;
+    export { name_1 as name };
+    let decorators_1: Function[];
+    export { decorators_1 as decorators };
+    export namespace args_1 {
+        let onSubmit: import("storybook/test").Mock<(...args: any[]) => any>;
+        let suggestedFrom: string;
+    }
+    export { args_1 as args };
+    export function render_1(args: any): any;
+    export { render_1 as render };
+    export function play_1({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_1 as play };
+}
+export namespace States {
+    let decorators_2: Function[];
+    export { decorators_2 as decorators };
+    export function render_2(): any;
+    export { render_2 as render };
+}
+export namespace Combined {
+    let name_2: string;
+    export { name_2 as name };
+    let decorators_3: Function[];
+    export { decorators_3 as decorators };
+    export function render_3(): any;
+    export { render_3 as render };
+    export function play_2({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_2 as play };
+}
+declare namespace meta {
+    export let title: string;
+    export { SignInProviders as component };
+    export let tags: string[];
+    export namespace parameters {
+        let layout: string;
+    }
+}
+import { SignInProviders } from './SignIn.jsx';

package/dist/lib/types/Sparkline.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @param {Object} props
+ * @param {Array<number|Object>} props.data     numbers, or objects with a `value` key.
+ * @param {'line'|'bar'} [props.type='line']     line or mini-bar.
+ * @param {'teal'|'olive'|'clay'|'mauve'|'amber'|1|2|3|4} [props.color='teal']  token colour.
+ * @param {number} [props.width=88]              px width.
+ * @param {number} [props.height=24]             px height.
+ * @param {string} props.label                   accessible name (e.g. "sessions, last 8 weeks, trending up"). required.
+ * @param {string} [props.className]             extra class.
+ */
+export default function Sparkline({ data, type, color, width, height, label, className }: {
+    data: Array<number | any>;
+    type?: "line" | "bar";
+    color?: "teal" | "olive" | "clay" | "mauve" | "amber" | 1 | 2 | 3 | 4;
+    width?: number;
+    height?: number;
+    label: string;
+    className?: string;
+}): any;

package/dist/lib/types/StatTiles.d.ts

@@ -0,0 +1,115 @@
+/**
+ * StatTile — one KPI: a mono eyebrow label, a big tabular display number, an optional sub line.
+ *
+ * @param {object} props
+ * @param {string} props.label - the metric name (lowercase chrome; e.g. "transcripts").
+ * @param {React.ReactNode} props.value - the headline figure (USER CONTENT — pre-formatted, e.g. "4.2M").
+ * @param {React.ReactNode} [props.sub] - an optional secondary line under the value (e.g. "9,610 turns").
+ * @param {React.ComponentType<{className?: string}>} [props.icon] - optional lucide icon for the label row.
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export function StatTile({ label, value, sub, icon: Icon, className, ...rest }: {
+    label: string;
+    value: React.ReactNode;
+    sub?: React.ReactNode;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    className?: string;
+}): any;
+/**
+ * @typedef {object} TileSpec
+ * @property {string} key - stable key for the tile.
+ * @property {string} label - the metric name.
+ * @property {React.ReactNode} value - the headline figure.
+ * @property {React.ReactNode} [sub] - optional sub line.
+ * @property {React.ComponentType<{className?: string}>} [icon] - optional label icon.
+ */
+/**
+ * StatGrid — an auto-fit responsive grid of StatTiles (columns min ~160px, equal gaps).
+ *
+ * @param {object} props
+ * @param {TileSpec[]} props.tiles - the KPI tiles to render, in order.
+ * @param {string} [props.className] - extra classes appended to the grid.
+ */
+export function StatGrid({ tiles, className, ...rest }: {
+    tiles: TileSpec[];
+    className?: string;
+}): any;
+/**
+ * GovTile — a governance fact: a mono eyebrow label, an icon, and a value that may carry one
+ * scarce earth-tone accent (e.g. amber for a "members only" / scarce policy). The value is mono,
+ * not the big display number — governance reads as a stated setting, not a metric.
+ *
+ * @param {object} props
+ * @param {string} props.label - the governance dimension (e.g. "access", "your role").
+ * @param {React.ReactNode} props.value - the setting (USER CONTENT — e.g. "members only", "contributor").
+ * @param {React.ComponentType<{className?: string}>} [props.icon] - optional lucide icon for the label row.
+ * @param {'amber'|'teal'|'olive'|'clay'|'mauve'} [props.tone] - optional earth-tone accent on the value.
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export function GovTile({ label, value, icon: Icon, tone, className, ...rest }: {
+    label: string;
+    value: React.ReactNode;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    tone?: "amber" | "teal" | "olive" | "clay" | "mauve";
+    className?: string;
+}): any;
+/**
+ * @typedef {object} ProviderDatum
+ * @property {string} label - provider name (USER CONTENT — case preserved; e.g. "claude-code").
+ * @property {number} value - this provider's count.
+ */
+/**
+ * ProviderBars — a labeled horizontal distribution. Each row is a provider name, a monochrome bar
+ * whose width is its share of `total`, and a tabular %. Bars are one ink weight (no per-row hue):
+ * the eye reads length + label + the written %, so the distribution survives greyscale and AT.
+ *
+ * @param {object} props
+ * @param {ProviderDatum[]} props.data - the providers, in the order to display (caller pre-sorts).
+ * @param {number} [props.total] - the denominator for the shares; defaults to the sum of values.
+ * @param {string} [props.label='provider distribution'] - accessible name for the list (lowercase chrome).
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export function ProviderBars({ data, total, label, className, ...rest }: {
+    data: ProviderDatum[];
+    total?: number;
+    label?: string;
+    className?: string;
+}): any;
+export type TileSpec = {
+    /**
+     * - stable key for the tile.
+     */
+    key: string;
+    /**
+     * - the metric name.
+     */
+    label: string;
+    /**
+     * - the headline figure.
+     */
+    value: React.ReactNode;
+    /**
+     * - optional sub line.
+     */
+    sub?: React.ReactNode;
+    /**
+     * - optional label icon.
+     */
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+};
+export type ProviderDatum = {
+    /**
+     * - provider name (USER CONTENT — case preserved; e.g. "claude-code").
+     */
+    label: string;
+    /**
+     * - this provider's count.
+     */
+    value: number;
+};

package/dist/lib/types/StatTiles.stories.d.ts

@@ -0,0 +1,31 @@
+export default meta;
+export namespace KPIs {
+    let decorators: Function[];
+    function render(): any;
+}
+export namespace Governance {
+    let decorators_1: Function[];
+    export { decorators_1 as decorators };
+    export function render_1(): any;
+    export { render_1 as render };
+}
+export namespace ProviderDistribution {
+    let decorators_2: Function[];
+    export { decorators_2 as decorators };
+    export function render_2(): any;
+    export { render_2 as render };
+}
+export namespace SingleTile {
+    let decorators_3: Function[];
+    export { decorators_3 as decorators };
+    export function render_3(): any;
+    export { render_3 as render };
+}
+declare namespace meta {
+    export let title: string;
+    export { StatTile as component };
+    export namespace parameters {
+        let layout: string;
+    }
+}
+import { StatTile } from './StatTiles.jsx';

package/dist/lib/types/StepWizard.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @typedef {Object} WizardStep
+ * @property {string} id     stable id for the step (aria wiring + completed/reachable sets)
+ * @property {React.ReactNode} label  the step's lowercase chrome label, shown under its number
+ */
+/**
+ * The rail alone: numbered square markers joined by connector lines. Pure/controlled — it owns no
+ * state. current = amber fill + bold near-black number + aria-current="step"; completed = olive +
+ * check glyph (clickable to jump back); future/unreachable = hairline + --ink-4 + aria-disabled
+ * (not clickable). Completed steps are always reachable.
+ *
+ * @param {Object} props
+ * @param {WizardStep[]} props.steps        the ordered steps
+ * @param {string} props.current            id of the active step
+ * @param {Set<string>} [props.completed]   ids of finished steps (olive + check, jump-back enabled)
+ * @param {Set<string>} [props.reachable]   ids the user may jump to (the gate). current + completed are implicitly reachable
+ * @param {(id: string) => void} [props.onJump]  called with a step id when a reachable/complete marker is activated
+ * @param {string} [props['aria-label']]    accessible name for the rail (default "progress")
+ */
+export function StepIndicator({ steps, current, completed, reachable, onJump, "aria-label": ariaLabel, }: {
+    steps: WizardStep[];
+    current: string;
+    completed?: Set<string>;
+    reachable?: Set<string>;
+    onJump?: (id: string) => void;
+}): any;
+/**
+ * @typedef {Object} WizardBodyArgs
+ * @property {WizardStep} step      the active step descriptor
+ * @property {number} index         its zero-based position
+ * @property {boolean} isLast       whether it's the final step
+ * @property {(valid: boolean) => void} setValid  report whether the step may advance (gates continue)
+ */
+/**
+ * Uncontrolled wizard: the rail + a per-step body slot + a sticky footer action bar.
+ * Tracks current / completed / reachable internally. Continue advances, marks the step complete,
+ * and unlocks the next step; on the last step its primary action reads "submit" and fires
+ * onComplete. Back is enabled on every step except the first.
+ *
+ * Step bodies come from either `children` (an array, one node per step — index-aligned to `steps`)
+ * or a `renderStep` render-prop called with {step, index, isLast, setValid}. A step is advanceable
+ * unless its render-prop has reported setValid(false); plain-children bodies are always valid.
+ *
+ * @param {Object} props
+ * @param {WizardStep[]} props.steps   the ordered steps (>= 1)
+ * @param {(args: { completed: Set<string> }) => void} [props.onComplete]  fired when the last step's submit is activated
+ * @param {(args: WizardBodyArgs) => React.ReactNode} [props.renderStep]   render-prop for the active step's body
+ * @param {React.ReactNode[]} [props.children]  index-aligned step bodies (alternative to renderStep)
+ * @param {string} [props.continueLabel='continue']  primary label for non-final steps
+ * @param {string} [props.submitLabel='submit']      primary label for the final step
+ * @param {string} [props.backLabel='back']          secondary (back) label
+ * @param {string} [props['aria-label']]  accessible name for the rail
+ */
+export default function StepWizard({ steps, onComplete, renderStep, children, continueLabel, submitLabel, backLabel, "aria-label": ariaLabel, }: {
+    steps: WizardStep[];
+    onComplete?: (args: {
+        completed: Set<string>;
+    }) => void;
+    renderStep?: (args: WizardBodyArgs) => React.ReactNode;
+    children?: React.ReactNode[];
+    continueLabel?: string;
+    submitLabel?: string;
+    backLabel?: string;
+}): any;
+export type WizardStep = {
+    /**
+     * stable id for the step (aria wiring + completed/reachable sets)
+     */
+    id: string;
+    /**
+     * the step's lowercase chrome label, shown under its number
+     */
+    label: React.ReactNode;
+};
+export type WizardBodyArgs = {
+    /**
+     * the active step descriptor
+     */
+    step: WizardStep;
+    /**
+     * its zero-based position
+     */
+    index: number;
+    /**
+     * whether it's the final step
+     */
+    isLast: boolean;
+    /**
+     * report whether the step may advance (gates continue)
+     */
+    setValid: (valid: boolean) => void;
+};

package/dist/lib/types/StepWizard.stories.d.ts

@@ -0,0 +1,18 @@
+export default meta;
+export namespace Default {
+    function render(): any;
+    function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace Indicator {
+    export function render_1(): any;
+    export { render_1 as render };
+}
+declare namespace meta {
+    export let title: string;
+    export { StepWizard as component };
+    export let tags: string[];
+    export let decorators: Function[];
+}
+import StepWizard from './StepWizard.jsx';

package/dist/lib/types/StepsWaterfall.d.ts

@@ -0,0 +1,67 @@
+/** Human-readable ms duration: "4.2s", "42s", "2m 14s", "1.5h". Tabular-friendly, no leading zeros. */
+export function formatDuration(ms: any): string;
+/**
+ * @typedef {object} Task
+ * @property {string} id - stable key; passed back to onJump (e.g. the prompt turn id).
+ * @property {number} [index] - the displayed task number (#1). Falls back to row order + 1.
+ * @property {string} prompt - the user prompt that opened the task (USER CONTENT — case preserved).
+ * @property {number} durationMs - how long the task took, in ms (drives the bar + the label).
+ * @property {number} [tools] - tool calls in the task (shown as "n tools" when no `turns`).
+ * @property {number} [turns] - assistant turns in the task (shown as "n turns").
+ * @property {'ok'|'error'} [outcome] - 'error' draws the clay marker + the "error" word/icon.
+ * @property {string} [error] - a short error label; shown in place of "error" when present.
+ */
+/**
+ * StepsWaterfall — render `tasks` as a duration waterfall: a header (total + count + collapse-all)
+ * over a list of selectable rows, each with a monochrome duration bar.
+ *
+ * @param {object} props
+ * @param {Task[]} props.tasks - the tasks, in order; one row each.
+ * @param {(id: string) => void} [props.onJump] - called with a task id when its row is chosen.
+ * @param {number} [props.totalMs] - total session time; defaults to the sum of task durations.
+ * @param {boolean} [props.defaultCollapsed=false] - start with the rows collapsed.
+ * @param {string} [props.label='steps by duration'] - accessible name for the list (lowercase chrome).
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export default function StepsWaterfall({ tasks, onJump, totalMs, defaultCollapsed, label, className, ...rest }: {
+    tasks: Task[];
+    onJump?: (id: string) => void;
+    totalMs?: number;
+    defaultCollapsed?: boolean;
+    label?: string;
+    className?: string;
+}): any;
+export type Task = {
+    /**
+     * - stable key; passed back to onJump (e.g. the prompt turn id).
+     */
+    id: string;
+    /**
+     * - the displayed task number (#1). Falls back to row order + 1.
+     */
+    index?: number;
+    /**
+     * - the user prompt that opened the task (USER CONTENT — case preserved).
+     */
+    prompt: string;
+    /**
+     * - how long the task took, in ms (drives the bar + the label).
+     */
+    durationMs: number;
+    /**
+     * - tool calls in the task (shown as "n tools" when no `turns`).
+     */
+    tools?: number;
+    /**
+     * - assistant turns in the task (shown as "n turns").
+     */
+    turns?: number;
+    /**
+     * - 'error' draws the clay marker + the "error" word/icon.
+     */
+    outcome?: "ok" | "error";
+    /**
+     * - a short error label; shown in place of "error" when present.
+     */
+    error?: string;
+};

package/dist/lib/types/StepsWaterfall.stories.d.ts

@@ -0,0 +1,94 @@
+export default meta;
+export namespace Default {
+    namespace args {
+        export { TASKS as tasks };
+        export let totalMs: number;
+    }
+    function play({ args, canvasElement }: {
+        args: any;
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace Dense {
+    export namespace args_1 {
+        export { DENSE as tasks };
+    }
+    export { args_1 as args };
+}
+export namespace WithError {
+    export namespace args_2 {
+        export { WITH_ERROR as tasks };
+    }
+    export { args_2 as args };
+}
+export namespace Collapsed {
+    export namespace args_3 {
+        export { TASKS as tasks };
+        let totalMs_1: number;
+        export { totalMs_1 as totalMs };
+        export let defaultCollapsed: boolean;
+    }
+    export { args_3 as args };
+}
+declare namespace meta {
+    export let title: string;
+    export { StepsWaterfall as component };
+    export let decorators: Function[];
+    export namespace parameters {
+        let layout: string;
+    }
+    export namespace args_4 {
+        let onJump: import("storybook/test").Mock<(...args: any[]) => any>;
+    }
+    export { args_4 as args };
+}
+declare const TASKS: ({
+    id: string;
+    index: number;
+    prompt: string;
+    durationMs: number;
+    turns: number;
+    outcome: string;
+    error?: undefined;
+} | {
+    id: string;
+    index: number;
+    prompt: string;
+    durationMs: number;
+    turns: number;
+    outcome: string;
+    error: string;
+})[];
+declare const DENSE: ({
+    id: string;
+    prompt: string;
+    durationMs: number;
+    tools: number;
+    outcome?: undefined;
+    error?: undefined;
+} | {
+    id: string;
+    prompt: string;
+    durationMs: number;
+    tools: number;
+    outcome: string;
+    error: string;
+})[];
+declare const WITH_ERROR: ({
+    id: string;
+    index: number;
+    prompt: string;
+    durationMs: number;
+    turns: number;
+    outcome: string;
+    error?: undefined;
+} | {
+    id: string;
+    index: number;
+    prompt: string;
+    durationMs: number;
+    turns: number;
+    outcome: string;
+    error: string;
+})[];
+import StepsWaterfall from './StepsWaterfall.jsx';

package/dist/lib/types/Switch.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @typedef {Object} SwitchProps
+ * @property {boolean} [checked]        controlled on/off state; pair with onChange.
+ * @property {boolean} [defaultChecked=false] initial state when uncontrolled.
+ * @property {(next: boolean) => void} [onChange] called with the next state on toggle.
+ * @property {boolean} [disabled=false] real `disabled` attribute (dim, not focusable).
+ * @property {boolean} [busy=false]     sets aria-busy; pairs with an aria-live marker.
+ * @property {React.ReactNode} [label]  text rendered in the associated .sw-label.
+ * @property {string} [onText='on']     state-marker text shown when checked.
+ * @property {string} [offText='off']   state-marker text shown when unchecked.
+ * @property {React.ComponentType<{size?: number}>} [stateIcon] override icon for the
+ *           .sw-state marker; defaults to CircleCheck (on) / Circle (off).
+ * @property {string} [id]              id for the control; links the label's `for`.
+ */
+/**
+ * @param {SwitchProps} props
+ */
+export default function Switch({ checked, defaultChecked, onChange, disabled, busy, label, onText, offText, stateIcon: StateIcon, id, }: SwitchProps): any;
+export type SwitchProps = {
+    /**
+     * controlled on/off state; pair with onChange.
+     */
+    checked?: boolean;
+    /**
+     * initial state when uncontrolled.
+     */
+    defaultChecked?: boolean;
+    /**
+     * called with the next state on toggle.
+     */
+    onChange?: (next: boolean) => void;
+    /**
+     * real `disabled` attribute (dim, not focusable).
+     */
+    disabled?: boolean;
+    /**
+     * sets aria-busy; pairs with an aria-live marker.
+     */
+    busy?: boolean;
+    /**
+     * text rendered in the associated .sw-label.
+     */
+    label?: React.ReactNode;
+    /**
+     * state-marker text shown when checked.
+     */
+    onText?: string;
+    /**
+     * state-marker text shown when unchecked.
+     */
+    offText?: string;
+    /**
+     * override icon for the
+     * .sw-state marker; defaults to CircleCheck (on) / Circle (off).
+     */
+    stateIcon?: React.ComponentType<{
+        size?: number;
+    }>;
+    /**
+     * id for the control; links the label's `for`.
+     */
+    id?: string;
+};

package/dist/lib/types/Switch.stories.d.ts

@@ -0,0 +1,134 @@
+export default meta;
+export const Playground: {};
+export namespace On {
+    namespace args {
+        let label: string;
+        let defaultChecked: boolean;
+    }
+}
+export namespace Off {
+    export namespace args_1 {
+        let label_1: string;
+        export { label_1 as label };
+        let defaultChecked_1: boolean;
+        export { defaultChecked_1 as defaultChecked };
+    }
+    export { args_1 as args };
+}
+export namespace Disabled {
+    export namespace args_2 {
+        let label_2: string;
+        export { label_2 as label };
+        let defaultChecked_2: boolean;
+        export { defaultChecked_2 as defaultChecked };
+        export let disabled: boolean;
+    }
+    export { args_2 as args };
+}
+export namespace Busy {
+    export namespace args_3 {
+        let label_3: string;
+        export { label_3 as label };
+        let defaultChecked_3: boolean;
+        export { defaultChecked_3 as defaultChecked };
+        export let busy: boolean;
+        export let onText: string;
+    }
+    export { args_3 as args };
+}
+export namespace CustomStateIcon {
+    export namespace args_4 {
+        let label_4: string;
+        export { label_4 as label };
+        export { EyeOff as stateIcon };
+        let onText_1: string;
+        export { onText_1 as onText };
+        export let offText: string;
+    }
+    export { args_4 as args };
+}
+export namespace NoLabel {
+    export namespace args_5 {
+        let label_5: any;
+        export { label_5 as label };
+    }
+    export { args_5 as args };
+}
+export namespace DisabledOff {
+    export namespace args_6 {
+        let label_6: string;
+        export { label_6 as label };
+        let defaultChecked_4: boolean;
+        export { defaultChecked_4 as defaultChecked };
+        let disabled_1: boolean;
+        export { disabled_1 as disabled };
+    }
+    export { args_6 as args };
+}
+export namespace Toggles {
+    function render(): any;
+    function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+declare namespace meta {
+    export let title: string;
+    export { Switch as component };
+    export let tags: string[];
+    export let decorators: Function[];
+    export namespace argTypes {
+        export namespace checked {
+            let control: string;
+        }
+        export namespace defaultChecked_5 {
+            let control_1: string;
+            export { control_1 as control };
+        }
+        export { defaultChecked_5 as defaultChecked };
+        export namespace disabled_2 {
+            let control_2: string;
+            export { control_2 as control };
+        }
+        export { disabled_2 as disabled };
+        export namespace busy_1 {
+            let control_3: string;
+            export { control_3 as control };
+        }
+        export { busy_1 as busy };
+        export namespace label_7 {
+            let control_4: string;
+            export { control_4 as control };
+        }
+        export { label_7 as label };
+        export namespace onText_2 {
+            let control_5: string;
+            export { control_5 as control };
+        }
+        export { onText_2 as onText };
+        export namespace offText_1 {
+            let control_6: string;
+            export { control_6 as control };
+        }
+        export { offText_1 as offText };
+        export namespace onChange {
+            let action: string;
+        }
+    }
+    export namespace args_7 {
+        let label_8: string;
+        export { label_8 as label };
+        let defaultChecked_6: boolean;
+        export { defaultChecked_6 as defaultChecked };
+        let disabled_3: boolean;
+        export { disabled_3 as disabled };
+        let busy_2: boolean;
+        export { busy_2 as busy };
+        let onText_3: string;
+        export { onText_3 as onText };
+        let offText_2: string;
+        export { offText_2 as offText };
+    }
+    export { args_7 as args };
+}
+import { EyeOff } from 'lucide-react';
+import Switch from './Switch.jsx';