@k2b/ui 0.49.0 → 0.51.0

package/dist/types/content/chart-time-axis.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A line chart whose X values are instants (Unix milliseconds). Its axis ticks land on round times in `timeZone`:
+ * minutes, hours, days, weeks, months, or years, whichever step keeps the requested number of ticks.
+ */
+export type ChartTimeAxis = {
+    /** IANA zone whose wall clock the ticks follow, such as the zone the data's buckets use. */
+    timeZone: string;
+    /** Locale of the default tick labels; `xAxis.format` replaces them. Defaults to `en`. */
+    locale?: string;
+};
+export type ChartTimeUnit = "minute" | "hour" | "day" | "week" | "month" | "year";
+export type ChartTimeStep = {
+    unit: ChartTimeUnit;
+    size: number;
+};
+/** The round step for a time span: the finest one that keeps at most `maxTicks` ticks. */
+export declare const chartTimeStep: (span: number, maxTicks: number) => ChartTimeStep;
+/** Tick instants inside `domain` that fall on round wall times of `step` in `timeZone`. */
+export declare const chartTimeTicks: (domain: readonly [number, number], timeZone: string, step: ChartTimeStep) => number[];
+/** Default label of a tick: the clock time, the day at local midnight, the month or the year. */
+export declare const chartTimeLabel: (tick: number, step: ChartTimeStep, axis: ChartTimeAxis) => string;
+/**
+ * Replaces the renderer's X tick labels, which sit on decimal millisecond steps, with labels on round times. The
+ * renderer drew the X axis over the explicit `domain`, so its horizontal axis line gives the pixel scale.
+ */
+export declare function timeAxisSvg(svg: string, domain: readonly [number, number], axis: ChartTimeAxis, maxTicks: number, format?: (value: number) => string): string;

package/dist/types/content/data-table-columns.d.ts

@@ -0,0 +1,72 @@
+import type { StatusTone } from "../surfaces/StatusBadge";
+/**
+ * What a column holds. It decides alignment, wrapping, the shown text, search and sort:
+ * text wraps; number, amount, bar, flow and delta read right-aligned with equal-width digits; date reads in the
+ * reader's language; status shows a badge from `states`.
+ */
+export type DataTableColumnType = "text" | "number" | "date" | "status" | "bar" | "amount" | "flow" | "delta";
+/** A number format by name, as a portable description stores it. `decimals` fixes the fraction digits. */
+export type DataTableNumberFormat = {
+    style?: "number" | "percent" | "currency";
+    /** ISO 4217 code; required for `style: "currency"`, `amount` and `flow`. */
+    currency?: string;
+    decimals?: number;
+    compact?: boolean;
+};
+/** The label and tone of one stored status value. */
+export type DataTableStatusState = {
+    label: string;
+    tone: StatusTone;
+};
+/** The typed part of a column, independent of how the row stores its values. */
+export type DataTableTypedColumn = {
+    type?: DataTableColumnType;
+    format?: DataTableNumberFormat;
+    /** Labels and tones of a status column, by stored value. */
+    states?: Readonly<Record<string, DataTableStatusState>>;
+    /** The value a bar column fills its track at; defaults to the largest value in the rows. */
+    max?: number;
+    /** The IANA zone a date column with a time reads in, such as the zone of the data's owner; defaults to the reader's. */
+    timeZone?: string;
+    /** How a delta column reads its change: `ratio` (default) `0.082` as `+8.2 %`, `points` `0.031` as `+3.1 pts`; `better` rates it. */
+    delta?: {
+        unit?: "ratio" | "points";
+        better?: "up" | "down";
+    };
+};
+export declare const isNumericColumnType: (type?: DataTableColumnType) => boolean;
+/** Formats a number the way a typed column shows it: in the reader's language, by the column's format. */
+export declare const formatTableNumber: (value: number, column: DataTableTypedColumn, locale: string) => string;
+/** A date column reads ISO text, a timestamp or a Date; a day without a time stays that day in every zone. */
+export declare const formatTableDate: (value: unknown, locale: string, timeZone?: string) => string | null;
+/** True when the value is missing: such a cell shows a dash, sorts last and never counts as zero. */
+export declare const isEmptyCell: (value: unknown) => boolean;
+/**
+ * The text a typed cell shows, for search, grouping and copied rows. A flow is the amount without its sign, as the
+ * arrow says the direction; a delta is its signed change.
+ */
+export declare const tableCellText: (value: unknown, column: DataTableTypedColumn, locale: string) => string;
+/** The value a typed column sorts by: numbers by value, dates by time, a status by its label, the rest as text. */
+export declare const tableSortValue: (value: unknown, column: DataTableTypedColumn, locale: string) => number | string | null;
+type Readable<T> = DataTableTypedColumn & {
+    id: string;
+    value?: keyof T | ((row: T) => unknown);
+};
+export declare const readTableValue: <T>(row: T, column: Readable<T>) => unknown;
+/**
+ * The rows any of whose shown values contains the query, ignoring case and accents. An empty query keeps every row.
+ * Matches the text a reader sees, so a status matches by its label and an amount as it is formatted.
+ */
+export declare const filterRows: <T>(rows: readonly T[], columns: readonly Readable<T>[], query: string, locale: string) => T[];
+/** Rows in the order of one column: values first, missing values last in both directions. */
+export declare const sortRows: <T>(rows: readonly T[], columns: readonly Readable<T>[], sort: {
+    key: string;
+    direction: "asc" | "desc";
+} | null | undefined, locale: string) => T[];
+/** Rows split by one column, in the order each group first appears; the label is the group's shown value. */
+export declare const groupRows: <T>(rows: readonly T[], column: Readable<T>, locale: string) => {
+    key: string;
+    label: string;
+    rows: T[];
+}[];
+export {};

