@notis_ai/cli 0.2.17 → 0.2.19

package/dist/space-sdk/src/ui/engine/registry.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The shortcut registry: owners, availability, clash checks and dispatch order. Pure (no DOM, no React), so it runs
+ * under node in tests and in the design check.
+ */
+import { type ChordSequence, type Clash, type KeySpec, type Locale } from '../../words';
+import type { HelpEntry, OwnerKind, ShortcutDef, ShortcutGroup } from './types';
+export declare const ROOT_OWNER = "notis";
+/** Thrown in dev and by the design check when two defs clash or a Space takes a host key. */
+export declare class NotisKeyClash extends Error {
+    readonly clash: Clash;
+    constructor(clash: Clash);
+}
+export interface RegisteredShortcut {
+    def: ShortcutDef;
+    owner: string;
+    ownerKind: OwnerKind;
+    /** Registration order; later wins within a scope. */
+    seq: number;
+    /** Scope order plus boost. */
+    rank: number;
+    /** Parsed alternatives. */
+    chords: ChordSequence[];
+}
+export interface RegistryOptions {
+    strict: boolean;
+    onClash?: (message: string) => void;
+}
+export interface DefineOwnerOptions {
+    parent?: string;
+    kind?: OwnerKind;
+    available?: boolean;
+}
+export declare class ShortcutRegistry {
+    private entries;
+    private owners;
+    private seq;
+    private version;
+    private listeners;
+    private warned;
+    options: RegistryOptions;
+    constructor(options?: Partial<RegistryOptions>);
+    subscribe(listener: () => void): () => void;
+    getVersion(): number;
+    notify(): void;
+    /** Declares a Space or a retained view. Ref counted: the last release removes it. */
+    defineOwner(id: string, options?: DefineOwnerOptions): () => void;
+    setOwnerAvailable(id: string, available: boolean): void;
+    private inheritedKind;
+    ownerKind(id: string): OwnerKind;
+    /** Available when it and every owner above it are available. Unknown owners count as available. */
+    isOwnerAvailable(id: string): boolean;
+    /**
+     * Registers a def. Returns an unregister function, or null when the def was dropped (production clash).
+     * Strict mode throws NotisKeyClash instead of dropping.
+     */
+    register(def: ShortcutDef, owner?: string): (() => void) | null;
+    private candidate;
+    private reject;
+    /** All registered entries, registration order. */
+    all(): readonly RegisteredShortcut[];
+    /**
+     * Entries that may answer a key now: owner available, `when` passing, highest rank first, latest first within a
+     * rank. `modalOnly` keeps only the modal scope (an open dialog or menu).
+     */
+    active(options?: {
+        modalOnly?: boolean;
+    }): RegisteredShortcut[];
+    /** Help sheet rows: available, not hidden, `when` passing, latest def per id. Space group first, then Notis. */
+    helpEntries(): HelpEntry[];
+    /** Labels for the help sheet in one language, for tests and text hosts. */
+    helpText(locale: Locale): Array<{
+        group: ShortcutGroup;
+        label: string;
+        keys: KeySpec[];
+    }>;
+}
+export declare function safeWhen(when: () => boolean): boolean;

package/dist/space-sdk/src/ui/engine/step.d.ts

@@ -0,0 +1,11 @@
+export interface StepOptions {
+    /** Wrap from the last item to the first (and back). Default true. */
+    wrap?: boolean;
+    /** The key is held (`event.repeat`): never wrap, stop at the edge. */
+    repeat?: boolean;
+}
+/**
+ * Next cursor id for J/K stepping. Wraps only on a fresh press, so holding J stops at the last row instead of
+ * spinning back to the top. No cursor: J lands on the first item, K on the last.
+ */
+export declare function stepCursor(ids: readonly string[], cursor: string | null | undefined, delta: number, options?: StepOptions): string | null;

package/dist/space-sdk/src/ui/engine/types.d.ts

