@peasant-labs/fairtrade 0.0.0

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

@@ -0,0 +1,67 @@
+/**
+ * A grouped tri-state multi-select tree. See GroupedMultiSelectProps.
+ * @param {GroupedMultiSelectProps} props
+ */
+export default function GroupedMultiSelect({ groups, value, defaultValue, onChange, tokenLabel, defaultOpen, ariaLabel, }: GroupedMultiSelectProps): any;
+export type GMSItem = {
+    /**
+     * unique selection id (what lands in the value Set).
+     */
+    id: string;
+    /**
+     * the item title — user content, rendered verbatim.
+     */
+    label: any;
+    /**
+     * one-line secondary metadata (e.g. "42 turns · jun 3").
+     */
+    meta?: any;
+    /**
+     * token count for the running tally; defaults to 0.
+     */
+    tokens?: number;
+};
+export type GMSGroup = {
+    /**
+     * unique group id.
+     */
+    id: string;
+    /**
+     * the group title — user content, rendered verbatim.
+     */
+    label: any;
+    /**
+     * the group's selectable items.
+     */
+    items: GMSItem[];
+};
+export type GroupedMultiSelectProps = {
+    /**
+     * the project-grouped tree to render.
+     */
+    groups: GMSGroup[];
+    /**
+     * controlled set of selected item ids; pair with onChange.
+     */
+    value?: Set<string>;
+    /**
+     * initial selection for uncontrolled use.
+     */
+    defaultValue?: Set<string>;
+    /**
+     * called with the next selection Set on any toggle.
+     */
+    onChange?: (next: Set<string>) => void;
+    /**
+     * noun for the tally (chrome, lowercased in display).
+     */
+    tokenLabel?: string;
+    /**
+     * ids of groups expanded on first render (uncontrolled).
+     */
+    defaultOpen?: string[];
+    /**
+     * accessible name for the tree container.
+     */
+    ariaLabel?: string;
+};

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

