@syntrologie/runtime-sdk 2.13.0 → 2.15.0

package/dist/config/schema.js

@@ -12,8 +12,9 @@ import {
   TileNotificationRuleZ,
   TileZ,
   configSchemas
-} from "../chunk-XDYJ64IN.js";
-import "../chunk-BU4Z6PD7.js";
+} from "../chunk-GX7BBYX6.js";
+import "../chunk-4HXPGXUC.js";
+import "../chunk-JMHRHAEL.js";
 export {
   CanvasConfigResponseZ,
   CanvasElementConfigZ,

package/dist/controllers/DecisionController.d.ts

@@ -0,0 +1,48 @@
+/**
+ * DecisionController
+ *
+ * A Lit ReactiveController that replaces the `useDecision()` React hook
+ * from RuntimeProvider.tsx. Evaluates a DecisionStrategy against the runtime
+ * when the host element connects and exposes the result as reactive properties.
+ *
+ * Usage:
+ * ```ts
+ * class MyElement extends LitElement {
+ *   private _decision = new DecisionController(
+ *     this,
+ *     runtime,
+ *     strategy,
+ *     false  // defaultValue
+ *   );
+ *
+ *   render() {
+ *     if (this._decision.isLoading) return html`...`;
+ *     return this._decision.value ? html`<shown-content>` : html``;
+ *   }
+ * }
+ * ```
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { DecisionStrategy } from '../decisions/types.js';
+import type { SmartCanvasRuntime } from '../runtime.js';
+export declare class DecisionController<T> implements ReactiveController {
+    private _host;
+    private _runtime;
+    private _strategy;
+    private _defaultValue;
+    private _value;
+    private _isFallback;
+    private _isLoading;
+    private _cancelled;
+    constructor(host: ReactiveControllerHost, runtime: SmartCanvasRuntime | null | undefined, strategy: DecisionStrategy<T> | null | undefined, defaultValue: T);
+    get value(): T;
+    get isFallback(): boolean;
+    get isLoading(): boolean;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Update the strategy and re-evaluate. Triggers a host update when done.
+     */
+    setStrategy(strategy: DecisionStrategy<T> | null | undefined): void;
+    private _evaluate;
+}

package/dist/controllers/NotificationsController.d.ts

@@ -0,0 +1,59 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { EventBus } from '../events/EventBus.js';
+import type { ActiveNotification } from '../notifications/types.js';
+import type { TileConfig } from '../types.js';
+/**
+ * NotificationsController — Lit ReactiveController equivalent of useNotifications().
+ *
+ * Subscribes to the EventBus, evaluates notification rules from tile configs,
+ * and manages the active toast queue.
+ *
+ * Features:
+ * - Max 3 visible toasts (FIFO eviction when exceeded)
+ * - Deduplication by tileId + itemId
+ * - Cooldown per rule (prevents rapid re-firing)
+ * - Auto-dismiss after TTL
+ * - Publishes NOTIFICATION_SHOWN / NOTIFICATION_DISMISSED telemetry events
+ *
+ * Usage (decorator-free):
+ *   class MyElement extends LitElement {
+ *     private _notifications: NotificationsController;
+ *
+ *     constructor() {
+ *       super();
+ *       this._notifications = new NotificationsController(this, eventBus, tiles);
+ *     }
+ *
+ *     render() {
+ *       return html`${this._notifications.notifications.map(...)}`;
+ *     }
+ *   }
+ */
+export declare class NotificationsController implements ReactiveController {
+    private host;
+    private eventBus;
+    private tiles;
+    private _notifications;
+    private _cooldownMap;
+    private _timerIds;
+    private _unsubscribe;
+    constructor(host: ReactiveControllerHost, eventBus: EventBus | null, tiles: TileConfig[]);
+    /** Returns the current list of active (visible) notifications. */
+    get notifications(): ActiveNotification[];
+    /** Update the tile configs (and thus notification rules) after construction. */
+    setTiles(tiles: TileConfig[]): void;
+    /**
+     * Swap the EventBus after construction (e.g. when runtimeRef changes).
+     * Tears down the existing subscription and re-subscribes on the new bus.
+     */
+    setEventBus(eventBus: EventBus | null): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Manually dismiss a notification by ID.
+     * Cancels its auto-dismiss timer and publishes NOTIFICATION_DISMISSED.
+     */
+    dismiss(id: string): void;
+    private _publishDismissed;
+    private _scheduleDismiss;
+}

