@camstack/ui-library 1.2.189 → 1.2.190

package/dist/composites/clips/ClipPanel.d.ts

@@ -0,0 +1,8 @@
+import { CamProfile, Clip } from '@camstack/types';
+export interface ClipPanelProps {
+    readonly deviceId: number;
+    readonly clip: Clip;
+    readonly profile: CamProfile;
+    readonly onProfileChange: (profile: CamProfile) => void;
+}
+export declare function ClipPanel({ deviceId, clip, profile, onProfileChange }: ClipPanelProps): import("react").JSX.Element;

package/dist/composites/clips/ClipSilentSources.d.ts

@@ -0,0 +1,4 @@
+import { ClipSourceNotice } from './clip-source-state.js';
+export declare function ClipSilentSources({ silent }: {
+    readonly silent: readonly ClipSourceNotice[];
+}): import("react").JSX.Element | null;

package/dist/composites/clips/ClipSourceRow.d.ts

@@ -0,0 +1,9 @@
+import { ClipSourceNotice } from './clip-source-state.js';
+export interface ClipSourceRowProps {
+    readonly notice: ClipSourceNotice;
+    /** How old this source's catalog is, or null when it was read live. */
+    readonly catalogAge: string | null;
+    readonly checked: boolean;
+    readonly onToggle: (source: string, next: boolean) => void;
+}
+export declare function ClipSourceRow({ notice, catalogAge, checked, onToggle }: ClipSourceRowProps): import("react").JSX.Element;

package/dist/composites/clips/ClipTile.d.ts

@@ -0,0 +1,7 @@
+import { Clip } from '@camstack/types';
+export interface ClipTileProps {
+    readonly clip: Clip;
+    readonly selected: boolean;
+    readonly onSelect: (clip: Clip) => void;
+}
+export declare function ClipTile({ clip, selected, onSelect }: ClipTileProps): import("react").JSX.Element;

package/dist/composites/clips/ClipsBrowser.d.ts

@@ -0,0 +1,4 @@
+export interface ClipsBrowserProps {
+    readonly deviceId: number;
+}
+export declare function ClipsBrowser({ deviceId }: ClipsBrowserProps): import("react").JSX.Element;

package/dist/composites/clips/clip-day-window.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Day navigation for the clips browser — and the window `listClips` is asked
+ * for.
+ *
+ * Every recording timestamp on the wire is the CAMERA's wall clock (D549
+ * decision 7), and the operator navigates a calendar, so a "day" here is a
+ * LOCAL wall-clock day: from the instant local midnight starts to the instant
+ * the next local midnight starts, half-open. Two consequences that are pinned
+ * by spec because both are invisible until they are wrong:
+ *
+ *  - Building the window in UTC shifts every list by the browser's offset, and
+ *    an operator in Berlin would see a 22:00 clip filed under the next day.
+ *  - Walking days by adding 86 400 000 ms repeats or skips a calendar day
+ *    across a DST change. The walk goes through `Date`'s own day arithmetic.
+ *
+ * A day id is `YYYY-MM-DD` — the shape a URL and a `<input type="date">` both
+ * take, so navigation never needs a second representation.
+ */
+/** The half-open instant range `listClips` is asked for. */
+export interface ClipDayWindow {
+    readonly since: number;
+    readonly until: number;
+}
+/** The LOCAL calendar day an instant falls in, as `YYYY-MM-DD`. */
+export declare function toDayId(instant: Date): string;
+/** The half-open local-wall-clock window of one day. */
+export declare function dayWindow(dayId: string): ClipDayWindow;
+/** Walk `days` calendar days from `dayId` — DST-safe, because `Date` does it. */
+export declare function shiftDay(dayId: string, days: number): string;
+/**
+ * The day, spelled out for the header.
+ *
+ * An empty list has to say WHICH day it is empty for — "no clips" with no date
+ * beside it is the ambiguity this surface exists to remove — so this label is
+ * rendered next to every state, not only the populated one.
+ */
+export declare function formatDayLabel(dayId: string): string;

package/dist/composites/clips/clip-source-state.d.ts

