@peasant-labs/fairtrade 0.0.0

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

@@ -0,0 +1,132 @@
+/**
+ * @typedef {Object} CheckboxProps
+ * @property {boolean} [checked]        controlled checked state (pair with onChange)
+ * @property {boolean} [defaultChecked] initial state for uncontrolled use (default false)
+ * @property {(checked: boolean, event: import('react').ChangeEvent<HTMLInputElement>) => void} [onChange]
+ * @property {boolean} [disabled]       native disabled attribute (default false)
+ * @property {import('react').ReactNode} [children] label text (rendered as passed, not lowercased)
+ */
+/**
+ * A single checkbox: <label class="check"> wrapping the styled <input type="checkbox" class="check-box">.
+ * @param {CheckboxProps & import('react').InputHTMLAttributes<HTMLInputElement>} props
+ */
+export default function Checkbox({ checked, defaultChecked, onChange, disabled, children, ...rest }: CheckboxProps & any): any;
+/**
+ * @typedef {Object} RadioProps
+ * @property {string} name              shared group name; radios must come in groups of >=2 so any one
+ *                                      can be deselected by picking another. for a lone binary choice
+ *                                      use Checkbox or Switch, never a single standalone Radio.
+ * @property {string} [value]           the value submitted / matched when this radio is selected
+ * @property {boolean} [checked]        controlled checked state (pair with onChange)
+ * @property {boolean} [defaultChecked] initial state for uncontrolled use (default false)
+ * @property {(event: import('react').ChangeEvent<HTMLInputElement>) => void} [onChange]
+ * @property {boolean} [disabled]       native disabled attribute (default false)
+ * @property {import('react').ReactNode} [children] label text (rendered as passed, not lowercased)
+ */
+/**
+ * A single radio: <label class="is-radio"> wrapping the styled <input type="radio" class="is-radio-dot">.
+ * Always render via RadioGroup (or at least two sibling radios sharing `name`) so a selection can be
+ * changed; a lone radio cannot be deselected, which is an accessibility anti-pattern. For a single
+ * binary choice use Checkbox or Switch instead.
+ * @param {RadioProps & import('react').InputHTMLAttributes<HTMLInputElement>} props
+ */
+export function Radio({ name, value, checked, defaultChecked, onChange, disabled, children, ...rest }: RadioProps & any): any;
+/**
+ * @typedef {Object} RadioOption
+ * @property {string} value
+ * @property {import('react').ReactNode} label
+ * @property {boolean} [disabled]
+ */
+/**
+ * @typedef {Object} RadioGroupProps
+ * @property {string} name              shared name for every radio in the group (required for single-select)
+ * @property {string} [value]          controlled selected value (pair with onChange)
+ * @property {string} [defaultValue]   initial selected value for uncontrolled use
+ * @property {(value: string, event: import('react').ChangeEvent<HTMLInputElement>) => void} [onChange]
+ * @property {RadioOption[]} options    the choices to render
+ * @property {string} ariaLabel        accessible name for the role=radiogroup container; required for
+ *                                     an accessible group (a radiogroup with no name is an a11y failure)
+ */
+/**
+ * A group of radios: <div class="is-radios" role="radiogroup"> of <label class="is-radio"> rows.
+ * Only one option is selectable because every input shares `name`.
+ * @param {RadioGroupProps & import('react').HTMLAttributes<HTMLDivElement>} props
+ */
+export function RadioGroup({ name, value, defaultValue, onChange, options, ariaLabel, ...rest }: RadioGroupProps & any): any;
+export type CheckboxProps = {
+    /**
+     * controlled checked state (pair with onChange)
+     */
+    checked?: boolean;
+    /**
+     * initial state for uncontrolled use (default false)
+     */
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean, event: any) => void;
+    /**
+     * native disabled attribute (default false)
+     */
+    disabled?: boolean;
+    /**
+     * label text (rendered as passed, not lowercased)
+     */
+    children?: any;
+};
+export type RadioProps = {
+    /**
+     * shared group name; radios must come in groups of >=2 so any one
+     * can be deselected by picking another. for a lone binary choice
+     * use Checkbox or Switch, never a single standalone Radio.
+     */
+    name: string;
+    /**
+     * the value submitted / matched when this radio is selected
+     */
+    value?: string;
+    /**
+     * controlled checked state (pair with onChange)
+     */
+    checked?: boolean;
+    /**
+     * initial state for uncontrolled use (default false)
+     */
+    defaultChecked?: boolean;
+    onChange?: (event: any) => void;
+    /**
+     * native disabled attribute (default false)
+     */
+    disabled?: boolean;
+    /**
+     * label text (rendered as passed, not lowercased)
+     */
+    children?: any;
+};
+export type RadioOption = {
+    value: string;
+    label: any;
+    disabled?: boolean;
+};
+export type RadioGroupProps = {
+    /**
+     * shared name for every radio in the group (required for single-select)
+     */
+    name: string;
+    /**
+     * controlled selected value (pair with onChange)
+     */
+    value?: string;
+    /**
+     * initial selected value for uncontrolled use
+     */
+    defaultValue?: string;
+    onChange?: (value: string, event: any) => void;
+    /**
+     * the choices to render
+     */
+    options: RadioOption[];
+    /**
+     * accessible name for the role=radiogroup container; required for
+     * an accessible group (a radiogroup with no name is an a11y failure)
+     */
+    ariaLabel: string;
+};

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