package/dist/controllers/RuntimeController.d.ts

@@ -0,0 +1,52 @@
+/**
+ * RuntimeController — Lit ReactiveController equivalent of the React runtime hooks.
+ *
+ * Replaces the following hooks from RuntimeProvider.tsx for Lit-based components:
+ *   useRuntime()         → controller.runtime
+ *   useRuntimeContext()  → controller.context
+ *   usePageContext()     → controller.page
+ *   useSessionContext()  → controller.session
+ *   useViewportContext() → controller.viewport
+ *
+ * Usage:
+ *   class MyElement extends LitElement {
+ *     static override properties = { ... };
+ *
+ *     #runtimeCtrl = new RuntimeController(this, myRuntime);
+ *
+ *     override render() {
+ *       const page = this.#runtimeCtrl.page;
+ *       return html`<p>${page?.url}</p>`;
+ *     }
+ *   }
+ *
+ * The controller subscribes to runtime.context.subscribe() when the host connects
+ * to the DOM and calls host.requestUpdate() on every context change, mirroring
+ * the React useState/useEffect pattern in RuntimeProvider.
+ *
+ * Decorator-free: relies on static `properties` declarations on the host element
+ * instead of @property / @state decorators (tsconfig does not enable
+ * experimentalDecorators).
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { PageContext, RuntimeContext, SessionContext, ViewportContext } from '../context/types.js';
+import type { SmartCanvasRuntime } from '../runtime.js';
+export declare class RuntimeController implements ReactiveController {
+    readonly host: ReactiveControllerHost;
+    private readonly _runtime;
+    private _context;
+    private _unsubscribe;
+    constructor(host: ReactiveControllerHost, runtime: SmartCanvasRuntime);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /** The SmartCanvasRuntime instance (equivalent to useRuntime()). */
+    get runtime(): SmartCanvasRuntime;
+    /** Current reactive RuntimeContext snapshot (equivalent to useRuntimeContext()). */
+    get context(): RuntimeContext | null;
+    /** Current page context (equivalent to usePageContext()). */
+    get page(): PageContext | null;
+    /** Current session context (equivalent to useSessionContext()). */
+    get session(): SessionContext | null;
+    /** Current viewport context (equivalent to useViewportContext()). */
+    get viewport(): ViewportContext | null;
+}

package/dist/controllers/RuntimeEventsController.d.ts

@@ -0,0 +1,42 @@
+/**
+ * RuntimeEventsController
+ *
+ * A Lit ReactiveController that replaces the `useRuntimeEvents()` React hook
+ * from RuntimeProvider.tsx. Subscribes to the runtime event bus when the host
+ * element connects to the DOM and unsubscribes when it disconnects.
+ *
+ * Usage:
+ * ```ts
+ * class MyElement extends LitElement {
+ *   private _events = new RuntimeEventsController(
+ *     this,
+ *     runtime,
+ *     { names: ['ui.click'] },
+ *     (event) => { ... }
+ *   );
+ * }
+ * ```
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { EventFilter, NormalizedEvent } from '../events/types.js';
+import type { SmartCanvasRuntime } from '../runtime.js';
+export type { EventFilter };
+export declare class RuntimeEventsController implements ReactiveController {
+    private _host;
+    private _runtime;
+    private _filter;
+    private _callback;
+    private _unsubscribe;
+    constructor(host: ReactiveControllerHost, runtime: SmartCanvasRuntime | null | undefined, filter: EventFilter | undefined, callback: (event: NormalizedEvent) => void);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Update the event filter. Resubscribes immediately if the host is connected.
+     */
+    setFilter(filter: EventFilter | undefined): void;
+    /**
+     * Update the event callback. Resubscribes immediately if the host is connected.
+     */
+    setCallback(callback: (event: NormalizedEvent) => void): void;
+    private _subscribe;
+}

package/dist/controllers/ThemeController.d.ts