@@ -0,0 +1,34 @@
+import { ClipSource } from '@camstack/types';
+/** How loudly a source's state should read. Never the whole message. */
+export type ClipSourceTone = 'ok' | 'warn' | 'error';
+/** A source's state, rendered. */
+export interface ClipSourceNotice {
+    /** The source's own id (`analytics`, `native:reolink:hub`, …). */
+    readonly source: string;
+    /** The operator-facing source name the provider gave it. */
+    readonly label: string;
+    /** One line, unique per state. Never "no clips". */
+    readonly headline: string;
+    /** The provider's reason, verbatim, or null when it gave none. */
+    readonly detail: string | null;
+    readonly tone: ClipSourceTone;
+    /**
+     * Did this source contribute rows to the list on screen?
+     *
+     * `sleeping` answers TRUE: a sleeping camera serves its persisted catalog
+     * (D549 decision 4), so its clips ARE in the list — only their age is
+     * different. The other three contribute nothing, and an empty day must name
+     * them as the reason rather than claim the camera was quiet.
+     */
+    readonly answered: boolean;
+}
+/** Turn one source row into the line the picker and the list show. */
+export declare function describeSource(source: ClipSource): ClipSourceNotice;
+/**
+ * How old a source's catalog is, or null when it did not say.
+ *
+ * Null is NOT "now". A source that omits `catalogAsOf` was read live and has
+ * no age to show; inventing "just now" for a source that never told us would
+ * be the same lie as drawing a cached list as current (D549 decision 13).
+ */
+export declare function formatCatalogAge(catalogAsOf: number | undefined, now: number): string | null;

package/dist/composites/clips/clip-thumbnail-fetch.d.ts

@@ -0,0 +1,16 @@
+import { ClipTileMedia } from './clip-tile-media.js';
+/** The `fetch` this module uses — injected so the contract is testable. */
+export type ThumbnailFetcher = (url: string, init: RequestInit) => Promise<Response>;
+/** A minted still, or the reason there is none. */
+export type MintedThumbnail = {
+    readonly kind: 'image';
+    readonly blob: Blob;
+} | ClipTileMedia;
+/**
+ * Ask a mint route for one still.
+ *
+ * Never rejects: a thrown fetch is a refusal like any other, because a tile
+ * that throws is a tile that renders nothing and says nothing — the exact
+ * failure this module exists to prevent.
+ */
+export declare function fetchMintedThumbnail(url: string, fetcher: ThumbnailFetcher): Promise<MintedThumbnail>;

package/dist/composites/clips/clip-tile-media.d.ts

@@ -0,0 +1,27 @@
+import { Clip } from '@camstack/types';
+/** The four things a tile can be. */
+export type ClipTileMedia = {
+    readonly kind: 'vouched';
+    readonly url: string;
+} | {
+    readonly kind: 'mint';
+    readonly url: string;
+} | {
+    readonly kind: 'unavailable';
+    readonly reason: string;
+    readonly text: string;
+} | {
+    readonly kind: 'none';
+    readonly text: string;
+};
+/** What to draw for one clip's tile. */
+export declare function resolveTileMedia(clip: Clip): ClipTileMedia;
+/**
+ * A mint that answered 204 — latch its `x-camstack-reason` to this instant.
+ *
+ * The refusal is about NOW (a full queue, a sleeping camera), so it replaces
+ * the offer for as long as the tile is mounted and is not retried behind the
+ * operator's back. An unknown reason is shown raw rather than dropped: a
+ * firmware inventing a refusal must not become a blank tile.
+ */
+export declare function latchMintRefusal(reason: string): ClipTileMedia;

package/dist/composites/clips/clip-view-state.d.ts

