@notis_ai/cli 0.2.17 → 0.2.19

package/dist/space-sdk/src/ui/overlay/Menu.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Menu (toolkit spec 2.8): a trigger and a list of items that opens in the layer root, so inside a Space it renders
+ * in the Space shadow root and picks up the adopted toolkit sheet.
+ *
+ * Keys while open: arrows, Home, End, Enter and Space move and choose; Right opens a submenu, Left closes it; an
+ * item's `keys` choose it; a letter jumps to the next item starting with it. Escape closes through the engine's
+ * escape chain (overlay layer). Focus sits in the menu, so the engine's typing rule keeps page keys silent.
+ *
+ * Keys while closed: an item's `keys` still choose it while the trigger shows (menu accelerators, registered with the
+ * engine and hidden from the help sheet). See `MenuProps.accelerators`.
+ */
+import React, { type MouseEvent as ReactMouseEvent, type ReactElement, type ReactNode } from 'react';
+import { type KeySpec, type Words } from '../../words';
+import type { Align, Side } from './position';
+export interface MenuProps {
+    /**
+     * The element that opens the menu (usually a button). Its own props and ref are kept. Leave it out and pass
+     * `anchor` with a controlled `open` to open the menu at an element the caller already draws.
+     */
+    trigger?: ReactElement;
+    /**
+     * Without a trigger: the element the menu opens at (and gives focus back to). The menu then focuses its first
+     * item when it opens, as after a keyboard open.
+     */
+    anchor?: HTMLElement | null | React.RefObject<HTMLElement | null>;
+    children: ReactNode;
+    align?: Align;
+    side?: Side;
+    /** Accessible name of the menu. */
+    label?: Words | string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    /**
+     * Default true: while the menu is closed and its trigger (or anchor) shows and is enabled, an item's `keys` choose
+     * it, and its `onSelect` runs without an event. On the page they answer at route scope; inside a dialog at modal
+     * scope, while focus is in that dialog and no other menu is open. They come last: any other shortcut on the same
+     * key goes first, and so does a key sequence that starts with it. They are not listed in the help sheet: the menu
+     * shows them. Left out: sequence keys ('g i'), keys Notis keeps for itself in a Space, items of a disabled
+     * submenu and items your own component draws (only `Menu.Item` written in the menu's children, fragments and
+     * `Menu.Sub` included, is read). Pass false for a menu drawn once per row or card, or one whose keys a list or
+     * selection bar already handles.
+     */
+    accelerators?: boolean;
+}
+export interface MenuController {
+    close(): void;
+    isOpen: boolean;
+}
+/** Inside a menu: close it from a custom item. */
+export declare function useMenu(): MenuController;
+declare function MenuRoot({ trigger, anchor, children, align, side, label, open: controlledOpen, onOpenChange, className, accelerators }: MenuProps): React.JSX.Element;
+export interface MenuItemProps {
+    children: ReactNode;
+    icon?: ReactNode | string;
+    /**
+     * Shown as a discreet keycap; chooses the item while the menu is open, and while it is closed and its trigger
+     * shows (see `MenuProps.accelerators`).
+     */
+    keys?: KeySpec | KeySpec[];
+    tone?: 'default' | 'danger';
+    /** The click, or no event when the item's key chose it while the menu was closed. */
+    onSelect?: (event?: ReactMouseEvent<HTMLButtonElement>) => void;
+    /** A check item: shows a check when true. */
+    checked?: boolean;
+    disabled?: boolean;
+    /** Default true. */
+    closeOnSelect?: boolean;
+    className?: string;
+}
+declare function MenuItem({ children, icon, keys, tone, onSelect, checked, disabled, closeOnSelect, className }: MenuItemProps): React.JSX.Element;
+declare function MenuSeparator(): React.JSX.Element;
+export interface MenuSubProps {
+    label: ReactNode;
+    icon?: ReactNode | string;
+    disabled?: boolean;
+    children: ReactNode;
+    /** Accessible name of the submenu; default its label when the label is text. */
+    menuLabel?: Words | string;
+}
+declare function MenuSub({ label, icon, disabled, children, menuLabel }: MenuSubProps): React.JSX.Element | null;
+type MenuComponent = typeof MenuRoot & {
+    Item: typeof MenuItem;
+    Separator: typeof MenuSeparator;
+    Sub: typeof MenuSub;
+};
+export declare const Menu: MenuComponent;
+export { MenuItem, MenuSeparator, MenuSub };