@@ -0,0 +1,110 @@
+/**
+ * ThemeController — Lit ReactiveController replacing ThemeProvider + useTheme.
+ *
+ * Merges theme config with defaults, flattens to CSS variables,
+ * and injects them into the host's shadow root.
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { CanvasThemeConfig } from '../theme/types.js';
+export interface ThemeState {
+    config: Required<CanvasThemeConfig>;
+    mode: 'light' | 'dark';
+    cssVariables: Record<string, string>;
+}
+export declare class ThemeController implements ReactiveController {
+    #private;
+    get config(): Required<{
+        content?: {
+            background?: string | undefined;
+            border?: string | undefined;
+            backgroundHover?: string | undefined;
+            borderRadius?: string | undefined;
+            textColor?: string | undefined;
+            bodyPadding?: string | undefined;
+            textSecondaryColor?: string | undefined;
+            itemDivider?: string | undefined;
+            itemGap?: string | undefined;
+            itemPadding?: string | undefined;
+            itemFontSize?: string | undefined;
+            bodyFontSize?: string | undefined;
+            categoryPadding?: string | undefined;
+            categoryGap?: string | undefined;
+            categoryFontSize?: string | undefined;
+            searchBackground?: string | undefined;
+            searchColor?: string | undefined;
+            chevronColor?: string | undefined;
+        } | undefined;
+        overlay?: {
+            background?: string | undefined;
+            border?: string | undefined;
+            borderRadius?: string | undefined;
+            titleColor?: string | undefined;
+            textColor?: string | undefined;
+            arrowColor?: string | undefined;
+            arrowSize?: string | undefined;
+            scrimOpacity?: string | undefined;
+            highlightRing?: string | undefined;
+        } | undefined;
+        borderRadius?: string | undefined;
+        mode?: "dark" | "light" | undefined;
+        fontFamily?: string | undefined;
+        colorPrimary?: string | undefined;
+        colorPrimaryHover?: string | undefined;
+        canvas?: {
+            position?: "right" | "left" | undefined;
+            layout?: "push" | "overlay" | undefined;
+            background?: string | undefined;
+            blur?: string | undefined;
+            border?: string | undefined;
+            width?: string | undefined;
+            transitionDuration?: string | undefined;
+            transitionEasing?: string | undefined;
+            transitionFade?: string | undefined;
+        } | undefined;
+        launcher?: {
+            size?: string | undefined;
+            icon?: string | undefined;
+            background?: string | undefined;
+            backgroundHover?: string | undefined;
+            color?: string | undefined;
+            shadow?: string | undefined;
+            borderRadius?: string | undefined;
+        } | undefined;
+        tile?: {
+            background?: string | undefined;
+            border?: string | undefined;
+            backgroundHover?: string | undefined;
+            shadow?: string | undefined;
+            borderRadius?: string | undefined;
+            titleColor?: string | undefined;
+            textColor?: string | undefined;
+            iconBackground?: string | undefined;
+            iconShadow?: string | undefined;
+            headerPadding?: string | undefined;
+            bodyPadding?: string | undefined;
+            gap?: string | undefined;
+        } | undefined;
+        notification?: {
+            background?: string | undefined;
+            border?: string | undefined;
+            borderRadius?: string | undefined;
+            textColor?: string | undefined;
+            iconBackground?: string | undefined;
+            textSecondaryColor?: string | undefined;
+            successColor?: string | undefined;
+            warningColor?: string | undefined;
+            errorColor?: string | undefined;
+            progressGradient?: string | undefined;
+        } | undefined;
+    }>;
+    get mode(): "dark" | "light";
+    get cssVariables(): Record<string, string>;
+    constructor(host: ReactiveControllerHost & HTMLElement, themeConfig?: CanvasThemeConfig, workspaceTheme?: CanvasThemeConfig);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    hostUpdated(): void;
+    /**
+     * Update theme config and re-compute + re-inject CSS variables.
+     */
+    setThemeConfig(themeConfig: CanvasThemeConfig, workspaceTheme?: CanvasThemeConfig): void;
+}

package/dist/controllers/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Lit ReactiveControllers — replacements for React hooks.
+ *
+ * These controllers provide the same reactive state management as the
+ * React hooks in RuntimeProvider.tsx and notification hooks, but work
+ * with any LitElement host via the ReactiveController protocol.
+ */
+export { DecisionController } from './DecisionController.js';
+export { NotificationsController } from './NotificationsController.js';
+export { RuntimeController } from './RuntimeController.js';
+export { RuntimeEventsController } from './RuntimeEventsController.js';
+export type { ThemeState } from './ThemeController.js';
+export { ThemeController } from './ThemeController.js';