@@ -0,0 +1,34 @@
+import { Clip, ClipSource } from '@camstack/types';
+import { ClipSourceNotice } from './clip-source-state.js';
+/** React Query's settled-ness, narrowed to what this decision needs. */
+export type ClipQueryStatus = 'pending' | 'error' | 'success';
+export interface ClipsViewInput {
+    readonly dayId: string;
+    readonly clipsStatus: ClipQueryStatus;
+    readonly clips: readonly Clip[];
+    readonly sourcesStatus: ClipQueryStatus;
+    readonly sources: readonly ClipSource[];
+    /** The picker's selection. Absent means every source (D554 decision 3). */
+    readonly selected?: readonly string[];
+    readonly clipsError?: string;
+    readonly sourcesError?: string;
+}
+export type ClipsViewState = {
+    readonly kind: 'loading';
+} | {
+    readonly kind: 'failed';
+    readonly message: string;
+} | {
+    readonly kind: 'empty';
+    readonly dayId: string;
+    readonly answered: readonly ClipSourceNotice[];
+    readonly silent: readonly ClipSourceNotice[];
+    /** No source could answer at all — a different fact from a quiet day. */
+    readonly nobodyAnswered: boolean;
+} | {
+    readonly kind: 'listed';
+    readonly clips: readonly Clip[];
+    readonly answered: readonly ClipSourceNotice[];
+    readonly silent: readonly ClipSourceNotice[];
+};
+export declare function resolveClipsView(input: ClipsViewInput): ClipsViewState;

package/dist/composites/hls-video.d.ts

