@kitn.ai/ui 0.15.1 → 0.17.0

package/dist/components/tasks-card.d.ts

@@ -0,0 +1,72 @@
+import { JSX } from 'solid-js';
+import { CardEnvelope, CardHost, CardResolution } from '../primitives/card-contract';
+export interface TasksTask {
+    id: string;
+    label: string;
+    description?: string;
+    checked?: boolean;
+    disabled?: boolean;
+}
+export interface TasksCardData {
+    mode?: 'select';
+    heading?: string;
+    tasks: TasksTask[];
+    selectAll?: boolean;
+    confirmLabel?: string;
+    allowEmpty?: boolean;
+    min?: number;
+    max?: number;
+    dismissible?: boolean;
+}
+export interface TasksCardResult {
+    selected: string[];
+}
+export type TasksCardEnvelope = CardEnvelope<'tasks', TasksCardData>;
+export declare const TASKS_CARD_TYPE: "tasks";
+/** De-dupe tasks by id (first wins). Returns the usable list + an optional error. */
+export declare function normalizeTasks(tasks: unknown): {
+    tasks: TasksTask[];
+    error?: string;
+};
+/** The ids of the initially-checked tasks (in input order). */
+export declare function initialSelected(tasks: TasksTask[]): string[];
+/** The selected ids in input order (selection set ∩ tasks, preserving task order). */
+export declare function selectedInOrder(tasks: TasksTask[], selected: Set<string>): string[];
+/** The toggleable (non-disabled) task ids. */
+export declare function toggleableIds(tasks: TasksTask[]): string[];
+export type SelectAllState = 'checked' | 'unchecked' | 'indeterminate';
+/** Select-all tri-state over the toggleable rows. */
+export declare function selectAllState(tasks: TasksTask[], selected: Set<string>): SelectAllState;
+/** Whether select-all should be shown: requested AND not blocked by `max` (since
+ *  "all" would violate max). */
+export declare function showSelectAll(data: TasksCardData, tasks: TasksTask[]): boolean;
+/** Whether confirm is enabled for the current selection count. */
+export declare function canConfirm(data: TasksCardData, count: number): boolean;
+/** Whether an unchecked row is blocked because `max` is reached. */
+export declare function isMaxReached(data: TasksCardData, count: number): boolean;
+/** The disabled-reason text for confirm (for aria-describedby), or undefined. */
+export declare function confirmReason(data: TasksCardData, count: number): string | undefined;
+export interface TasksCardProps {
+    /** The tasks definition (CardEnvelope.data). */
+    data?: TasksCardData;
+    /** The card id used to correlate every emitted CardEvent. */
+    cardId?: string;
+    /** The envelope title rendered in the card chrome. */
+    heading?: string;
+    /** Optional explicit CardHost (otherwise read from a CardProvider, otherwise the
+     *  bubbling `kai-card` CustomEvent off `hostElement`). */
+    host?: CardHost;
+    /** The custom-element host node, for the bubbling `kai-card` fallback emit. */
+    hostElement?: HTMLElement;
+    class?: string;
+    /** When set, render the chromed read-only summary instead of the interactive controls. */
+    resolution?: CardResolution;
+}
+/**
+ * `TasksCard` — a selectable task/plan list (checkbox rows + optional select-all
+ * + a confirm button) inside `Card` chrome. Row toggling and select-all are local
+ * UI state; only the final confirm emits the Card contract's `submit` verb
+ * (`{ kind:'submit', cardId, data:{ selected } }`) with the checked ids in
+ * input order. Emits `ready` on mount and `error` for an unusable definition.
+ */
+export declare function TasksCard(props: TasksCardProps): JSX.Element;

package/dist/components/text-shimmer.d.ts

@@ -0,0 +1,9 @@
+import { JSX } from 'solid-js';
+export interface TextShimmerProps extends JSX.HTMLAttributes<HTMLElement> {
+    as?: string;
+    duration?: number;
+    spread?: number;
+    children: JSX.Element;
+}
+declare function TextShimmer(props: TextShimmerProps): JSX.Element;
+export { TextShimmer };

package/dist/components/thinking-bar.d.ts

@@ -0,0 +1,10 @@
+import { JSX } from 'solid-js';
+export interface ThinkingBarProps {
+    class?: string;
+    text?: string;
+    onStop?: () => void;
+    stopLabel?: string;
+    onClick?: () => void;
+}
+declare function ThinkingBar(props: ThinkingBarProps): JSX.Element;
+export { ThinkingBar };

package/dist/components/toast.d.ts

