@alxxsck/ai-assistant 2.25.3 → 2.26.0

package/dist/api/chat-attachments.api.d.ts

@@ -30,7 +30,6 @@ type BackendTransportDependencies = {
     wait?: typeof abortableDelay;
     pollIntervalMs?: number;
     maxPolls?: number;
-    createId?: () => string;
 };
 export declare const createBackendChatAttachmentTransport: (config: WidgetConfig, api: Pick<AppApi, "onSessionExpired">, dependencies?: BackendTransportDependencies) => ChatAttachmentTransport;
 export {};

package/dist/bridge-ai-chat-widget.es.js

@@ -1,4 +1,4 @@
-import { C as A, E as e, S as s, d as E, c } from "./index-DDvZeFFo.js";
+import { C as A, E as e, S as s, d as E, c } from "./index-D01wjcEK.js";
 export {
   A as ChatWidgetInstance,
   e as EXTERNALLY_AVAILABLE_ACTIONS,

package/dist/domain/client-environment/ClientEnvironmentRuntime.d.ts

@@ -0,0 +1,61 @@
+import type { CustomerInteractionSession } from "@/types";
+import { changeProjectionV1, collectClientEnvironmentV1 } from "./collectClientEnvironment";
+type ClientEnvironmentRuntimeOptions = Readonly<{
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    collect?: typeof collectClientEnvironmentV1;
+    project?: typeof changeProjectionV1;
+    createId?: () => string;
+    now?: () => number;
+    random?: () => number;
+    sdkVersion?: string;
+}>;
+export declare class ClientEnvironmentRuntime {
+    private readonly getSession;
+    private readonly onSessionExpired;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly collect;
+    private readonly project;
+    private readonly createId;
+    private readonly now;
+    private readonly random;
+    private readonly sdkVersion;
+    private sessionId;
+    private accessToken;
+    private generation;
+    private runtimeId;
+    private nextSequence;
+    private latestFenceRevision;
+    private lastStartedAt;
+    private cooldownUntil;
+    private lastCollectedProjection;
+    private acknowledged;
+    private active;
+    private pending;
+    private recovery;
+    private awaitingRenewalToken;
+    private currentProjectionUncertain;
+    private suppressedProjectionKey;
+    private pumpTimer;
+    private readonly eventWaiters;
+    private started;
+    private destroyed;
+    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void, options?: ClientEnvironmentRuntimeOptions);
+    start(): void;
+    ensureForEvent(expectedSessionId: string): Promise<string | null>;
+    updateSession(session: CustomerInteractionSession): void;
+    destroy(): void;
+    private requestCurrentObservation;
+    private startRecovery;
+    private pump;
+    private upload;
+    private runAttempts;
+    private sendOnce;
+    private withEventDeadline;
+    private delay;
+    private resetGeneration;
+    private safeCreateId;
+    private cancelGeneration;
+}
+export {};

package/dist/domain/client-environment/collectClientEnvironment.d.ts

@@ -0,0 +1,6 @@
+import { type ClientEnvironmentBrowserSources, type ClientEnvironmentChangeProjectionV1, type ClientEnvironmentCollectionInput, type ClientEnvironmentObservationV1 } from "./types";
+export declare const CLIENT_ENVIRONMENT_BROWSER_INSTANCE_STORAGE_KEY = "lola-ai-assistant:client-environment:browser-instance:v1";
+export declare const browserClientEnvironmentSources: ClientEnvironmentBrowserSources;
+export declare const resolveClientEnvironmentBrowserInstanceId: (sources?: ClientEnvironmentBrowserSources) => string | null;
+export declare const collectClientEnvironmentV1: (input: ClientEnvironmentCollectionInput, sources?: ClientEnvironmentBrowserSources) => ClientEnvironmentObservationV1;
+export declare const changeProjectionV1: (observation: ClientEnvironmentObservationV1, previous?: ClientEnvironmentChangeProjectionV1 | null) => ClientEnvironmentChangeProjectionV1;

package/dist/domain/client-environment/types.d.ts

