@khaos-systems/helm 0.2.3 → 0.3.0

package/dist/components/matter/MtInput.d.ts

@@ -1,7 +1,7 @@
 import { InputHTMLAttributes } from 'react';
 interface MtInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'variant'> {
     size?: 'medium' | 'large';
-    variant?: 'default' | 'ghost';
+    variant?: 'default' | 'ghost' | 'panel';
     placeholder?: string;
 }
 /**

package/dist/components/matter/MtSearch.d.ts

@@ -1,7 +1,7 @@
 import { InputHTMLAttributes } from 'react';
 interface MtSearchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'variant' | 'type'> {
     size?: 'medium' | 'large';
-    variant?: 'default' | 'ghost';
+    variant?: 'default' | 'ghost' | 'panel';
 }
 export declare function MtSearch({ size, variant, className, value: propValue, onChange, placeholder, ...props }: MtSearchProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/matter/MtSelect.d.ts

@@ -22,7 +22,7 @@ interface MtSelectProps {
         icon?: React.ReactNode;
         disabled?: boolean;
     }[];
-    variant?: 'default' | 'ghost';
+    variant?: 'default' | 'ghost' | 'accent' | 'panel';
     showCaret?: boolean;
 }
 type MtSelectComponent = ((props: MtSelectProps) => React.ReactElement) & {

package/dist/components/matter/MtToast.d.ts

@@ -0,0 +1,31 @@
+import { type ReactNode } from 'react';
+type ToastVariant = 'default' | 'error' | 'success';
+interface MtToastContextValue {
+    /** Show a toast with the given message. */
+    toast: (message: string, options?: {
+        variant?: ToastVariant;
+        durationMs?: number;
+    }) => void;
+}
+/**
+ * Hook to show toasts from anywhere in the app.
+ *
+ * Returns `null` if no `<MtToastProvider>` is present above in the tree.
+ */
+export declare function useMtToast(): MtToastContextValue | null;
+/**
+ * Site-wide toast provider built on Radix Toast.
+ *
+ * Wrap your app root with `<MtToastProvider>` and use the `useMtToast()` hook
+ * to dispatch toasts from any component.
+ *
+ * ```tsx
+ * <MtToastProvider>
+ *   <App />
+ * </MtToastProvider>
+ * ```
+ */
+export declare function MtToastProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/matter/experimental/collection/MtCollection.d.ts