package/dist/types/content/data-table-messages.d.ts

@@ -3,6 +3,24 @@ declare const dataTableMessages: import("@k2b/stdlib").Catalog<{
     noColumns: string;
     noRecords: string;
     loadingRows: string;
+    noMatch: ({ query }: {
+        query: string;
+    }) => string;
+    clearSearch: string;
+    details: string;
+    showDetails: string;
+    rowCount: ({ count }: {
+        count: number;
+    }) => string;
+    search: string;
+    searchTable: ({ label }: {
+        label: string;
+    }) => string;
+    groupRows: string;
+    notGrouped: string;
+    groupedBy: ({ label }: {
+        label: string;
+    }) => string;
 }>;
 export type DataTableMessages = ReturnType<(typeof dataTableMessages)["resolve"]>["t"];
 /** Resolved from the inherited render locale. */

package/dist/types/content/flow-amount-messages.d.ts

@@ -0,0 +1,11 @@
+declare const flowAmountMessages: import("@k2b/stdlib").Catalog<{
+    in: string;
+    out: string;
+    none: string;
+    invalid: string;
+}>;
+export type FlowAmountMessages = ReturnType<(typeof flowAmountMessages)["resolve"]>["t"];
+/** Resolved from an explicit locale override, else the inherited render locale. */
+export declare const useFlowAmountMessages: (override?: () => string | undefined) => (() => FlowAmountMessages);
+export declare const checkFlowAmountMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/content/index.d.ts

@@ -1,8 +1,10 @@
+export type { ChartDateFormat, ChartDatum, ChartDatumRole, ChartFormat, ChartNumberFormat } from "../charts/core";
+export { BalanceSummary, type BalanceSummaryProps } from "./BalanceSummary";
 export type { CalendarAttendee, CalendarCommand, CalendarController, CalendarCustomView, CalendarDayBadge, CalendarEvent, CalendarEventColor, CalendarEventLink, CalendarEventRenderContext, CalendarEventTimeChange, CalendarExternalDrag, CalendarLabels, CalendarProps, CalendarQuickCreateControls, CalendarRange, CalendarRecurrence, CalendarResource, CalendarSelectionControls, CalendarView, } from "./Calendar";
 export { default as Calendar } from "./Calendar";
-export type { ChartKind, ChartLabels, ChartProps, ChartRenderOptions } from "./Chart";
+export type { ChartKind, ChartKindProps, ChartLabels, ChartProps, ChartRenderOptions } from "./Chart";
 export { default as Chart } from "./Chart";
-export type { ChartExplorerColumn, ChartExplorerProps, ChartLegendEntry } from "./ChartExplorer";
+export type { ChartExplorerColumn, ChartExplorerProps, ChartFrameRequest, ChartLegendEntry } from "./ChartExplorer";
 export { ChartExplorer } from "./ChartExplorer";
 export type { ChartExplorerControlsProps } from "./ChartExplorerControls";
 export { ChartExplorerControls } from "./ChartExplorerControls";