@@ -0,0 +1,54 @@
+import type { KeySpec, Locale, Platform, Scope, Words } from '../../words';
+export type { KeySpec, Locale, Platform, Scope, Words };
+export type ShortcutGroup = 'space' | 'notis';
+export interface ShortcutDef {
+    /** Stable id: 'list.next', 'space:tickets.triage'. */
+    id: string;
+    /** One spec or alternatives. */
+    keys: KeySpec | KeySpec[];
+    scope: Scope;
+    label: Words;
+    /** Help sheet group. Default 'space' under a Space owner, 'notis' otherwise. */
+    group?: ShortcutGroup;
+    /** Extra gate, evaluated at dispatch (and when the help sheet opens). */
+    when?: () => boolean;
+    /** Fire on key repeat (a held key). Default false. */
+    repeat?: boolean;
+    /** Fire while focus is in a text field. Default false. */
+    allowInFields?: boolean;
+    /** Not listed in the help sheet. */
+    hidden?: boolean;
+    /**
+     * Added to the scope order (0 to 99). The selection bar registers its actions at `collection` with
+     * `boost: 25` while something is selected, so they win over row keys.
+     */
+    boost?: number;
+    /** Owner override. Default: the nearest `<ShortcutScope>` (or `useShortcutScope`) above, else 'notis'. */
+    owner?: string;
+    /** Return false when not handled: the engine keeps looking. */
+    run: (event: KeyboardEvent) => void | boolean;
+}
+export type OwnerKind = 'space' | 'host';
+export interface ScopeHandle {
+    owner: string;
+    available: boolean;
+    isAvailable(): boolean;
+}
+export type EngineHost = 'portal' | 'preview';
+export interface EngineSettings {
+    host: EngineHost;
+    locale: Locale;
+    platform: Platform;
+    /** Dev and design check: clashes throw. Production: the later def is dropped and logged once. */
+    strict: boolean;
+    /** Production clash log (telemetry). Default console.warn, once per message. */
+    onClash?: (message: string) => void;
+}
+export interface HelpEntry {
+    id: string;
+    keys: KeySpec[];
+    label: Words;
+    group: ShortcutGroup;
+    scope: Scope;
+    owner: string;
+}

package/dist/space-sdk/src/ui/fields/fieldWords.d.ts

@@ -0,0 +1,56 @@
+/** Words of the editable fields (EN/FR). Kept with the fields until they move into `src/words`. */
+export declare const FIELD_WORDS: Readonly<{
+    save: {
+        en: string;
+        fr: string;
+    };
+    saving: {
+        en: string;
+        fr: string;
+    };
+    cancel: {
+        en: string;
+        fr: string;
+    };
+    unsaved: {
+        en: string;
+        fr: string;
+    };
+    changed: {
+        en: string;
+        fr: string;
+    };
+    empty: {
+        en: string;
+        fr: string;
+    };
+    choose: {
+        en: string;
+        fr: string;
+    };
+    edit: {
+        en: string;
+        fr: string;
+    };
+    done: {
+        en: string;
+        fr: string;
+    };
+    saveFailed: {
+        en: string;
+        fr: string;
+    };
+    /** A multi-select's search: the entry that adds the typed text, and the line when nothing matches it. */
+    add: {
+        en: string;
+        fr: string;
+    };
+    noMatch: {
+        en: string;
+        fr: string;
+    };
+    addFailed: {
+        en: string;
+        fr: string;
+    };
+}>;

