@peasant-labs/fairtrade 0.0.0

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

@@ -0,0 +1,44 @@
+export default meta;
+export namespace Marks {
+    let decorators: Function[];
+    function render(): any;
+    function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace Tags {
+    let decorators_1: Function[];
+    export { decorators_1 as decorators };
+    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 Names {
+    let decorators_2: Function[];
+    export { decorators_2 as decorators };
+    export function render_2(): any;
+    export { render_2 as render };
+}
+export namespace AccentLegendStory {
+    export let name: string;
+    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 { ProviderIcon as component };
+    export let tags: string[];
+    export namespace parameters {
+        let layout: string;
+    }
+}
+import { ProviderIcon } from './ProviderIcon.jsx';

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

@@ -0,0 +1,199 @@
+/**
+ * @typedef {Object} RailShellProps
+ * @property {React.ReactNode} [toolbar]      optional sticky top toolbar (mono chrome row); omitted when absent.
+ * @property {React.ReactNode} children        the main content / canvas column (scrolls; min-width:0).
+ * @property {React.ReactNode} rail            the rail contents — compose with <RailSection> children.
+ * @property {'left'|'right'} [railSide='right']  which side the desktop rail sits on.
+ * @property {string} [sheetTitle='details']   the bottom-sheet toggle label (mono, lowercased) on mobile.
+ * @property {React.ReactNode} [sheetMeta]     quiet right-side content in the sheet header (e.g. a count).
+ * @property {string} [className]              extra class on the root.
+ */
+/**
+ * The shell frame: a two-column canvas + sticky-rail layout on desktop that collapses the rail into
+ * a fixed bottom-sheet below 880px. The main column scrolls and is min-width:0 so a wide canvas
+ * stays contained; the rail is a 320px sticky hairline card. The same `rail` content renders in both
+ * the desktop card and the mobile sheet, so avoid `id` attributes inside it. The sheet's expand /
+ * collapse is a button reporting aria-expanded and is wired to the sheet body via aria-controls.
+ */
+export default function RailShell({ toolbar, children, rail, railSide, sheetTitle, sheetMeta, className, }: {
+    toolbar: any;
+    children: any;
+    rail: any;
+    railSide?: string;
+    sheetTitle?: string;
+    sheetMeta: any;
+    className?: string;
+}): any;
+/**
+ * @typedef {Object} RailSectionProps
+ * @property {React.ReactNode} [title]         mono section header (lowercased by css).
+ * @property {React.ComponentType} [icon]      optional lucide icon component shown before the title.
+ * @property {React.ReactNode} [meta]          quiet right-aligned header content (a count, a glyph).
+ * @property {React.ReactNode} children         the section body.
+ * @property {boolean} [collapsible=false]     when true, the header is a button that toggles the body.
+ * @property {boolean} [defaultOpen=true]      initial open state when collapsible.
+ * @property {string} [className]              extra class on the section.
+ */
+/**
+ * One titled hairline section inside a rail: a mono header (optional icon + title + meta) over a
+ * body. When `collapsible`, the header becomes a button reporting aria-expanded and wired to the
+ * body via aria-controls; the chevron rotates open. Sections divide from one another with the
+ * rail card's hairlines.
+ */
+export function RailSection({ title, icon: Icon, meta, children, collapsible, defaultOpen, className, }: {
+    title: any;
+    icon: any;
+    meta: any;
+    children: any;
+    collapsible?: boolean;
+    defaultOpen?: boolean;
+    className?: string;
+}): any;
+/**
+ * @typedef {Object} SplitRailProps
+ * @property {React.ReactNode} left            content of the left column (e.g. an outline tree).
+ * @property {React.ReactNode} right           content of the right column (e.g. filters).
+ * @property {string} [leftTitle='outline']    left column header (mono, lowercased).
+ * @property {string} [rightTitle='filters']   right column header (mono, lowercased).
+ * @property {React.ComponentType} [leftIcon]  optional lucide icon for the left header.
+ * @property {React.ComponentType} [rightIcon] optional lucide icon for the right header.
+ * @property {React.ReactNode} [leftMeta]      quiet right-aligned content in the left header.
+ * @property {React.ReactNode} [rightMeta]     quiet right-aligned content in the right header.
+ * @property {string} [className]              extra class on the root.
+ */
+/**
+ * The dual-rail variant: two independently-collapsible columns (outline-left / filters-right), each
+ * a hairline panel that collapses on its own. Side by side on desktop; stacks to a single column on
+ * mobile. Use as the `rail` of a RailShell, or standalone as a two-pane control surface.
+ */
+export function SplitRail({ left, right, leftTitle, rightTitle, leftIcon, rightIcon, leftMeta, rightMeta, className, }: {
+    left: any;
+    right: any;
+    leftTitle?: string;
+    rightTitle?: string;
+    leftIcon: any;
+    rightIcon: any;
+    leftMeta: any;
+    rightMeta: any;
+    className?: string;
+}): any;
+export type RailShellProps = {
+    /**
+     * optional sticky top toolbar (mono chrome row); omitted when absent.
+     */
+    toolbar?: React.ReactNode;
+    /**
+     * the main content / canvas column (scrolls; min-width:0).
+     */
+    children: React.ReactNode;
+    /**
+     * the rail contents — compose with <RailSection> children.
+     */
+    rail: React.ReactNode;
+    /**
+     * which side the desktop rail sits on.
+     */
+    railSide?: "left" | "right";
+    /**
+     * the bottom-sheet toggle label (mono, lowercased) on mobile.
+     */
+    sheetTitle?: string;
+    /**
+     * quiet right-side content in the sheet header (e.g. a count).
+     */
+    sheetMeta?: React.ReactNode;
+    /**
+     * extra class on the root.
+     */
+    className?: string;
+};
+export type RailSectionProps = {
+    /**
+     * mono section header (lowercased by css).
+     */
+    title?: React.ReactNode;
+    /**
+     * optional lucide icon component shown before the title.
+     */
+    icon?: React.ComponentType;
+    /**
+     * quiet right-aligned header content (a count, a glyph).
+     */
+    meta?: React.ReactNode;
+    /**
+     * the section body.
+     */
+    children: React.ReactNode;
+    /**
+     * when true, the header is a button that toggles the body.
+     */
+    collapsible?: boolean;
+    /**
+     * initial open state when collapsible.
+     */
+    defaultOpen?: boolean;
+    /**
+     * extra class on the section.
+     */
+    className?: string;
+};
+export type SplitRailPanelProps = {
+    /**
+     * mono header for the column.
+     */
+    title?: React.ReactNode;
+    /**
+     * optional lucide icon before the title.
+     */
+    icon?: React.ComponentType;
+    /**
+     * quiet right-aligned header content.
+     */
+    meta?: React.ReactNode;
+    /**
+     * the column body.
+     */
+    children: React.ReactNode;
+    /**
+     * initial open state (each column collapses independently).
+     */
+    defaultOpen?: boolean;
+};
+export type SplitRailProps = {
+    /**
+     * content of the left column (e.g. an outline tree).
+     */
+    left: React.ReactNode;
+    /**
+     * content of the right column (e.g. filters).
+     */
+    right: React.ReactNode;
+    /**
+     * left column header (mono, lowercased).
+     */
+    leftTitle?: string;
+    /**
+     * right column header (mono, lowercased).
+     */
+    rightTitle?: string;
+    /**
+     * optional lucide icon for the left header.
+     */
+    leftIcon?: React.ComponentType;
+    /**
+     * optional lucide icon for the right header.
+     */
+    rightIcon?: React.ComponentType;
+    /**
+     * quiet right-aligned content in the left header.
+     */
+    leftMeta?: React.ReactNode;
+    /**
+     * quiet right-aligned content in the right header.
+     */
+    rightMeta?: React.ReactNode;
+    /**
+     * extra class on the root.
+     */
+    className?: string;
+};

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

@@ -0,0 +1,32 @@
+export default meta;
+export namespace Default {
+    function render(): any;
+}
+export namespace RailLeft {
+    export function render_1(): any;
+    export { render_1 as render };
+}
+export namespace Split {
+    export function render_2(): any;
+    export { render_2 as render };
+}
+export namespace SplitInShell {
+    export function render_3(): any;
+    export { render_3 as render };
+}
+export namespace MobileSheet {
+    export function render_4(): any;
+    export { render_4 as render };
+    export function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+declare namespace meta {
+    export let title: string;
+    export { RailShell as component };
+    export namespace parameters {
+        let layout: string;
+    }
+    export let tags: string[];
+}
+import RailShell from './RailShell.jsx';

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

@@ -0,0 +1,53 @@
+/**
+ * RedactionReview — the safe-by-default review surface.
+ *
+ * @param {object} props
+ * @param {'minimal'|'standard'|'maximum'} [props.level='standard'] - the selected redaction level
+ * @param {(level: string) => void} [props.onLevel] - called with the next level on select
+ * @param {Array<{id, category, confidence:number, before?:string, secret?:string, after:string, kept?:boolean}>} [props.matches]
+ *        - the flagged matches. `before`/`secret` is the original (one or the other), `after` the
+ *          redacted form. `kept` (controlled mode) = the user opted OUT, secret leaves as-is.
+ * @param {(id: string, kept: boolean) => void} [props.onToggle] - called when a match is toggled;
+ *        when given, the component is controlled (read `kept` off each match).
+ * @param {number} [props.scanned] - sessions/files scanned so far (defaults to `total`: done).
+ * @param {number} [props.total=0] - total to scan.
+ * @param {string|boolean} [props.failure] - honest-failure banner text; truthy shows the banner.
+ * @param {string} [props.className]
+ */
+export function RedactionReview({ level, onLevel, matches, onToggle, scanned, total, failure, className, ...rest }: {
+    level?: "minimal" | "standard" | "maximum";
+    onLevel?: (level: string) => void;
+    matches?: Array<{
+        id: any;
+        category: any;
+        confidence: number;
+        before?: string;
+        secret?: string;
+        after: string;
+        kept?: boolean;
+    }>;
+    onToggle?: (id: string, kept: boolean) => void;
+    scanned?: number;
+    total?: number;
+    failure?: string | boolean;
+    className?: string;
+}): any;
+/**
+ * WhereDoesThisGo — the transparency panel shown before an outbound action. the destination url,
+ * then a two-column split: "what gets sent" (Send icon, add rail) vs "what stays private" (Lock
+ * icon, neutral rail). calm, square, hairline. each column header pairs an icon with its word so
+ * the two halves never read on color alone.
+ *
+ * @param {object} props
+ * @param {string} props.destination - the outbound url (code -> mono, not lowercased)
+ * @param {string[]} [props.sent] - the things that WILL be sent
+ * @param {string[]} [props.private] - the things that stay on the machine
+ * @param {string} [props.className]
+ */
+export function WhereDoesThisGo({ destination, sent, private: stays, className, ...rest }: {
+    destination: string;
+    sent?: string[];
+    private?: string[];
+    className?: string;
+}): any;
+export default RedactionReview;

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

@@ -0,0 +1,120 @@
+export default meta;
+export namespace Default {
+    function render(args: any): any;
+    namespace args {
+        let level: string;
+        let scanned: number;
+        let total: number;
+    }
+    function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace WithScanFailure {
+    export function render_1(args: any): any;
+    export { render_1 as render };
+    export namespace args_1 {
+        let level_1: string;
+        export { level_1 as level };
+        let scanned_1: number;
+        export { scanned_1 as scanned };
+        let total_1: number;
+        export { total_1 as total };
+        export let failure: boolean;
+    }
+    export { args_1 as args };
+    export function play_1({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_1 as play };
+}
+export namespace Empty {
+    export function render_2(args: any): any;
+    export { render_2 as render };
+    export namespace args_2 {
+        let level_2: string;
+        export { level_2 as level };
+        let scanned_2: number;
+        export { scanned_2 as scanned };
+        let total_2: number;
+        export { total_2 as total };
+        export let matches: any[];
+    }
+    export { args_2 as args };
+}
+export namespace Transparency {
+    export function render_3(args: any): any;
+    export { render_3 as render };
+    export namespace parameters {
+        namespace controls {
+            let include: string[];
+        }
+    }
+    export namespace args_3 {
+        export let destination: string;
+        export let sent: string[];
+        let _private: string[];
+        export { _private as private };
+    }
+    export { args_3 as args };
+    export function play_2({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_2 as play };
+}
+export namespace LightTheme {
+    export function render_4(args: any): any;
+    export { render_4 as render };
+    export namespace args_4 {
+        let level_3: string;
+        export { level_3 as level };
+        let scanned_3: number;
+        export { scanned_3 as scanned };
+        let total_3: number;
+        export { total_3 as total };
+    }
+    export { args_4 as args };
+    export namespace globals {
+        let theme: string;
+        namespace backgrounds {
+            let value: string;
+        }
+    }
+}
+declare namespace meta {
+    export let title: string;
+    export { RedactionReview as component };
+    export let tags: string[];
+    export let decorators: Function[];
+    export namespace argTypes {
+        export namespace level_4 {
+            let control: string;
+            let options: string[];
+        }
+        export { level_4 as level };
+        export namespace total_4 {
+            let control_1: string;
+            export { control_1 as control };
+        }
+        export { total_4 as total };
+        export namespace scanned_4 {
+            let control_2: string;
+            export { control_2 as control };
+        }
+        export { scanned_4 as scanned };
+        export namespace matches_1 {
+            let control_3: boolean;
+            export { control_3 as control };
+        }
+        export { matches_1 as matches };
+        export namespace onToggle {
+            let control_4: boolean;
+            export { control_4 as control };
+        }
+        export namespace onLevel {
+            let control_5: boolean;
+            export { control_5 as control };
+        }
+    }
+}
+import { RedactionReview } from './Redaction.jsx';

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

@@ -0,0 +1,97 @@
+/**
+ * The inline destructive-confirm: a trigger button that, on click, swaps in place to
+ * "{label}? [yes] [cancel]" — never a modal, so the row never reflows out from under the cursor.
+ * yes fires onConfirm and (if it doesn't throw) reverts to the trigger; cancel reverts immediately.
+ *
+ * @param {Object} props
+ * @param {React.ReactNode} [props.label='remove']       the trigger's lowercase chrome label
+ * @param {string} [props.confirmLabel]                  the verb echoed in the prompt + on yes (defaults to label, lowercased)
+ * @param {React.ReactNode} [props.icon]                 optional leading glyph for the trigger (e.g. <Trash2 />)
+ * @param {() => (void | Promise<void>)} props.onConfirm fired when yes is activated
+ * @param {boolean} [props.busy=false]                   external pending flag — disables yes + shows "{verb}…"
+ * @param {boolean} [props.disabled=false]               disables the trigger entirely
+ * @param {string} [props['aria-label']]                 accessible name for the trigger (defaults from label/confirmLabel)
+ * @param {string} [props.className]                     extra class on the wrapper
+ */
+export function ConfirmInline({ label, confirmLabel, icon, onConfirm, busy, disabled, "aria-label": ariaLabel, className, }: {
+    label?: React.ReactNode;
+    confirmLabel?: string;
+    icon?: React.ReactNode;
+    onConfirm: () => (void | Promise<void>);
+    busy?: boolean;
+    disabled?: boolean;
+}): any;
+/**
+ * @typedef {Object} RosterMember
+ * @property {string} handle           the member's handle (user content — never lowercased)
+ * @property {string} [name]           display name (user content)
+ * @property {'owner'|'member'|'contributor'|'guest'} role  the member's role
+ * @property {boolean} [owner]         locks the row: role select disabled, "owner" shown as text + lock glyph, no remove
+ * @property {string} [org]            an org affiliation chip (user content, e.g. a github org login)
+ * @property {string} [avatar]         avatar image url; falls back to the handle's initial
+ * @property {string} [id]             stable key (defaults to handle)
+ */
+/**
+ * A member role roster: one row per member with avatar/handle + name, an org chip, a role select,
+ * and (for non-owner rows) an inline remove. Owner rows are locked — the role reads as plain
+ * "owner" text beside a lock glyph and there's no remove, mirroring village where the owner can't
+ * be reassigned or removed here.
+ *
+ * @param {Object} props
+ * @param {RosterMember[]} props.members           the members to list
+ * @param {(member: RosterMember, role: string) => void} [props.onRole]   fired when a row's role select changes
+ * @param {(member: RosterMember) => (void | Promise<void>)} [props.onRemove]  fired when a row's remove is confirmed
+ * @param {string} [props.title='members']         section header label (lowercase chrome)
+ * @param {string[]} [props.roles]                 selectable roles (default member/contributor/guest; owner is never offered)
+ */
+export default function RoleRoster({ members, onRole, onRemove, title, roles, }: {
+    members: RosterMember[];
+    onRole?: (member: RosterMember, role: string) => void;
+    onRemove?: (member: RosterMember) => (void | Promise<void>);
+    title?: string;
+    roles?: string[];
+}): any;
+/**
+ * A clay-bordered section wrapping destructive actions (e.g. "delete collective"). Fronted by a
+ * warning glyph + the literal word "warning" so the danger framing is never carried by the clay
+ * border alone. children is the body — typically a sentence of consequence + a
+ * <ConfirmInline confirmLabel="delete" />.
+ *
+ * @param {Object} props
+ * @param {React.ReactNode} [props.title='danger zone']  the section header label (lowercase chrome)
+ * @param {React.ReactNode} props.children               the destructive actions / explanation
+ */
+export function DangerZone({ title, children }: {
+    title?: React.ReactNode;
+    children: React.ReactNode;
+}): any;
+export type RosterMember = {
+    /**
+     * the member's handle (user content — never lowercased)
+     */
+    handle: string;
+    /**
+     * display name (user content)
+     */
+    name?: string;
+    /**
+     * the member's role
+     */
+    role: "owner" | "member" | "contributor" | "guest";
+    /**
+     * locks the row: role select disabled, "owner" shown as text + lock glyph, no remove
+     */
+    owner?: boolean;
+    /**
+     * an org affiliation chip (user content, e.g. a github org login)
+     */
+    org?: string;
+    /**
+     * avatar image url; falls back to the handle's initial
+     */
+    avatar?: string;
+    /**
+     * stable key (defaults to handle)
+     */
+    id?: string;
+};

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

@@ -0,0 +1,23 @@
+export default meta;
+export namespace Roster {
+    function render(): any;
+}
+export namespace ConfirmRemove {
+    export function render_1(): any;
+    export { render_1 as render };
+    export function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace Danger {
+    export let name: string;
+    export function render_2(): any;
+    export { render_2 as render };
+}
+declare namespace meta {
+    export let title: string;
+    export { RoleRoster as component };
+    export let tags: string[];
+    export let decorators: Function[];
+}
+import RoleRoster from './RoleRoster.jsx';

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

@@ -0,0 +1,78 @@
+/**
+ * SignInProviders — a multi-provider OAuth split button.
+ *
+ * the first provider is the PRIMARY action ("continue with <label>"); the rest
+ * live behind a chevron that opens a keyboard-operable menu. clicking the
+ * primary or any menu row calls onSignIn(providerId).
+ *
+ * @param {object} props
+ * @param {Array<{id:string,label:string}>} [props.providers] ordered; [0] is primary. defaults to PROVIDERS.
+ * @param {(id:string)=>void} [props.onSignIn] called with the chosen provider id.
+ * @param {string} [props.className]
+ * @returns {JSX.Element|null}
+ */
+export function SignInProviders({ providers, onSignIn, className, ...rest }: {
+    providers?: Array<{
+        id: string;
+        label: string;
+    }>;
+    onSignIn?: (id: string) => void;
+    className?: string;
+}): JSX.Element | null;
+/**
+ * HandleClaim — the post-OAuth handle-claim card.
+ *
+ * a mono @-prefixed input with live validation shown as an ICON + a WORD (never
+ * color alone), one or two suggestion chips, and a "claim handle" button that
+ * stays disabled until the handle validates as available. the typed handle keeps
+ * its case; validation normalizes a copy.
+ *
+ * @param {object} props
+ * @param {(handle:string)=>void} [props.onSubmit] called with the typed handle on claim.
+ * @param {(raw:string)=>{state:'idle'|'available'|'taken'|'invalid'|'checking',hint?:string}} [props.validate]
+ *        override the validator; defaults to the built-in handle rule + taken set.
+ * @param {string} [props.initialValue] seed the field (kept verbatim, case preserved).
+ * @param {string} [props.suggestedFrom] a provider username to derive suggestion chips from.
+ * @param {string[]} [props.suggestions] explicit suggestion chips (overrides suggestedFrom).
+ * @param {string} [props.className]
+ * @returns {JSX.Element}
+ */
+export function HandleClaim({ onSubmit, validate, initialValue, suggestedFrom, suggestions, className, ...rest }: {
+    onSubmit?: (handle: string) => void;
+    validate?: (raw: string) => {
+        state: "idle" | "available" | "taken" | "invalid" | "checking";
+        hint?: string;
+    };
+    initialValue?: string;
+    suggestedFrom?: string;
+    suggestions?: string[];
+    className?: string;
+}): JSX.Element;
+/**
+ * OnboardingCard — the two steps composed into one onboarding specimen: the
+ * provider split button up top, the handle-claim card below. a thin pass-through
+ * wrapper so a consumer (and the combined story) can show the whole front door.
+ *
+ * @param {object} props
+ * @param {Array<{id:string,label:string}>} [props.providers]
+ * @param {(id:string)=>void} [props.onSignIn]
+ * @param {(handle:string)=>void} [props.onSubmit]
+ * @param {string} [props.suggestedFrom]
+ * @param {string} [props.className]
+ * @returns {JSX.Element}
+ */
+export function OnboardingCard({ providers, onSignIn, onSubmit, suggestedFrom, className, ...rest }: {
+    providers?: Array<{
+        id: string;
+        label: string;
+    }>;
+    onSignIn?: (id: string) => void;
+    onSubmit?: (handle: string) => void;
+    suggestedFrom?: string;
+    className?: string;
+}): JSX.Element;
+export const PROVIDERS: {
+    id: string;
+    label: string;
+}[];
+export default SignInProviders;