@@ -17,17 +19,23 @@ export type { ChartDatumRef, ChartSelection, ChartTooltip, ChartTooltipFormatter
 export type { ChartSnapshot } from "./chart-snapshot";
 export { prepareChartSnapshot } from "./chart-snapshot";
 export type { StateTimelineChartOptions, StateTimelineDomain, StateTimelineInterval, StateTimelineRow, StateTimelineState, } from "./chart-state-timeline";
+export type { ChartTimeAxis } from "./chart-time-axis";
 export { highlightSql } from "./code-highlight";
 export { type CollectionSelection, createCollectionSelection, type SelectionModifiers } from "./collection-selection";
 export type { DataTableColumn, DataTableControlsProps, DataTableFooter, DataTableHeaderProps, DataTablePanelFooterProps, DataTablePanelProps, DataTableProps, DataTableRenderCell, DataTableRenderHeader, DataTableSort, } from "./DataTable";
 export { default as DataTable } from "./DataTable";
+export type { DataTableToolsProps, DataTableView, DataTableViewOptions } from "./DataTableTools";
+export { createDataTableView, DataTableTools } from "./DataTableTools";
 export type { DocCodeHighlighter, DocCodeProps, DocConcept, DocNoteVariant, DocRow } from "./Docs";
 export { DocCode, DocConceptGrid, DocInlineCode, DocLead, DocNote, DocPage, DocRows, DocSection } from "./Docs";
+export type { DataTableColumnType, DataTableNumberFormat, DataTableStatusState, DataTableTypedColumn, } from "./data-table-columns";
+export { filterRows, sortRows } from "./data-table-columns";
 export { FileBrowserPanel, type FileBrowserPanelProps, type FileSource, openFileBrowser } from "./FileBrowser";
 export { FileGrid, type FileGridGroup, type FileGridOpenProps, type FileGridProps, type FileGridSelectableProps } from "./FileGrid";
 export { default as FileTree, type FileTreeActions, type FileTreeEntry, type FileTreeProps } from "./FileTree";
 export { type FileType, FileTypeIcon, type FileTypeIconProps, fileKindLabel, fileTypeOf } from "./FileTypeIcon";
 export { canPreviewFile, default as FileView, type FileViewContent, type FileViewFile, type FileViewPreviewKind, type FileViewProps, type FileViewRenderer, type FileViewRendererProps, formatFileViewSize, getFileViewPreviewKind, } from "./FileView";
+export { FlowAmount, type FlowAmountDirection, type FlowAmountProps, flowDirection } from "./FlowAmount";
 export type { KbdProps } from "./Kbd";
 export { Kbd } from "./Kbd";
 export type { LabelChipProps } from "./LabelChip";
@@ -52,6 +60,8 @@ export { type MarkdownLinkInput, type MarkdownReference, type MarkdownReferenceK
 export { Pagination, type PaginationProps } from "./Pagination";
 export type { PdfPreviewProps, PdfPreviewRequest } from "./PdfPreview";
 export { default as PdfPreview } from "./PdfPreview";
+export type { PdfViewerProps } from "./PdfViewer";
+export { default as PdfViewer } from "./PdfViewer";
 export type { RangeOption, RangePickerProps } from "./RangePicker";
 export { default as RangePicker } from "./RangePicker";
 export { ReactionBar, type ReactionBarItem, type ReactionBarProps } from "./ReactionBar";

package/dist/types/content/pdf-document.d.ts

@@ -0,0 +1,5 @@
+import { type PdfDocumentHandle } from "./pdf-limits";
+export type { PdfDocumentHandle, PdfPageImage, PdfPageSize } from "./pdf-limits";
+export { PDF_LIMITS, PDF_TOO_LARGE, pageImageWidth } from "./pdf-limits";
+/** Opens a PDF; `null` after an abort. Throws `PDF_TOO_LARGE` past `PDF_LIMITS`, or pdf.js's error for a broken file. */
+export declare const openPdfDocument: (data: Blob | ArrayBuffer, signal: AbortSignal) => Promise<PdfDocumentHandle | null>;

package/dist/types/content/pdf-engine.d.ts

@@ -0,0 +1,9 @@
+import { type PdfDocumentHandle } from "./pdf-limits";
+/**
+ * The PDF engine: pdf.js and the glue `PdfViewer` needs. The @k2b/ui build bundles this module on its own into
+ * `pdf-viewer-engine.js`; `openPdfDocument` loads it by address, so a host's bundle never contains pdf.js. The legacy
+ * build also runs on older Safari on iPad. Parsing never runs code from the document: there is no scripting, XFA stays
+ * off, and pdf.js loads nothing beyond the given bytes. `workerUrl` is resolved against this module, next to which the
+ * host's bundler put the worker file.
+ */
+export declare function openPdf(data: ArrayBuffer, signal: AbortSignal, workerUrl: string): Promise<PdfDocumentHandle | null>;

package/dist/types/content/pdf-limits.d.ts

@@ -0,0 +1,43 @@
+/** Shapes and bounds shared by `PdfViewer`, its loader, and the pdf.js engine. */
+/** A page's size in PDF points at scale 1. */
+export type PdfPageSize = {
+    width: number;
+    height: number;
+};
+/** One drawn page: an object URL the caller revokes, and its size in pixels. */
+export type PdfPageImage = {
+    url: string;
+    width: number;
+    height: number;
+};
+export type PdfDocumentHandle = {
+    pages: readonly PdfPageSize[];
+    /** Draws one page `widthPx` wide; `null` after an abort. The caller revokes the returned URL. */
+    draw: (index: number, widthPx: number, signal: AbortSignal) => Promise<PdfPageImage | null>;
+    /**
+     * Lays the selectable, searchable text of one page into `container`. Positions are relative to the page; the font
+     * follows `--total-scale-factor` (CSS pixels per point) on the container or above, so zoom changes only that value.
+     */
+    textLayer: (index: number, container: HTMLElement, signal: AbortSignal) => Promise<void>;
+    close: () => Promise<void>;
+};
+/**
+ * Bounds for one document. Bytes and pages bound parsing work and memory; a larger document falls back to the
+ * browser's own viewer. Canvas pixels stay below the size Safari still draws (larger canvases come out blank).
+ */
+export declare const PDF_LIMITS: {
+    readonly maxBytes: number;
+    readonly maxPages: 2000;
+    readonly maxCanvasPixels: 16000000;
+    readonly maxImageWidth: 4096;
+};
+/** The name of the error a document past `PDF_LIMITS` raises; the host shows the browser's viewer instead. */
+export declare const PDF_TOO_LARGE = "PdfTooLargeError";
+export declare const pdfTooLarge: (message: string) => Error;
+/**
+ * Pixel width for a page image shown `displayWidth` CSS pixels wide: display width times the device pixel ratio
+ * (at most 2), at least 400 px where the page allows it, at most `PDF_LIMITS.maxImageWidth`, and always small enough
+ * that the canvas stays under `PDF_LIMITS.maxCanvasPixels` for the page's height-to-width `ratio`, also for a very
+ * tall page. Very deep zoom turns slightly soft, never blank.
+ */
+export declare const pageImageWidth: (displayWidth: number, pixelRatio: number, ratio: number) => number;

package/dist/types/content/pdf-messages.d.ts

@@ -10,6 +10,22 @@ declare const pdfMessages: import("@k2b/stdlib").Catalog<{
     pdfPreviewRendering: string;
     previewPdf: string;
     renderPdfPreview: string;
+    pdfPage: ({ number, total }: {
+        number: number;
+        total: number;
+    }) => string;
+    pdfPageShort: ({ number, total }: {
+        number: number;
+        total: number;
+    }) => string;
+    pdfZoom: string;
+    pdfZoomOut: string;
+    pdfZoomIn: string;
+    pdfZoomPercent: ({ value }: {
+        value: number;
+    }) => string;
+    pdfFitWidth: string;
+    pdfFitWidthLabel: string;
 }>;
 export type PdfMessages = ReturnType<(typeof pdfMessages)["resolve"]>["t"];
 /** Resolved from the inherited render locale. */

package/dist/types/inputs/ChoiceInputs.d.ts

@@ -14,6 +14,10 @@ export type SliderProps = FieldProps & Omit<JSX.InputHTMLAttributes<HTMLInputEle
     formatValue?: (value: number) => string;
     showValue?: boolean;
     center?: boolean;
+    /**
+     * The value the setting starts from. With it, a changed value shows in the accent color and a reset button
+     * appears in a slot the slider always keeps, so nothing moves. Double-click resets too.
+     */
     defaultValue?: number;
 };
 export declare function Slider(props: SliderProps): JSX.Element;

package/dist/types/inputs/ChoiceSlider.d.ts

@@ -34,3 +34,15 @@ export type ChoiceSliderProps = {
  * never changes. Unavailable stops stay visible and are skipped.
  */
 export declare function ChoiceSlider(props: ChoiceSliderProps): JSX.Element;
+export type ChoiceSliderIndicatorProps = {
+    /** How many stops the slider it stands for has. */
+    count: number;
+    /** The chosen stop's index, or `null` (or a negative index) for a choice that is none of the stops. */
+    index: number | null;
+    class?: string;
+};
+/**
+ * The slider in small and without interaction, 24 px wide: rail, fill and thumb in the same look, for a trigger that
+ * opens the real slider. It is decoration; the trigger's own label says the value.
+ */
+export declare function ChoiceSliderIndicator(props: ChoiceSliderIndicatorProps): JSX.Element;

package/dist/types/inputs/DatePicker.d.ts

@@ -52,6 +52,28 @@ export type DateRangePickerProps = DatePickerBaseProps<DateRangeValue> & {
 };
 /** `below` is a line under the trigger that the panel must not cover, such as a typed field's status line. */
 export declare const placeDatePopover: (trigger: HTMLElement, popover: HTMLElement, wide: boolean, below?: HTMLElement) => void;
+/** One month of days. Exported for composite pickers in this package (the period picker shows two side by side). */
+export declare function DatePickerPanel(props: {
+    visibleMonth: () => Date;
+    setVisibleMonth: (date: Date) => void;
+    selected?: () => string | null | undefined;
+    range?: () => DateRangeValue;
+    focusDate?: () => string | null | undefined;
+    onSelect: (date: string) => void;
+    onDayPreview?: (date: string | null) => void;
+    dateConfig?: DateContext;
+    /** Earliest and latest selectable day as date keys. */
+    min?: string;
+    max?: string;
+    /** Which month steps this panel offers; a second month beside it offers the other one. */
+    nav?: "both" | "previous" | "next";
+    /** Leaves the days of neighbouring months empty (`visibility: hidden`), so two months side by side never show a day twice. */
+    hideOutside?: boolean;
+    /** Whether a day is already on screen, also in a neighbouring panel; arrow keys then move there without paging. */
+    isShown?: (date: Date) => boolean;
+    /** Where keyboard navigation looks for the day to focus; the panel itself by default. */
+    focusRoot?: () => HTMLElement | undefined;
+}): JSX.Element;
 export declare function DatePicker(props: DatePickerProps): JSX.Element;
 export declare function DateTimePicker(props: DateTimePickerProps): JSX.Element;
 export declare function DateRangePicker(props: DateRangePickerProps): JSX.Element;

package/dist/types/inputs/PeriodPicker.d.ts

@@ -0,0 +1,24 @@
+import { type JSX } from "solid-js";
+import type { DateContext, MaybeAccessor, ValueFieldProps } from "./field-contract";
+import { type PeriodPreset, type PeriodValue } from "./period";
+export type PeriodPickerProps = Omit<ValueFieldProps<PeriodValue | null>, "value"> & {
+    /** A preset key or two explicit days; `null` or an unknown preset key shows the placeholder. */
+    value: MaybeAccessor<PeriodValue | null>;
+    /** The presets in list order, for example `periodPresets.thisMonth` or an app's own `{ key, label, resolve }`. */
+    presets: readonly PeriodPreset[];
+    /** Offers "Custom range" with a calendar in the same popover. On by default. */
+    custom?: boolean;
+    /** Time zone, week start and locale. Presets resolve "today" in `timeZone`; pass the zone the data uses. */
+    dateConfig?: DateContext;
+    /** The instant "today" is read from. Pass the server's instant so the first render and the browser agree. */
+    now?: Date;
+    /** Shows that a change is saving: the trigger keeps its size, cannot be opened, and shows a spinner. */
+    loading?: boolean;
+};
+/**
+ * PeriodPicker — one control for the period an evaluation or dashboard shows: presets such as "This month" plus a
+ * custom range, edited in the same popover (a bottom sheet on phones). The trigger shows the preset with its days or
+ * the custom days with their count, and keeps the width of its longest text so nothing beside it moves.
+ */
+export declare function PeriodPicker(props: PeriodPickerProps): JSX.Element;
+export default PeriodPicker;

package/dist/types/inputs/SelectChip.d.ts

@@ -27,6 +27,8 @@ export type SelectChipProps<T extends string | number = string> = ValueFieldProp
     loading?: boolean;
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
+    /** Keeps the width of the longest option label, so a new choice never moves what sits beside the chip. */
+    stableWidth?: boolean;
 };
 export declare function SelectChip<T extends string | number = string>(props: SelectChipProps<T>): JSX.Element;
 export default SelectChip;

package/dist/types/inputs/date-picker.d.ts

@@ -42,6 +42,12 @@ export declare const splitDateTime: (value: string | null | undefined, context?:
 };
 export declare const isCompleteTime: (value: string) => boolean;
 export declare const toDateTimeValue: (date: string, time: string, context?: DateContext) => string | null;
+/**
+ * The value an applied draft commits. An untouched draft keeps the exact value: the panel shows minutes in the
+ * picker's zone, and a wall time that a daylight-saving change repeats names two instants, so rebuilding it could
+ * move the value by an hour or drop its seconds.
+ */
+export declare const draftDateTimeValue: (value: string | null | undefined, date: string, time: string, context?: DateContext) => string | null;
 export declare const formatDateTimeValue: (value: string | null | undefined, context?: DateContext) => string;
 export declare const normalizeTimeInput: (value: string) => string;
 export declare const filterTimeInput: (value: string) => string;

package/dist/types/inputs/index.d.ts

@@ -12,8 +12,8 @@ export type { ColorInputProps, PinInputProps, SliderProps, } from "./ChoiceInput
 export { ColorInput, PinInput, Slider } from "./ChoiceInputs";
 export type { ChoiceListOption, ChoiceListProps } from "./ChoiceList";
 export { ChoiceList } from "./ChoiceList";
-export type { ChoiceSliderOption, ChoiceSliderProps } from "./ChoiceSlider";
-export { ChoiceSlider } from "./ChoiceSlider";
+export type { ChoiceSliderIndicatorProps, ChoiceSliderOption, ChoiceSliderProps } from "./ChoiceSlider";
+export { ChoiceSlider, ChoiceSliderIndicator } from "./ChoiceSlider";
 export type { ChoiceTileOption, ChoiceTilesProps } from "./ChoiceTiles";
 export { ChoiceTiles } from "./ChoiceTiles";
 export type { ColorChoiceOption, ColorChoicesProps } from "./ColorChoices";
@@ -48,8 +48,14 @@ export type { MultiSelectFetchDataFn, MultiSelectInputProps, MultiSelectOption,
 export { MultiSelectInput } from "./MultiSelectInput";
 export type { MarkdownEditorProps } from "./markdown/MarkdownEditor";
 export { MarkdownEditor } from "./markdown/MarkdownEditor";
+export type { SlashCommandsProps } from "./markdown/SlashCommands";
+export { SlashCommands } from "./markdown/SlashCommands";
 export type { NumberInputProps } from "./NumberInput";
 export { NumberInput } from "./NumberInput";
+export type { PeriodPickerProps } from "./PeriodPicker";
+export { PeriodPicker } from "./PeriodPicker";
+export type { PeriodClock, PeriodContext, PeriodPreset, PeriodRange, PeriodValue } from "./period";
+export { formatPeriodDays, formatPeriodRange, isPeriodDay, parsePeriodValue, periodContext, periodDayCount, periodInstants, periodPresets, resolvePeriod, } from "./period";
 export type { QrScannerError, QrScannerProps } from "./QrScanner";
 export { QrScanner } from "./QrScanner";
 export type { RichSelectFact, RichSelectFooter, RichSelectItem, RichSelectProps, RichSelectSection, RichSelectStatus, } from "./RichSelect";

package/dist/types/inputs/input-messages.d.ts

@@ -9,6 +9,9 @@ declare const inputMessages: import("@k2b/stdlib").Catalog<{
         index: number;
         total: number;
     }) => string;
+    resetTo: ({ value }: {
+        value: string;
+    }) => string;
 }>;
 export type InputMessages = ReturnType<(typeof inputMessages)["resolve"]>["t"];
 /** Resolved from the inherited render locale. */