@@ -0,0 +1,75 @@
+export default meta;
+export const Playground: {};
+export namespace Checked {
+    namespace args {
+        let defaultChecked: boolean;
+        let children: string;
+    }
+}
+export namespace Disabled {
+    export namespace args_1 {
+        export let disabled: boolean;
+        let defaultChecked_1: boolean;
+        export { defaultChecked_1 as defaultChecked };
+        let children_1: string;
+        export { children_1 as children };
+    }
+    export { args_1 as args };
+}
+export namespace Group {
+    function render(): any;
+}
+export namespace LicenseRadios {
+    export function render_1(): any;
+    export { render_1 as render };
+}
+export namespace RadioGroupProviders {
+    export function render_2(): any;
+    export { render_2 as render };
+}
+export namespace RadioGroupControlled {
+    export function render_3(): any;
+    export { render_3 as render };
+}
+export namespace ClicksToCheck {
+    export namespace args_2 {
+        let children_2: string;
+        export { children_2 as children };
+    }
+    export { args_2 as args };
+    export function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+declare namespace meta {
+    export let title: string;
+    export { Checkbox as component };
+    export let tags: string[];
+    export let decorators: Function[];
+    export namespace argTypes {
+        export namespace defaultChecked_2 {
+            let control: string;
+        }
+        export { defaultChecked_2 as defaultChecked };
+        export namespace disabled_1 {
+            let control_1: string;
+            export { control_1 as control };
+        }
+        export { disabled_1 as disabled };
+        export namespace children_3 {
+            let control_2: string;
+            export { control_2 as control };
+        }
+        export { children_3 as children };
+    }
+    export namespace args_3 {
+        let children_4: string;
+        export { children_4 as children };
+        let defaultChecked_3: boolean;
+        export { defaultChecked_3 as defaultChecked };
+        let disabled_2: boolean;
+        export { disabled_2 as disabled };
+    }
+    export { args_3 as args };
+}
+import Checkbox from './Checkbox.jsx';

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

@@ -0,0 +1,85 @@
+/**
+ * @typedef {'ok'|'warn'|'err'} ChipTone
+ * @typedef {'sm'} ChipSize
+ */
+/**
+ * a static chip: an icon names the thing, a short label confirms it, color reinforces. wraps
+ * `<span class="chip">` with the parametric tone / size modifiers and an optional real x-button.
+ * @param {object} props
+ * @param {ChipTone} [props.tone] - semantic tone -> .chip-ok / .chip-warn / .chip-err (default: none)
+ * @param {ChipSize} [props.size] - 'sm' -> .chip-sm dense box (default: none)
+ * @param {string} [props.brand] - a provider/company name (claude, gemini, openai, cursor, opencode, or an alias).
+ *        When the chip names a company, pass this instead of `icon`: it leads with the real brand mark, never a generic glyph. (ignored when not resolvable)
+ * @param {React.ElementType} [props.icon] - leading lucide icon component ref (e.g. icon={Hash}) (ignored when `brand` is set)
+ * @param {boolean} [props.chrome=false] - mark this as a ui-chrome chip -> lowercases the label. Leave off for user content (ids, names, data values).
+ * @param {boolean} [props.removable=false] - render a real .chipx-x button with an X icon
+ * @param {() => void} [props.onRemove] - called when the x-button is clicked
+ * @param {string} [props.removeLabel] - aria-label for the x-button (default: `remove ${children}`; effectively required when children is not a plain string)
+ * @param {string} [props.className] - extra classes appended after the chip classes
+ * @param {React.ReactNode} props.children - the chip label / content (not force-lowercased unless chrome)
+ */
+export default function Chip({ tone, size, brand, icon: Icon, chrome, removable, onRemove, removeLabel, className, children, ...rest }: {
+    tone?: ChipTone;
+    size?: ChipSize;
+    brand?: string;
+    icon?: React.ElementType;
+    chrome?: boolean;
+    removable?: boolean;
+    onRemove?: () => void;
+    removeLabel?: string;
+    className?: string;
+    children: React.ReactNode;
+}): any;
+/**
+ * a filter / toggle chip: a real `<button class="chip chip-toggle" aria-pressed>`. selected shows a
+ * leading check (.chipx-tick, revealed by css) and an amber fill; the css carries the rest. supports
+ * controlled (pressed + onChange) and uncontrolled (defaultPressed) use.
+ * @param {object} props
+ * @param {boolean} [props.pressed] - controlled pressed state
+ * @param {boolean} [props.defaultPressed=false] - initial pressed state when uncontrolled
+ * @param {(next: boolean) => void} [props.onChange] - called with the next pressed state on click
+ * @param {string} [props.brand] - a provider/company name; leads with the real brand mark when NOT pressed (ignored when `icon` is wanted instead)
+ * @param {React.ElementType} [props.icon] - leading icon shown when NOT pressed (e.g. icon={Filter}) (ignored when `brand` is set)
+ * @param {string} [props.className] - extra classes appended after the chip classes
+ * @param {React.ReactNode} props.children - the toggle label (not force-lowercased)
+ */
+export function FilterChip({ pressed, defaultPressed, onChange, brand, icon: Icon, className, children, ...rest }: {
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onChange?: (next: boolean) => void;
+    brand?: string;
+    icon?: React.ElementType;
+    className?: string;
+    children: React.ReactNode;
+}): any;
+/**
+ * a status dot ALWAYS paired with a label, so status never rides on color alone. renders the small
+ * filled .chipx-dot square (tinted via the --c color var) followed by the required label text.
+ * by default it ships inside a `.chip` chassis to match the specimen; pass bare to drop the wrapper.
+ * @param {object} props
+ * @param {string} props.label - the status word (required; names the state) — not force-lowercased
+ * @param {string} [props.color] - css color for the dot, written to style="--c:..." (default: token fallback)
+ * @param {boolean} [props.bare=false] - omit the surrounding .chip wrapper, render dot + label only
+ * @param {string} [props.className] - extra classes appended after the chip class (ignored when bare)
+ */
+export function StatusDot({ label, color, bare, className, ...rest }: {
+    label: string;
+    color?: string;
+    bare?: boolean;
+    className?: string;
+}): any;
+/**
+ * a numeric notification count: a trailing pill of tabular digits (.chipx-count). neutral by default;
+ * .unread flips it to the scarce amber. tnum keeps digits tabular.
+ * @param {object} props
+ * @param {number|string} props.count - the value to display
+ * @param {boolean} [props.unread=false] - amber unread treatment -> .unread
+ * @param {string} [props.className] - extra classes appended after the count classes
+ */
+export function CountBadge({ count, unread, className, ...rest }: {
+    count: number | string;
+    unread?: boolean;
+    className?: string;
+}): any;
+export type ChipTone = "ok" | "warn" | "err";
+export type ChipSize = "sm";

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

@@ -0,0 +1,190 @@
+export default meta;
+export const Playground: {};
+export namespace WithIcon {
+    namespace args {
+        export let brand: any;
+        export { Hash as icon };
+        export let children: string;
+    }
+}
+export namespace ToneOk {
+    export namespace args_1 {
+        let brand_1: any;
+        export { brand_1 as brand };
+        export let tone: string;
+        export { ShieldCheck as icon };
+        export let chrome: boolean;
+        let children_1: string;
+        export { children_1 as children };
+    }
+    export { args_1 as args };
+}
+export namespace ToneWarn {
+    export namespace args_2 {
+        let brand_2: any;
+        export { brand_2 as brand };
+        let tone_1: string;
+        export { tone_1 as tone };
+        let chrome_1: boolean;
+        export { chrome_1 as chrome };
+        let children_2: string;
+        export { children_2 as children };
+    }
+    export { args_2 as args };
+}
+export namespace ToneErr {
+    export namespace args_3 {
+        let brand_3: any;
+        export { brand_3 as brand };
+        let tone_2: string;
+        export { tone_2 as tone };
+        let chrome_2: boolean;
+        export { chrome_2 as chrome };
+        let children_3: string;
+        export { children_3 as children };
+    }
+    export { args_3 as args };
+}
+export namespace Small {
+    export namespace args_4 {
+        export let size: string;
+        let brand_4: string;
+        export { brand_4 as brand };
+        let children_4: string;
+        export { children_4 as children };
+    }
+    export { args_4 as args };
+}
+export namespace SmallTones {
+    function render(): any;
+}
+export namespace RemovableSmall {
+    export namespace args_5 {
+        let brand_5: any;
+        export { brand_5 as brand };
+        let size_1: string;
+        export { size_1 as size };
+        export let removable: boolean;
+        export { Tag as icon };
+        let children_5: string;
+        export { children_5 as children };
+        export let removeLabel: string;
+        export let onRemove: import("storybook/test").Mock<(...args: any[]) => any>;
+    }
+    export { args_5 as args };
+}
+export namespace Tones {
+    export function render_1(): any;
+    export { render_1 as render };
+}
+export namespace Removable {
+    export namespace args_6 {
+        let brand_6: any;
+        export { brand_6 as brand };
+        let removable_1: boolean;
+        export { removable_1 as removable };
+        export { Tag as icon };
+        let children_6: string;
+        export { children_6 as children };
+        let onRemove_1: import("storybook/test").Mock<(...args: any[]) => any>;
+        export { onRemove_1 as onRemove };
+    }
+    export { args_6 as args };
+    export function play({ args, canvasElement }: {
+        args: any;
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace Filter_ {
+    export let name: string;
+    export function render_2(): any;
+    export { render_2 as render };
+    export function play_1({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_1 as play };
+}
+export namespace FilterControlled {
+    let name_1: string;
+    export { name_1 as name };
+    export function render_3(): any;
+    export { render_3 as render };
+}
+export namespace Status {
+    let name_2: string;
+    export { name_2 as name };
+    export function render_4(): any;
+    export { render_4 as render };
+}
+export namespace StatusDotBare {
+    let name_3: string;
+    export { name_3 as name };
+    export function render_5(): any;
+    export { render_5 as render };
+}
+export namespace Count {
+    let name_4: string;
+    export { name_4 as name };
+    export function render_6(): any;
+    export { render_6 as render };
+}
+declare namespace meta {
+    export let title: string;
+    export { Chip as component };
+    export let tags: string[];
+    export namespace argTypes {
+        export namespace tone_3 {
+            let control: string;
+            let options: string[];
+        }
+        export { tone_3 as tone };
+        export namespace size_2 {
+            let control_1: string;
+            export { control_1 as control };
+            let options_1: string[];
+            export { options_1 as options };
+        }
+        export { size_2 as size };
+        export namespace brand_7 {
+            let control_2: string;
+            export { control_2 as control };
+            let options_2: string[];
+            export { options_2 as options };
+        }
+        export { brand_7 as brand };
+        export namespace chrome_3 {
+            let control_3: string;
+            export { control_3 as control };
+        }
+        export { chrome_3 as chrome };
+        export namespace removable_2 {
+            let control_4: string;
+            export { control_4 as control };
+        }
+        export { removable_2 as removable };
+        export namespace children_7 {
+            let control_5: string;
+            export { control_5 as control };
+        }
+        export { children_7 as children };
+    }
+    export namespace args_7 {
+        let children_8: string;
+        export { children_8 as children };
+        let brand_8: string;
+        export { brand_8 as brand };
+        let tone_4: any;
+        export { tone_4 as tone };
+        let size_3: any;
+        export { size_3 as size };
+        let chrome_4: boolean;
+        export { chrome_4 as chrome };
+        let removable_3: boolean;
+        export { removable_3 as removable };
+    }
+    export { args_7 as args };
+}
+import { Hash } from 'lucide-react';
+import { ShieldCheck } from 'lucide-react';
+import { Tag } from 'lucide-react';
+import Chip from './Chip.jsx';

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

@@ -0,0 +1,68 @@
+/**
+ * CommandBlock — a square `$ command` block: a mono command line with a leading dim `$`, and a copy
+ * button that flips to an olive check + the word "copied" for ~1.5s.
+ *
+ * @param {object} props
+ * @param {string} props.command - the literal shell command (case preserved — never lowercased).
+ * @param {string} [props.label] - an accessible name for the copy button; defaults to the command.
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export function CommandBlock({ command, label, className, ...rest }: {
+    command: string;
+    label?: string;
+    className?: string;
+}): any;
+/**
+ * @typedef {object} CliStep
+ * @property {string} title - the step heading (e.g. "install"). Chrome — rendered lowercase by CSS.
+ * @property {string} [body] - optional prose explaining the step (body font, case preserved).
+ * @property {string} [command] - optional shell command for the step, rendered as a CommandBlock.
+ */
+/**
+ * CliSteps — a numbered step list: each step is a square amber-tinted number marker + a title + an
+ * optional body + an optional CommandBlock, with a connector line running between the markers.
+ *
+ * @param {object} props
+ * @param {CliStep[]} props.steps - the steps, in order; numbered from 1.
+ * @param {string} [props.label='getting started'] - accessible name for the list (lowercase chrome).
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export function CliSteps({ steps, label, className, ...rest }: {
+    steps: CliStep[];
+    label?: string;
+    className?: string;
+}): any;
+/**
+ * GettingStarted — a dismissible card wrapping <CliSteps>: a header (title + close button) over the
+ * step list. Dismissing persists "dismissed" to localStorage under `storageKey`, so the card stays
+ * gone across reloads; when no key is given it dismisses for the session only.
+ *
+ * @param {object} props
+ * @param {string} [props.title='getting started'] - the card heading (lowercase chrome).
+ * @param {CliStep[]} props.steps - the onboarding steps, passed through to CliSteps.
+ * @param {string} [props.storageKey] - localStorage key the dismissed flag persists under.
+ * @param {() => void} [props.onDismiss] - called after the card is dismissed.
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export function GettingStarted({ title, steps, storageKey, onDismiss, className, ...rest }: {
+    title?: string;
+    steps: CliStep[];
+    storageKey?: string;
+    onDismiss?: () => void;
+    className?: string;
+}): any;
+export default CliSteps;
+export type CliStep = {
+    /**
+     * - the step heading (e.g. "install"). Chrome — rendered lowercase by CSS.
+     */
+    title: string;
+    /**
+     * - optional prose explaining the step (body font, case preserved).
+     */
+    body?: string;
+    /**
+     * - optional shell command for the step, rendered as a CommandBlock.
+     */
+    command?: string;
+};

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

@@ -0,0 +1,24 @@
+export default meta;
+export namespace Steps {
+    function render(): any;
+}
+export namespace Command {
+    export function render_1(): any;
+    export { render_1 as render };
+    export function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace GettingStartedCard {
+    export function render_2(): any;
+    export { render_2 as render };
+}
+declare namespace meta {
+    export let title: string;
+    export { CliSteps as component };
+    export let decorators: Function[];
+    export namespace parameters {
+        let layout: string;
+    }
+}
+import { CliSteps } from './CliOnboard.jsx';

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

@@ -0,0 +1,6 @@
+export default function CommandPalette({ open, onClose, onTheme, sections }: {
+    open: any;
+    onClose: any;
+    onTheme: any;
+    sections: any;
+}): any;

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

@@ -0,0 +1,94 @@
+export default meta;
+export namespace Playground {
+    namespace parameters {
+        let layout: string;
+    }
+    function render(args: any): any;
+}
+export namespace Default {
+    export namespace parameters_1 {
+        let layout_1: string;
+        export { layout_1 as layout };
+    }
+    export { parameters_1 as parameters };
+    export function render_1(args: any): any;
+    export { render_1 as render };
+    export function play({ args, canvasElement }: {
+        args: any;
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace Filtered {
+    export namespace parameters_2 {
+        let layout_2: string;
+        export { layout_2 as layout };
+    }
+    export { parameters_2 as parameters };
+    export function render_2(args: any): any;
+    export { render_2 as render };
+    export function play_1({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_1 as play };
+}
+export namespace Empty {
+    export namespace parameters_3 {
+        let layout_3: string;
+        export { layout_3 as layout };
+    }
+    export { parameters_3 as parameters };
+    export function render_3(args: any): any;
+    export { render_3 as render };
+    export function play_2({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_2 as play };
+}
+export namespace EscapeCloses {
+    export namespace parameters_4 {
+        let layout_4: string;
+        export { layout_4 as layout };
+    }
+    export { parameters_4 as parameters };
+    export function render_4(args: any): any;
+    export { render_4 as render };
+    export function play_3({ args, canvasElement }: {
+        args: any;
+        canvasElement: any;
+    }): Promise<void>;
+    export { play_3 as play };
+}
+declare namespace meta {
+    export let title: string;
+    export { CommandPalette as component };
+    export let tags: string[];
+    export let decorators: Function[];
+    export namespace argTypes {
+        namespace open {
+            let control: string;
+        }
+        namespace sections {
+            let control_1: string;
+            export { control_1 as control };
+        }
+        namespace onClose {
+            let action: string;
+        }
+        namespace onTheme {
+            let action_1: string;
+            export { action_1 as action };
+        }
+    }
+    export namespace args {
+        export { SECTIONS as sections };
+        let onClose_1: import("storybook/test").Mock<(...args: any[]) => any>;
+        export { onClose_1 as onClose };
+        let onTheme_1: import("storybook/test").Mock<(...args: any[]) => any>;
+        export { onTheme_1 as onTheme };
+    }
+}
+import CommandPalette from './CommandPalette.jsx';
+declare const SECTIONS: {
+    id: string;
+    label: string;
+}[];