@@ -14,16 +14,24 @@
  *  - [MUI DataGrid](https://mui.com/x/react-data-grid/)
  */
 import React, { ReactNode } from 'react';
+import type { MtCollectionAssigneeOption } from './MtCollectionEntryControls';
 /**
  * Minimal interface for an item represented in the collection.
  */
 export interface MtCollectionEntry {
     id: any;
 }
+export interface MtCollectionDiscreteValueOption {
+    value: string;
+    label?: string;
+    icon?: string;
+    color?: string;
+}
 export interface MtCollectionProperty {
     id: string;
     label: string;
     groupable?: boolean;
+    discreteValues?: Array<string | MtCollectionDiscreteValueOption>;
 }
 export interface MtCollectionViewSettingsState {
     visiblePropertyIds?: string[];
@@ -70,6 +78,14 @@ export interface MtCollectionLayoutProps<T extends MtCollectionEntry> {
     viewSettings?: MtCollectionViewSettingsState;
     /** Custom renderer for each entry. Layouts should fall back to their own default if omitted. */
     renderEntry?: MtCollectionEntryRenderer<T>;
+    /** Optional assignee options for entry-level assignee controls. */
+    assigneeOptions?: MtCollectionAssigneeOption[];
+    /** Optional callback invoked when a layout updates an entry field. */
+    onUpdateEntry?: (entry: T, patch: Partial<T>) => void | Promise<void>;
+    /** When true, subtask expand/collapse and add-subtask controls are shown. */
+    subtasksEnabled?: boolean;
+    /** Called when the user clicks "+ Add subtask" for a parent entry. */
+    onAddSubtask?: (parentEntry: T) => void | Promise<void>;
 }
 /**
  * Props for MtCollection component
@@ -77,6 +93,8 @@ export interface MtCollectionLayoutProps<T extends MtCollectionEntry> {
 export interface MtCollectionProps<T extends MtCollectionEntry> {
     entries: T[];
     views: MtCollectionView<T>[];
+    /** Optional template views used when creating new views from available layouts. */
+    viewTemplates?: MtCollectionView<T>[];
     properties?: MtCollectionProperty[];
     /**  Undefined will render default toolbar, null will render no toolbar. */
     toolbar?: ReactNode | null;
@@ -85,8 +103,30 @@ export interface MtCollectionProps<T extends MtCollectionEntry> {
     showViewSettings?: boolean;
     viewSettings?: ReactNode;
     className?: string;
+    assigneeOptions?: MtCollectionAssigneeOption[];
+    currentUserQuickFilter?: {
+        assignee: string;
+        label: string;
+        avatarSrc?: string;
+    };
+    onUpdateEntry?: (entry: T, patch: Partial<T>) => void | Promise<void>;
+    onAddEntry?: () => void | Promise<void>;
+    /** When true, subtask expand/collapse and add-subtask controls are shown. */
+    subtasksEnabled?: boolean;
+    /** Called when the user clicks "+ Add subtask" for a parent entry. */
+    onAddSubtask?: (parentEntry: T) => void | Promise<void>;
+    /** Persist a view and optionally return its persisted id. */
+    onSaveView?: (view: MtCollectionView<T>) => Promise<string | void>;
+    /** Delete a persisted view. */
+    onDeleteView?: (viewId: string) => Promise<void>;
+    /** Bulk-delete entries by id. Called immediately with no confirmation dialog. */
+    onDeleteEntries?: (ids: Set<string>) => void | Promise<void>;
+    /** Persist a reordered list of view IDs. */
+    onReorderViews?: (viewIds: string[]) => void | Promise<void>;
+    /** Callback invoked when an entry is clicked (e.g. to navigate to detail). */
+    onEntryClick?: (entry: T) => void;
 }
 /**
  * MtCollection component: top-level collection container.
  */
-export declare function MtCollection<T extends MtCollectionEntry>({ entries, views, properties, toolbar, renderEntry, showViewSettings, viewSettings, className, }: MtCollectionProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function MtCollection<T extends MtCollectionEntry>({ entries, views, viewTemplates, properties, toolbar, renderEntry, showViewSettings, viewSettings, className, assigneeOptions, currentUserQuickFilter, onUpdateEntry, onAddEntry, subtasksEnabled, onAddSubtask, onSaveView, onDeleteView, onDeleteEntries, onReorderViews, onEntryClick, }: MtCollectionProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/components/matter/experimental/collection/MtCollectionContext.d.ts

@@ -1,4 +1,5 @@
 import type { MtCollectionEntry, MtCollectionProperty, MtCollectionView } from './MtCollection';
+import type { MtCollectionQuickFilterState } from './MtCollectionEntryUtils';
 /**
  * Context props for MtCollection.
  * We use context here as I don’t want to assume anything
@@ -6,7 +7,9 @@ import type { MtCollectionEntry, MtCollectionProperty, MtCollectionView } from '
  */
 interface MtCollectionContextProps<T extends MtCollectionEntry> {
     entries: T[];
+    onAddEntry?: () => void | Promise<void>;
     views: MtCollectionView<T>[];
+    viewTemplates: MtCollectionView<T>[];
     currentView: MtCollectionView<T> | null;
     showViewSettings: boolean;
     setShowViewSettings: (show: boolean) => void;
@@ -20,12 +23,32 @@ interface MtCollectionContextProps<T extends MtCollectionEntry> {
     properties: MtCollectionProperty[];
     setProperties: (properties: MtCollectionProperty[]) => void;
     setCurrentView: (view: MtCollectionView<T> | null) => void;
-    addView: (view: MtCollectionView<T>) => void;
+    addView: (view: MtCollectionView<T>) => void | Promise<void>;
     updateView: (viewId: string, patch: Partial<MtCollectionView<T>>) => void;
-    deleteView: (viewId: string) => void;
+    deleteView: (viewId: string) => void | Promise<void>;
+    reorderViews: (viewIds: string[]) => void | Promise<void>;
     hasCurrentViewUnsavedChanges: boolean;
-    saveCurrentViewAsDefault: () => void;
+    saveCurrentViewAsDefault: () => void | Promise<void>;
     revertCurrentViewToDefault: () => void;
+    quickFilters: MtCollectionQuickFilterState;
+    setQuickFilters: (patch: Partial<MtCollectionQuickFilterState>) => void;
+    transientQuickFilters: MtCollectionQuickFilterState;
+    setTransientQuickFilters: (patch: Partial<MtCollectionQuickFilterState>) => void;
+    currentUserQuickFilter?: {
+        assignee: string;
+        label: string;
+        avatarSrc?: string;
+    };
+    /** Set of selected entry IDs. */
+    selectedIds: Set<string>;
+    /** Toggle selection for a single entry by its id. */
+    toggleSelected: (id: string) => void;
+    /** Clear all selections. */
+    clearSelection: () => void;
+    /** Callback to delete selected entries (no confirmation). Only present when consumer provides it. */
+    onDeleteEntries?: (ids: Set<string>) => void | Promise<void>;
+    /** Callback invoked when an entry is clicked (e.g. to navigate to detail). */
+    onEntryClick?: (entry: T) => void;
 }
 export declare const MtCollectionContext: import("react").Context<MtCollectionContextProps<any> | null>;
 export declare function useMtCollection<T extends MtCollectionEntry>(): MtCollectionContextProps<T>;

package/dist/components/matter/experimental/collection/MtCollectionEntryControls.d.ts

@@ -1,3 +1,4 @@
+import type { MtCollectionDiscreteValueOption } from './MtCollection';
 export type MtCollectionAssigneeOption = {
     value: string;
     label: string;
@@ -5,26 +6,41 @@ export type MtCollectionAssigneeOption = {
 export declare function MtCollectionPriorityBadge({ priority }: {
     priority?: string;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function MtPrioritySelect({ value, onChange }: {
+export declare function getIssueTypeOption(options: Array<string | MtCollectionDiscreteValueOption> | undefined, value: string | undefined): MtCollectionDiscreteValueOption | undefined;
+export declare function MtIssueTypePreview({ value, options, size, }: {
+    value?: string;
+    options?: Array<string | MtCollectionDiscreteValueOption>;
+    size?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MtPrioritySelect({ value, onChange, options, }: {
     value?: string;
     onChange: (value: string) => void;
+    options?: Array<string | MtCollectionDiscreteValueOption>;
 }): import("react/jsx-runtime").JSX.Element;
 export declare const MtPrioirtySelect: typeof MtPrioritySelect;
-export declare function MtStateSelect({ value, onChange }: {
+export declare function MtStateSelect({ value, onChange, options, }: {
     value?: string;
     onChange: (value: string) => void;
+    options?: Array<string | MtCollectionDiscreteValueOption>;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function MtIssueTypeSelect({ value, onChange }: {
+export declare function MtIssueTypeSelect({ value, onChange, options, }: {
     value?: string;
     onChange: (value: string) => void;
+    options?: Array<string | MtCollectionDiscreteValueOption>;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function MtCollectionSummaryInput({ value, onChange, placeholder, }: {
+export declare function MtCollectionSummaryInput({ value, onChange, placeholder, className, inputSize, contentWidthCh, autoWidth, minAutoWidthPx, maxAutoWidthPx, }: {
     value: string;
     onChange: (value: string) => void;
     placeholder?: string;
+    className?: string;
+    inputSize?: number;
+    contentWidthCh?: number;
+    autoWidth?: boolean;
+    minAutoWidthPx?: number;
+    maxAutoWidthPx?: number;
 }): import("react/jsx-runtime").JSX.Element;
 export declare function MtCollectionAssigneeDropdown({ assignee, options, onChange, }: {
     assignee?: string;
     options: MtCollectionAssigneeOption[];
-    onChange: (value: string) => void;
+    onChange: (value?: string) => void;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/components/matter/experimental/collection/MtCollectionEntryUtils.d.ts

@@ -1,5 +1,7 @@
 import type { MtFilterGroup } from '../../MtFilter';
+import type { MtFilterField } from '../../MtFilter';
 import type { MtSortRule } from '../../MtSort';
+import type { MtCollectionProperty } from './MtCollection';
 type MtCollectionLegacyFilterState = {
     query?: string;
     status?: string[];
@@ -9,6 +11,7 @@ type MtCollectionLegacyFilterState = {
 export type MtCollectionQuickFilterState = {
     status?: string[];
     assignee?: string[];
+    requiredAssignee?: string;
     search?: string;
 };
 export type MtCollectionFilterState = MtFilterGroup | MtCollectionLegacyFilterState;
@@ -16,11 +19,32 @@ export declare function getCollectionEntryId(entry: any): string;
 export declare function getCollectionEntrySummary(entry: any): any;
 export declare function getCollectionEntryPriority(entry: any): any;
 export declare function getCollectionEntryAssignee(entry: any): any;
+export declare function getCollectionEntryType(entry: any): string;
 export declare function toggleCollectionFilterValue(values: string[] | undefined, value: string): string[];
 export declare function getUniqueEntryValues(entries: any[], key: string): string[];
 export declare function applyCollectionFilters(entries: any[], filterState: MtCollectionFilterState | undefined): any[];
 export declare function getDefaultCollectionFilter(): MtFilterGroup;
 export declare function getCollectionFilterRuleCount(filterState: MtCollectionFilterState | undefined): number;
+export declare const COLLECTION_SORT_FIELDS: {
+    value: string;
+    label: string;
+}[];
+export declare const COLLECTION_FILTER_FIELDS: MtFilterField[];
+/**
+ * Build filter fields enriched with dropdown options from property `discreteValues`.
+ *
+ * The base set of filter fields is always present. When a `properties` schema is
+ * provided, fields whose id matches a property with `discreteValues` will offer
+ * those values as selectable options in the filter value dropdown.
+ *
+ * Property id mapping: `status`/`state` → "status", `type`/`entryType`/`issueType` → "type".
+ */
+export declare function buildCollectionFilterFields(properties?: MtCollectionProperty[]): MtFilterField[];
+export declare const COLLECTION_FILTER_OPERATORS: {
+    value: string;
+    label: string;
+    requiresValue: boolean;
+}[];
 export declare function isCollectionFilterActive(filterState: MtCollectionFilterState | undefined): boolean;
 export declare function applyCollectionSort(entries: any[], sortRules: MtSortRule[] | undefined, fallbackSortBy?: string): any[];
 export declare function applyCollectionQuickFilters(entries: any[], quickFilters: MtCollectionQuickFilterState | undefined): any[];

package/dist/components/matter/experimental/collection/MtCollectionSelectionToolbar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Floating selection toolbar that appears at the bottom of the collection when one or more
+ * entries are selected. Provides bulk-action controls.
+ *
+ * Disabled stubs: Status, Assignee, Dates, Tags
+ * Active action: Delete (immediate, no confirmation)
+ */
+export declare function MtCollectionSelectionToolbar(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/matter/experimental/collection/MtCollectionTaskListEntry.d.ts

@@ -1,10 +1,41 @@
+import { MtCollectionAssigneeOption } from './MtCollectionEntryControls';
+import type { MtCollectionDiscreteValueOption } from './MtCollection';
 type MtCollectionTaskListEntryProps = {
     entry: any;
     visiblePropertySet: Set<string>;
+    properties?: Array<{
+        id: string;
+        label: string;
+    }>;
+    statusOptions?: string[];
+    priorityOptions?: string[];
+    issueTypeOptions?: Array<string | MtCollectionDiscreteValueOption>;
     onSummaryChange?: (nextSummary: string) => void;
     onPriorityChange?: (nextPriority: string) => void;
     onStatusChange?: (nextStatus: string) => void;
     onIssueTypeChange?: (nextType: string) => void;
+    assigneeOptions?: MtCollectionAssigneeOption[];
+    onAssigneeChange?: (nextAssignee?: string) => void;
+    onPropertyChange?: (propertyId: string, value: unknown) => void;
+    /** Nesting depth for subtask indentation (0 = top-level). */
+    depth?: number;
+    /** Whether subtask support is active for this collection. */
+    subtasksEnabled?: boolean;
+    /** Whether this entry has subtasks. */
+    hasSubtasks?: boolean;
+    /** Number of direct subtasks for this entry. */
+    subtaskCount?: number;
+    /** Whether the subtask tree below this entry is expanded. */
+    isExpanded?: boolean;
+    /** Toggle expand/collapse. */
+    onToggleExpand?: () => void;
+    /** Add a subtask under this entry. */
+    onAddSubtask?: () => void;
+    dragHandleProps?: {
+        ref?: (element: HTMLElement | null) => void;
+        attributes?: Record<string, unknown>;
+        listeners?: Record<string, unknown>;
+    };
 };
-export declare function MtCollectionTaskListEntry({ entry, visiblePropertySet, onSummaryChange, onPriorityChange, onStatusChange, onIssueTypeChange, }: MtCollectionTaskListEntryProps): import("react/jsx-runtime").JSX.Element;
+export declare function MtCollectionTaskListEntry({ entry, visiblePropertySet, properties, statusOptions, priorityOptions, issueTypeOptions, onSummaryChange, onPriorityChange, onStatusChange, onIssueTypeChange, assigneeOptions, onAssigneeChange, onPropertyChange, depth, subtasksEnabled, hasSubtasks, subtaskCount, isExpanded, onToggleExpand, onAddSubtask, dragHandleProps, }: MtCollectionTaskListEntryProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/matter/experimental/collection/MtCollectionToast.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+/**
+ * Lightweight toast hook for collection layouts.
+ * Returns a `showToast` function and a `ToastPortal` component that should be
+ * rendered at the end of the layout.
+ */
+export declare function useCollectionToast(durationMs?: number): {
+    showToast: (message: string) => void;
+    ToastPortal: () => React.ReactPortal | null;
+};

package/dist/components/matter/experimental/collection/index.d.ts

@@ -1,9 +1,10 @@
 export { MtCollection } from './MtCollection';
-export type { MtCollectionEntry, MtCollectionView, MtCollectionProps } from './MtCollection';
+export type { MtCollectionDiscreteValueOption, MtCollectionEntry, MtCollectionProps, MtCollectionView, } from './MtCollection';
 export { MtCollectionListLayout } from './layouts/MtCollectionListLayout';
 export { MtCollectionGridLayout } from './layouts/MtCollectionGridLayout';
 export { MtCollectionTableLayout } from './layouts/MtCollectionTableLayout';
 export { MtCollectionBoardLayout } from './layouts/MtCollectionBoardLayout';
 export { MtCollectionGanttLayout } from './layouts/MtCollectionGanttLayout';
+export { MtCollectionPlanLayout } from './layouts/MtCollectionPlanLayout';
 export { MtCollectionToolbar } from './MtCollectionToolbar';
 export { MtCollectionViewSettings } from './MtCollectionViewSettings';

package/dist/components/matter/experimental/collection/layouts/MtCollectionBoardLayout.d.ts

@@ -1,2 +1,35 @@
 import { MtCollectionLayoutComponent } from '../MtCollection';
+import React from 'react';
+import { type MtCollectionAssigneeOption } from '../MtCollectionEntryControls';
+import type { MtCollectionDiscreteValueOption } from '../MtCollection';
+export declare function MtCollectionBoardCard({ entry, onSummaryChange, onPriorityChange, onStatusChange, onIssueTypeChange, onAssigneeChange, onClick, isDragPreview, visiblePropertySet, parentDisplayId, statusOptions, priorityOptions, issueTypeOptions, assigneeOptions, }: {
+    entry: any;
+    onSummaryChange?: (nextSummary: string) => void;
+    onPriorityChange?: (nextPriority: string) => void;
+    onStatusChange?: (nextStatus: string) => void;
+    onIssueTypeChange?: (nextType: string) => void;
+    onAssigneeChange?: (nextAssignee?: string) => void;
+    onClick?: () => void;
+    isDragPreview?: boolean;
+    visiblePropertySet: Set<string>;
+    parentDisplayId?: string;
+    statusOptions?: string[];
+    priorityOptions?: string[];
+    issueTypeOptions?: Array<string | MtCollectionDiscreteValueOption>;
+    assigneeOptions?: MtCollectionAssigneeOption[];
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SortableBoardCard({ id, children, onClick, }: {
+    id: string;
+    children: React.ReactNode;
+    onClick?: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DroppableColumn({ columnKey, label, trailing, entryIds, children, }: {
+    columnKey: string;
+    label: React.ReactNode;
+    trailing?: React.ReactNode;
+    entryIds: string[];
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** @deprecated Use DroppableColumn instead */
+export declare const BoardDroppableColumn: typeof DroppableColumn;
 export declare const MtCollectionBoardLayout: MtCollectionLayoutComponent;

package/dist/components/matter/experimental/collection/layouts/MtCollectionPlanLayout.d.ts

@@ -0,0 +1,2 @@
+import { MtCollectionLayoutComponent } from '../MtCollection';
+export declare const MtCollectionPlanLayout: MtCollectionLayoutComponent;

package/dist/components/matter/experimental/collection/layouts/useBoardDnd.d.ts

@@ -0,0 +1,40 @@
+import { type DragOverEvent, type DragEndEvent, type DragStartEvent } from '@dnd-kit/core';
+export declare function areColumnOrdersEqual(a: Record<string, string[]>, b: Record<string, string[]>): boolean;
+export interface BoardDndColumn {
+    key: string;
+    label: string;
+    [extraKey: string]: unknown;
+}
+/**
+ * Shared board DnD hook used by both the board and plan layouts.
+ *
+ * Manages column ordering, drag state, and cross-column movement.
+ * The consumer provides columns with their entries and a callback
+ * for handling cross-column moves (e.g. updating status or dates).
+ */
+export declare function useBoardDnd<TColumn extends BoardDndColumn>({ columns, entriesByColumn, onCrossColumnMove, onPositionChange, disableSameColumnReorder, onReorderBlocked, }: {
+    /** Column definitions (board groups or plan weeks). */
+    columns: TColumn[];
+    /** Map from column key → entries in that column. */
+    entriesByColumn: Map<string, any[]>;
+    /** Called when a card is dropped in a different column. */
+    onCrossColumnMove?: (activeId: string, entry: any, sourceColumnKey: string, destinationColumnKey: string, destinationColumn: TColumn) => void;
+    /** Called when a card is dropped to persist its new position. */
+    onPositionChange?: (activeId: string, entry: any, newPosition: number) => void;
+    /** When true, within-column reordering is disabled (cross-column moves still work). */
+    disableSameColumnReorder?: boolean;
+    /** Called when a within-column reorder was attempted but blocked by `disableSameColumnReorder`. */
+    onReorderBlocked?: () => void;
+}): {
+    activeDragId: string | null;
+    entryById: Map<string, any>;
+    orderedColumns: {
+        column: TColumn;
+        entryIds: string[];
+    }[];
+    sensors: import("@dnd-kit/core").SensorDescriptor<import("@dnd-kit/core").SensorOptions>[];
+    onDragStart: (event: DragStartEvent) => void;
+    onDragOver: (event: DragOverEvent) => void;
+    onDragEnd: (event: DragEndEvent) => void;
+    onDragCancel: () => void;
+};