package/dist/space-sdk/src/ui/fields/fields.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Editable fields: facts that edit in place. A form is an `EditableFields` around `FieldRow`s; each row holds a
+ * control (`FieldText`, `FieldLongText`, `FieldSelect`, `FieldMultiSelect`, `FieldDisclosure`) or any custom node
+ * (a slot). The caller owns the values and the dirty state; once something changed the form shows Save and Cancel.
+ * `FieldList` lays rows out the same way without the form (facts that save on their own, a read-only sheet).
+ * Styled by the fields section of toolkit.css.
+ *
+ * Keys: Cmd/Ctrl+Enter saves (also from inside a field); Escape in a field leaves the field, Escape again cancels
+ * (an escape layer above the reader and the selection, so unsaved edits go before the reader closes).
+ *
+ * A save that throws or rejects keeps the draft (the form never resets it) and shows a polite status line in the bar
+ * until the next save, a cancel or a clean form. Save shows Saving while the returned promise runs.
+ *
+ * The bar is sticky at the bottom. Only while it sits in the corner of the floating Notis button (bottom right of the
+ * window, from the host's --notis-fab-safe-* vars) does it keep Save clear of the button (data-fab).
+ */
+import { type ReactNode } from 'react';
+import { type Words } from '../../words';
+type Text = Words | string;
+/** Escape cancels unsaved edits before the selection clears and the reader closes. */
+export declare const FIELDS_ESCAPE_PRIORITY: number;
+export declare const FIELDS_SAVE_KEYS = "mod+enter";
+export interface EditableFieldsProps {
+    /** Something differs from the saved values: shows Save and Cancel and arms the keys. */
+    dirty: boolean;
+    saving?: boolean;
+    /** Save stays visible but cannot run (a required value is missing). */
+    saveDisabled?: boolean;
+    /** A rejection (or a throw) keeps the draft and shows FIELD_WORDS.saveFailed, unless `error` says more. */
+    onSave: () => void | Promise<unknown>;
+    onCancel: () => void;
+    /** Shown in the bar, above the buttons (a validation or save error), as a polite status line. */
+    error?: ReactNode;
+    /** Accessible name of the form. */
+    label?: Text;
+    /** Under the rows, above the bar (a section the caller draws). */
+    footer?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+export declare function EditableFields({ dirty, saving, saveDisabled, onSave, onCancel, error, label, footer, children, className, }: EditableFieldsProps): import("react").JSX.Element;
+export interface FieldListProps {
+    /** Accessible name of the rows (a group); leave it out when a heading next to them already names them. */
+    label?: Text;
+    /**
+     * A form a visitor fills in from empty (a signup on a Site): each label sits above its field and every input shows
+     * its box at rest, so an empty field never reads as a value.
+     */
+    filled?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * `FieldRow`s laid out as in a form, without Save and Cancel: facts that save on their own (a select that applies at
+ * once) or a read-only sheet. The rows take the same columns and the same narrow-width stacking as in a form.
+ */
+export declare function FieldList({ label, filled, children, className }: FieldListProps): import("react").JSX.Element;
+export interface FieldRowProps {
+    label: Text;
+    /** One muted line under the value. The control in the row is described by it (aria-describedby). */
+    hint?: ReactNode;
+    /** Label above the value at every width (long text). */
+    stacked?: boolean;
+    /** Marks a value that differs from the saved one. */
+    changed?: boolean;
+    /**
+     * The value is wrong: the hint reads as the error (destructive text) and a text control in the row is marked
+     * aria-invalid. Put what is wrong in `hint`.
+     */
+    invalid?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+export declare function FieldRow({ label, hint, stacked, changed, invalid, children, className }: FieldRowProps): import("react").JSX.Element;
+export interface FieldTextProps {
+    value: string;
+    onChange: (value: string) => void;
+    /** Accessible name (the row label). */
+    label: Text;
+    placeholder?: Text;
+    readOnly?: boolean;
+    /** 'title' for the name at the top of a reader. */
+    size?: 'default' | 'title';
+    maxLength?: number;
+    /** The value is wrong (aria-invalid). Default: the row's `invalid`. */
+    invalid?: boolean;
+    /** Ids of what describes the field (aria-describedby). Default: the row's hint. */
+    describedBy?: string;
+    className?: string;
+}
+export declare function FieldText({ value, onChange, label, placeholder, readOnly, size, maxLength, invalid, describedBy, className, }: FieldTextProps): import("react").JSX.Element;
+export interface FieldLongTextProps extends Omit<FieldTextProps, 'size'> {
+    /**
+     * Height in lines where the browser cannot fit the box to its text (no `field-sizing`); default 4. Elsewhere the box
+     * fits its text, one line at least.
+     */
+    rows?: number;
+}
+export declare function FieldLongText({ value, onChange, label, placeholder, readOnly, maxLength, rows, invalid, describedBy, className, }: FieldLongTextProps): import("react").JSX.Element;
+export interface FieldOption<V extends string> {
+    value: V;
+    label: Text;
+    icon?: ReactNode | string;
+    /** Muted words after the label (a cost, a short explanation). */
+    hint?: Text;
+    disabled?: boolean;
+}
+export interface FieldSelectProps<V extends string> {
+    value: V | null;
+    options: readonly FieldOption<V>[];
+    onChange: (value: V) => void;
+    /** Accessible name of the button and its menu. */
+    label: Text;
+    /** Shown when no option matches `value`. */
+    placeholder?: Text;
+    readOnly?: boolean;
+    /** Shown above the options (an upgrade note). */
+    menuHeader?: ReactNode;
+    className?: string;
+}
+export declare function FieldSelect<V extends string>({ value, options, onChange, label, placeholder, readOnly, menuHeader, className, }: FieldSelectProps<V>): import("react").JSX.Element;
+export interface FieldMultiSelectProps<V extends string> {
+    values: readonly V[];
+    options: readonly FieldOption<V>[];
+    /** Called with the next values, in the options' order. */
+    onChange: (values: V[]) => void;
+    label: Text;
+    placeholder?: Text;
+    /** The last value cannot be removed; `onNeedOne` runs instead. */
+    minOne?: boolean;
+    onNeedOne?: () => void;
+    readOnly?: boolean;
+    /** A search box above the options, for long lists (case and accents ignored). Implied by `onAdd`. */
+    searchable?: boolean;
+    /**
+     * Offers to add the typed text as a new option (Add "text") when no option is named exactly that. Return the new
+     * option's value to select it, and add the option to `options`. A rejection keeps the typed text and says it failed.
+     */
+    onAdd?: (text: string) => V | void | Promise<V | void>;
+    className?: string;
+}
+/** Applies a toggle of `value` (pure, for the control and its tests). */
+export declare function toggleFieldValue<V extends string>(values: readonly V[], value: V, order: readonly V[], minOne?: boolean): V[] | null;
+export declare function FieldMultiSelect<V extends string>({ values, options, onChange, label, placeholder, minOne, onNeedOne, readOnly, searchable, onAdd, className, }: FieldMultiSelectProps<V>): import("react").JSX.Element;
+export interface FieldDisclosureProps {
+    /**
+     * The value as words (shown closed, and on the button while open). A long one (a long day, a schedule) wraps
+     * in a narrow reader instead of losing its end.
+     */
+    summary: ReactNode;
+    /** Accessible name of the button. */
+    label: Text;
+    /** The editor, shown under the summary while open. */
+    children: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    readOnly?: boolean;
+    className?: string;
+}
+export declare function FieldDisclosure({ summary, label, children, open, defaultOpen, onOpenChange, readOnly, className, }: FieldDisclosureProps): import("react").JSX.Element;
+export {};

package/dist/space-sdk/src/ui/fields/index.d.ts

@@ -0,0 +1,5 @@
+export { EditableFields, FIELDS_ESCAPE_PRIORITY, FIELDS_SAVE_KEYS, FieldDisclosure, FieldList, FieldLongText, FieldMultiSelect, FieldRow, FieldSelect, FieldText, toggleFieldValue, } from './fields';
+export type { EditableFieldsProps, FieldDisclosureProps, FieldListProps, FieldLongTextProps, FieldMultiSelectProps, FieldOption, FieldRowProps, FieldSelectProps, FieldTextProps, } from './fields';
+export { FIELD_WORDS } from './fieldWords';
+export { changedFieldKeys, useFieldDraft } from './useFieldDraft';
+export type { FieldDraft } from './useFieldDraft';

package/dist/space-sdk/src/ui/fields/useFieldDraft.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A draft of a record for `EditableFields`: edits stay local until Save, Cancel goes back to the saved values, and a
+ * new saved record (after a save or a refresh) moves under the draft: fields the user edited keep their edits, every
+ * other field takes the new saved value.
+ */
+/** Keys whose values differ (compared as JSON, so arrays and plain objects compare by content). */
+export declare function changedFieldKeys<T extends object>(saved: T, draft: T): Array<keyof T>;
+/**
+ * The draft drawn from `previousSaved`, moved onto `saved`: the fields edited since `previousSaved` keep their edits,
+ * the others take the new saved values, and a field the saved record no longer has (a removed entry) is dropped.
+ */
+export declare function rebaseFieldDraft<T extends object>(previousSaved: T, draft: T, saved: T): T;
+export interface FieldDraft<T extends object> {
+    draft: T;
+    set: <K extends keyof T>(key: K, value: T[K]) => void;
+    patch: (values: Partial<T>) => void;
+    dirty: boolean;
+    changed: (key: keyof T) => boolean;
+    /** Back to the saved values. */
+    reset: () => void;
+}
+export declare function useFieldDraft<T extends object>(saved: T): FieldDraft<T>;

package/dist/space-sdk/src/ui/gallery/AttachmentGallery.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The attachment row of Notis conversations: 140px cards (image thumbnail or file icon, name, extension) in a
+ * horizontal snap scroller with edge fades. Images open the ImageViewer on the gallery's images; other files open in
+ * a new tab unless `onOpen` or `renderOpener` takes them.
+ */
+import { type ReactNode } from 'react';
+import { type Words } from '../../words';
+import { type GalleryNoticeTone, type ImageViewerImage } from './ImageViewer';
+export type GalleryItemKind = 'image' | 'video' | 'audio' | 'pdf' | 'file';
+export interface GalleryItem {
+    url?: string | null;
+    /** File name shown under the thumbnail. Default `file.<extension>`. */
+    name?: string | null;
+    /** MIME type, used to tell images from other files. */
+    type?: string | null;
+    /** Extension without the dot; shown as the badge. Default: taken from the name. */
+    extension?: string | null;
+    size?: number | null;
+    /** Overrides the kind found from `type` and `extension`. */
+    kind?: GalleryItemKind;
+    /** The card icon for non-images: an icon name or a node. Default: by kind. */
+    icon?: ReactNode | string;
+    /** A smaller picture for the image card. Default: `url`. */
+    thumbnailUrl?: string | null;
+}
+export interface GalleryOpenerProps {
+    /** The card class; put it on the element that opens the item. */
+    className: string;
+    /** The card content (thumbnail, name, badge). */
+    children: ReactNode;
+    index: number;
+}
+export interface AttachmentGalleryProps<T extends GalleryItem = GalleryItem> {
+    items: readonly T[];
+    /** Accessible name of the row. Default "Attachments". */
+    label?: Words | string;
+    className?: string;
+    /** Opens a non-image item. Default: its url in a new tab. */
+    onOpen?: (item: T, index: number) => void;
+    /** Renders a custom opener for an item (a preview pill); return undefined to keep the default button. */
+    renderOpener?: (item: T, props: GalleryOpenerProps) => ReactNode | undefined;
+    /** A small button in the card's top right corner (for example share). */
+    itemAction?: (item: T, index: number) => ReactNode;
+    /** Extra buttons in the image viewer's control bar. */
+    viewerActions?: (image: ImageViewerImage, index: number) => ReactNode;
+    /** Copy and download outcomes from the image viewer. */
+    onNotice?: (tone: GalleryNoticeTone, text: string) => void;
+}
+/** The kind of an attachment, from its MIME type and extension (a webm voice note is audio). */
+export declare function galleryItemKind(item: GalleryItem): GalleryItemKind;
+/** The name a card shows. */
+export declare function galleryItemName(item: GalleryItem): string;
+export declare function AttachmentGallery<T extends GalleryItem = GalleryItem>({ items, label, className, onOpen, renderOpener, itemAction, viewerActions, onNotice, }: AttachmentGalleryProps<T>): import("react").JSX.Element | null;

package/dist/space-sdk/src/ui/gallery/ImageViewer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Full-screen image viewer (the Portal's attachment lightbox): zoom (buttons, wheel, + - 0), drag to pan, arrows
+ * between images, download, copy link, Escape or a backdrop click to close. Modal: focus moves in, Tab stays inside,
+ * and focus returns on close.
+ */
+import { type ReactNode } from 'react';
+export interface ImageViewerImage {
+    src: string;
+    /** Alt text, also the download file name. */
+    alt?: string;
+}
+export type GalleryNoticeTone = 'success' | 'error';
+export interface ImageViewerProps {
+    images: readonly ImageViewerImage[];
+    /** The image shown first. Default 0. */
+    initialIndex?: number;
+    onClose: () => void;
+    /** Where the viewer mounts. Default: the pinned layer root, else the page body (inside a Space: its layer root). */
+    container?: Element | DocumentFragment | null;
+    /** Extra buttons placed first in the control bar for the current image (for example a share button). */
+    actions?: (image: ImageViewerImage, index: number) => ReactNode;
+    /** Reports copy and download outcomes (a toast). The copy button also shows a check for a moment. */
+    onNotice?: (tone: GalleryNoticeTone, text: string) => void;
+    className?: string;
+}
+export declare const IMAGE_VIEWER_ZOOM_LEVELS: readonly number[];
+export declare function ImageViewer({ container, ...props }: ImageViewerProps): import("react").JSX.Element | null;

package/dist/space-sdk/src/ui/gallery/galleryWords.d.ts

@@ -0,0 +1,95 @@
+/** EN/FR words of the attachment gallery and the image viewer. */
+export declare const GALLERY_WORDS: Readonly<{
+    attachments: {
+        en: string;
+        fr: string;
+    };
+    open: {
+        en: string;
+        fr: string;
+    };
+    scrollBack: {
+        en: string;
+        fr: string;
+    };
+    scrollForward: {
+        en: string;
+        fr: string;
+    };
+    viewer: {
+        en: string;
+        fr: string;
+    };
+    previous: {
+        en: string;
+        fr: string;
+    };
+    previousHint: {
+        en: string;
+        fr: string;
+    };
+    next: {
+        en: string;
+        fr: string;
+    };
+    nextHint: {
+        en: string;
+        fr: string;
+    };
+    counter: {
+        en: string;
+        fr: string;
+    };
+    zoomIn: {
+        en: string;
+        fr: string;
+    };
+    zoomInHint: {
+        en: string;
+        fr: string;
+    };
+    zoomOut: {
+        en: string;
+        fr: string;
+    };
+    zoomOutHint: {
+        en: string;
+        fr: string;
+    };
+    resetZoom: {
+        en: string;
+        fr: string;
+    };
+    fit: {
+        en: string;
+        fr: string;
+    };
+    download: {
+        en: string;
+        fr: string;
+    };
+    copyLink: {
+        en: string;
+        fr: string;
+    };
+    linkCopied: {
+        en: string;
+        fr: string;
+    };
+    copyFailed: {
+        en: string;
+        fr: string;
+    };
+    downloadFailed: {
+        en: string;
+        fr: string;
+    };
+    close: {
+        en: string;
+        fr: string;
+    };
+    closeHint: {
+        en: string;
+        fr: string;
+    };
+}>;

package/dist/space-sdk/src/ui/gallery/index.d.ts

@@ -0,0 +1,5 @@
+export { AttachmentGallery, galleryItemKind, galleryItemName } from './AttachmentGallery';
+export type { AttachmentGalleryProps, GalleryItem, GalleryItemKind, GalleryOpenerProps } from './AttachmentGallery';
+export { IMAGE_VIEWER_ZOOM_LEVELS, ImageViewer } from './ImageViewer';
+export type { GalleryNoticeTone, ImageViewerImage, ImageViewerProps } from './ImageViewer';
+export { GALLERY_WORDS } from './galleryWords';

package/dist/space-sdk/src/ui/icons.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The toolkit's built-in icons: a small inline SVG set under the Phosphor names the action catalogue uses, so the
+ * toolkit has no icon dependency. Every `icon` prop also takes any ReactNode (a Phosphor component, for example).
+ */
+import React, { type ReactNode } from 'react';
+export declare function hasIcon(name: string): boolean;
+/** A built-in icon by name; an unknown name renders nothing. Decorative: the control carries the label. */
+export declare function Icon({ name, className }: {
+    name: string;
+    className?: string;
+}): React.JSX.Element | null;
+/** Renders an `icon` prop: a name from the set, or any node the caller passes. */
+export declare function renderIcon(icon: ReactNode | string | undefined, className?: string): ReactNode;

package/dist/space-sdk/src/ui/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @notis/sdk/ui - the Notis toolkit.
+ *
+ * Host-provided: a Space bundle never contains this code. Its build
+ * externalizes `@notis/sdk/ui` and the host shares its own instance as
+ * `window.__NotisSDKUI` (see ../runtimeModules.ts). Toolkit modules append
+ * their export lines below.
+ */
+export {};
+export * from './layout';
+export * from './engine';
+export * from './keycap';
+export * from './overlay';
+export * from './list';
+export * from './board';
+export * from './actions';
+export * from './open';
+export * from './blocks';
+export * from './gallery';
+export { Icon, hasIcon, renderIcon } from './icons';
+export { adoptToolkitStyles, getToolkitStyleSheet, getToolkitStyleText, registerToolkitStyles } from './styles';
+export { COMPARES, DEFAULT_COMPARE, DEFAULT_PRESET, PRESETS, compareRange, customPeriod, dayCount, formatPeriodParam, fromIsoDay, isCompareId, isPresetId, normalizePeriod, parsePeriodParam, periodRanges, presetRange, samePeriod, toIsoDay, } from './period/periods';
+export type { CompareId, DateRange as PeriodRange, Period, PresetId } from './period/periods';
+export { dayNumberLabel, formatDateRange, formatDayHeading, formatDelta, formatLongDay, formatMonthYear, formatNumber, formatShortDay, formatValue, intlLocale, weekdayNames, } from './period/dateFormat';
+export type { Delta, DeltaTone } from './period/dateFormat';
+export { CALENDAR_WORDS, CHART_WORDS, COMPARE_WORDS, PERIOD_WORDS, PRESET_WORDS, TIMELINE_WORDS, VS_WORDS, } from './period/dateWords';
+export { usePeriod } from './period/usePeriod';
+export type { UsePeriodOptions, UsePeriodResult } from './period/usePeriod';
+export { PERIOD_PICKER_TWO_MONTHS_MIN, PeriodPicker } from './period/PeriodPicker';
+export type { PeriodPickerProps } from './period/PeriodPicker';
+export { DayPicker } from './calendar/DayPicker';
+export type { DateRange, DayPickerProps, Matcher } from './calendar/DayPicker';
+export { CALENDAR_NARROW_MAX, CALENDAR_TRAY_SIDE_MIN, CalendarView } from './calendar/CalendarView';
+export type { CalendarItemVariant, CalendarViewProps } from './calendar/CalendarView';
+export { CALENDAR_VIEWS } from './calendar/calendarMath';
+export type { CalendarViewKind } from './calendar/calendarMath';
+export { TIMELINE_ZOOMS, layoutTimeline, timelineWindow } from './timeline/timelineMath';
+export type { TimelineLaneInfo, TimelineWindow, TimelineZoom } from './timeline/timelineMath';
+export { TimelineView } from './timeline/TimelineView';
+export type { TimelineViewProps } from './timeline/TimelineView';
+export { Chart, ChartContainer, ChartLegend, ChartStyle, ChartTooltip, ChartTooltipContent, barLabel, barShape, seriesColor, useChart, } from './charts/Chart';
+export type { ChartConfig, ChartContainerProps, ChartKind, ChartLegendItem, ChartLegendProps, ChartProps, ChartSeries, ChartTooltipContentProps, } from './charts/Chart';
+export { buildBins, binUnit, periodSeries, sparkPaths, total } from './charts/chartData';
+export type { Bin, BinUnit, DatedPoint, PeriodChartRow, PeriodSeriesInput } from './charts/chartData';
+export { StatRow, metricView } from './charts/StatRow';
+export type { StatMetric, StatRowProps } from './charts/StatRow';
+export { ChartTable, Sparkline } from './charts/ChartTable';
+export type { ChartTableProps, SparklineProps } from './charts/ChartTable';
+export { RenderChartData } from './charts/RenderChartData';
+export type { RenderChartDataProps } from './charts/RenderChartData';
+export { Area, AreaChart, Bar, BarChart, CartesianGrid, Cell, ComposedChart, LabelList, Legend, Line, LineChart, Pie, PieChart, ReferenceDot, ReferenceLine, ResponsiveContainer, Scatter, XAxis, YAxis, } from './charts/Chart';
+export * from './fields';
+export * from './comments';
+export * from './present';

package/dist/space-sdk/src/ui/keycap/Keycap.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Keycap (toolkit spec 2.2): how a shortcut reads on screen, the same on every Notis surface. Caps are aria-hidden;
+ * screen readers get the spelled-out words ("Command A", "G then I").
+ */
+import { type ReactNode } from 'react';
+import { type KeySpec } from '../../words';
+import type { KeycapOn } from '../engine/keycapContext';
+export type { KeycapOn };
+export interface KeycapProps {
+    keys: KeySpec | readonly KeySpec[];
+    /** Surface the caps sit on. Default from the nearest `KeycapSurface`, else 'surface'. */
+    on?: KeycapOn;
+    className?: string;
+}
+export declare function Keycap({ keys, on, className }: KeycapProps): import("react").JSX.Element | null;
+/** Sets the default `on` of every Keycap below (SelectionBar: pill, menus and the help sheet: discreet). */
+export declare function KeycapSurface({ on, children }: {
+    on: KeycapOn;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+/** The shortcut as text in the toolkit locale and platform ("⇧E", "Ctrl+A", "G then I"), for tooltips and titles. */
+export declare function useKeyLabel(keys: KeySpec | readonly KeySpec[]): string;