package/dist/space-sdk/src/ui/overlay/Popover.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Popover (toolkit spec 2.8): a trigger and a floating panel in the layer root (inside the Space shadow root).
+ * Closes on a press outside and on Escape (the engine's escape chain). `modal` traps Tab and isolates page keys
+ * to the modal scope (aria-modal); a non-modal popover leaves page keys alone.
+ */
+import React, { type ReactElement, type ReactNode } from 'react';
+import type { Words } from '../../words';
+import type { Align, Side } from './position';
+export interface PopoverController {
+    close(): void;
+}
+export interface PopoverProps {
+    trigger: ReactElement;
+    /** The panel content, or a function that receives `close`. */
+    content: ReactNode | ((controller: PopoverController) => ReactNode);
+    side?: Side;
+    align?: Align;
+    /** Traps Tab and isolates page keys while open. Default false. */
+    modal?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Accessible name of the panel. */
+    label?: Words | string;
+    className?: string;
+    /** Focus the first focusable element on open (default true); else the panel itself. */
+    autoFocus?: boolean;
+}
+export declare function Popover({ trigger, content, side, align, modal, open: controlledOpen, onOpenChange, label, className, autoFocus }: PopoverProps): React.JSX.Element;

package/dist/space-sdk/src/ui/overlay/Tooltip.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tooltip (toolkit spec 2.8): a label and an optional shortcut on a black pill, the Manager's tooltip. Shows after
+ * 500ms of hover or at once on keyboard focus; hides on leave, blur, a press or any key. Never takes focus.
+ */
+import React, { type ReactElement } from 'react';
+import type { KeySpec, Words } from '../../words';
+import type { Align, Side } from './position';
+export interface TooltipProps {
+    label: Words | string;
+    keys?: KeySpec | KeySpec[];
+    side?: Side;
+    align?: Align;
+    /** Hover delay in ms. Default 500. */
+    delay?: number;
+    /** One focusable element. */
+    children: ReactElement;
+    disabled?: boolean;
+}
+export declare function Tooltip({ label, keys, side, align, delay, children, disabled }: TooltipProps): React.JSX.Element;

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

@@ -0,0 +1,9 @@
+export { Menu, MenuItem, MenuSeparator, MenuSub, useMenu } from './Menu';
+export type { MenuController, MenuItemProps, MenuProps, MenuSubProps } from './Menu';
+export { Popover } from './Popover';
+export type { PopoverController, PopoverProps } from './Popover';
+export { Tooltip } from './Tooltip';
+export type { TooltipProps } from './Tooltip';
+export { LAYER_ROOT_ATTRIBUTE, LayerRootProvider, findLayerRoot, useLayerRoot } from './layerRoot';
+export { place } from './position';
+export type { Align, Side } from './position';

package/dist/space-sdk/src/ui/overlay/layerRoot.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Where overlays (Menu, Popover, Tooltip) render (toolkit spec 1.4.8): the nearest element with the layer-root
+ * attribute inside the current shadow root, so they open inside the Space and pick up its adopted toolkit sheet and
+ * theme; in the Portal document, the page body.
+ *
+ * A shadow root without a host layer root gets one, created inside the app root (which carries the theme and the
+ * Portal token snapshot) or, without it, at the end of the shadow root.
+ */
+import React, { type ReactNode } from 'react';
+export declare const LAYER_ROOT_ATTRIBUTE = "data-notis-layer-root";
+/** Pins the layer root for a subtree (a host that renders its own overlay container). */
+export declare function LayerRootProvider({ root, children }: {
+    root: HTMLElement | null;
+    children?: ReactNode;
+}): React.JSX.Element;
+/** The layer root for overlays opened from `from` (usually the trigger element). */
+export declare function findLayerRoot(from: Node | null | undefined): HTMLElement | null;
+/**
+ * The layer root: the pinned one from LayerRootProvider, else found from `anchor` (an element inside the view),
+ * else the page body.
+ */
+export declare function useLayerRoot(anchor?: Element | null): HTMLElement | null;
+/** The pinned layer root only (overlays fall back to findLayerRoot from their trigger). */
+export declare function usePinnedLayerRoot(): HTMLElement | null;

package/dist/space-sdk/src/ui/overlay/position.d.ts

@@ -0,0 +1,31 @@
+/** Placement of a floating panel next to its anchor (pure). Flips to the other side when it does not fit. */
+export type Side = 'bottom' | 'top' | 'right' | 'left';
+export type Align = 'start' | 'center' | 'end';
+export interface RectLike {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+export interface PlaceOptions {
+    side?: Side;
+    align?: Align;
+    offset?: number;
+    /** Keeps this far from the viewport edges. */
+    margin?: number;
+    viewport: {
+        width: number;
+        height: number;
+    };
+}
+export interface Placement {
+    top: number;
+    left: number;
+    side: Side;
+}
+export declare function place(anchor: RectLike, size: {
+    width: number;
+    height: number;
+}, options: PlaceOptions): Placement;

package/dist/space-sdk/src/ui/period/PeriodPicker.d.ts

@@ -0,0 +1,30 @@
+/**
+ * PeriodPicker (toolkit spec 2.11, deck round 6 "period picker, like Stripe"): two triggers. The first picks a preset
+ * (Today ... This year) or a custom range on the DayPicker with Apply and Cancel; the second picks what to compare it
+ * with. Pair it with `usePeriod` so the period lives in the URL.
+ *
+ * Inside a menu the arrows move between options and days and Escape closes it (the engine's escape chain). The picker
+ * registers no page keys.
+ */
+import * as React from 'react';
+import { type Locale } from '../../words/types';
+import { type Period, type PresetId } from './periods';
+export interface PeriodPickerProps {
+    value: Period;
+    onChange: (period: Period) => void;
+    /** Shows the "Compare to" trigger. Default true. */
+    compare?: boolean;
+    /**
+     * Presets offered, in order. Default every preset. `custom` adds the custom range: its entry and the calendar to
+     * pick days in. Leave it out for presets only (no calendar).
+     */
+    presets?: readonly PresetId[];
+    locale?: Locale;
+    className?: string;
+}
+/** Below this width the range menu stacks the presets over one month (deck `data-one`). */
+export declare const PERIOD_PICKER_TWO_MONTHS_MIN = 700;
+export declare function PeriodPicker({ value, onChange, compare, presets, locale: localeProp, className }: PeriodPickerProps): React.JSX.Element;
+export declare namespace PeriodPicker {
+    var displayName: string;
+}

package/dist/space-sdk/src/ui/period/dateFormat.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Locale-aware dates and numbers for the period, calendar, timeline and chart pieces. Pure: Intl only.
+ * `en` formats as en-US (the Portal's English), `fr` as fr-FR.
+ */
+import { type Locale } from '../../words/types';
+import type { DateRange } from './periods';
+/** The `Intl` locale tag for a toolkit locale (fr-FR or en-US), for Space code that formats with `Intl` itself. */
+export declare function intlLocale(locale: Locale): string;
+/** A cached `Intl.DateTimeFormat` for a toolkit locale and options. */
+export declare function dateFormat(locale: Locale, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+/** The text with its first letter upper case ("lundi" reads "Lundi"). */
+export declare function upFirst(text: string): string;
+/**
+ * A date range in words, never a dash: "May 17 to Jun 15, 2026" / "17 mai au 15 juin 2026". A month or year both days
+ * share shows once ("Oct 1 to 15, 2026" / "1er au 15 oct. 2026"). One day reads as that day.
+ */
+export declare function formatDateRange(range: DateRange, locale: Locale, options?: Intl.DateTimeFormatOptions): string;
+/** One day, long: "Monday, January 5, 2026" / "Lundi 5 janvier 2026". */
+export declare function formatLongDay(date: Date, locale: Locale): string;
+/**
+ * A day heading (the agenda, meeting days): "Monday, October 19" / "Lundi 19 octobre", with the year when it is not
+ * `thisYear` ("Friday, January 1, 2027").
+ */
+export declare function formatDayHeading(date: Date, locale: Locale, thisYear?: number): string;
+/** One day, short: "Jan 5" / "5 janv.". */
+export declare function formatShortDay(date: Date, locale: Locale): string;
+/** "January 2026" / "Janvier 2026". */
+export declare function formatMonthYear(date: Date, locale: Locale): string;
+/** Seven weekday names starting Monday. `narrow` for the day picker, `short` for grids. */
+export declare function weekdayNames(locale: Locale, width?: 'narrow' | 'short' | 'long'): string[];
+/** The number in a month cell: the first of a month carries the month name ("Feb 1" / "1er févr."). */
+export declare function dayNumberLabel(date: Date, locale: Locale, short?: boolean): string;
+/** A number in the locale ("1,020" / "1 020"). */
+export declare function formatNumber(value: number, locale: Locale, options?: Intl.NumberFormatOptions): string;
+/** A plain value: one decimal under 10 when it has one, whole numbers above. */
+export declare function formatValue(value: number, locale: Locale): string;
+export type DeltaTone = 'good' | 'destructive';
+export interface Delta {
+    /** "+12%" / "−3,4 %". */
+    text: string;
+    tone: DeltaTone;
+    up: boolean;
+    /** The change in percent, signed. */
+    percent: number;
+}
+/**
+ * The change from `previous` to `current`. Null when there is nothing to compare with (no previous value or zero).
+ * `higherIsBetter: false` turns a rise red (costs, errors).
+ */
+export declare function formatDelta(current: number, previous: number | null | undefined, locale: Locale, higherIsBetter?: boolean): Delta | null;

package/dist/space-sdk/src/ui/period/dateWords.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Words of the period picker, calendar, timeline and charts (toolkit spec 2.11), EN and FR.
+ * French uses tu, as everywhere in Notis. Pure: no React.
+ */
+import { type Words } from '../../words/types';
+import type { CompareId, PresetId } from './periods';
+export declare const PRESET_WORDS: Readonly<Record<PresetId, Words>>;
+export declare const COMPARE_WORDS: Readonly<Record<CompareId, Words>>;
+/** "vs ..." after a delta. The stat row drops the leading "vs " under the previous value. */
+export declare const VS_WORDS: Readonly<Record<'prev' | 'year', Words>>;
+export declare const PERIOD_WORDS: Readonly<{
+    range: Words;
+    compare: Words;
+    apply: Words;
+    cancel: Words;
+    pickStart: Words;
+    pickEnd: Words;
+    prevMonth: Words;
+    nextMonth: Words;
+    thisPeriod: Words;
+    value: Words;
+    previous: Words;
+}>;
+export declare const CHART_WORDS: Readonly<{
+    tip: Words;
+    tipCompare: Words;
+    label: Words;
+    date: Words;
+    metric: Words;
+    trend: Words;
+    change: Words;
+    stats: Words;
+    noValue: Words;
+}>;
+export declare const CALENDAR_WORDS: Readonly<{
+    month: Words;
+    week: Words;
+    agenda: Words;
+    view: Words;
+    items: Words;
+    today: Words;
+    tomorrow: Words;
+    yesterday: Words;
+    prevMonth: Words;
+    nextMonth: Words;
+    prevWeek: Words;
+    nextWeek: Words;
+    prevAgenda: Words;
+    nextAgenda: Words;
+    agendaEmpty: Words;
+    agendaToday: Words;
+    more: Words;
+    less: Words;
+    /** The "+N" link of a narrow month cell, where the full words do not fit. */
+    moreShort: Words;
+    /** "Show less" in a narrow month cell. */
+    lessShort: Words;
+    noDate: Words;
+    trayShow: Words;
+    trayHide: Words;
+    keyToday: Words;
+    keyPrev: Words;
+    keyNext: Words;
+    keyNextItem: Words;
+    keyPrevItem: Words;
+    keyNextDay: Words;
+    keyPrevDay: Words;
+    keyOpen: Words;
+}>;
+export declare const TIMELINE_WORDS: Readonly<{
+    zoom: Words;
+    week: Words;
+    month: Words;
+    quarter: Words;
+    today: Words;
+    items: Words;
+    empty: Words;
+    earlier: Words;
+    later: Words;
+    bar: Words;
+    barPlain: Words;
+    keyToday: Words;
+    keyPrev: Words;
+    keyNext: Words;
+    keyNextItem: Words;
+    keyPrevItem: Words;
+    keyOpen: Words;
+}>;

package/dist/space-sdk/src/ui/period/periods.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Periods for dashboards (toolkit spec 2.11). Pure: date-fns only, no React, no DOM.
+ *
+ * A period is a preset (or a custom day range) plus a comparison. Ranges are whole local days: `from` is the start of
+ * its first day and `to` the end of its last day, both inclusive. Custom days are ISO dates (`2026-01-31`).
+ *
+ * URL value (one text param, `period` by default):
+ *   `last30`                       preset, default comparison
+ *   `last30~year`                  preset with a comparison
+ *   `2026-01-01..2026-01-31~none`  custom range
+ * The comparison is left out when it equals the default, so links stay short.
+ */
+export type PresetId = 'today' | 'yesterday' | 'last7' | 'last30' | 'last90' | 'thisMonth' | 'lastMonth' | 'thisQuarter' | 'thisYear' | 'custom';
+export type CompareId = 'prev' | 'year' | 'none';
+export interface Period {
+    preset: PresetId;
+    compare: CompareId;
+    /** ISO day, custom ranges only. */
+    from?: string;
+    /** ISO day, custom ranges only. */
+    to?: string;
+}
+export interface DateRange {
+    from: Date;
+    to: Date;
+}
+export declare const PRESETS: readonly PresetId[];
+export declare const COMPARES: readonly CompareId[];
+export declare const DEFAULT_PRESET: PresetId;
+export declare const DEFAULT_COMPARE: CompareId;
+export declare function isPresetId(value: unknown): value is PresetId;
+export declare function isCompareId(value: unknown): value is CompareId;
+/** `2026-01-31` for a local date. */
+export declare function toIsoDay(date: Date): string;
+/** A local date at the start of an ISO day, or null when the text is not a real day. */
+export declare function fromIsoDay(value: string | undefined | null): Date | null;
+/** Number of calendar days in a range, both ends included. */
+export declare function dayCount(range: DateRange): number;
+/**
+ * The days a preset covers, as of `now`.
+ * A custom range must end today or earlier with its first day first; anything else falls back to the last 30 days.
+ */
+export declare function presetRange(preset: PresetId, now?: Date, custom?: {
+    from?: string;
+    to?: string;
+}): DateRange;
+/**
+ * The range a period is compared with.
+ * - prev: the same number of days just before (`[from - n, from - 1]`).
+ * - year: the same calendar days one year back (29 February lands on 28 February).
+ * - none: no comparison.
+ */
+export declare function compareRange(range: DateRange, compare: CompareId): DateRange | null;
+/** The range and comparison range of a period. */
+export declare function periodRanges(period: Period, now?: Date): {
+    range: DateRange;
+    compareRange: DateRange | null;
+};
+/** A period whose custom days are dropped unless the preset is custom. */
+export declare function normalizePeriod(period: Period): Period;
+/** A custom period for two days, in any order. */
+export declare function customPeriod(a: Date, b: Date, compare: CompareId): Period;
+/** The URL value of a period. The comparison is left out when it equals `defaultCompare`. */
+export declare function formatPeriodParam(period: Period, defaultCompare?: CompareId): string;
+/** Reads a URL value; anything unreadable gives the defaults. */
+export declare function parsePeriodParam(value: string | null | undefined, defaults?: {
+    preset?: PresetId;
+    compare?: CompareId;
+}): Period;
+export declare function samePeriod(a: Period, b: Period): boolean;

package/dist/space-sdk/src/ui/period/usePeriod.d.ts

@@ -0,0 +1,23 @@
+import { type CompareId, type DateRange, type Period, type PresetId } from './periods';
+export interface UsePeriodOptions {
+    /** URL parameter holding the period. A Space declares it as a text param. Default `period`. */
+    param?: string;
+    /** Preset when the URL has none. Default `last30`. */
+    default?: PresetId;
+    /** Comparison when the URL has none. Default `prev`. */
+    compare?: CompareId;
+}
+export interface UsePeriodResult {
+    period: Period;
+    range: DateRange;
+    compareRange: DateRange | null;
+    set(period: Period): void;
+}
+/**
+ * The period of a dashboard, kept in the URL so links keep it (toolkit spec 2.11).
+ *
+ * In a Space the value lives in the Space's view params (declare `period` as a text param, or the host drops it) and
+ * changes go through `useViewParams().setParams`, replacing the history entry. On a Notis page outside a Space it lives in the page's query string.
+ * Ranges are computed for today and recomputed when the period changes.
+ */
+export declare function usePeriod(options?: UsePeriodOptions): UsePeriodResult;

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

@@ -0,0 +1,3 @@
+export * from './presentWords';
+export * from './screens';
+export * from './useAudienceScreen';

package/dist/space-sdk/src/ui/present/presentWords.d.ts

@@ -0,0 +1,27 @@
+/** EN/FR words of the second-screen presenter: the audience window and what the presenter is told. */
+export declare const PRESENT_WORDS: Readonly<{
+    audienceTitle: {
+        en: string;
+        fr: string;
+    };
+    fillScreen: {
+        en: string;
+        fr: string;
+    };
+    dragToScreen: {
+        en: string;
+        fr: string;
+    };
+    pressAgain: {
+        en: string;
+        fr: string;
+    };
+    blocked: {
+        en: string;
+        fr: string;
+    };
+    onOtherScreen: {
+        en: string;
+        fr: string;
+    };
+}>;

package/dist/space-sdk/src/ui/present/screens.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pure helpers of the second-screen presenter: is a second screen there, which one shows the audience, where its
+ * window opens, which key does what and how the page's styles reach the audience window.
+ */
+import type { NotisHtmlFramePresentAction } from '../../runtime';
+export type PresentAction = NotisHtmlFramePresentAction;
+/** The window name of the audience window. Electron recognises it and fills the other display. */
+export declare const AUDIENCE_WINDOW_NAME = "notis-presenter-audience";
+/** The part of a ScreenDetailed (Window Management API) the presenter reads. */
+export type ScreenArea = {
+    availLeft: number;
+    availTop: number;
+    availWidth: number;
+    availHeight: number;
+    isInternal?: boolean;
+    isPrimary?: boolean;
+    label?: string;
+};
+/** True when the desktop spans more than one screen. Chrome and Electron tell without asking; others say no. */
+export declare function hasSecondScreen(win: Window | undefined): boolean;
+/** The screen for the audience: never the current one, an external screen first, then the largest. */
+export declare function pickAudienceScreen(screens: readonly ScreenArea[], current: ScreenArea | null | undefined): ScreenArea | null;
+/** `window.open` features placing the audience window over the whole of a screen, or a plain window without one. */
+export declare function audienceFeatures(screen: ScreenArea | null): string;
+/** The action of a key press in the audience window, or null when the key is not one or belongs to a field. */
+export declare function keyAction(event: Pick<KeyboardEvent, 'key' | 'altKey' | 'ctrlKey' | 'metaKey' | 'defaultPrevented' | 'target'>): PresentAction | null;
+/** True when a click lands on something of its own (a field, a button, a link) rather than on the slide. */
+export declare function clickHasOwnTarget(target: EventTarget | null): boolean;
+/** True when the audience window covers its whole screen, in full screen or as a borderless full-size window. */
+export declare function fillsScreen(win: Window): boolean;
+/**
+ * Copy the page's styles into the audience window: the document's links, style elements and constructed sheets, then
+ * those of the Space's shadow root (its bundle and the toolkit). Constructed sheets cannot move between documents, so
+ * they are copied as text. The `<html>` class and style (light or dark) come along.
+ */
+export declare function copyStylesInto(target: Document, source: Document, shadowRoot?: ShadowRoot | null): void;

package/dist/space-sdk/src/ui/present/useAudienceScreen.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The second-screen presenter, like PowerPoint: with two screens, the audience sees the presentation full screen on
+ * the other one while this window stays the presenter's (notes, previews, timer). The Space renders the audience view
+ * with `portal(...)`, in its own React tree, so both windows show the same state and stay in sync.
+ *
+ * The browser asks once to place windows on screens (Window Management API); Electron never asks and fills the other
+ * display itself. One screen, or a browser without the API: `open` answers 'one-screen' and the Space presents as
+ * before.
+ */
+import { type ReactNode, type ReactPortal } from 'react';
+import type { Words } from '../../words';
+import { type PresentAction } from './screens';
+/**
+ * 'opened': the audience window is up. 'one-screen': present in this window. 'press-again': the browser just asked
+ * for permission and used up the press, so the window could not open; the same press works now. 'blocked': the
+ * browser blocked the window.
+ */
+export type AudienceOpenResult = 'opened' | 'one-screen' | 'press-again' | 'blocked';
+export type UseAudienceScreenOptions = {
+    /** A key, click or right click in the audience window. Escape is 'stop'. */
+    onAction: (action: PresentAction) => void;
+    /** The audience window closed (by the person, by Escape in the Space, or by `close`). */
+    onClose?: () => void;
+    /** The audience window's title. Default: "Presentation". */
+    title?: Words | string;
+};
+export type UseAudienceScreenResult = {
+    /** True when a second screen is connected (updates when one is plugged in or out). */
+    secondScreen: boolean;
+    isOpen: boolean;
+    /** Open the audience window on the other screen. Call from the press itself; `anchor` is an element of the Space. */
+    open: (anchor?: Element | null) => Promise<AudienceOpenResult>;
+    close: () => void;
+    /** Render the audience view into the audience window; null while it is closed. */
+    portal: (node: ReactNode) => ReactPortal | null;
+};
+/** The second-screen presenter. See the module comment. */
+export declare function useAudienceScreen(options: UseAudienceScreenOptions): UseAudienceScreenResult;

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

@@ -0,0 +1,21 @@
+/**
+ * One toolkit stylesheet for the document and every Space shadow root (toolkit spec 1.4.7).
+ *
+ * The host registers the text of `@notis/sdk/toolkit.css` once (`registerToolkitStyles`), and `adoptToolkitStyles(root)`
+ * appends the same CSSStyleSheet to `adoptedStyleSheets` of each root. Nothing is adopted before the host registers:
+ * the SDK never looks for the sheet among the page's own stylesheets, because a host that bundles its CSS would hand
+ * over its whole merged stylesheet instead of the toolkit.
+ */
+/** Registers the toolkit stylesheet: its CSS text, or an already built sheet. Later roots adopt this one. */
+export declare function registerToolkitStyles(source: string | CSSStyleSheet): void;
+/** The registered toolkit CSS text; null until the host registers it. */
+export declare function getToolkitStyleText(): string | null;
+/** The shared sheet; null without constructable stylesheets or until the host registers the CSS. */
+export declare function getToolkitStyleSheet(): CSSStyleSheet | null;
+/**
+ * Adds the registered toolkit sheet to a document or shadow root, once. Without constructable stylesheets the root
+ * gets one `<style>` element instead. Returns false, and adds nothing, while the host has not registered the CSS.
+ */
+export declare function adoptToolkitStyles(root: Document | ShadowRoot): boolean;
+/** Test hook: forget the registered sheet. */
+export declare function resetToolkitStylesForTests(): void;

package/dist/space-sdk/src/ui/timeline/TimelineView.d.ts

@@ -0,0 +1,44 @@
+/**
+ * TimelineView (toolkit spec 2.11, deck round 5 "timeline"): bars across days, one lane per group, zoomed by week,
+ * month or quarter. The roadmap scrolls sideways; lane labels and the date axis stay put.
+ *
+ * Keys (spec 3, settled in 6): `[` and `]` move the window earlier or later, T comes back to today and puts the
+ * cursor on the bar running today, J/K and the up and down arrows walk the bars lane by lane, Enter opens.
+ */
+import * as React from 'react';
+import { type Locale, type Words } from '../../words/types';
+import type { DateInput } from '../calendar/calendarMath';
+import { type TimelineLaneInfo, type TimelineZoom } from './timelineMath';
+export interface TimelineViewProps<T> {
+    items: readonly T[];
+    getStart: (item: T) => DateInput;
+    getEnd: (item: T) => DateInput;
+    /** The lane an item sits in. */
+    lane: (item: T) => TimelineLaneInfo;
+    /** Lane order (and lanes that show even when empty). */
+    lanes?: readonly TimelineLaneInfo[];
+    /** Default `item.id`. */
+    getId?: (item: T) => string;
+    /** Default `item.title` (or `item.name`). */
+    getTitle?: (item: T) => string;
+    /** Status words for the bar's accessible name. */
+    getStatus?: (item: T) => string;
+    /** Colour group of a bar: `todo`, `active`, `waiting` or `done` (deck status groups). */
+    getGroup?: (item: T) => string | undefined;
+    /** Draws the inside of a bar; default its title. */
+    bar?: (item: T) => React.ReactNode;
+    zoom?: TimelineZoom;
+    defaultZoom?: TimelineZoom;
+    onZoomChange?: (zoom: TimelineZoom) => void;
+    onOpen?: (item: T) => void;
+    openId?: string | null;
+    label?: Words | string;
+    locale?: Locale;
+    className?: string;
+    /** Today, for tests and previews. */
+    today?: Date;
+}
+export declare function TimelineView<T>(props: TimelineViewProps<T>): React.JSX.Element;
+export declare namespace TimelineView {
+    var displayName: string;
+}