package/dist/types/inputs/markdown/MarkdownEditor.d.ts

@@ -14,6 +14,11 @@ export type MarkdownEditorProps = ValueFieldProps<string> & {
     completions?: readonly Completion[];
     showStats?: boolean;
     variant?: "default" | "paper" | "embedded";
+    /**
+     * The font of the text, its highlighting, and the placeholder together: `mono` (default) for Markdown source,
+     * `sans` for a message composer whose text later shows in the interface font.
+     */
+    font?: "mono" | "sans";
     fill?: boolean;
     /** Groups save and close at the end of the toolbar. The caller owns navigation and unsaved-change confirmation. */
     onClose?: () => void;

package/dist/types/inputs/markdown/SlashCommands.d.ts

@@ -0,0 +1,20 @@
+import { type JSX } from "solid-js";
+import { type CommandSource } from "../../actions/command-items";
+export type SlashCommandsProps = {
+    /** The editor's textarea, from `MarkdownEditor`'s `textareaRef`. The commands attach once it is there. */
+    textarea: HTMLTextAreaElement | undefined;
+    /** The same entries as `CommandMenu`'s `items`. */
+    items: CommandSource;
+    /**
+     * The composer box the list docks to, such as the frame around the editor and its "+" row. Defaults to the editor
+     * itself.
+     */
+    composer?: HTMLElement;
+};
+/**
+ * Slash commands for a `MarkdownEditor`: `/` at the start of a line or after a space opens the entries docked above the
+ * composer, as wide as it is. Place it beside the editor and pass the editor's textarea. It listens to the textarea itself, so editors without
+ * commands carry none of it: native listeners run before the editor's own, and a key it uses is marked handled with
+ * `preventDefault`, which the editor respects.
+ */
+export declare function SlashCommands(props: SlashCommandsProps): JSX.Element;

package/dist/types/inputs/period-picker-messages.d.ts

@@ -0,0 +1,34 @@
+/** Labels of the built-in period presets and the picker's own words. */
+declare const periodPickerMessages: import("@k2b/stdlib").Catalog<{
+    period: string;
+    choosePeriod: string;
+    custom: string;
+    from: string;
+    to: string;
+    backToPresets: string;
+    since: ({ date }: {
+        date: string;
+    }) => string;
+    days: ({ count }: {
+        count: number;
+    }) => string;
+    today: string;
+    yesterday: string;
+    "this-week": string;
+    "last-week": string;
+    "this-month": string;
+    "last-month": string;
+    "this-quarter": string;
+    "last-quarter": string;
+    "this-year": string;
+    "last-year": string;
+    all: string;
+}>;
+export type PeriodPickerMessages = ReturnType<(typeof periodPickerMessages)["resolve"]>["t"];
+/** The translated label of a built-in preset key, if it is one. */
+export declare const builtInPresetLabel: (t: PeriodPickerMessages, key: string) => string | undefined;
+/** Resolved from the inherited render locale. */
+export declare const usePeriodPickerMessages: () => (() => PeriodPickerMessages);
+export declare const resolvePeriodPickerMessages: (locale?: string) => PeriodPickerMessages;
+export declare const checkPeriodPickerMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/inputs/period.d.ts

@@ -0,0 +1,134 @@
+/**
+ * A period as an app stores it: a preset key that stays relative ("this month" is next month's month too), or two
+ * explicit days. Days are date keys such as `2026-11-01`; `end` is inclusive.
+ */
+export type PeriodValue = {
+    preset: string;
+} | {
+    start: string;
+    end: string;
+};
+/** Inclusive days of a period. `null` is an open edge, for example "All time" without a known first day. */
+export type PeriodRange = {
+    start: string | null;
+    end: string | null;
+};
+/** What a preset resolves against: today in the period's time zone and the first day of the week. */
+export type PeriodContext = {
+    today: string;
+    weekStartsOn: 0 | 1;
+};
+export type PeriodPreset = {
+    key: string;
+    /** Shown in the list and the trigger. Built-in presets bring a translated label; app presets name their own. */
+    label?: string;
+    resolve: (context: PeriodContext) => PeriodRange;
+};
+/** The clock a period is resolved with. Server and browser pass the same values so the first render agrees. */
+export type PeriodClock = {
+    /** The instant "today" is read from; defaults to now. */
+    now?: Date;
+    /** IANA time zone the days belong to, for example a base's zone; defaults to the runtime zone. */
+    timeZone?: string;
+    /** First day of the week, as in the calendar's date config; Monday by default. */
+    weekStartsOn?: 0 | 1;
+    /** Alias of `weekStartsOn`, accepted from a shared date config. */
+    firstDayOfWeek?: 0 | 1;
+};
+/** Adds whole days to a date key; calendar days, so a DST change never moves it. */
+export declare const addPeriodDays: (key: string, count: number) => string;
+/** Number of days in an inclusive range of date keys. */
+export declare const periodDayCount: (range: {
+    start: string;
+    end: string;
+}) => number;
+/**
+ * Built-in presets. Each covers its whole calendar period ("This month" is the 1st to the last day, not up to
+ * today) in the period's time zone; weeks start on the context's first day of the week.
+ */
+export declare const periodPresets: {
+    today: {
+        key: string;
+        resolve: ({ today }: PeriodContext) => {
+            start: string;
+            end: string;
+        };
+    };
+    yesterday: {
+        key: string;
+        resolve: ({ today }: PeriodContext) => {
+            start: string;
+            end: string;
+        };
+    };
+    thisWeek: {
+        key: string;
+        resolve: (context: PeriodContext) => PeriodRange;
+    };
+    lastWeek: {
+        key: string;
+        resolve: (context: PeriodContext) => PeriodRange;
+    };
+    thisMonth: {
+        key: string;
+        resolve: ({ today }: PeriodContext) => PeriodRange;
+    };
+    lastMonth: {
+        key: string;
+        resolve: ({ today }: PeriodContext) => PeriodRange;
+    };
+    thisQuarter: {
+        key: string;
+        resolve: ({ today }: PeriodContext) => PeriodRange;
+    };
+    lastQuarter: {
+        key: string;
+        resolve: ({ today }: PeriodContext) => PeriodRange;
+    };
+    thisYear: {
+        key: string;
+        resolve: ({ today }: PeriodContext) => PeriodRange;
+    };
+    lastYear: {
+        key: string;
+        resolve: ({ today }: PeriodContext) => PeriodRange;
+    };
+    /** Everything up to today; `since` is the first day with data when the app knows it, else the start stays open. */
+    all: (options?: {
+        since?: string | null;
+    }) => PeriodPreset;
+};
+/** A real calendar day key, not only the shape (`2026-02-30` is refused). */
+export declare const isPeriodDay: (value: unknown) => value is string;
+/** Accepts a stored or URL value only when it is a known preset key or two real days in order. */
+export declare const parsePeriodValue: (value: unknown, presets: readonly PeriodPreset[]) => PeriodValue | undefined;
+/** The context presets resolve against: today in the clock's time zone. */
+export declare const periodContext: (clock?: PeriodClock) => PeriodContext;
+/**
+ * Resolves a value to inclusive days. Returns `undefined` for a preset key the list does not contain, so a stored
+ * period that no longer exists is never silently replaced.
+ */
+export declare const resolvePeriod: (value: PeriodValue, presets: readonly PeriodPreset[], clock?: PeriodClock) => PeriodRange | undefined;
+/**
+ * The instants a query uses for a resolved period: `from` is the start of the first day and `to` the start of the
+ * day after the last one (exclusive), both in the time zone. Days are never assumed to last 24 hours.
+ */
+export declare const periodInstants: (range: PeriodRange, timeZone: string) => {
+    from: string | null;
+    to: string | null;
+};
+/**
+ * Short days of a preset, for the list and the trigger: "Sat, Nov 7", "Nov 1 – 30", "2025", "since 3/14/2019".
+ * The year is added only when the period is not in today's year.
+ */
+export declare const formatPeriodDays: (range: PeriodRange, today: string, locale: string, since: (date: string) => string) => string;
+/** Explicit days as numbers with the year: "01.–07.11.2026" in German, "11/1/2026 – 11/7/2026" in English. */
+export declare const formatPeriodRange: (range: {
+    start: string;
+    end: string;
+}, locale: string) => string;
+/** The widest explicit range within today's year, all of it (two-digit days, a three-digit count), so a trigger can reserve its width. */
+export declare const widePeriodRangeSample: (today: string) => {
+    start: string;
+    end: string;
+};

package/dist/types/intl/Format.d.ts

@@ -31,6 +31,11 @@ export type FormatCurrencyProps = SpanProps & LocaleProp & FallbackProp & {
     currency: string;
     /** Fixed fraction digits. Defaults to the currency's standard digits. */
     decimals?: number;
+    /**
+     * When the sign shows, as in `Intl.NumberFormat`: `"exceptZero"` writes `+1.234,50 €` and `-80,00 €` for a
+     * balance change or net amount, `"never"` drops it. Defaults to `"auto"` (only negative amounts carry a sign).
+     */
+    signDisplay?: Intl.NumberFormatOptions["signDisplay"];
 };
 export type FormatBytesProps = SpanProps & LocaleProp & FallbackProp & {
     value: number | null | undefined;