@@ -0,0 +1,93 @@
+export declare const CLIENT_ENVIRONMENT_SCHEMA_VERSION: 1;
+export declare const CLIENT_ENVIRONMENT_CHANGE_PROJECTION_VERSION: 1;
+export type ClientEnvironmentOrientation = "portrait" | "landscape" | "unknown";
+export interface ClientEnvironmentObservationV1 {
+    readonly schemaVersion: typeof CLIENT_ENVIRONMENT_SCHEMA_VERSION;
+    readonly clientObservationId: string;
+    readonly clientRuntimeId: string;
+    readonly clientSequence: number;
+    readonly browserInstanceId: string | null;
+    readonly collectedAt: string;
+    readonly sdk: Readonly<{
+        name: "lola-ai-assistant";
+        version: string;
+    }>;
+    readonly locale: Readonly<{
+        language: string | null;
+        languages: readonly string[];
+        timeZone: string | null;
+        localUtcOffsetMinutes: number | null;
+    }>;
+    readonly screen: Readonly<{
+        widthCssPx: number | null;
+        heightCssPx: number | null;
+        availableWidthCssPx: number | null;
+        availableHeightCssPx: number | null;
+        devicePixelRatio: number | null;
+        orientation: ClientEnvironmentOrientation;
+    }>;
+    readonly viewport: Readonly<{
+        widthCssPx: number | null;
+        heightCssPx: number | null;
+        visualWidthCssPx: number | null;
+        visualHeightCssPx: number | null;
+        visualScale: number | null;
+    }>;
+    readonly interaction: Readonly<{
+        maxTouchPoints: number | null;
+        coarsePointer: boolean | null;
+        hoverSupported: boolean | null;
+    }>;
+}
+export interface ClientEnvironmentCollectionInput {
+    readonly clientObservationId: string;
+    readonly clientRuntimeId: string;
+    readonly clientSequence: number;
+    readonly sdkVersion: string;
+}
+export interface BrowserInstanceStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+export interface ClientEnvironmentBrowserSources {
+    readonly now: () => unknown;
+    readonly language: () => unknown;
+    readonly languages: () => unknown;
+    readonly timeZone: () => unknown;
+    readonly timeZoneOffsetMinutes: () => unknown;
+    readonly screenWidth: () => unknown;
+    readonly screenHeight: () => unknown;
+    readonly screenAvailableWidth: () => unknown;
+    readonly screenAvailableHeight: () => unknown;
+    readonly devicePixelRatio: () => unknown;
+    readonly screenOrientationType: () => unknown;
+    readonly viewportWidth: () => unknown;
+    readonly viewportHeight: () => unknown;
+    readonly visualViewportWidth: () => unknown;
+    readonly visualViewportHeight: () => unknown;
+    readonly visualViewportScale: () => unknown;
+    readonly maxTouchPoints: () => unknown;
+    readonly coarsePointer: () => unknown;
+    readonly hoverSupported: () => unknown;
+    readonly storage: () => BrowserInstanceStorage | null | undefined;
+    readonly randomUuid: () => unknown;
+}
+export interface ClientEnvironmentChangeProjectionV1 {
+    readonly projectionVersion: typeof CLIENT_ENVIRONMENT_CHANGE_PROJECTION_VERSION;
+    readonly browserInstanceId: string | null;
+    readonly language: string | null;
+    readonly languages: readonly string[];
+    readonly timeZone: string | null;
+    readonly localUtcOffsetMinutes: number | null;
+    readonly screenWidthCssPx: number | null;
+    readonly screenHeightCssPx: number | null;
+    readonly screenAvailableWidthCssPx: number | null;
+    readonly screenAvailableHeightCssPx: number | null;
+    readonly devicePixelRatio: number | null;
+    readonly orientation: ClientEnvironmentOrientation;
+    readonly viewportWidthBucketCssPx: number | null;
+    readonly visualScale: number | null;
+    readonly maxTouchPoints: number | null;
+    readonly coarsePointer: boolean | null;
+    readonly hoverSupported: boolean | null;
+}

package/dist/domain/command/CommandRuntime.d.ts

@@ -53,6 +53,7 @@ export declare class CommandRuntime {
     private requireEnvelopeTarget;
     private findTargetElement;
     private applyDefaultHighlight;
+    private applyHighlightEffect;
     private removeDefaultHighlight;
     private observeTarget;
     private createTargetActivationReporter;

package/dist/domain/tracking/LolaEventTracker.d.ts

@@ -1,4 +1,5 @@
 import type { CustomerInteractionSession } from "@/types";
+import type { ClientEnvironmentRuntime } from "@/domain/client-environment/ClientEnvironmentRuntime";
 export type TrackEvent = {
     event: string;
     params?: Record<string, unknown>;
@@ -6,6 +7,9 @@ export type TrackEvent = {
 export declare class LolaEventTracker {
     private readonly getSession;
     private readonly onSessionExpired;
-    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void);
+    private readonly clientEnvironment;
+    private destroyed;
+    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void, clientEnvironment: Pick<ClientEnvironmentRuntime, "ensureForEvent">);
     track(trackingEvent: TrackEvent): Promise<void>;
+    destroy(): void;
 }