@@ -0,0 +1,48 @@
+import { ToastItem, ToastVariant } from '../primitives/toast-store';
+export type { ToastItem, ToastVariant };
+/** Why a toast went away — surfaced to `onDismiss` (and the facade event). */
+export type ToastDismissReason = 'timeout' | 'close' | 'action';
+export type ToastPosition = 'top-center' | 'top-right' | 'top-left' | 'bottom-center' | 'bottom-right' | 'bottom-left';
+export interface ToastRegionProps {
+    /** The toasts to render. Newest is shown on top. Set as a JS property on the
+     *  element; mutate by passing a new array reference. */
+    toasts: ToastItem[];
+    /** Where the stack anchors. Defaults to `'top-center'`. */
+    position?: ToastPosition;
+    /** Max simultaneously-visible toasts; the rest queue and promote as slots
+     *  free up. Defaults to `3`. */
+    max?: number;
+    /** Stacking: 'expanded' (default, full column) | 'collapsed' (Sonner-style
+     *  pile that expands on hover/focus). Attribute: stack. */
+    stack?: 'expanded' | 'collapsed';
+    /** When set, this region renders only the toasts scoped to that element and
+     *  anchors over its bounds (top-center), following it on scroll/resize. Unset =
+     *  the global, viewport-anchored region. */
+    target?: HTMLElement;
+    /** Fired when a toast leaves, with the reason. */
+    onDismiss?: (id: string, reason: ToastDismissReason) => void;
+    /** Fired when a toast's action button is pressed. */
+    onAction?: (id: string, label: string) => void;
+}
+interface ToastProps {
+    item: ToastItem;
+    onDismiss: (reason: ToastDismissReason) => void;
+    onAction?: (label: string) => void;
+    /** Hold the auto-dismiss timer (the region sets this true while the whole stack
+     *  is hovered/expanded, so peers don't dismiss out from under the cursor). */
+    paused?: boolean;
+}
+/**
+ * A single toast pill. Auto-dismisses after its (action-floored) duration, holds
+ * the timer while hovered (this pill) OR while `paused` (the whole stack is
+ * hovered), and animates in/out via `createPresence`. Pure + prop-driven — the
+ * parent `ToastRegion` owns the list + queue.
+ */
+export declare function Toast(props: ToastProps): import("solid-js").JSX.Element;
+/**
+ * Renders a stack of toasts at a viewport edge. Caps the visible count at `max`
+ * (newest on top); overflow waits in a queue and is promoted as visible toasts
+ * leave. `aria-live=polite` / `role=region` so screen readers announce new
+ * toasts without stealing focus.
+ */
+export declare function ToastRegion(props: ToastRegionProps): import("solid-js").JSX.Element;

package/dist/components/tool.d.ts

@@ -0,0 +1,16 @@
+import { JSX } from 'solid-js';
+export interface ToolPart {
+    type: string;
+    state: 'input-streaming' | 'input-available' | 'output-available' | 'output-error';
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    toolCallId?: string;
+    errorText?: string;
+}
+export interface ToolProps {
+    toolPart: ToolPart;
+    defaultOpen?: boolean;
+    class?: string;
+}
+declare function Tool(props: ToolProps): JSX.Element;
+export { Tool };

package/dist/components/use-card-resolution.d.ts

@@ -0,0 +1,16 @@
+import { Accessor } from 'solid-js';
+import { CardResolution } from '../primitives/card-contract';
+export interface ResolutionController<R extends CardResolution = CardResolution> {
+    resolution: Accessor<R | undefined>;
+    isResolved: Accessor<boolean>;
+    /** A finished resolution the user can't take back here (action | submit | expired). */
+    isTerminal: Accessor<boolean>;
+    /** A deferred resolution (`dismissed`) — set aside, still re-openable. */
+    isDeferred: Accessor<boolean>;
+    isOptimistic: Accessor<boolean>;
+    setLocal: (r: R) => void;
+}
+export declare function useCardResolution<R extends CardResolution = CardResolution>(opts: {
+    prop: Accessor<R | undefined>;
+    data: Accessor<unknown>;
+}): ResolutionController<R>;

package/dist/components/voice-input.d.ts

@@ -0,0 +1,7 @@
+export interface VoiceInputProps {
+    onTranscribe: (audio: Blob) => Promise<string>;
+    onTranscription: (text: string) => void;
+    disabled?: boolean;
+    class?: string;
+}
+export declare function VoiceInput(props: VoiceInputProps): import("solid-js").JSX.Element;