@datum-cloud/datum-ui 1.8.0 → 2.1.0

package/dist/components/features/data-table/types.d.ts

@@ -1,6 +1,7 @@
-import type { Cell, Column, ColumnDef, Row, RowSelectionState, SortingState, Table } from '@tanstack/react-table';
+import type { Cell, Column, ColumnDef, ReactTable, Row, RowData, RowSelectionState, SortingState, Table } from '@tanstack/react-table';
 import type { ReactNode } from 'react';
 import type { ActionItem } from '../more-actions';
+import type { DataTableFeatures } from './core/features';
 export type { ActionItem } from '../more-actions';
 export interface FilterOption {
     readonly label: string;
@@ -71,16 +72,16 @@ export interface ServerFetchArgs {
     readonly filters: FilterValue;
     readonly search: string;
 }
-export interface ServerTransformResult<TData> {
+export interface ServerTransformResult<TData extends RowData> {
     readonly data: TData[];
     readonly cursor?: string;
     readonly hasNextPage: boolean;
 }
-export interface InlineContentRenderParams<TData> {
+export interface InlineContentRenderParams<TData extends RowData> {
     readonly onClose: () => void;
     readonly rowData: TData | null;
 }
-export interface InlineContentEntry<TData> {
+export interface InlineContentEntry<TData extends RowData> {
     readonly id: string;
     readonly position: 'top' | 'row';
     readonly rowId?: string;
@@ -89,7 +90,7 @@ export interface InlineContentEntry<TData> {
     readonly className?: string;
     readonly render: (params: InlineContentRenderParams<TData>) => ReactNode;
 }
-export interface InlineContentProps<TData> {
+export interface InlineContentProps<TData extends RowData> {
     readonly position: 'top' | 'row';
     readonly rowId?: string;
     readonly open: boolean;
@@ -97,22 +98,22 @@ export interface InlineContentProps<TData> {
     readonly className?: string;
     readonly children: (params: InlineContentRenderParams<TData>) => ReactNode;
 }
-export interface SelectionColumnOptions<TData = unknown> {
+export interface SelectionColumnOptions<TData extends RowData = Record<string, any>> {
     /** CSS class for cell checkboxes */
     readonly className?: string;
     /** CSS class for header checkbox */
     readonly headerClassName?: string;
     /** Custom header render (replaces default "select all" checkbox) */
     readonly renderHeader?: (props: {
-        table: Table<TData>;
+        table: Table<DataTableFeatures, TData>;
     }) => ReactNode;
     /** Custom cell render (replaces default row checkbox) */
     readonly renderCell?: (props: {
-        row: Row<TData>;
+        row: Row<DataTableFeatures, TData>;
     }) => ReactNode;
 }
-export interface DataTableContextValue<TData> {
-    readonly table: Table<TData>;
+export interface DataTableContextValue<TData extends RowData> {
+    readonly table: ReactTable<DataTableFeatures, TData>;
     readonly mode: 'client' | 'server';
     readonly sorting: SortingState;
     readonly filters: FilterValue;
@@ -131,9 +132,9 @@ export interface DataTableContextValue<TData> {
     readonly registerInlineContent: (entry: InlineContentEntry<TData>) => void;
     readonly unregisterInlineContent: (id: string) => void;
 }
-export interface UseDataTableClientOptions<TData> {
+export interface UseDataTableClientOptions<TData extends RowData> {
     readonly data: TData[];
-    readonly columns: ColumnDef<TData, unknown>[];
+    readonly columns: ColumnDef<DataTableFeatures, TData, unknown>[];
     readonly pageSize?: number;
     readonly getRowId?: (row: TData) => string;
     readonly enableRowSelection?: boolean | SelectionColumnOptions<TData>;
@@ -144,8 +145,8 @@ export interface UseDataTableClientOptions<TData> {
     readonly filterFns?: FilterFnMap;
     readonly stateAdapter?: StateAdapter;
 }
-export interface UseDataTableServerOptions<TResponse, TData> {
-    readonly columns: ColumnDef<TData, unknown>[];
+export interface UseDataTableServerOptions<TResponse, TData extends RowData> {
+    readonly columns: ColumnDef<DataTableFeatures, TData, unknown>[];
     readonly fetchFn: (args: ServerFetchArgs) => Promise<TResponse>;
     readonly transform: (response: TResponse) => ServerTransformResult<TData>;
     readonly limit?: number;
@@ -155,9 +156,9 @@ export interface UseDataTableServerOptions<TResponse, TData> {
     readonly defaultFilters?: FilterValue;
     readonly stateAdapter?: StateAdapter;
 }
-interface DataTableBaseProps<TData> {
+interface DataTableBaseProps<TData extends RowData> {
     readonly data: TData[];
-    readonly columns: ColumnDef<TData, unknown>[];
+    readonly columns: ColumnDef<DataTableFeatures, TData, unknown>[];
     readonly sorting: SortingState;
     readonly setSorting: (sorting: SortingState) => void;
     readonly filters: FilterValue;
@@ -174,12 +175,12 @@ interface DataTableBaseProps<TData> {
     readonly className?: string;
     readonly children: ReactNode;
 }
-export interface DataTableClientProps<TData> extends DataTableBaseProps<TData> {
+export interface DataTableClientProps<TData extends RowData> extends DataTableBaseProps<TData> {
     readonly pagination: ClientPaginationState;
     readonly searchableColumns?: string[];
     readonly searchFn?: (row: TData, search: string) => boolean;
 }
-export interface DataTableServerProps<TData> extends DataTableBaseProps<TData> {
+export interface DataTableServerProps<TData extends RowData> extends DataTableBaseProps<TData> {
     readonly isLoading: boolean;
     readonly pagination: ServerPaginationState;
 }
@@ -224,24 +225,24 @@ export interface FilterCheckboxProps {
     readonly sheetTitle?: string;
     readonly modal?: boolean;
 }
-export interface ColumnHeaderProps<TData, TValue> {
-    readonly column: Column<TData, TValue>;
+export interface ColumnHeaderProps<TData extends RowData, TValue> {
+    readonly column: Column<DataTableFeatures, TData, TValue>;
     readonly title: string;
     readonly className?: string;
 }
-export interface RowActionsProps<TData> {
-    readonly row: Row<TData>;
+export interface RowActionsProps<TData extends RowData> {
+    readonly row: Row<DataTableFeatures, TData>;
     readonly actions: readonly ActionItem<TData>[];
     readonly isLoading?: boolean;
     readonly className?: string;
     readonly responsive?: boolean;
     readonly sheetTitle?: string;
 }
-export interface BulkActionsProps<TData> {
+export interface BulkActionsProps<TData extends RowData> {
     readonly children: (selectedRows: TData[]) => ReactNode;
     readonly className?: string;
 }
-export interface ContentProps<TData = unknown> {
+export interface ContentProps<TData extends RowData = Record<string, any>> {
     readonly emptyMessage?: ReactNode;
     readonly className?: string;
     readonly tableClassName?: string;
@@ -249,8 +250,8 @@ export interface ContentProps<TData = unknown> {
     readonly headerRowClassName?: string;
     readonly headerCellClassName?: string;
     readonly bodyClassName?: string;
-    readonly rowClassName?: string | ((row: Row<TData>) => string);
-    readonly cellClassName?: string | ((cell: Cell<TData, unknown>) => string);
+    readonly rowClassName?: string | ((row: Row<DataTableFeatures, TData>) => string);
+    readonly cellClassName?: string | ((cell: Cell<DataTableFeatures, TData, unknown>) => string);
 }
 export interface PaginationProps {
     readonly pageSizes?: readonly number[];
@@ -282,7 +283,7 @@ export interface LoadingProps {
     readonly className?: string;
 }
 export type FilterStrategy = 'checkbox' | 'select' | 'date-gte' | 'date-lte' | FilterFn;
-export interface DataTableStoreState<TData> {
+export interface DataTableStoreState<TData extends RowData> {
     readonly data: TData[];
     readonly filteredData: TData[];
     readonly sorting: SortingState;
@@ -299,7 +300,7 @@ export interface DataTableStoreState<TData> {
     /** Monotonic counter incremented on every state change. Used by table-dependent selectors to detect updates. */
     readonly _version: number;
 }
-export interface DataTableStore<TData> {
+export interface DataTableStore<TData extends RowData> {
     readonly getSnapshot: () => DataTableStoreState<TData>;
     readonly subscribe: (listener: () => void) => () => void;
     readonly setData: (data: TData[]) => void;
@@ -321,7 +322,7 @@ export interface DataTableStore<TData> {
     readonly registerInlineContent: (entry: InlineContentEntry<TData>) => void;
     readonly unregisterInlineContent: (id: string) => void;
 }
-export interface CreateStoreOptions<TData> {
+export interface CreateStoreOptions<TData extends RowData> {
     readonly data: TData[];
     readonly mode: 'client' | 'server';
     readonly defaultSort?: SortingState;

package/dist/components/features/date-time/date-time.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+import type { DateTimeProps } from './types';
+/**
+ * Date display with the shared Datum hover tooltip (UTC, local zone, relative, epoch).
+ */
+export declare function DateTime({ date, variant, format, addSuffix, tooltip, timezone, disableTimezone, className, separator, timestamp, children, }: DateTimeProps): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;

package/dist/components/features/date-time/formatters.d.ts

@@ -0,0 +1,13 @@
+import type { FormatterOptions } from './types';
+/** e.g. "June 12th at 11:30 AM" — used for absolute / table dates. */
+export declare const DEFAULT_DATE_FORMAT = "MMMM do 'at' h:mm a";
+export declare function getBrowserTimezone(): string;
+export declare function parseDate(date: string | Date): Date | null;
+export declare function formatAbsoluteDate(date: Date, options: FormatterOptions): string;
+export declare function formatRelativeDate(date: Date, options: FormatterOptions): string;
+export declare function getTimezoneAbbreviation(date: Date, timezone: string): string;
+export declare function formatCombinedDate(date: Date, options: FormatterOptions, separator?: string): string;
+export declare function formatUTCDate(date: Date, format?: string): string;
+export declare function formatTimezoneDate(date: Date, timezone: string, format?: string): string;
+/** Microseconds since epoch, matching the Datum DateTime tooltip. */
+export declare function getTimestamp(date: Date): string;

package/dist/components/features/date-time/index.d.ts

@@ -0,0 +1,3 @@
+export { DateTime } from './date-time';
+export { DEFAULT_DATE_FORMAT, formatAbsoluteDate, formatCombinedDate, formatRelativeDate, formatTimezoneDate, formatUTCDate, getTimestamp, getTimezoneAbbreviation, parseDate, } from './formatters';
+export type { DateTimeProps, DateTimeVariant, FormatterOptions, TooltipMode } from './types';

package/dist/components/features/date-time/types.d.ts

@@ -0,0 +1,47 @@
+import type { ReactNode } from 'react';
+export type DateTimeVariant = 'absolute' | 'relative' | 'both' | 'detailed';
+export type TooltipMode = boolean | 'auto' | 'timezone' | 'alternate' | 'detailed';
+export interface DateTimeProps {
+    /** Date to format — a `Date` or parseable ISO string. */
+    date?: string | Date;
+    /**
+     * `absolute` — formatted date.
+     * `relative` — "X ago".
+     * `both` — absolute plus relative.
+     * `detailed` — absolute in the trigger; tooltip lists UTC, local, relative, and epoch.
+     */
+    variant?: DateTimeVariant;
+    /** date-fns format string for absolute dates. */
+    format?: string;
+    /** Append "ago" (and similar) to relative dates. Defaults to true. */
+    addSuffix?: boolean;
+    /**
+     * Tooltip behavior:
+     * - true/false: show or hide
+     * - `auto`: opposite format, or timezone for absolute dates
+     * - `timezone`: timezone name and abbreviation
+     * - `alternate`: opposite of the visible variant
+     * - `detailed`: UTC, local zone, relative, and epoch
+     */
+    tooltip?: TooltipMode;
+    /** IANA timezone. Defaults to the browser timezone. */
+    timezone?: string;
+    /** Skip timezone conversion and format in the runtime local zone. */
+    disableTimezone?: boolean;
+    className?: string;
+    /** Separator between absolute and relative when `variant="both"`. */
+    separator?: string;
+    /**
+     * Epoch shown on the `detailed` tooltip Timestamp row.
+     * Defaults to microseconds derived from the date.
+     */
+    timestamp?: string;
+    /** Replace the formatted trigger. Must be a single element (Tooltip `asChild`). */
+    children?: ReactNode;
+}
+export interface FormatterOptions {
+    timezone: string;
+    disableTimezone: boolean;
+    format?: string;
+    addSuffix?: boolean;
+}

package/dist/components/features/grouped-table/grouped-table.d.ts

@@ -1,2 +1,3 @@
+import type { RowData } from '@tanstack/react-table';
 import type { GroupedTableProps } from './types';
-export declare function GroupedTable<TData>(props: GroupedTableProps<TData>): import("react").JSX.Element;
+export declare function GroupedTable<TData extends RowData>(props: GroupedTableProps<TData>): import("react").JSX.Element;

package/dist/components/features/grouped-table/lib/bucket-rows.d.ts

@@ -1,4 +1,5 @@
-import type { Row } from '@tanstack/react-table';
+import type { Row, RowData } from '@tanstack/react-table';
+import type { DataTableFeatures } from '../../data-table/core/features';
 interface GroupLike {
     id: string;
     rows: unknown[];
@@ -9,5 +10,5 @@ interface GroupLike {
  * positions to learn which row id belongs to which group, so bucketing is correct
  * regardless of a custom getRowId.
  */
-export declare function bucketRows<TData>(groups: GroupLike[], coreRows: Row<TData>[], filteredRows: Row<TData>[]): Map<string, Row<TData>[]>;
+export declare function bucketRows<TData extends RowData>(groups: GroupLike[], coreRows: Row<DataTableFeatures, TData>[], filteredRows: Row<DataTableFeatures, TData>[]): Map<string, Row<DataTableFeatures, TData>[]>;
 export {};

package/dist/components/features/grouped-table/lib/compose-columns.d.ts

@@ -1,10 +1,11 @@
-import type { ColumnDef } from '@tanstack/react-table';
+import type { ColumnDef, RowData } from '@tanstack/react-table';
 import type { SelectionColumnOptions } from '../../data-table';
+import type { DataTableFeatures } from '../../data-table/core/features';
 import type { ActionItem } from '../../more-actions';
-export interface ComposeOptions<TData> {
+export interface ComposeOptions<TData extends RowData> {
     enableRowSelection?: boolean | SelectionColumnOptions<TData>;
     enableSorting?: boolean;
     rowActions?: (row: TData) => ActionItem<TData>[];
     rowActionsSheetTitle?: string;
 }
-export declare function composeColumns<TData>(columns: ColumnDef<TData, unknown>[], options: ComposeOptions<TData>): ColumnDef<TData, unknown>[];
+export declare function composeColumns<TData extends RowData>(columns: ColumnDef<DataTableFeatures, TData, unknown>[], options: ComposeOptions<TData>): ColumnDef<DataTableFeatures, TData, unknown>[];

package/dist/components/features/grouped-table/lib/sort-rows.d.ts

@@ -1,6 +1,7 @@
-import type { Row, SortingState } from '@tanstack/react-table';
+import type { Row, RowData, SortingState } from '@tanstack/react-table';
+import type { DataTableFeatures } from '../../data-table/core/features';
 /**
  * Sort a single group's rows by the active sort (first entry; v1 is single-sort).
  * Returns the same reference when there is no sort, so React can skip re-renders.
  */
-export declare function sortRows<TData>(rows: Row<TData>[], sorting: SortingState): Row<TData>[];
+export declare function sortRows<TData extends RowData>(rows: Row<DataTableFeatures, TData>[], sorting: SortingState): Row<DataTableFeatures, TData>[];

package/dist/components/features/grouped-table/types.d.ts

@@ -1,9 +1,10 @@
-import type { Cell, ColumnDef, Row, RowSelectionState, SortingState } from '@tanstack/react-table';
+import type { Cell, ColumnDef, Row, RowData, RowSelectionState, SortingState } from '@tanstack/react-table';
 import type { ReactNode } from 'react';
 import type { SelectionColumnOptions } from '../data-table';
+import type { DataTableFeatures } from '../data-table/core/features';
 import type { ActionItem } from '../more-actions';
 export type DefaultExpanded = 'all' | 'none' | string[];
-export interface GroupedTableGroup<TData> {
+export interface GroupedTableGroup<TData extends RowData> {
     /** Stable key used for expand state. */
     id: string;
     /** Group header label. */
@@ -14,9 +15,9 @@ export interface GroupedTableGroup<TData> {
     /** Per-group override of the table-level default. */
     defaultOpen?: boolean;
 }
-export interface GroupedTableProps<TData> {
+export interface GroupedTableProps<TData extends RowData> {
     /** TanStack column defs. `size` (px) drives the shared grid template; unsized columns flex. */
-    columns: ColumnDef<TData, unknown>[];
+    columns: ColumnDef<DataTableFeatures, TData, unknown>[];
     groups: GroupedTableGroup<TData>[];
     /** Uncontrolled initial state. Default `'all'`. A string[] opens exactly those ids. */
     defaultExpanded?: DefaultExpanded;
@@ -67,7 +68,7 @@ export interface GroupedTableProps<TData> {
     /** Each group's `<tbody>`. */
     bodyClassName?: string;
     /** Each data `<tr>`; receives the row for per-row styling. */
-    rowClassName?: string | ((row: Row<TData>) => string);
+    rowClassName?: string | ((row: Row<DataTableFeatures, TData>) => string);
     /** Each data `<td>`; receives the cell for per-cell styling. */
-    cellClassName?: string | ((cell: Cell<TData, unknown>) => string);
+    cellClassName?: string | ((cell: Cell<DataTableFeatures, TData, unknown>) => string);
 }

package/dist/components/features/grouped-table/use-grouped-expansion.d.ts

@@ -1,5 +1,6 @@
+import type { RowData } from '@tanstack/react-table';
 import type { DefaultExpanded, GroupedTableGroup } from './types';
-export declare function useGroupedExpansion<TData>(groups: GroupedTableGroup<TData>[], opts: {
+export declare function useGroupedExpansion<TData extends RowData>(groups: GroupedTableGroup<TData>[], opts: {
     defaultExpanded?: DefaultExpanded;
     expanded?: string[];
     onExpandedChange?: (ids: string[]) => void;

package/dist/components/features/index.d.ts

@@ -10,6 +10,7 @@ export * from './avatar-stack';
 export * from './calendar-date-picker';
 export * from './code-editor';
 export * from './data-table';
+export * from './date-time';
 export * from './date-time-picker';
 export * from './dropdown';
 export * from './dropzone';

package/dist/components/features/logs/components/detail.d.ts

@@ -0,0 +1,3 @@
+export declare function LogsDetail({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/dist/components/features/logs/components/explorer.d.ts

@@ -0,0 +1,3 @@
+export declare function LogsExplorer({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/dist/components/features/logs/components/filters.d.ts

@@ -0,0 +1,11 @@
+import type { LogFacet } from '../types';
+export declare function LogsFilterGroup({ facet, defaultOpen, }: {
+    facet: LogFacet;
+    defaultOpen?: boolean;
+}): import("react").JSX.Element;
+export declare function LogsTimeRangeFilter({ className }: {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function LogsFilters({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/dist/components/features/logs/components/root.d.ts

@@ -0,0 +1,2 @@
+import type { LogsRootProps } from '../types';
+export declare function LogsRoot({ entries, facets, timeRange, defaultTimeRange, filters, defaultFilters, search, defaultSearch, live, defaultLive, selectedId, defaultSelectedId, isLoading, error, columns, onTimeRangeChange, onFiltersChange, onSearchChange, onLiveChange, onSelectedIdChange, onRefresh, onExport, className, children, }: LogsRootProps): import("react").JSX.Element;

package/dist/components/features/logs/components/status-badge.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedLogLine } from '../types';
+export declare function LogsSeverityBadge({ severity }: {
+    severity?: string;
+}): import("react").JSX.Element;
+export declare function LogsStatusBadge({ parsed }: {
+    parsed: ParsedLogLine;
+}): import("react").JSX.Element;

package/dist/components/features/logs/components/table.d.ts

@@ -0,0 +1,3 @@
+export declare function LogsTable({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/dist/components/features/logs/components/toolbar.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+export declare function LogsSearch({ placeholder, className, }: {
+    placeholder?: string;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function LogsLiveToggle({ className }: {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function LogsToolbar({ children, className, }: {
+    children?: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/components/features/logs/fixtures/index.d.ts

@@ -0,0 +1,2 @@
+import type { LokiQueryRangeResponse } from '../types';
+export declare const queryRangeFixture: LokiQueryRangeResponse;

package/dist/components/features/logs/hooks/use-controllable-state.d.ts

@@ -0,0 +1,5 @@
+export declare function useControllableState<T>({ value, defaultValue, onChange, }: {
+    value?: T;
+    defaultValue: T;
+    onChange?: (value: T) => void;
+}): [T, (value: T) => void];

package/dist/components/features/logs/hooks/use-logs.d.ts

@@ -0,0 +1,3 @@
+import type { LogsContextValue } from '../types';
+export declare const LogsContext: import("react").Context<LogsContextValue | null>;
+export declare function useLogs(): LogsContextValue;

package/dist/components/features/logs/index.d.ts

@@ -0,0 +1,4 @@
+export { useLogs } from './hooks/use-logs';
+export { Logs } from './logs';
+export type { BuildLogQLOptions, LogColumnId, LogEntry, LogFacet, LogFacetOption, LogFilters, LogsContextValue, LogsRootProps, LogTimeRange, LokiQueryRangeResponse, LokiStream, ParsedHttpLogLine, ParsedLogLine, ParsedTextLogLine, } from './types';
+export { buildLogQL, facetsFromEntries, filterEntries, flattenLokiStreams, httpStatusBadgeType, httpStatusTextClass, lastThirtyMinutes, logLineDisplay, nsToDate, parseLogLine, severityBadgeType, } from './utils';

package/dist/components/features/logs/logs.d.ts

@@ -0,0 +1,18 @@
+import { LogsDetail } from './components/detail';
+import { LogsExplorer } from './components/explorer';
+import { LogsFilterGroup, LogsFilters, LogsTimeRangeFilter } from './components/filters';
+import { LogsRoot } from './components/root';
+import { LogsTable } from './components/table';
+import { LogsLiveToggle, LogsSearch, LogsToolbar } from './components/toolbar';
+export declare const Logs: {
+    readonly Root: typeof LogsRoot;
+    readonly Explorer: typeof LogsExplorer;
+    readonly Filters: typeof LogsFilters;
+    readonly FilterGroup: typeof LogsFilterGroup;
+    readonly TimeRangeFilter: typeof LogsTimeRangeFilter;
+    readonly Toolbar: typeof LogsToolbar;
+    readonly Search: typeof LogsSearch;
+    readonly LiveToggle: typeof LogsLiveToggle;
+    readonly Table: typeof LogsTable;
+    readonly Detail: typeof LogsDetail;
+};

package/dist/components/features/logs/types.d.ts

@@ -0,0 +1,105 @@
+import type { ReactNode } from 'react';
+export interface LokiStream {
+    stream: Record<string, string>;
+    values: Array<[timestampNs: string, line: string]>;
+}
+export interface LokiQueryRangeResponse {
+    status: 'success' | 'error';
+    data?: {
+        resultType: 'streams' | 'vector';
+        result: LokiStream[];
+    };
+    errorType?: string;
+    error?: string;
+}
+export interface LogEntry {
+    id: string;
+    timestamp: Date;
+    timestampNs: string;
+    line: string;
+    labels: Record<string, string>;
+}
+export interface LogFacetOption {
+    value: string;
+    count?: number;
+}
+export interface LogFacet {
+    name: string;
+    label: string;
+    options: LogFacetOption[];
+}
+export interface LogTimeRange {
+    from: string;
+    to: string;
+}
+export type LogFilters = Record<string, string[]>;
+export type LogColumnId = 'time' | 'severity' | 'status' | 'service' | 'resource' | 'path' | 'message';
+export interface ParsedHttpLogLine {
+    kind: 'http';
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+}
+export interface ParsedTextLogLine {
+    kind: 'text';
+    line: string;
+}
+export type ParsedLogLine = ParsedHttpLogLine | ParsedTextLogLine;
+export interface BuildLogQLOptions {
+    matchers?: LogFilters;
+    lineContains?: string;
+}
+export type LogSeverity = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'FATAL' | (string & {});
+export interface LogsRootProps {
+    entries: readonly LogEntry[];
+    facets?: readonly LogFacet[];
+    timeRange?: LogTimeRange;
+    defaultTimeRange?: LogTimeRange;
+    filters?: LogFilters;
+    defaultFilters?: LogFilters;
+    search?: string;
+    defaultSearch?: string;
+    live?: boolean;
+    defaultLive?: boolean;
+    selectedId?: string | null;
+    defaultSelectedId?: string | null;
+    isLoading?: boolean;
+    error?: ReactNode;
+    columns?: readonly LogColumnId[];
+    onTimeRangeChange?: (range: LogTimeRange) => void;
+    onFiltersChange?: (filters: LogFilters) => void;
+    onSearchChange?: (search: string) => void;
+    onLiveChange?: (live: boolean) => void;
+    onSelectedIdChange?: (id: string | null) => void;
+    onRefresh?: () => void;
+    onExport?: (entries: readonly LogEntry[]) => void;
+    className?: string;
+    children: ReactNode;
+}
+export interface LogsContextValue {
+    entries: readonly LogEntry[];
+    facets: readonly LogFacet[];
+    timeRange: LogTimeRange;
+    setTimeRange: (range: LogTimeRange) => void;
+    filters: LogFilters;
+    setFilters: (filters: LogFilters) => void;
+    toggleFilterValue: (name: string, value: string) => void;
+    resetFilters: () => void;
+    search: string;
+    setSearch: (search: string) => void;
+    live: boolean;
+    setLive: (live: boolean) => void;
+    selectedId: string | null;
+    setSelectedId: (id: string | null) => void;
+    selectedEntry: LogEntry | null;
+    selectedIndex: number;
+    selectPrevious: () => void;
+    selectNext: () => void;
+    isLoading: boolean;
+    error: ReactNode;
+    columns: readonly LogColumnId[];
+    hasActiveFilters: boolean;
+    onRefresh?: () => void;
+    onExport?: (entries: readonly LogEntry[]) => void;
+}

package/dist/components/features/logs/utils/build-logql.d.ts

@@ -0,0 +1,2 @@
+import type { BuildLogQLOptions } from '../types';
+export declare function buildLogQL({ matchers, lineContains }?: BuildLogQLOptions): string;

package/dist/components/features/logs/utils/constants.d.ts

@@ -0,0 +1,6 @@
+import type { LogColumnId } from '../types';
+export declare const DEFAULT_LOG_COLUMNS: readonly LogColumnId[];
+export declare const CANONICAL_FACET_NAMES: readonly ["severity", "service_name", "resource_name"];
+export declare const FACET_LABELS: Record<string, string>;
+export declare const SEVERITY_ORDER: readonly ["ERROR", "FATAL", "WARN", "WARNING", "INFO", "DEBUG", "TRACE"];
+export declare const DEFAULT_LOGQL_MATCHER = "{service_name=~\".+\"}";

package/dist/components/features/logs/utils/facets.d.ts

@@ -0,0 +1,3 @@
+import type { LogEntry, LogFacet, LogFilters } from '../types';
+export declare function facetsFromEntries(entries: readonly LogEntry[], names?: readonly string[]): LogFacet[];
+export declare function filterEntries(entries: readonly LogEntry[], filters: LogFilters, search?: string): LogEntry[];

package/dist/components/features/logs/utils/flatten-loki.d.ts

@@ -0,0 +1,3 @@
+import type { LogEntry, LokiQueryRangeResponse } from '../types';
+export declare function nsToDate(timestampNs: string): Date;
+export declare function flattenLokiStreams(response: LokiQueryRangeResponse): LogEntry[];

package/dist/components/features/logs/utils/format-timestamp.d.ts

@@ -0,0 +1,4 @@
+export declare function formatLogTimestamp(date: Date): string;
+export declare function formatRelativeTimestamp(date: Date, now?: Date): string;
+export declare function formatUtcTimestamp(date: Date): string;
+export declare function formatLocalTimestamp(date: Date): string;

package/dist/components/features/logs/utils/index.d.ts

@@ -0,0 +1,8 @@
+export { buildLogQL } from './build-logql';
+export { CANONICAL_FACET_NAMES, DEFAULT_LOG_COLUMNS, DEFAULT_LOGQL_MATCHER, FACET_LABELS, SEVERITY_ORDER, } from './constants';
+export { facetsFromEntries, filterEntries } from './facets';
+export { flattenLokiStreams, nsToDate } from './flatten-loki';
+export { formatLocalTimestamp, formatLogTimestamp, formatRelativeTimestamp, formatUtcTimestamp, } from './format-timestamp';
+export { logLineDisplay, parseLogLine } from './parse-log-line';
+export { httpStatusBadgeType, httpStatusTextClass, severityBadgeType } from './severity';
+export { filtersAreActive, lastThirtyMinutes } from './time-range';

package/dist/components/features/logs/utils/parse-log-line.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedLogLine } from '../types';
+export declare function parseLogLine(line: string): ParsedLogLine;
+export declare function logLineDisplay(line: string): {
+    parsed: ParsedLogLine;
+    path: string | null;
+    message: string;
+};

package/dist/components/features/logs/utils/severity.d.ts

@@ -0,0 +1,5 @@
+import type { BadgeProps } from '../../../base/badge';
+export type SeverityBadgeType = NonNullable<BadgeProps['type']>;
+export declare function severityBadgeType(severity: string | undefined): SeverityBadgeType;
+export declare function httpStatusBadgeType(status: number): SeverityBadgeType;
+export declare function httpStatusTextClass(status: number): string;

package/dist/components/features/logs/utils/time-range.d.ts

@@ -0,0 +1,3 @@
+import type { LogTimeRange } from '../types';
+export declare function lastThirtyMinutes(now?: Date): LogTimeRange;
+export declare function filtersAreActive(filters: Record<string, string[]>): boolean;

package/dist/data-table/index.mjs

@@ -1,2 +1,2 @@
-import { _ as DEFAULT_DEBOUNCE_MS, a as useDataTablePagination, b as DEFAULT_PAGE_SIZES, c as useDataTableSelection, d as resolvePath, f as rowMatchesSearch, g as useNuqsAdapter, h as createSelectionColumn, i as useDataTableLoading, l as useDataTableSorting, m as DataTableColumnHeader, n as useDataTableFilters, o as useDataTableRows, p as DataTableRowActions, r as useDataTableInlineContents, s as useDataTableSearch, t as DataTable, u as createDataTableStore, v as DEFAULT_LOADING_ROWS, y as DEFAULT_PAGE_SIZE } from "../data-table-mByk373T.mjs";
-export { DEFAULT_DEBOUNCE_MS, DEFAULT_LOADING_ROWS, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_SIZES, DataTable, DataTableColumnHeader, DataTableRowActions, createDataTableStore, createSelectionColumn, resolvePath, rowMatchesSearch, useDataTableFilters, useDataTableInlineContents, useDataTableLoading, useDataTablePagination, useDataTableRows, useDataTableSearch, useDataTableSelection, useDataTableSorting, useNuqsAdapter };
+import { _ as useNuqsAdapter, a as useDataTablePagination, b as DEFAULT_PAGE_SIZE, c as useDataTableSelection, d as resolvePath, f as rowMatchesSearch, g as createSelectionColumn, h as DataTableColumnHeader, i as useDataTableLoading, l as useDataTableSorting, m as DataTableRowActions, n as useDataTableFilters, o as useDataTableRows, p as dataTableFeatures, r as useDataTableInlineContents, s as useDataTableSearch, t as DataTable, u as createDataTableStore, v as DEFAULT_DEBOUNCE_MS, x as DEFAULT_PAGE_SIZES, y as DEFAULT_LOADING_ROWS } from "../data-table-Du7_FLBi.mjs";
+export { DEFAULT_DEBOUNCE_MS, DEFAULT_LOADING_ROWS, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_SIZES, DataTable, DataTableColumnHeader, DataTableRowActions, createDataTableStore, createSelectionColumn, dataTableFeatures, resolvePath, rowMatchesSearch, useDataTableFilters, useDataTableInlineContents, useDataTableLoading, useDataTablePagination, useDataTableRows, useDataTableSearch, useDataTableSelection, useDataTableSorting, useNuqsAdapter };