@camstack/ui-library 1.2.291 → 1.2.292

package/dist/composites/stream-broker-selector.d.ts

@@ -1,24 +1,3 @@
-/**
-* StreamBrokerSelector — reusable per-device "preferred stream" picker.
-*
-* Renders a single `<Select>` with options sourced from the device's
-* camera-streams cap (`getRtspEntries`). The first option is always
-* "Auto (best available)"; remaining options are one per enabled
-* RTSP restream entry, labelled by stream profile (`High` / `Mid` /
-* `Low` …) and tagged with codec + resolution when the broker reports
-* them.
-*
-* Used by addon-built panels that don't flow through the form-builder
-* `ConfigUISchema` aggregator (the cap-driven aggregator already
-* embeds an equivalent `select` field with server-resolved options —
-* the addons return the same list inline). Reach for this composite
-* when you need an out-of-form selector in a bespoke React tree (e.g.
-* an addon's wizard page, a debug panel, etc.).
-*
-* Loading / empty / error states all render a degraded select rather
-* than vanishing — the operator can always pick `Auto` even if the
-* device's broker is currently unreachable.
-*/
 import { type ReactElement } from "react";
 export interface StreamBrokerSelectorProps {
 	readonly deviceId: number;

package/dist/composites/training/TrainingBaseModelPicker.d.ts

@@ -1,13 +1,3 @@
-/**
-* TrainingBaseModelPicker — select trainable base models for a new training
-* job. Each row lists every cluster placement where that model is the
-* effective root detector (`node · device`), or “Not in use on any node”.
-*
-* Default is multi-select: Select-all-roots picks the roots the cluster
-* actually runs; Clear empties. Pass `multiple={false}` for one model at a
-* time (radio-like); “Select cluster root” picks the first cluster root (or
-* a recommended root when present).
-*/
 import type { JSX } from "react";
 import { type TrainingBaseModelPlacement } from "./root-detector-placements";
 export type { TrainingBaseModelPlacement };

package/dist/composites/training/retrain-review-badge.d.ts

@@ -17,6 +17,7 @@
 import type { ReactElement } from "react";
 import type { RetrainReviewStatusName } from "@camstack/types";
 import { type BadgeProps, type BadgeSize, type BadgeStyle, type BadgeVariant } from "../../primitives/badge";
+import { type UiTextFn } from "../../contexts/ui-text";
 /** A review verdict, plus the pre-confirmation `draft` state. */
 export type RetrainReviewBadgeKind = RetrainReviewStatusName | "draft";
 export interface RetrainReviewBadgeLook {
@@ -27,7 +28,7 @@ export interface RetrainReviewBadgeLook {
 	readonly className: string;
 }
 /** The badge look for a verdict. Pure. */
-export declare function retrainReviewBadgeLook(kind: RetrainReviewBadgeKind): RetrainReviewBadgeLook;
+export declare function retrainReviewBadgeLook(kind: RetrainReviewBadgeKind, t?: UiTextFn): RetrainReviewBadgeLook;
 export interface RetrainReviewBadgeProps extends Omit<BadgeProps, "variant" | "style" | "children" | "dashed"> {
 	readonly kind: RetrainReviewBadgeKind;
 	readonly approximate?: boolean;

package/dist/composites/webrtc-diagnostics/endpoint-test.d.ts

@@ -5,6 +5,7 @@
 */
 import { type GatherResult, type IceServerConfig, type RelayLoopbackResult } from "./endpoint-probe";
 import { type NatMappingVerdict, type SrflxObservation } from "./nat-mapping";
+import { type UiTextFn } from "../../contexts/ui-text";
 export type IceEndpointScheme = "stun" | "turn" | "turns" | "other";
 export interface IceEndpoint extends IceServerConfig {
 	/** Stable key: the URL is unique within the flattened list. */
@@ -56,4 +57,4 @@ export declare function testEndpoint(endpoint: IceEndpoint): Promise<EndpointTes
 /** The STUN destinations the NAT check queries: configured first, public fallbacks to reach two. */
 export declare function natCheckDestinations(endpoints: readonly IceEndpoint[]): readonly string[];
 export declare function srflxObservations(gather: GatherResult): readonly SrflxObservation[];
-export declare function runNatCheck(endpoints: readonly IceEndpoint[]): Promise<NatCheckResult>;
+export declare function runNatCheck(endpoints: readonly IceEndpoint[], t?: UiTextFn): Promise<NatCheckResult>;

package/dist/composites/webrtc-diagnostics/nat-mapping.d.ts

@@ -16,6 +16,7 @@
 * `likely`, never `confirmed`, because it cannot be told apart from the second
 * server simply not answering.
 */
+import { type UiTextFn } from "../../contexts/ui-text";
 export interface SrflxObservation {
 	readonly address: string;
 	readonly port: number;
@@ -41,4 +42,4 @@ export interface NatMappingVerdict {
 * this check is about plain STUN binding.
 */
 export declare function distinctStunDestinations(urls: readonly string[]): readonly string[];
-export declare function compareSrflxMappings(observations: readonly SrflxObservation[], stunDestinationsQueried: number): NatMappingVerdict;
+export declare function compareSrflxMappings(observations: readonly SrflxObservation[], stunDestinationsQueried: number, t?: UiTextFn): NatMappingVerdict;

package/dist/composites/webrtc-diagnostics/session-run.d.ts

@@ -12,6 +12,7 @@
 * Every number in the report is `null` until something measured it (D393).
 */
 import type { WebrtcSessionDebug } from "@camstack/types";
+import { type UiTextFn } from "../../contexts/ui-text";
 import type { StreamDebugSample, WebrtcDebugStats } from "../stream-debug/webrtc-debug-stats";
 import { type HubCandidateSummary, type IceCandidateType, type ParsedIceCandidate } from "./ice-candidates";
 import { type DiagnosticIcePolicy, type SessionVerdict } from "./session-verdict";
@@ -135,4 +136,4 @@ export interface HubSessionRunReport {
 	readonly serverError: string | null;
 	readonly verdict: SessionVerdict;
 }
-export declare function finalizeSessionRun(state: SessionRunState, durationMs: number): HubSessionRunReport;
+export declare function finalizeSessionRun(state: SessionRunState, durationMs: number, t?: UiTextFn): HubSessionRunReport;

package/dist/composites/webrtc-diagnostics/session-verdict.d.ts

@@ -7,6 +7,7 @@
 * A layer whose deciding number was not measured makes the verdict `unknown`
 * — a guessed verdict is the thing an operator trusts and stops measuring.
 */
+import { type UiTextFn } from "../../contexts/ui-text";
 import type { HubReachabilityFlag } from "./ice-candidates";
 export type SessionVerdictLayer = "transport" | "hub-dtls" | "media-black-hole" | "hub-not-sending" | "loss-keyframe" | "healthy" | "unknown";
 export interface SessionVerdict {
@@ -35,4 +36,4 @@ export interface VerdictInput {
 export declare const PLI_STORM_COUNT = 3;
 /** Packet loss over the run above which a freeze is attributed to loss. */
 export declare const LOSS_PERCENT_HIGH = 2;
-export declare function classifySessionVerdict(input: VerdictInput): SessionVerdict;
+export declare function classifySessionVerdict(input: VerdictInput, t?: UiTextFn): SessionVerdict;

package/dist/contexts/ui-text.d.ts

@@ -0,0 +1,49 @@
+/**
+* The words a shared composite shows, resolved by the HOST.
+*
+* Serves the strings of ui-library's OWN components (tables, pickers, badges
+* and the like). The strings of an addon's pages and widgets are served by
+* `createAddonI18n` / `useAddonT` in `../i18n`; both follow the admin language
+* (the admin sets `<html lang>` AND mounts `AdminUiTextProvider`).
+*
+* This package ships no catalogue and no i18n dependency. A composite asks
+* `useUiText()` for `t(key, english, vars?)`: the English text is the fallback
+* and the key is what the host's catalogue (the admin UI's `i18n/*.json`, under
+* `uiLibrary.*`) translates. Without a provider the English fallback is
+* rendered, `{{var}}` interpolated, so a spec or a standalone page needs no
+* set-up.
+*
+* - Plurals: pass `count` and a `{ one, other }` fallback; the host resolves
+*   `key_one` / `key_other`. Never build a plural with a ternary suffix.
+* - Sentences with inline elements: `<UiTrans uiKey fallback components />`,
+*   the fallback marks each element as `<0>…</0>`, `<1>…</1>` and the host
+*   translates the whole sentence. Never concatenate fragments around elements.
+*/
+import { type ReactElement, type ReactNode } from "react";
+export type UiTextVars = Readonly<Record<string, string | number | boolean | null | undefined>>;
+/** The English fallback: one string, or `{ one, other }` for a counted noun. */
+export type UiTextFallback = string | {
+	readonly one: string;
+	readonly other: string;
+};
+export interface UiTextOptions extends UiTextVars {
+	readonly count?: number;
+}
+export type UiTextFn = (key: string, fallback: UiTextFallback, vars?: UiTextOptions) => string;
+/** English fallback with `{{var}}` interpolation; what renders without a host. */
+export declare const defaultUiText: UiTextFn;
+export declare function UiTextProvider({ t, children }: {
+	readonly t: UiTextFn;
+	readonly children: ReactNode;
+}): ReactElement;
+export declare function useUiText(): UiTextFn;
+/** Split `a <0>b</0> c` into text and `components[0]` wrapped around `b`. */
+export declare function renderTagged(text: string, components: readonly ReactElement[]): readonly ReactNode[];
+export interface UiTransProps {
+	readonly uiKey: string;
+	readonly fallback: UiTextFallback;
+	readonly components?: readonly ReactElement[];
+	readonly values?: UiTextOptions;
+}
+/** A translated sentence whose `<0>…</0>` spans are wrapped in `components[0]`. */
+export declare function UiTrans({ uiKey, fallback, components, values }: UiTransProps): ReactElement;

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

@@ -597,6 +597,10 @@ export declare const useDeviceManagerEnable: typeof trpc.deviceManager.enable.us
 export declare const useDeviceManagerDisable: typeof trpc.deviceManager.disable.useMutation;
 /** Generated alias around `trpc.deviceManager.remove.useMutation`. */
 export declare const useDeviceManagerRemove: typeof trpc.deviceManager.remove.useMutation;
+/** Generated alias around `trpc.deviceManager.listDeletedSince.useQuery`. */
+export declare const useDeviceManagerListDeletedSince: typeof trpc.deviceManager.listDeletedSince.useQuery;
+/** Generated alias around `trpc.deviceManager.cleanupDeletedDevicesData.useMutation`. */
+export declare const useDeviceManagerCleanupDeletedDevicesData: typeof trpc.deviceManager.cleanupDeletedDevicesData.useMutation;
 /** Generated alias around `trpc.deviceManager.removeByIntegration.useMutation`. */
 export declare const useDeviceManagerRemoveByIntegration: typeof trpc.deviceManager.removeByIntegration.useMutation;
 /** Generated alias around `trpc.deviceManager.getStreamProfileMap.useQuery`. */

package/dist/i18n/addon-i18n.d.ts

@@ -0,0 +1,46 @@
+/**
+* Translation core for the pages and widgets an addon ships.
+*
+* Serves the strings of an ADDON's own pages and widgets. The strings of
+* ui-library's own components are served by `useUiText` in
+* `../contexts/ui-text`; both follow the admin language (the admin sets
+* `<html lang>` AND mounts `AdminUiTextProvider`).
+*
+* Why this is not i18next: an addon page is a Module Federation remote and
+* i18next is NOT a shared singleton (`addon-admin-ui/vite.config.ts`), so a
+* remote cannot reach the host's instance. This module lives in the ui-library,
+* which IS the host-shared singleton, so every remote sees the same registry.
+*
+* Two seams keep call sites stable when the hub starts serving bundles
+* (`translations.getBundle({ lang, ns })`):
+*  - bundles enter ONLY through {@link registerAddonBundle}; a call site never
+*    imports a JSON file, it asks `useAddonT(ns)`;
+*  - the language comes ONLY from {@link currentAddonLanguage}, which reads the
+*    `lang` attribute the host admin sets on `<html>` (and falls back to the
+*    browser language for a host-less page such as the agent dashboard).
+*/
+/** A translation bundle: nested keys, leaves are message strings. */
+export interface TranslationTree {
+	readonly [key: string]: string | TranslationTree;
+}
+/** Values interpolated into `{{name}}` placeholders; a numeric `count` also picks the plural form. */
+export type TranslationVars = Readonly<Record<string, string | number>>;
+/** `status.ok_one` / `status.ok_other` are addressed as `status.ok`. */
+type StripPlural<K extends string> = K extends `${infer Base}_${"zero" | "one" | "two" | "few" | "many" | "other"}` ? Base : K;
+/** Every dotted key a bundle answers, plural variants collapsed to their base. */
+export type TranslationKey<T> = { [K in keyof T & string]: T[K] extends string ? StripPlural<K> : `${K}.${TranslationKey<T[K]>}` }[keyof T & string];
+/** Lower-cased primary subtag: `it-IT` -> `it`. */
+export declare function normalizeLanguage(raw: string | null | undefined): string;
+/** The language the host admin shows, else the browser's, else English. */
+export declare function currentAddonLanguage(): string;
+/** Install (or replace) one language of one namespace. Subscribers re-render. */
+export declare function registerAddonBundle(ns: string, lang: string, tree: TranslationTree): void;
+/** Subscribe to bundle changes AND to the host switching language. */
+export declare function subscribeAddonI18n(listener: () => void): () => void;
+/** Changes whenever a rendered string could differ (new bundle, new language). */
+export declare function addonI18nSnapshot(): string;
+/** Replace `{{name}}` placeholders; an unknown name is left visible. */
+export declare function interpolate(message: string, vars: TranslationVars | undefined): string;
+/** Resolve a key in `lang`, then in English; an unknown key answers itself. */
+export declare function translateAddonKey(ns: string, lang: string, key: string, vars?: TranslationVars): string;
+export {};

package/dist/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export { currentAddonLanguage, normalizeLanguage, registerAddonBundle, type TranslationKey, type TranslationTree, type TranslationVars, translateAddonKey } from "./addon-i18n";
+export { type AddonBundles, type AddonI18n, type AddonT, type AddonTFunction, type AddonTransProps, createAddonI18n, renderMarkup, useAddonT } from "./use-addon-t";

package/dist/i18n/use-addon-t.d.ts

@@ -0,0 +1,57 @@
+import { type ReactElement, type ReactNode } from "react";
+import { type TranslationKey, type TranslationTree, type TranslationVars } from "./addon-i18n";
+/** Translate one key of the namespace this function was made for. */
+export type AddonTFunction<K extends string = string> = (key: K, vars?: TranslationVars) => string;
+export interface AddonT<K extends string = string> {
+	readonly t: AddonTFunction<K>;
+	/** The language in effect (`en`, `it`, ...). */
+	readonly lang: string;
+}
+/**
+* `t` for one addon namespace. The language is the host's; `langOverride` is
+* for a widget the host hands an explicit language (the pre-auth login page).
+* Prefer the typed `useT` that
+* {@link createAddonI18n} returns; this is the untyped form behind it.
+*/
+export declare function useAddonT<K extends string = string>(ns: string, langOverride?: string): AddonT<K>;
+/**
+* Render a message that mixes text with inline elements. The message marks them
+* with named tags (`Delete <b>{{name}}</b>?`); `components` maps each tag name
+* to the element that wraps its content. Placeholders are interpolated into
+* the text nodes only, so a value containing `<` can never become markup.
+*/
+export declare function renderMarkup(message: string, components: Readonly<Record<string, ReactElement>>, vars: TranslationVars | undefined): ReactNode[];
+export interface AddonTransProps<K extends string> {
+	readonly i18nKey: K;
+	readonly values?: TranslationVars;
+	/** Tag name used in the message -> the element wrapping that tag's content. */
+	readonly components?: Readonly<Record<string, ReactElement>>;
+}
+export interface AddonI18n<K extends string> {
+	readonly ns: string;
+	/** Typed `t` bound to this addon's namespace. */
+	readonly useT: (langOverride?: string) => AddonT<K>;
+	/**
+	* `t` outside React (a class component, a helper that builds an error
+	* message): answers in the language in effect NOW, does not re-render.
+	*/
+	readonly translate: AddonTFunction<K>;
+	/** A sentence with inline elements; never concatenate translated fragments. */
+	readonly Trans: (props: AddonTransProps<K>) => ReactElement;
+}
+export type AddonBundles<T extends TranslationTree> = {
+	readonly en: T;
+} & Readonly<Record<string, TranslationTree>>;
+/**
+* Register an addon's bundled JSON under its namespace and return the hooks its
+* components use. The bundles are only the INITIAL content of the registry: a
+* later hub-served bundle replaces them through `registerAddonBundle` and no
+* call site changes.
+*
+* ```ts
+* import en from './en.json'
+* import it from './it.json'
+* export const { useT, Trans } = createAddonI18n('model-studio', { en, it })
+* ```
+*/
+export declare function createAddonI18n<T extends TranslationTree>(ns: string, bundles: AddonBundles<T>): AddonI18n<TranslationKey<T>>;