@peasant-labs/fairtrade 0.0.0

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

@@ -0,0 +1,48 @@
+export default meta;
+export namespace Phases {
+    function render(): any;
+    function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace TaskBoundaryDivider {
+    export let name: string;
+    export function render_1(): any;
+    export { render_1 as render };
+    export function play_1({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_1 as play };
+}
+export namespace Checkpoint {
+    export function render_2(): any;
+    export { render_2 as render };
+    export function play_2({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_2 as play };
+}
+export namespace TurnContext {
+    export function render_3(): any;
+    export { render_3 as render };
+    export function play_3({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_3 as play };
+}
+export namespace Divider {
+    let name_1: string;
+    export { name_1 as name };
+    export function render_4(): any;
+    export { render_4 as render };
+}
+declare namespace meta {
+    export let title: string;
+    export { TaskBoundary as component };
+    export let tags: string[];
+    export let decorators: Function[];
+    export namespace parameters {
+        let layout: string;
+    }
+}
+import { TaskBoundary } from './TranscriptMarkers.jsx';

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

@@ -0,0 +1,77 @@
+/**
+ * Lay `items` out as a squarified treemap filling [0,0,width,height]. Returns one
+ * tile per item (input length preserved). Zero/negative-value items get zero-size
+ * tiles (no area, so they never overlap). When every value is 0, values fall back
+ * to equal (so a no-churn set still tiles legibly). A non-positive width or height
+ * yields all-zero tiles (no NaN/Infinity).
+ *
+ * @param {Array<{id:string, value:number}>} items
+ * @param {number} width
+ * @param {number} height
+ * @returns {Array<{id:string, x:number, y:number, w:number, h:number}>}
+ */
+export function squarify(items: Array<{
+    id: string;
+    value: number;
+}>, width: number, height: number): Array<{
+    id: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}>;
+/**
+ * @typedef {Object} TreemapDatum
+ * @property {string} id                 stable key (also the default selection token)
+ * @property {string} label              human label, e.g. "ingest/stream.go" (leaf shown)
+ * @property {number} value              non-negative sizing weight; tile AREA ∝ value
+ * @property {number} [intensity=0]      0..4 monochrome ramp level (a SECOND metric)
+ * @property {string} [unit='lines']     noun for the aria-label, e.g. "lines", "calls"
+ */
+/**
+ * Treemap — a squarified, strict-monochrome treemap. One tile per datum, AREA
+ * proportional to `value`, an optional 0..4 grayscale `intensity` reinforcing a
+ * second metric. No hue, no verdict — facts for orientation. Each tile is a real
+ * <button> (label + aria-label "<label> — N <unit>"), focus-visible ring, and a
+ * title, so sliver tiles whose label is suppressed stay identifiable. Clicking a
+ * tile fires `onSelect(id, datum)`.
+ *
+ * Emits a `role="group"` container so the interactive tiles stay in the a11y tree
+ * (role="img" would make them presentational). Renders nothing for an empty set.
+ *
+ * @param {Object} props
+ * @param {TreemapDatum[]} [props.data=[]]              the tiles (area ∝ value)
+ * @param {(id:string, datum:TreemapDatum)=>void} [props.onSelect]  fired on tile click
+ * @param {number} [props.height=320]                   container height in px
+ * @param {string} [props.ariaLabel]                    label for the group landmark
+ * @param {string} [props.className]                    extra class on the container
+ */
+export default function Treemap({ data, onSelect, height, ariaLabel, className, }: {
+    data?: TreemapDatum[];
+    onSelect?: (id: string, datum: TreemapDatum) => void;
+    height?: number;
+    ariaLabel?: string;
+    className?: string;
+}): any;
+export type TreemapDatum = {
+    /**
+     * stable key (also the default selection token)
+     */
+    id: string;
+    /**
+     * human label, e.g. "ingest/stream.go" (leaf shown)
+     */
+    label: string;
+    /**
+     * non-negative sizing weight; tile AREA ∝ value
+     */
+    value: number;
+    /**
+     * 0..4 monochrome ramp level (a SECOND metric)
+     */
+    intensity?: number;
+    /**
+     * noun for the aria-label, e.g. "lines", "calls"
+     */
+    unit?: string;
+};

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

@@ -0,0 +1,101 @@
+declare namespace _default {
+    export let title: string;
+    export { Treemap as component };
+    export namespace parameters {
+        let layout: string;
+        namespace docs {
+            namespace description {
+                let component: string;
+            }
+        }
+    }
+    export let decorators: Function[];
+    export namespace argTypes {
+        namespace height {
+            namespace control {
+                let type: string;
+                let min: number;
+                let max: number;
+                let step: number;
+            }
+        }
+        namespace onSelect {
+            let action: string;
+        }
+        namespace data {
+            let control_1: boolean;
+            export { control_1 as control };
+        }
+        namespace ariaLabel {
+            let control_2: string;
+            export { control_2 as control };
+        }
+    }
+}
+export default _default;
+export namespace Default {
+    namespace args {
+        export { CHANGE_SET as data };
+        let height_1: number;
+        export { height_1 as height };
+        let onSelect_1: import("storybook/test").Mock<(...args: any[]) => any>;
+        export { onSelect_1 as onSelect };
+        let ariaLabel_1: string;
+        export { ariaLabel_1 as ariaLabel };
+    }
+    function play({ args, canvasElement }: {
+        args: any;
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace Dense {
+    export namespace args_1 {
+        export { DENSE_SET as data };
+        let height_2: number;
+        export { height_2 as height };
+        let onSelect_2: import("storybook/test").Mock<(...args: any[]) => any>;
+        export { onSelect_2 as onSelect };
+        let ariaLabel_2: string;
+        export { ariaLabel_2 as ariaLabel };
+    }
+    export { args_1 as args };
+}
+export namespace SingleTile {
+    export namespace args_2 {
+        let data_1: {
+            id: string;
+            label: string;
+            value: number;
+            intensity: number;
+        }[];
+        export { data_1 as data };
+        let height_3: number;
+        export { height_3 as height };
+        let onSelect_3: import("storybook/test").Mock<(...args: any[]) => any>;
+        export { onSelect_3 as onSelect };
+    }
+    export { args_2 as args };
+}
+export namespace Light {
+    export namespace args_3 { }
+    export { args_3 as args };
+    export namespace globals {
+        let theme: string;
+        namespace backgrounds {
+            let value: string;
+        }
+    }
+}
+import Treemap from './Treemap.jsx';
+declare const CHANGE_SET: {
+    id: string;
+    label: string;
+    value: number;
+    intensity: number;
+}[];
+declare const DENSE_SET: {
+    id: string;
+    label: string;
+    value: number;
+    intensity: number;
+}[];

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

@@ -0,0 +1,54 @@
+/**
+ * VisibilityEye — a compact glyph that signals a transcript's visibility, with a tooltip naming the
+ * exact mode on hover / focus. Eye = public, EyeOff = private, Users = shared. The glyph is paired
+ * with a visually-hidden word so the state never reads on shape or color alone.
+ *
+ * @param {{ visibility?: 'public'|'private'|'shared', sharedWith?: string, size?: 'sm'|'md'|'lg' }} props
+ */
+export function VisibilityEye({ visibility, sharedWith, size }: {
+    visibility?: "public" | "private" | "shared";
+    sharedWith?: string;
+    size?: "sm" | "md" | "lg";
+}): any;
+/**
+ * VisibilitySegmented — a private | public segmented control with a one-line description under each
+ * option, and an optional "shared" override note when the server owns the state. The pressed option
+ * carries aria-pressed + a leading icon + the amber selected fill, so the choice is never color-only.
+ *
+ * @param {{ value?: 'public'|'private'|'shared', onChange?: (v:'public'|'private')=>void,
+ *           sharedNote?: string, label?: string }} props
+ */
+export function VisibilitySegmented({ value, onChange, sharedNote, label, }: {
+    value?: "public" | "private" | "shared";
+    onChange?: (v: "public" | "private") => void;
+    sharedNote?: string;
+    label?: string;
+}): any;
+/**
+ * ScopeChip — a small toggle group scoping a view to task / file / change (a chip set). One chip is
+ * pressed at a time; the pressed chip carries aria-pressed + the selected fill, so the active scope
+ * never reads on color alone.
+ *
+ * @param {{ scope?: string, onChange?: (v:string)=>void,
+ *           options?: {value:string,label:string}[], label?: string }} props
+ */
+export function ScopeChip({ scope, onChange, options, label }: {
+    scope?: string;
+    onChange?: (v: string) => void;
+    options?: {
+        value: string;
+        label: string;
+    }[];
+    label?: string;
+}): any;
+/**
+ * FocusedModeToggle — a single toggle button for "focused" mode (your prompts & the assistant's
+ * replies only). Carries aria-pressed + an icon + the word, so the on / off state is never color-only.
+ *
+ * @param {{ on?: boolean, onToggle?: (next:boolean)=>void }} props
+ */
+export function FocusedModeToggle({ on, onToggle }: {
+    on?: boolean;
+    onToggle?: (next: boolean) => void;
+}): any;
+export default VisibilitySegmented;

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

@@ -0,0 +1,126 @@
+export default meta;
+export namespace Eyes {
+    function render(): any;
+    namespace parameters {
+        namespace controls {
+            let disable: boolean;
+        }
+    }
+    function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace Segmented {
+    export function render_1(args: any): any;
+    export { render_1 as render };
+    export namespace args {
+        let value: string;
+        let label: string;
+    }
+    export function play_1({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_1 as play };
+}
+export namespace SharedNote {
+    export function render_2(args: any): any;
+    export { render_2 as render };
+    export namespace args_1 {
+        let value_1: string;
+        export { value_1 as value };
+        export let sharedNote: string;
+    }
+    export { args_1 as args };
+    export function play_2({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_2 as play };
+}
+export namespace Scope {
+    export function render_3(): any;
+    export { render_3 as render };
+    export namespace parameters_1 {
+        export namespace controls_1 {
+            let disable_1: boolean;
+            export { disable_1 as disable };
+        }
+        export { controls_1 as controls };
+    }
+    export { parameters_1 as parameters };
+    export function play_3({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_3 as play };
+}
+export namespace FocusedMode {
+    export function render_4(): any;
+    export { render_4 as render };
+    export namespace parameters_2 {
+        export namespace controls_2 {
+            let disable_2: boolean;
+            export { disable_2 as disable };
+        }
+        export { controls_2 as controls };
+    }
+    export { parameters_2 as parameters };
+    export function play_4({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_4 as play };
+}
+export namespace AllControls {
+    export function render_5(): any;
+    export { render_5 as render };
+    export namespace parameters_3 {
+        export namespace controls_3 {
+            let disable_3: boolean;
+            export { disable_3 as disable };
+        }
+        export { controls_3 as controls };
+    }
+    export { parameters_3 as parameters };
+}
+export namespace LightTheme {
+    export function render_6(args: any): any;
+    export { render_6 as render };
+    export namespace args_2 {
+        let value_2: string;
+        export { value_2 as value };
+    }
+    export { args_2 as args };
+    export namespace globals {
+        let theme: string;
+        namespace backgrounds {
+            let value_3: string;
+            export { value_3 as value };
+        }
+    }
+}
+declare namespace meta {
+    export let title: string;
+    export { VisibilitySegmented as component };
+    export let tags: string[];
+    export let decorators: Function[];
+    export namespace argTypes {
+        export namespace value_4 {
+            let control: string;
+            let options: string[];
+        }
+        export { value_4 as value };
+        export namespace onChange {
+            let control_1: boolean;
+            export { control_1 as control };
+        }
+        export namespace sharedNote_1 {
+            let control_2: string;
+            export { control_2 as control };
+        }
+        export { sharedNote_1 as sharedNote };
+        export namespace label_1 {
+            let control_3: string;
+            export { control_3 as control };
+        }
+        export { label_1 as label };
+    }
+}
+import { VisibilitySegmented } from './VisibilityControl.jsx';

package/dist/lib/types/chart-shared.d.ts

@@ -0,0 +1,63 @@
+/**
+ * ChartFrame - the hairline card chrome shared by ChartBar + ChartLine: an optional head
+ * (lucide icon + lowercase title + tabular aside), an optional sub line, the plot, and an
+ * optional swatch+label legend.
+ */
+export function ChartFrame({ icon: Icon, title, aside, sub, legend, className, children }: {
+    icon: any;
+    title: any;
+    aside: any;
+    sub: any;
+    legend: any;
+    className?: string;
+    children: any;
+}): any;
+/**
+ * ChartTooltip - the custom Recharts tooltip content: a square bordered chip, lowercase mono
+ * key, tabular values, each row prefixed by its series swatch (colour + label, never colour alone).
+ */
+export function ChartTooltip({ active, payload, label, labelFormatter, valueFormatter }: {
+    active: any;
+    payload: any;
+    label: any;
+    labelFormatter: any;
+    valueFormatter: any;
+}): any;
+export function resolveSeries(series: any): any;
+export const SERIES_CLASS: {
+    teal: string;
+    olive: string;
+    clay: string;
+    mauve: string;
+    amber: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+};
+export const SERIES_VAR: {
+    teal: string;
+    olive: string;
+    clay: string;
+    mauve: string;
+    amber: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+};
+export const RAMP: string[];
+export function seriesClass(color: any): any;
+export function seriesVar(color: any): any;
+export function cartesianProps(): {
+    accessibilityLayer: boolean;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+};
+export namespace noAnim {
+    let isAnimationActive: boolean;
+}

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

@@ -0,0 +1,53 @@
+export { default as Switch } from "./Switch.jsx";
+export { default as Tabs } from "./Tabs.jsx";
+export { default as Pager } from "./Pager.jsx";
+export { default as Pagination } from "./Pagination.jsx";
+export { default as Menu } from "./Menu.jsx";
+export { default as EmptyState } from "./EmptyState.jsx";
+export { default as DataTable } from "./DataTable.jsx";
+export { default as ChartBar } from "./ChartBar.jsx";
+export { default as ChartLine } from "./ChartLine.jsx";
+export { default as Sparkline } from "./Sparkline.jsx";
+export { default as Accordion } from "./Accordion.jsx";
+export { default as Dialog } from "./Dialog.jsx";
+export { default as CommandPalette } from "./CommandPalette.jsx";
+export { default as CommitGraph } from "./CommitGraph.jsx";
+export { default as DiffView } from "./DiffView.jsx";
+export { default as TimeStrip } from "./TimeStrip.jsx";
+export { default as PolicySelect } from "./PolicySelect.jsx";
+export { default as MapCanvas } from "./MapCanvas.jsx";
+export { default as StepsWaterfall } from "./StepsWaterfall.jsx";
+export { default as GroupedMultiSelect } from "./GroupedMultiSelect.jsx";
+export { default as ToolCallRenderer } from "./ToolRenderers.jsx";
+export { default as Tour } from "./Tour.jsx";
+export { default as FacetRail } from "./FacetRail.jsx";
+export { default as Button, ButtonGroup, Segmented } from "./Button.jsx";
+export { default as Input, Textarea, Select, Field } from "./Input.jsx";
+export { default as Checkbox, Radio, RadioGroup } from "./Checkbox.jsx";
+export { default as Chip, FilterChip, StatusDot, CountBadge } from "./Chip.jsx";
+export { default as Card, CardImg, Row, MetaItem } from "./Card.jsx";
+export { default as Breadcrumb, Steps } from "./Breadcrumb.jsx";
+export { default as Tooltip, Popover } from "./Tooltip.jsx";
+export { Avatar, AvatarGroup, Kbd, KbdChord, Tag } from "./Avatar.jsx";
+export { default as BrandMark, resolveBrand } from "./BrandMark.jsx";
+export { Skeleton, Progress, Spinner, Toast, FeedbackPanel } from "./Feedback.jsx";
+export { default as Timeline, TimelineItem, ToolCall, ThinkingBlock } from "./Timeline.jsx";
+export { default as ToastProvider, useToast } from "./ToastHost.jsx";
+export { default as DateRange, DateRangeCalendar, formatRange, DATE_PRESETS } from "./DateRange.jsx";
+export { default as MapNode, IntensitySwatch, RampLegend, Heatmap, IntensityScope, coverageLevel, effortLevel, locSize } from "./Intensity.jsx";
+export { default as Treemap, squarify } from "./Treemap.jsx";
+export { default as StepWizard, StepIndicator } from "./StepWizard.jsx";
+export { default as Explainer, Term } from "./Explainer.jsx";
+export { default as RedactionReview, WhereDoesThisGo } from "./Redaction.jsx";
+export { default as ConsentDialog, ConsentSummary } from "./ConsentDialog.jsx";
+export { default as ModerationQueue, ApprovalBar } from "./ModerationQueue.jsx";
+export { default as RoleRoster, ConfirmInline, DangerZone } from "./RoleRoster.jsx";
+export { default as RailShell, RailSection, SplitRail } from "./RailShell.jsx";
+export { default as ProviderIcon, ProviderTag, ProviderName, AccentLegend, PROVIDER_ACCENT } from "./ProviderIcon.jsx";
+export { default as EvidenceCaption, EvidenceTarget } from "./EvidenceCaption.jsx";
+export { PhaseDivider, Phase, TaskBoundary, CheckpointMarker, TurnContextBar } from "./TranscriptMarkers.jsx";
+export { default as ConnectionPill, DataState, TeachingEmptyState } from "./ConnectionState.jsx";
+export { default as SignInProviders, HandleClaim, OnboardingCard } from "./SignIn.jsx";
+export { default as CliSteps, CommandBlock, GettingStarted } from "./CliOnboard.jsx";
+export { StatTile, StatGrid, GovTile, ProviderBars } from "./StatTiles.jsx";
+export { default as VisibilitySegmented, VisibilityEye, ScopeChip, FocusedModeToggle } from "./VisibilityControl.jsx";

package/dist/lib/types/story-frame.d.ts

@@ -0,0 +1,12 @@
+/**
+ * frame(size) -> a CSF `decorators` array that wraps the story in a fixed-width, left-aligned box.
+ * @param {'narrow'|'panel'|'wide'|'full'} size
+ * @returns {Array<Function>}
+ */
+export function frame(size?: "narrow" | "panel" | "wide" | "full"): Array<Function>;
+export namespace FRAME_W {
+    let narrow: number;
+    let panel: number;
+    let wide: number;
+    let full: string;
+}