@@ -1,7 +1,22 @@
 import { QualityOption } from './hls-quality';
 export interface HlsVideoProps {
-    /** Master `.m3u8` URL (typically relative, through the hub data-plane). */
+    /** Media URL (typically relative, through the hub data-plane) — an HLS
+     *  master `.m3u8`, or a progressive `.mp4` when {@link format} says so. */
     readonly url: string;
+    /**
+     * What {@link url} is. Absent means `hls` — every existing caller is
+     * unchanged by construction.
+     *
+     * `mp4` is the NATIVE-CLIP path (D549 22): a vendor addon fetched the
+     * camera's own file, muxed it once with `+faststart` and serves it with
+     * `Range`, so a plain `<video src>` seeks natively and hls.js is not
+     * involved at all — handing it an MP4 would have it parse the file as a
+     * manifest and fail. **Nothing is appended to the URL**: the hub's
+     * `/addon/<id>/<prefix>` proxy takes the same-origin session cookie, which
+     * is what the native-Safari branch below already relies on, so the URL is
+     * never a credential.
+     */
+    readonly format?: 'hls' | 'mp4';
     /** Bearer token for the admin-gated data-plane route (optional). */
     readonly authToken?: string | null;
     /** Poster painted until the first frame decodes (optional). */
@@ -23,4 +38,4 @@ export interface HlsVideoProps {
      */
     readonly selectedLevel?: number;
 }
-export declare function HlsVideo({ url, authToken, posterUrl, autoPlay, className, onQualityOptions, selectedLevel, }: HlsVideoProps): import("react").JSX.Element;
+export declare function HlsVideo({ url, format, authToken, posterUrl, autoPlay, className, onQualityOptions, selectedLevel, }: HlsVideoProps): import("react").JSX.Element;

package/dist/composites/stream-panel.d.ts

@@ -83,6 +83,13 @@ export interface StreamPanelProps {
      * player. Clearing it returns the panel to live mode.
      */
     readonly playbackUrl?: string;
+    /**
+     * What {@link playbackUrl} is. Absent means `hls` — the recorder's manifest,
+     * which is what every caller passed before native clips existed. A vendor
+     * addon's own clip is `mp4` and the hero plays it as a plain media URL
+     * (D549 22); passing it as `hls` would hand an MP4 to a manifest parser.
+     */
+    readonly playbackFormat?: 'hls' | 'mp4';
     /** Bearer token for the admin-gated data-plane playback route (optional). */
     readonly playbackAuthToken?: string | null;
     /**
@@ -202,4 +209,4 @@ export interface StreamPanelProps {
     readonly chromeless?: boolean;
     readonly className?: string;
 }
-export declare function StreamPanel({ serverUrl, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, getSessionState, getSessionDebug, playbackUrl, playbackAuthToken, onExitPlayback, posterUrl, streams, activeStreamId: controlledStreamId, onStreamChange, deviceName, phase, pipelineMetrics, detections, stationaryObjects, defaultShowDetections, defaultShowMotion, streamStats, autoPlay, showPlayStop, snapshotSrc, snapshotLoading, onRefreshSnapshot, showStreamStats, children, extraOverlay, ptzAvailable, ptzShown, ptzOverlay, onPtzToggle, intercomAvailable, intercomShown, onIntercomToggle, chromeless, className, }: StreamPanelProps): import("react").JSX.Element;
+export declare function StreamPanel({ serverUrl, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, getSessionState, getSessionDebug, playbackUrl, playbackFormat, playbackAuthToken, onExitPlayback, posterUrl, streams, activeStreamId: controlledStreamId, onStreamChange, deviceName, phase, pipelineMetrics, detections, stationaryObjects, defaultShowDetections, defaultShowMotion, streamStats, autoPlay, showPlayStop, snapshotSrc, snapshotLoading, onRefreshSnapshot, showStreamStats, children, extraOverlay, ptzAvailable, ptzShown, ptzOverlay, onPtzToggle, intercomAvailable, intercomShown, onIntercomToggle, chromeless, className, }: StreamPanelProps): import("react").JSX.Element;

package/dist/contexts/vod-playback.d.ts

@@ -1,7 +1,19 @@
 import { ReactNode } from 'react';
 export interface VodPlaybackRequest {
-    /** Master `.m3u8` URL through the hub data-plane (relative). */
+    /** Media URL through the hub data-plane (relative) — an HLS master `.m3u8`,
+     *  or a progressive `.mp4` when {@link format} says so. */
     readonly url: string;
+    /**
+     * What {@link url} is. Absent means `hls`, so every existing controller is
+     * unchanged.
+     *
+     * A NATIVE clip (a camera's own file, fetched and muxed by its vendor addon)
+     * is `mp4`: the hero player sets `video.src` instead of handing it to
+     * hls.js, which would parse the file as a manifest and fail (D549 22). The
+     * value comes straight from `videoclips.getClipPlayback().format` — the
+     * provider is the only thing that knows.
+     */
+    readonly format?: 'hls' | 'mp4';
     /** Short human label shown in the hero while playing (e.g. a timestamp). */
     readonly label?: string;
 }

package/dist/generated/system-hooks.d.ts

@@ -2067,6 +2067,8 @@ export declare const useValveGetStatus: typeof trpc.valve.getStatus.useQuery;
 export declare const useVibrationGetStatus: typeof trpc.vibration.getStatus.useQuery;
 /** Generated alias around `trpc.videoclips.listClips.useQuery`. */
 export declare const useVideoclipsListClips: typeof trpc.videoclips.listClips.useQuery;
+/** Generated alias around `trpc.videoclips.listSources.useQuery`. */
+export declare const useVideoclipsListSources: typeof trpc.videoclips.listSources.useQuery;
 /** Generated alias around `trpc.videoclips.getClipPlayback.useQuery`. */
 export declare const useVideoclipsGetClipPlayback: typeof trpc.videoclips.getClipPlayback.useQuery;
 /** Generated alias around `trpc.waterHeater.setTargetTemp.useMutation`. */

package/dist/hooks/use-capability-presence.d.ts

@@ -0,0 +1,32 @@
+import { CapabilityInfo } from '@camstack/types';
+/**
+ * What is known about a capability's presence in this cluster.
+ *
+ * - `pending` — the registry has not answered. Render progress, never absence.
+ * - `present` — the registry answered and at least one addon provides it.
+ * - `absent`  — the registry answered, and nothing provides it (either the
+ *               capability is undeclared, or it is declared with no provider).
+ * - `unknown` — the read FAILED. Not an answer, so it is not `absent` either;
+ *               a surface that cannot reach the registry says so.
+ */
+export type CapabilityPresence = 'pending' | 'present' | 'absent' | 'unknown';
+/**
+ * Classify a settled registry answer.
+ *
+ * `null` is "no such capability". A row with an empty `providers` list is a
+ * capability that is DECLARED but that no addon supplies — indistinguishable
+ * to an operator from not having it, and the panel behind it would have
+ * nothing to call. Both are `absent`.
+ *
+ * Exported for the unit test: the mapping is the whole decision, and it is
+ * worth pinning without a React tree around it.
+ */
+export declare function classifyCapability(row: CapabilityInfo | null): 'present' | 'absent';
+/**
+ * Ask the hub's capability registry whether `capabilityName` has a provider.
+ *
+ * The four states map straight off React Query's `status`, so there is no
+ * place for a nullish fallback to turn "no answer" into "no providers" — the
+ * exact collapse this hook exists to make unrepresentable.
+ */
+export declare function useCapabilityPresence(capabilityName: string): CapabilityPresence;