@@ -0,0 +1,59 @@
+export default meta;
+export namespace Default {
+    namespace args {
+        export { GROUPS as groups };
+        export { SEEDED as defaultValue };
+        export let defaultOpen: string[];
+        export let tokenLabel: string;
+    }
+}
+export namespace Collapsed {
+    export namespace args_1 {
+        export { GROUPS as groups };
+        export { SEEDED as defaultValue };
+        let defaultOpen_1: any[];
+        export { defaultOpen_1 as defaultOpen };
+        let tokenLabel_1: string;
+        export { tokenLabel_1 as tokenLabel };
+    }
+    export { args_1 as args };
+}
+export namespace TogglesCascade {
+    export namespace args_2 {
+        export { GROUPS as groups };
+        let tokenLabel_2: string;
+        export { tokenLabel_2 as tokenLabel };
+    }
+    export { args_2 as args };
+    export function render(args: any): any;
+    export function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+declare namespace meta {
+    export let title: string;
+    export { GroupedMultiSelect as component };
+    export let tags: string[];
+    export let decorators: Function[];
+    export namespace argTypes {
+        export namespace tokenLabel_3 {
+            let control: string;
+        }
+        export { tokenLabel_3 as tokenLabel };
+        export namespace onChange {
+            let action: string;
+        }
+    }
+}
+declare const GROUPS: {
+    id: string;
+    label: string;
+    items: {
+        id: string;
+        label: string;
+        meta: string;
+        tokens: number;
+    }[];
+}[];
+declare const SEEDED: Set<string>;
+import GroupedMultiSelect from './GroupedMultiSelect.jsx';

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

@@ -0,0 +1,158 @@
+/**
+ * Field — the label + control + hint/error wrapper (.is-field) the inputs compose into.
+ * Renders the label above, the control (children) in the middle, and a hint (.is-hint) or, when
+ * `error` is a non-empty string, an error (.is-error with a TriangleAlert icon) below. Wires the
+ * label's htmlFor and the hint/error id to the control via the {id, describedBy, invalid}
+ * render-prop args so the standalone <Field> can be used with any control. The shipped Input /
+ * Textarea / Select use this internally, so most callers never touch Field directly.
+ *
+ * @param {Object} props
+ * @param {React.ReactNode} [props.label] - label text shown above the control. When `lock` is set it
+ *   is wrapped in `.is-lk` with a leading icon.
+ * @param {React.ComponentType<{size?:number}>} [props.lock] - optional lucide icon (e.g. lock={Lock})
+ *   rendered before the label inside `.is-lk` to flag a read-only/locked field.
+ * @param {string} [props.hint] - helper text rendered in `.is-hint` below the control (when no error).
+ * @param {string} [props.error] - error message; a non-empty string renders `.is-error` (TriangleAlert
+ *   + message) instead of the hint and is announced via aria-describedby.
+ * @param {string} [props.id] - control id; auto-generated when omitted. Used for label htmlFor.
+ * @param {(args:{id:string,describedBy:string|undefined,invalid:boolean})=>React.ReactNode} props.children
+ *   - render-prop receiving wiring ids; returns the control element.
+ * @returns {JSX.Element}
+ */
+export function Field({ label, lock: LockIcon, hint, error, id, children }: {
+    label?: React.ReactNode;
+    lock?: React.ComponentType<{
+        size?: number;
+    }>;
+    hint?: string;
+    error?: string;
+    id?: string;
+    children: (args: {
+        id: string;
+        describedBy: string | undefined;
+        invalid: boolean;
+    }) => React.ReactNode;
+}): JSX.Element;
+/**
+ * Input — a single-line text field with the full input-states wiring. When `iconLeft` is supplied the
+ * control sits inside an `.input-ico` wrapper (the icon is absolutely positioned, leaving room via the
+ * CSS padding). Error sets aria-invalid + the clay border via `.is-input[aria-invalid]` and links the
+ * message with aria-describedby. Supports controlled (`value` + `onChange`) and uncontrolled
+ * (`defaultValue`) use.
+ *
+ * Emits `<div class="is-field"><label class="label"/>[<div class="input-ico">]<input class="input is-input"/>[…]<span class="is-hint|is-error"/></div>`
+ * matching src/index.css with zero new CSS.
+ *
+ * @param {Object} props
+ * @param {React.ReactNode} [props.label] - label above the field.
+ * @param {React.ComponentType<{size?:number}>} [props.lock] - optional lucide icon shown beside the label (.is-lk).
+ * @param {string} [props.hint] - helper text under the field.
+ * @param {string} [props.error] - error message; non-empty marks the field invalid (aria-invalid, clay border, icon).
+ * @param {boolean} [props.invalid=false] - force the invalid border without a message (sets aria-invalid).
+ * @param {React.ComponentType<{size?:number}>} [props.iconLeft] - leading lucide icon component (wraps the input in .input-ico).
+ * @param {string} [props.type='text'] - native input type.
+ * @param {boolean} [props.readOnly=false] - native readonly (surface-2 fill, quiet, still selectable).
+ * @param {boolean} [props.disabled=false] - native disabled.
+ * @param {string|number} [props.value] - controlled value.
+ * @param {string|number} [props.defaultValue] - initial value for uncontrolled use.
+ * @param {(e:React.ChangeEvent<HTMLInputElement>)=>void} [props.onChange] - change handler.
+ * @param {string} [props.id] - input id; auto-generated + associated with the label when omitted.
+ * @returns {JSX.Element}
+ */
+export default function Input({ label, lock, hint, error, invalid, iconLeft: IconLeft, type, readOnly, disabled, value, defaultValue, onChange, id, ...rest }: {
+    label?: React.ReactNode;
+    lock?: React.ComponentType<{
+        size?: number;
+    }>;
+    hint?: string;
+    error?: string;
+    invalid?: boolean;
+    iconLeft?: React.ComponentType<{
+        size?: number;
+    }>;
+    type?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    value?: string | number;
+    defaultValue?: string | number;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    id?: string;
+}): JSX.Element;
+/**
+ * Textarea — the multi-line sibling of Input. Renders `textarea.input.is-input` (the CSS gives it an
+ * auto height with a min of one control row and vertical resize). Same label/hint/error and
+ * controlled/uncontrolled wiring as Input.
+ *
+ * @param {Object} props
+ * @param {React.ReactNode} [props.label] - label above the field.
+ * @param {React.ComponentType<{size?:number}>} [props.lock] - optional lucide icon beside the label (.is-lk).
+ * @param {string} [props.hint] - helper text under the field.
+ * @param {string} [props.error] - error message; non-empty marks the field invalid.
+ * @param {boolean} [props.invalid=false] - force the invalid border (sets aria-invalid).
+ * @param {number} [props.rows=3] - visible rows.
+ * @param {boolean} [props.readOnly=false] - native readonly.
+ * @param {boolean} [props.disabled=false] - native disabled.
+ * @param {string} [props.value] - controlled value.
+ * @param {string} [props.defaultValue] - initial value for uncontrolled use.
+ * @param {(e:React.ChangeEvent<HTMLTextAreaElement>)=>void} [props.onChange] - change handler.
+ * @param {string} [props.id] - id; auto-generated + associated with the label when omitted.
+ * @returns {JSX.Element}
+ */
+export function Textarea({ label, lock, hint, error, invalid, rows, readOnly, disabled, value, defaultValue, onChange, id, ...rest }: {
+    label?: React.ReactNode;
+    lock?: React.ComponentType<{
+        size?: number;
+    }>;
+    hint?: string;
+    error?: string;
+    invalid?: boolean;
+    rows?: number;
+    readOnly?: boolean;
+    disabled?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (e: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    id?: string;
+}): JSX.Element;
+/**
+ * Select — a styled native `<select>` inside a `.select-wrap` with a trailing ChevronDown (the chevron
+ * is decorative and ignores pointer events per the CSS). Pass options either as `children` (raw
+ * `<option>` elements) or an `options` array of {value,label}. Same label/hint/error +
+ * controlled/uncontrolled wiring as Input.
+ *
+ * Emits `<div class="is-field"><label/><div class="select-wrap"><select class="select"/>chevron</div>…</div>`.
+ *
+ * @param {Object} props
+ * @param {React.ReactNode} [props.label] - label above the field.
+ * @param {React.ComponentType<{size?:number}>} [props.lock] - optional lucide icon beside the label (.is-lk).
+ * @param {string} [props.hint] - helper text under the field.
+ * @param {string} [props.error] - error message; non-empty marks the field invalid.
+ * @param {boolean} [props.invalid=false] - force the invalid border (sets aria-invalid).
+ * @param {{value:string,label:string}[]} [props.options] - option list; alternative to passing <option> children.
+ * @param {React.ReactNode} [props.children] - raw <option> elements (used when `options` is omitted).
+ * @param {boolean} [props.disabled=false] - native disabled.
+ * @param {string} [props.value] - controlled value.
+ * @param {string} [props.defaultValue] - initial value for uncontrolled use.
+ * @param {(e:React.ChangeEvent<HTMLSelectElement>)=>void} [props.onChange] - change handler.
+ * @param {string} [props.id] - id; auto-generated + associated with the label when omitted.
+ * @returns {JSX.Element}
+ */
+export function Select({ label, lock, hint, error, invalid, options, children, disabled, value, defaultValue, onChange, id, ...rest }: {
+    label?: React.ReactNode;
+    lock?: React.ComponentType<{
+        size?: number;
+    }>;
+    hint?: string;
+    error?: string;
+    invalid?: boolean;
+    options?: {
+        value: string;
+        label: string;
+    }[];
+    children?: React.ReactNode;
+    disabled?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (e: React.ChangeEvent<HTMLSelectElement>) => void;
+    id?: string;
+}): JSX.Element;

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

@@ -0,0 +1,181 @@
+export default meta;
+export const Playground: {};
+export namespace WithLabel {
+    namespace args {
+        let label: string;
+        let defaultValue: string;
+    }
+}
+export namespace Hint {
+    export namespace args_1 {
+        let label_1: string;
+        export { label_1 as label };
+        let defaultValue_1: string;
+        export { defaultValue_1 as defaultValue };
+        export let hint: string;
+    }
+    export { args_1 as args };
+}
+export namespace Error {
+    export namespace args_2 {
+        let label_2: string;
+        export { label_2 as label };
+        let defaultValue_2: string;
+        export { defaultValue_2 as defaultValue };
+        export let error: string;
+    }
+    export { args_2 as args };
+}
+export namespace Invalid {
+    export namespace args_3 {
+        let label_3: string;
+        export { label_3 as label };
+        let defaultValue_3: string;
+        export { defaultValue_3 as defaultValue };
+        export let invalid: boolean;
+        let hint_1: string;
+        export { hint_1 as hint };
+    }
+    export { args_3 as args };
+}
+export namespace ReadOnly {
+    export namespace args_4 {
+        let label_4: string;
+        export { label_4 as label };
+        export { Lock as lock };
+        let defaultValue_4: string;
+        export { defaultValue_4 as defaultValue };
+        export let readOnly: boolean;
+        let hint_2: string;
+        export { hint_2 as hint };
+    }
+    export { args_4 as args };
+}
+export namespace Disabled {
+    export namespace args_5 {
+        let label_5: string;
+        export { label_5 as label };
+        let defaultValue_5: string;
+        export { defaultValue_5 as defaultValue };
+        export let disabled: boolean;
+    }
+    export { args_5 as args };
+}
+export namespace WithIcon {
+    export namespace args_6 {
+        let label_6: string;
+        export { label_6 as label };
+        export { Search as iconLeft };
+        export let type: string;
+        let defaultValue_6: string;
+        export { defaultValue_6 as defaultValue };
+        export let placeholder: string;
+    }
+    export { args_6 as args };
+}
+export namespace IconError {
+    export namespace args_7 {
+        let label_7: string;
+        export { label_7 as label };
+        export { Search as iconLeft };
+        let type_1: string;
+        export { type_1 as type };
+        let defaultValue_7: string;
+        export { defaultValue_7 as defaultValue };
+        let error_1: string;
+        export { error_1 as error };
+    }
+    export { args_7 as args };
+}
+export namespace IconReadOnly {
+    export namespace args_8 {
+        let label_8: string;
+        export { label_8 as label };
+        export { Search as iconLeft };
+        let type_2: string;
+        export { type_2 as type };
+        let defaultValue_8: string;
+        export { defaultValue_8 as defaultValue };
+        let readOnly_1: boolean;
+        export { readOnly_1 as readOnly };
+        let hint_3: string;
+        export { hint_3 as hint };
+    }
+    export { args_8 as args };
+}
+export namespace SelectStory {
+    let name: string;
+    function render(): any;
+}
+export namespace TextareaStory {
+    let name_1: string;
+    export { name_1 as name };
+    export function render_1(): any;
+    export { render_1 as render };
+}
+export namespace FieldComposed {
+    let name_2: string;
+    export { name_2 as name };
+    export function render_2(): any;
+    export { render_2 as render };
+}
+declare namespace meta {
+    export let title: string;
+    export { Input as component };
+    export let tags: string[];
+    export let decorators: Function[];
+    export namespace argTypes {
+        export namespace label_9 {
+            let control: string;
+        }
+        export { label_9 as label };
+        export namespace hint_4 {
+            let control_1: string;
+            export { control_1 as control };
+        }
+        export { hint_4 as hint };
+        export namespace error_2 {
+            let control_2: string;
+            export { control_2 as control };
+        }
+        export { error_2 as error };
+        export namespace type_3 {
+            let control_3: string;
+            export { control_3 as control };
+            export let options: string[];
+        }
+        export { type_3 as type };
+        export namespace invalid_1 {
+            let control_4: string;
+            export { control_4 as control };
+        }
+        export { invalid_1 as invalid };
+        export namespace readOnly_2 {
+            let control_5: string;
+            export { control_5 as control };
+        }
+        export { readOnly_2 as readOnly };
+        export namespace disabled_1 {
+            let control_6: string;
+            export { control_6 as control };
+        }
+        export { disabled_1 as disabled };
+        export namespace defaultValue_9 {
+            let control_7: string;
+            export { control_7 as control };
+        }
+        export { defaultValue_9 as defaultValue };
+    }
+    export namespace args_9 {
+        let label_10: string;
+        export { label_10 as label };
+        let defaultValue_10: string;
+        export { defaultValue_10 as defaultValue };
+        let type_4: string;
+        export { type_4 as type };
+    }
+    export { args_9 as args };
+}
+import { Lock } from 'lucide-react';
+import { Search } from 'lucide-react';
+import Input from './Input.jsx';

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

@@ -0,0 +1,55 @@
+/** clamp any number into the 0..4 ramp domain (integers only). */
+export function clampLevel(level: any): number;
+/**
+ * coverage ratio (recorded / total) → ramp level. 0 / unknown = none; ≥ 0.9
+ * reads as fully covered. mirrors peasant's traceabilityLevel quantiles.
+ */
+export function coverageLevel(recorded: any, total: any): 0 | 2 | 4 | 1 | 3;
+/** density (0..1) → ramp level for the bottom-edge effort bar. */
+export function effortLevel(density: any): 0 | 2 | 4 | 1 | 3;
+/** generic value-vs-max quantization (heatmap cells, sparklines). */
+export function quantize(value: any, max: any): 0 | 2 | 4 | 1 | 3;
+/** loc → node size class. small files are compact; large ones get real estate. */
+export function locSize(loc: any): "sm" | "md" | "lg" | "xs" | "xl";
+export function IntensitySwatch({ level, accent, size, label, className, ...rest }: {
+    [x: string]: any;
+    level?: number;
+    accent: any;
+    size: any;
+    label: any;
+    className?: string;
+}): any;
+export function RampLegend({ title, words, className }: {
+    title?: string;
+    words?: string[];
+    className?: string;
+}): any;
+export function Heatmap({ values, levels, max, labels, ariaLabel, className }: {
+    values: any;
+    levels: any;
+    max: any;
+    labels: any;
+    ariaLabel?: string;
+    className?: string;
+}): any;
+export function MapNode({ label, loc, coverage, recorded, total, selected, violation, effortPct, size, as, onClick, className, ...rest }: {
+    [x: string]: any;
+    label: any;
+    loc: any;
+    coverage?: number;
+    recorded: any;
+    total: any;
+    selected?: boolean;
+    violation?: number;
+    effortPct: any;
+    size: any;
+    as?: string;
+    onClick: any;
+    className?: string;
+}): any;
+export function IntensityScope({ children, className, ...rest }: {
+    [x: string]: any;
+    children: any;
+    className?: string;
+}): any;
+export default MapNode;

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

@@ -0,0 +1,108 @@
+export default meta;
+export const Playground: {};
+export namespace Ramp {
+    function render(): any;
+    function play({ canvasElement }: {
+        canvasElement: any;
+    }): Promise<void>;
+}
+export namespace Nodes {
+    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 Sizes {
+    export function render_2(): any;
+    export { render_2 as render };
+}
+export namespace HeatmapRow {
+    export let name: string;
+    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 { MapNode as component };
+    export let tags: string[];
+    export namespace argTypes {
+        namespace label {
+            let control: string;
+        }
+        namespace loc {
+            export namespace control_1 {
+                let type: string;
+                let min: number;
+                let max: number;
+            }
+            export { control_1 as control };
+        }
+        namespace coverage {
+            export namespace control_2 {
+                let type_1: string;
+                export { type_1 as type };
+                let min_1: number;
+                export { min_1 as min };
+                let max_1: number;
+                export { max_1 as max };
+                export let step: number;
+            }
+            export { control_2 as control };
+        }
+        namespace selected {
+            let control_3: string;
+            export { control_3 as control };
+        }
+        namespace violation {
+            export namespace control_4 {
+                let type_2: string;
+                export { type_2 as type };
+                let min_2: number;
+                export { min_2 as min };
+                let max_2: number;
+                export { max_2 as max };
+            }
+            export { control_4 as control };
+        }
+        namespace effortPct {
+            export namespace control_5 {
+                let type_3: string;
+                export { type_3 as type };
+                let min_3: number;
+                export { min_3 as min };
+                let max_3: number;
+                export { max_3 as max };
+                let step_1: number;
+                export { step_1 as step };
+            }
+            export { control_5 as control };
+        }
+        namespace size {
+            let control_6: string;
+            export { control_6 as control };
+            export let options: string[];
+        }
+    }
+    export namespace args {
+        let label_1: string;
+        export { label_1 as label };
+        let loc_1: number;
+        export { loc_1 as loc };
+        let coverage_1: number;
+        export { coverage_1 as coverage };
+        let selected_1: boolean;
+        export { selected_1 as selected };
+        let violation_1: number;
+        export { violation_1 as violation };
+        let effortPct_1: number;
+        export { effortPct_1 as effortPct };
+    }
+    export let decorators: ((Story: any) => any)[];
+}
+import MapNode from './Intensity.jsx';