@k2b/ui 0.29.0 → 0.31.0

package/dist/types/actions/Dropdown.d.ts

@@ -14,6 +14,8 @@ export type DropdownActionBase = {
      */
     ariaLabel?: string;
     description?: string;
+    /** Quiet trailing information, such as a count. */
+    trailing?: JSX.Element;
     variant?: "danger";
 };
 export type DropdownAction = (DropdownActionBase & {
@@ -107,6 +109,8 @@ export type DropdownItemProps = {
     icon?: string;
     image?: string;
     description?: string;
+    /** Quiet trailing information, such as a count. */
+    trailing?: JSX.Element;
     disabled?: boolean;
     danger?: boolean;
     variant?: "danger";

package/dist/types/actions/FilterChip.d.ts

@@ -28,9 +28,31 @@ export type FilterChipProps = {
     iconOnly?: boolean;
     /** Use a standard button appearance instead of the default filter field. */
     variant?: ButtonVariant;
+    /**
+     * An active chip names its first value instead of a count: "Tags: Customer", "Tags: Customer +2". Use it for the
+     * chips of `AppWorkspace.Head`; pass only the filter's name as `label`. The chip then grows with its value.
+     */
+    showValue?: boolean;
     disabled?: boolean;
     class?: string;
 };
 /** Section-aware controlled filter with immediate single- and multi-select commits. */
 export declare function FilterChip(props: FilterChipProps): JSX.Element;
 export default FilterChip;
+export type FilterToggleProps = {
+    label: JSX.Element;
+    icon: string;
+    /** Whether the filter is on. An active toggle carries the same tint as an active `FilterChip`. */
+    active: boolean;
+    /** Link to the URL with the filter switched. The link keeps working without JavaScript. */
+    href?: string;
+    onClick?: (event: MouseEvent) => void;
+    title?: string;
+    disabled?: boolean;
+    class?: string;
+};
+/**
+ * One on/off filter in the chip look: a link marked `aria-current="true"` while active, or a button with
+ * `aria-pressed`. Selection changes only colour and background, so neighbouring chips never move.
+ */
+export declare function FilterToggle(props: FilterToggleProps): JSX.Element;

package/dist/types/actions/ViewTabs.d.ts

@@ -0,0 +1,30 @@
+import { type JSX } from "solid-js";
+export type ViewTab = {
+    id: string;
+    label: string;
+    href: string;
+    icon?: string;
+    count?: number | string;
+};
+export type ViewTabsProps = {
+    /** Accessible name of the navigation landmark, e.g. "Views". */
+    label: string;
+    items: readonly ViewTab[];
+    /** Id of the open view; the server reads it from `?view=`. Unknown ids select nothing. */
+    current: string | undefined;
+    /** Tabs shown before More (default 5). */
+    max?: number;
+    class?: string;
+};
+/** Two deterministic strip levels; only opening the menu reads CSS visibility. */
+export declare function viewTabsLayout(items: readonly ViewTab[], current: string | undefined, max?: number): {
+    wide: number[];
+    compact: number[];
+    wideHidden: number;
+    compactHidden: number;
+};
+/**
+ * URL-backed object views. Every view is an ordinary document link, in the strip and under More, so reload, back,
+ * and forward keep the view the URL names.
+ */
+export declare function ViewTabs(props: ViewTabsProps): JSX.Element;

package/dist/types/actions/filter-messages.d.ts

@@ -1,5 +1,7 @@
 declare const filterMessages: import("@k2b/stdlib").Catalog<{
     filterActions: string;
+    filters: string;
+    reset: string;
 }>;
 export type FilterMessages = ReturnType<(typeof filterMessages)["resolve"]>["t"];
 /** Resolved from the inherited render locale. */

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

@@ -10,8 +10,8 @@ export type { DragPayload, DragSourceProps, DropTargetProps } from "./DragAndDro
 export { activeDrag, DragSource, DropTarget, useKeyboardDrag } from "./DragAndDrop";
 export type { DropdownAction, DropdownActionBase, DropdownChoice, DropdownItemProps, DropdownPosition, DropdownProps, DropdownSection, DropdownTriggerProps, } from "./Dropdown";
 export { Dropdown, DropdownItem, dropdownPosition } from "./Dropdown";
-export type { FilterChipOption, FilterChipProps, FilterChipSection } from "./FilterChip";
-export { FilterChip } from "./FilterChip";
+export type { FilterChipOption, FilterChipProps, FilterChipSection, FilterToggleProps } from "./FilterChip";
+export { FilterChip, FilterToggle } from "./FilterChip";
 export type { GestureKind, GestureMenuAction, GestureMenuItem, GestureMenuProps, GestureMenuSection } from "./GestureMenu";
 export { GestureMenu } from "./GestureMenu";
 export type { RemoveButtonProps } from "./RemoveButton";
@@ -26,3 +26,5 @@ export type { TabOption, TabsItemProps, TabsProps } from "./Tabs";
 export { Tabs } from "./Tabs";
 export type { ToolbarActionProps, ToolbarGroupProps, ToolbarLabelProps, ToolbarProps, ToolbarSeparatorProps } from "./Toolbar";
 export { Toolbar } from "./Toolbar";
+export type { ViewTab, ViewTabsProps } from "./ViewTabs";
+export { ViewTabs } from "./ViewTabs";

package/dist/types/chat/ChatComposer.d.ts

@@ -15,6 +15,18 @@ export type ChatCommandResult = void | "cancelled" | {
 } | {
     mention: ChatAttachment;
 };
+/** The draft as a successful `open` leaves it: without the `/…` token, with its references moved along. Save this one. */
+export type ChatCommandDraft = {
+    value: string;
+    mentions: readonly ChatMention[];
+};
+/**
+ * How an `open` row ends: on success (`void`) the token leaves as for an action; `"cancelled"` changes nothing; `failed`
+ * keeps the list open and the draft unchanged, and its text replaces the row's description until the row runs again.
+ */
+export type ChatCommandOpenResult = void | "cancelled" | {
+    failed: string;
+};
 /** A fixed place in the slash list. Sections keep the given order, also while searching. */
 export type ChatCommandSection = {
     id: string;
@@ -23,6 +35,20 @@ export type ChatCommandSection = {
     searched?: boolean;
     /** Only while searching or narrowed: absent from the overview (empty query), including its loading placeholder. */
     searchOnly?: boolean;
+    /** Only in the overview (empty query, no scope): absent while searching or narrowed, such as recently used rows. */
+    overviewOnly?: boolean;
+    /**
+     * Its local rows are fixed when the list opens: a row that arrives while the list is open waits for the next opening,
+     * so a section above others whose rows load in the background never pushes a visible row down. Rows that go away
+     * still leave at once.
+     */
+    fixedWhileOpen?: boolean;
+    /**
+     * Local rows still on their way, such as Commands from a catalog: the section ends with placeholder rows, three in
+     * the overview and one while searching, and its heading shows a spinner. Make it the last section, so rows that
+     * arrive only fill the end of the list and no visible row moves.
+     */
+    pending?: boolean;
 };
 /** First-word narrowing; Tab writes `words[0]` followed by a space. */
 export type ChatCommandScope = {
@@ -47,8 +73,15 @@ export type ChatCommand = {
     selected?: boolean;
     /** Retry discovery in a new opening, retaining the token and currently displayed rows. */
     searchAgain?: boolean;
+    /** Stays in every search of its section, after the matches, such as a row that retries loading the section. */
+    persistent?: boolean;
     /** Application name, searchable but not displayed. */
     app?: string;
+    /**
+     * Used recently by this person. While searching, a matching row moves one step up the ranking ladder of its section
+     * and comes before rows of equal rank. The overview keeps consumer order.
+     */
+    recent?: boolean;
     /** Stable row key for option ids, marking and de-duplication. Defaults to `name`. */
     id?: string;
     name: string;
@@ -62,6 +95,16 @@ export type ChatCommand = {
     busyLabel?: string;
     /** Failures restore an unchanged draft and appear once in the status line, without calling `onError`. */
     action?: (context: ChatCommandContext) => ChatCommandResult | Promise<ChatCommandResult>;
+    /**
+     * Leaves the composer, such as opening another app. Runs with the token and the list in place: the row shows
+     * `busyLabel` (default "Opening …") with a spinner instead of its description, and editing waits. A rejection ends like
+     * an action's: the token stays, the list closes and the status line names the reason. Closing the list, such as with
+     * Escape, cancels: `signal` aborts and the row ends at once. `signal` also aborts when the opening ends any other way
+     * than by success, so the opener can save the draft with its token again. A new `draftKey` cancels too, unless the
+     * opener calls `follow()` right before changing it itself: that next change keeps the opening, moves its busy line
+     * to the status line, and Escape still cancels. See `ChatCommandOpenResult`.
+     */
+    open?: (draft: ChatCommandDraft, signal: AbortSignal, follow: () => void) => Promise<ChatCommandOpenResult>;
     /** Selecting a reference inserts its display name and retains its opaque payload. */
     mention?: ChatAttachment;
     /**
@@ -104,7 +147,16 @@ export type ChatComposerProps = {
     fileSelection?: ChatFileSelection;
     /** Handle non-file clipboard content. Pasted files already use `fileSelection`. */
     onPaste?: ChatPasteHandler;
+    /** The add menu's entries after "Attach files". Not shown with `addOpensCommands`. */
     menuActions?: readonly ChatAction[];
+    /**
+     * "+" opens the slash list with a search field on top instead of the add menu, for keyboards where "/" is hard to
+     * reach, such as a phone's. The search field filters, narrows and chooses as typing after "/" does, and a reference
+     * lands where the field's caret was when "+" was pressed. Escape, "+" again, Back on a phone or a press outside
+     * closes the list without acting on what lies below, and the field gets its focus and selection back. `menuActions`
+     * do not show then: offer them as `commands`, and file selection as a row with `attachFiles`.
+     */
+    addOpensCommands?: boolean;
     models?: readonly ChatModelOption[];
     selectedModelId?: string | null;
     onModelChange?: (modelId: string) => void;

package/dist/types/chat/ChatDecision.d.ts

@@ -72,10 +72,25 @@ declare function ChatPreviewTitle(props: ChatPreviewTitleProps): JSX.Element;
 declare function ChatPreviewSentence(props: {
     children: JSX.Element;
 }): JSX.Element;
+export type ChatPreviewExcerptProps = {
+    children: JSX.Element;
+    /** Shows the whole text in place instead of the first lines, such as after `Chat.Preview.ShowAll`. */
+    expanded?: boolean;
+    id?: string;
+};
 /** The first lines of a longer text. It keeps its line breaks, shows about three lines, and fades out. */
-declare function ChatPreviewExcerpt(props: {
+declare function ChatPreviewExcerpt(props: ChatPreviewExcerptProps): JSX.Element;
+export type ChatPreviewShowAllProps = {
+    /** The id of the `Chat.Preview.Excerpt` this button opens. */
+    controls: string;
+    onShow: () => void;
     children: JSX.Element;
-}): JSX.Element;
+};
+/**
+ * Shows the rest of an excerpt in place, for a text with no page of its own to open. It looks like `ReadMore`; the
+ * caller removes it once the text is shown, and the focus moves to the text, so reading goes on where it was.
+ */
+declare function ChatPreviewShowAll(props: ChatPreviewShowAllProps): JSX.Element;
 export type ChatPreviewReadMoreProps = {
     href: string;
     children: JSX.Element;
@@ -120,6 +135,7 @@ export declare const ChatPreview: typeof ChatPreviewRoot & {
     Sentence: typeof ChatPreviewSentence;
     Excerpt: typeof ChatPreviewExcerpt;
     ReadMore: typeof ChatPreviewReadMore;
+    ShowAll: typeof ChatPreviewShowAll;
     Lines: typeof ChatPreviewLines;
     Line: typeof ChatPreviewLine;
     People: typeof ChatPreviewPeople;

package/dist/types/chat/ChatPrimitives.d.ts

@@ -53,5 +53,15 @@ export type ChatContextUsageProps = ChatContextUsageData & {
 };
 export declare const formatChatTokens: (tokens: number) => string;
 export declare function ChatMessage(props: ChatMessageProps): JSX.Element;
+export type ChatActivityToggleProps = {
+    /** The words that open the body, usually the count, such as "3 of 4 tasks". */
+    children: JSX.Element;
+};
+/**
+ * The words of an activity label that open its body, with the chevron right after them. With a toggle in its label,
+ * only these words are the disclosure, and the rest of the row, chips with links included, stays ordinary content.
+ * Outside an activity with a body it renders its words as plain text.
+ */
+export declare function ChatActivityToggle(props: ChatActivityToggleProps): JSX.Element;
 export declare function ChatActivity(props: ChatActivityProps): JSX.Element;
 export declare function ChatContextUsage(props: ChatContextUsageProps): JSX.Element;

package/dist/types/chat/chat-messages.d.ts

@@ -3,10 +3,14 @@ export declare const chatMessages: import("@k2b/stdlib").Catalog<{
     commandDraftChanged: string;
     markAdded: string;
     markRemoved: string;
+    commandOpening: string;
     commandSelected: string;
     attachments: string;
     assistant: string;
     addToChat: string;
+    addMenu: string;
+    commandSearch: string;
+    commandSearchLabel: string;
     attachFiles: string;
     addGuidance: string;
     chat: string;

package/dist/types/chat/command-search.d.ts

@@ -20,6 +20,8 @@ type Group = {
     rows: ChatCommandRow[];
     loading: boolean;
     placeholder: boolean;
+    /** Placeholder rows of a `pending` section, after its rows: three in the overview, one while searching. */
+    pendingRows: number;
 };
 export declare function chatCommandListModel(input: {
     query: string;

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

@@ -4,12 +4,12 @@ import { ChatTasks } from "./ChatTasks";
 export type { ChatTask, ChatTasksProps } from "./ChatTasks";
 import { ChatComposer } from "./ChatComposer";
 import { ChatDecision, ChatMark, ChatOutcome } from "./ChatDecision";
-import { ChatActivity, ChatContextUsage, ChatMessage } from "./ChatPrimitives";
+import { ChatActivity, ChatActivityToggle, ChatContextUsage, ChatMessage } from "./ChatPrimitives";
 import { ChatRoot } from "./ChatRoot";
 import { ChatTimeline } from "./ChatTimeline";
-export type { ChatCommand, ChatCommandContext, ChatCommandResult, ChatCommandScope, ChatCommandSearch, ChatCommandSection, ChatComposerProps, ChatFileSelection, ChatPasteHandler, } from "./ChatComposer";
-export type { ChatDecisionProps, ChatMarkProps, ChatOutcomeProps, ChatPreviewHeaderProps, ChatPreviewLineProps, ChatPreviewPeopleProps, ChatPreviewProps, ChatPreviewReadMoreProps, ChatPreviewTitleProps, } from "./ChatDecision";
-export type { ChatActivityProps, ChatContextUsageProps, ChatMessageProps } from "./ChatPrimitives";
+export type { ChatCommand, ChatCommandContext, ChatCommandDraft, ChatCommandOpenResult, ChatCommandResult, ChatCommandScope, ChatCommandSearch, ChatCommandSection, ChatComposerProps, ChatFileSelection, ChatPasteHandler, } from "./ChatComposer";
+export type { ChatDecisionProps, ChatMarkProps, ChatOutcomeProps, ChatPreviewExcerptProps, ChatPreviewHeaderProps, ChatPreviewLineProps, ChatPreviewPeopleProps, ChatPreviewProps, ChatPreviewReadMoreProps, ChatPreviewShowAllProps, ChatPreviewTitleProps, } from "./ChatDecision";
+export type { ChatActivityProps, ChatActivityToggleProps, ChatContextUsageProps, ChatMessageProps } from "./ChatPrimitives";
 export { formatChatTokens } from "./ChatPrimitives";
 export type { ChatRootProps } from "./ChatRoot";
 export type { ChatActivityItem, ChatMessageItem, ChatTimelineItem, ChatTimelineProps } from "./ChatTimeline";
@@ -22,7 +22,9 @@ export declare const Chat: typeof ChatRoot & {
     Tasks: typeof ChatTasks;
     Timeline: typeof ChatTimeline;
     Message: typeof ChatMessage;
-    Activity: typeof ChatActivity;
+    Activity: typeof ChatActivity & {
+        Toggle: typeof ChatActivityToggle;
+    };
     Composer: typeof ChatComposer;
     ContextUsage: typeof ChatContextUsage;
     ContextPopup: typeof ChatContextPopup;
@@ -35,10 +37,9 @@ export declare const Chat: typeof ChatRoot & {
         Sentence: (props: {
             children: import("solid-js").JSX.Element;
         }) => import("solid-js").JSX.Element;
-        Excerpt: (props: {
-            children: import("solid-js").JSX.Element;
-        }) => import("solid-js").JSX.Element;
+        Excerpt: (props: import("./ChatDecision").ChatPreviewExcerptProps) => import("solid-js").JSX.Element;
         ReadMore: (props: import("./ChatDecision").ChatPreviewReadMoreProps) => import("solid-js").JSX.Element;
+        ShowAll: (props: import("./ChatDecision").ChatPreviewShowAllProps) => import("solid-js").JSX.Element;
         Lines: (props: {
             label?: string;
             children: import("solid-js").JSX.Element;

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

@@ -85,6 +85,9 @@ export type DataTableProps<T> = {
     footer?: DataTableFooter<T>;
     hasMore?: boolean;
     loadingMore?: boolean;
+    loading?: boolean;
+    /** Initial placeholder count, clamped to an integer from 1 to 50. Defaults to 5. */
+    loadingRows?: number;
     onLoadMore?: () => void;
     empty?: JSX.Element;
     density?: "compact" | "normal";

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

@@ -0,0 +1,6 @@
+import { type JSX } from "solid-js";
+/**
+ * The required credits for maps built with `mapStyle()`, each one a link, for MapView's `attribution` slot.
+ * @example <MapView style={style} attribution={<MapAttribution />} height={320} />
+ */
+export declare function MapAttribution(): JSX.Element;

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

@@ -0,0 +1,5 @@
+import { type JSX } from "solid-js";
+import type { MapViewProps } from "./map-view-types";
+export type { MapViewProps } from "./map-view-types";
+/** A static server frame enhanced with a same-origin MapLibre worker only after it enters the viewport. */
+export declare function MapView(props: MapViewProps): JSX.Element;

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

@@ -0,0 +1,31 @@
+import { type JSX } from "solid-js";
+import { type MapFrame } from "./map-view-geometry";
+import type { MapViewFrameProps, MapViewMarker } from "./map-view-types";
+export type { MapViewFrameProps } from "./map-view-types";
+export declare const mapNumber: (value: number) => string;
+export declare const selectedMarker: (markers: MapViewMarker[], selectedId?: string) => MapViewMarker | undefined;
+export declare function frameStyle(frame: MapFrame, padding: number): JSX.CSSProperties;
+export declare function MapGeometry(props: MapViewFrameProps & {
+    frame: MapFrame;
+    boxStyle?: JSX.CSSProperties;
+    onSelect?: (id: string) => void;
+    /** Pins are buttons in MapView; the standalone frame draws them as labelled images, never focusable. */
+    interactive?: boolean;
+    /** 2^(live zoom - fitted zoom), so pin separation follows the person's zoom; 1 until then. */
+    zoomFactor?: number;
+}): JSX.Element;
+export type MapScale = {
+    label: string;
+    width: string;
+};
+export declare function referenceScale(frame: MapFrame, padding: number): MapScale;
+export declare function MapScaleBar(props: {
+    scale: MapScale;
+}): JSX.Element;
+/** The scale bar and the attribution share the bottom row, so a long attribution wraps before it covers the scale. */
+export declare function MapFootRow(props: {
+    scale?: MapScale;
+    children?: JSX.Element;
+}): JSX.Element;
+/** Geometry without a browser, a canvas, or a network dependency; suitable for server rendering and PDF output. */
+export declare function MapViewFrame(props: MapViewFrameProps): JSX.Element;

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

@@ -2,6 +2,7 @@ declare const dataTableMessages: import("@k2b/stdlib").Catalog<{
     dataTable: string;
     noColumns: string;
     noRecords: string;
+    loadingRows: string;
 }>;
 export type DataTableMessages = ReturnType<(typeof dataTableMessages)["resolve"]>["t"];
 /** Resolved from the inherited render locale. */

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

@@ -35,9 +35,15 @@ export type { LightboxAction, LightboxImage } from "./Lightbox";
 export { default as Lightbox } from "./Lightbox";
 export type { LogTableEntry } from "./LogEntriesTable";
 export { default as LogEntriesTable } from "./LogEntriesTable";
+export { MapAttribution } from "./MapAttribution";
+export { MapView } from "./MapView";
+export { MapViewFrame } from "./MapViewFrame";
 export { default as MarkdownView, type MarkdownRenderOptions, type MarkdownViewProps, renderSafeMarkdown } from "./MarkdownView";
 export type { MessageGroupEntry, MessageRowAction, MessageRowAttachment, MessageRowAuthor, MessageRowFile, MessageRowMedia, MessageRowProgress, MessageRowProps, MessageRowQuote, MessageRowReaction, MessageRowStatus, MessageRowThread, MessageSystemRowProps, } from "./MessageRow";
 export { MessageRow, MessageSystemRow, startsMessageGroup } from "./MessageRow";
+export { type MapPaletteColors, type MapTheme, mapPalette } from "./map-palette";
+export { type MapStyleOptions, mapAttribution, mapStyle } from "./map-style";
+export type { MapViewArea, MapViewFit, MapViewFrameProps, MapViewLine, MapViewLineTone, MapViewMarker, MapViewOwnLocation, MapViewPoint, MapViewProps, MapViewStyle, MapViewStyleSource, MapViewTone, } from "./map-view-types";
 export { MARKDOWN_CALLOUT_CLASSES, MARKDOWN_CALLOUT_ICON_ATTRIBUTES, type MarkdownInfoBlock, type MarkdownInfoBlockRenderInput, type MarkdownInfoBlockType, markdownInfoBlocks, renderMarkdownInfoBlock, scanMarkdownInfoBlock, } from "./markdown-info-blocks";
 export { type MarkdownLinkInput, type MarkdownReference, type MarkdownReferenceKind, type MarkdownReferenceType, markdownLinkReference, markdownReferenceIcon, markdownReferenceType, markdownReferenceTypeLabel, markStandaloneLinks, renderMarkdownLink, } from "./markdown-links";
 export { Pagination, type PaginationProps } from "./Pagination";

package/dist/types/content/map-palette.d.ts

@@ -0,0 +1,58 @@
+/** The map image colours. Each key is also the CSS token `--k2b-map-<kebab-key>` on `.k2b-map-view`. */
+export type MapPaletteColors = {
+    /** Background land, also behind the server frame before the map image arrives. */
+    land: string;
+    /** Woods, grass, and city green; large protected areas stay plain land. */
+    green: string;
+    water: string;
+    building: string;
+    road: string;
+    roadCasing: string;
+    motorway: string;
+    motorwayCasing: string;
+    /** Rail lines and footpaths. */
+    rail: string;
+    boundary: string;
+    /** Streets, suburbs, villages, and states. */
+    label: string;
+    /** Cities, towns, and countries. */
+    labelStrong: string;
+    waterLabel: string;
+};
+export type MapTheme = "light" | "dark";
+/**
+ * Plain data so a server can build the style JSON without CSS. The accent stays with the host's
+ * pins and lines; the map image only uses calm land, water, green, and road tones.
+ */
+export declare const mapPalette: {
+    readonly light: {
+        readonly land: "#f1efe9";
+        readonly green: "#e3ecd9";
+        readonly water: "#cfe3f3";
+        readonly building: "#e8e5dd";
+        readonly road: "#ffffff";
+        readonly roadCasing: "#dcd8ce";
+        readonly motorway: "#f6c76b";
+        readonly motorwayCasing: "#d9a443";
+        readonly rail: "#c4bfb4";
+        readonly boundary: "#aea89c";
+        readonly label: "#52525b";
+        readonly labelStrong: "#27272a";
+        readonly waterLabel: "#3a6383";
+    };
+    readonly dark: {
+        readonly land: "#1a1f26";
+        readonly green: "#1c2a22";
+        readonly water: "#14283a";
+        readonly building: "#20262e";
+        readonly road: "#2c333d";
+        readonly roadCasing: "#222830";
+        readonly motorway: "#5d6470";
+        readonly motorwayCasing: "#444a54";
+        readonly rail: "#39404a";
+        readonly boundary: "#4f5763";
+        readonly label: "#a1a1aa";
+        readonly labelStrong: "#e4e4e7";
+        readonly waterLabel: "#8fb5d3";
+    };
+};

package/dist/types/content/map-style.d.ts

@@ -0,0 +1,29 @@
+import type { StyleSpecification } from "maplibre-gl";
+import { type MapTheme } from "./map-palette";
+export type MapStyleOptions = {
+    theme: MapTheme;
+    /** Request locale such as `de` or `de-DE`; labels prefer `name:<language>`. */
+    locale: string;
+    /** Vector tile template with `{z}`, `{x}`, and `{y}`, for example `/_geo/tiles/{z}/{x}/{y}.pbf`. */
+    tiles: string;
+    /** Glyph template with `{fontstack}` and `{range}`, served from `@k2b/ui/map-glyphs/*`. */
+    glyphs: string;
+    /** Highest zoom the tiles carry; the map scales the last level up beyond it. Defaults to 14. */
+    maxzoom?: number;
+};
+/** Attribution for OpenMapTiles-schema maps with OpenStreetMap data from Geoapify, in display order. */
+export declare const mapAttribution: readonly [{
+    readonly label: "© OpenStreetMap";
+    readonly href: "https://www.openstreetmap.org/copyright";
+}, {
+    readonly label: "© OpenMapTiles";
+    readonly href: "https://openmaptiles.org/";
+}, {
+    readonly label: "Geoapify";
+    readonly href: "https://www.geoapify.com/";
+}];
+/**
+ * A flat Cloud map style for OpenMapTiles-schema vector tiles. The host passes the tile and glyph
+ * templates; there are no network defaults, sprites, extrusions, or relief.
+ */
+export declare function mapStyle(options: MapStyleOptions): StyleSpecification;

package/dist/types/content/map-view-geometry.d.ts

@@ -0,0 +1,55 @@
+import type { MapViewFrameProps, MapViewLine, MapViewMarker, MapViewPoint } from "./map-view-types";
+export declare const MIN_SPAN: number;
+export declare const EARTH_CIRCUMFERENCE = 40075016.686;
+/** Room around the fitted geometry: clears the floating controls, the notice, the scale bar and the attribution. */
+export declare const DEFAULT_PADDING = 64;
+/**
+ * `referenceWidth` is the fitted width when the container is wide enough; `minWidth` keeps the whole world at least as
+ * tall as the map, the smallest zoom MapLibre allows, so a world-scale fit lands where MapLibre puts it.
+ */
+export type MapFrame = {
+    minX: number;
+    minY: number;
+    spanX: number;
+    spanY: number;
+    aspect: number;
+    referenceWidth: number;
+    minWidth: number;
+    /** The fitted width on a 320 px phone: pins are kept apart from this scale up, so they never cover each other there. */
+    overlapWidth: number;
+};
+export declare function decodePolyline6(encoded: string): MapViewPoint[];
+export declare const linePoints: (line: MapViewLine) => MapViewPoint[];
+export declare function projectPoint(point: MapViewPoint): {
+    x: number;
+    y: number;
+};
+export declare function unprojectPoint(x: number, y: number): MapViewPoint;
+export declare function mapFrame(geometry: Pick<MapViewFrameProps, "markers" | "lines" | "areas" | "ownLocation" | "fit">, height: number, padding?: number): MapFrame | null;
+export declare function fitCamera(frame: MapFrame, width: number, padding?: number): {
+    center: [number, number];
+    zoom: number;
+};
+export declare const isStop: (marker: MapViewMarker) => boolean;
+export declare function sortMarkers(markers: MapViewMarker[]): MapViewMarker[];
+type PinOffset = {
+    dx: number;
+    dy: number;
+};
+/**
+ * Pin offsets in px, decided from the data alone: at the phone fit and checked for every wider fit up to the widest
+ * one, so they hold at any width. `zoomFactor` is 2^(live zoom - fitted zoom): 1 for the server frame, the first client
+ * frame and the untouched live map, so all three agree; when the person zooms, separation is decided for the new scale.
+ */
+export declare function pinOffsets(sortedMarkers: MapViewMarker[], frame: MapFrame, zoomFactor?: number, ownLocation?: MapViewPoint): Map<string, PinOffset>;
+/**
+ * The touch hit radius of each pin in px: up to 22 px (a 44 px target), but never into a neighbour's visible mark
+ * (radius up to 14 px) at any width, so a tap on a visible pin always reaches it.
+ */
+export declare function pinHitRadii(sortedMarkers: MapViewMarker[], frame: MapFrame, offsets: Map<string, PinOffset>, zoomFactor?: number): Map<string, number>;
+export declare const metersPerPixel: (lat: number, zoom: number) => number;
+export declare function scaleBar(mpp: number, maxPx?: number): {
+    meters: number;
+    label: string;
+};
+export {};

package/dist/types/content/map-view-live.d.ts

@@ -0,0 +1,2 @@
+import { Map, type MapOptions } from "maplibre-gl";
+export declare function createMap(options: MapOptions): Map;

package/dist/types/content/map-view-messages.d.ts

@@ -0,0 +1,21 @@
+export declare const useMapViewMessages: () => () => {
+    mapLabel: string;
+    summary: ({ count }: {
+        count: number;
+    }) => string;
+    pins: string;
+    zoomIn: string;
+    zoomOut: string;
+    locate: string;
+    loading: string;
+    error: string;
+    retry: string;
+    reload: string;
+    noWebgl: string;
+    ownLocation: string;
+    canvasTitle: string;
+    gestureWindows: string;
+    gestureMac: string;
+    gestureMobile: string;
+};
+export declare const checkMapViewMessages: () => import("@k2b/stdlib").CatalogIssue[];

package/dist/types/content/map-view-types.d.ts

@@ -0,0 +1,61 @@
+import type { StyleSpecification } from "maplibre-gl";
+import type { JSX } from "solid-js";
+export type MapViewPoint = {
+    lat: number;
+    lon: number;
+};
+export type MapViewTone = "accent" | "second" | "neutral" | "warning";
+export type MapViewMarker = {
+    id: string;
+    point: MapViewPoint;
+    /** A number, a single letter, or "+". Omit for a drop pin. */
+    mark?: number | string;
+    label: string;
+    tone?: MapViewTone;
+    selected?: boolean;
+};
+export type MapViewLineTone = "accent" | "muted" | "preview" | "previous";
+export type MapViewLine = {
+    id: string;
+    tone?: MapViewLineTone;
+} & ({
+    polyline6: string;
+} | {
+    points: MapViewPoint[];
+});
+export type MapViewArea = {
+    id: string;
+    polygon: MapViewPoint[];
+    tone?: MapViewTone;
+};
+export type MapViewOwnLocation = {
+    point: MapViewPoint;
+    accuracyMeters?: number;
+};
+export type MapViewStyle = string | StyleSpecification;
+export type MapViewStyleSource = MapViewStyle | {
+    light: MapViewStyle;
+    dark: MapViewStyle;
+};
+export type MapViewFit = "all" | "markers";
+export type MapViewFrameProps = {
+    markers?: MapViewMarker[];
+    lines?: MapViewLine[];
+    areas?: MapViewArea[];
+    ownLocation?: MapViewOwnLocation;
+    height: number;
+    padding?: number;
+    fit?: MapViewFit;
+    selectedId?: string;
+    attribution?: JSX.Element;
+    class?: string;
+};
+export type MapViewProps = Omit<MapViewFrameProps, "attribution"> & {
+    style: MapViewStyleSource;
+    attribution: JSX.Element;
+    onSelect?: (id: string) => void;
+    infoTile?: (marker: MapViewMarker) => JSX.Element;
+    notice?: JSX.Element;
+    empty?: JSX.Element;
+    onLocate?: () => void;
+};