@veltdev/sdk 5.0.2-beta.33 → 5.0.2-beta.35

package/app/client/snippyly.model.d.ts

@@ -24,6 +24,7 @@ import { TagElement } from "../models/element/tag-element.model";
 import { FeatureType } from "../utils/enums";
 import { UserContact } from "../models/data/user-contact.data.model";
 import { DocumentMetadata } from "../models/data/document-metadata.model";
+import { PageInfo } from "../models/data/page-info.model";
 import { ReactionElement } from "../models/element/reaction-element.model";
 import { CrdtElement } from "../models/element/crdt-element.model";
 import { VeltEventMetadata, VeltDebugInfo } from "../models/data/event-metadata.data.model";
@@ -55,6 +56,23 @@ export declare class Snippyly {
     * @param documentMetadata Document Metadata
     */
    setDocument: (id: string, documentMetadata?: DocumentMetadata) => Promise<void>;
+   /**
+    * Provide custom page info that the SDK should use instead of generating it from the browser
+    * (`window.location` / `document.title`). Newly created data (comments, reactions, recordings,
+    * presence, cursors, etc.) will use the provided page info. Already saved/existing data is not
+    * affected.
+    * @param pageInfo client-provided page info
+    * @param options optional; pass a `documentId` to scope the page info to a specific document
+    *                (per-document page info takes precedence over the global page info)
+    */
+   setPageInfo: (pageInfo: PageInfo, options?: { documentId?: string; }) => void;
+   /**
+    * Clear custom page info previously set via `setPageInfo`. The SDK will resume generating
+    * page info from the browser.
+    * @param options optional; pass a `documentId` to clear only that document's page info,
+    *                otherwise the global page info is cleared
+    */
+   clearPageInfo: (options?: { documentId?: string; }) => void;
    /**
     * Tell us the unique ID of the current document/resource on which you want to enable collaboration.
     * @param id unique document ID

package/app/models/data/notification.model.d.ts

@@ -257,3 +257,23 @@ export interface NotificationsDocConfig {
 export interface GetNotificationsDataQuery {
     type?: 'all' | 'forYou' | 'documents';
 }
+/**
+ * Configuration for the opt-in cross-organization "For You" notifications feature.
+ *
+ * When enabled, the SDK merges notifications from other organizations the user
+ * belongs to (resolved from the global `userNotificationIndex`) into the existing
+ * "For You" feed. All fields are optional; sensible defaults are applied by
+ * `NotificationService.setCrossOrganizationConfig`.
+ *
+ * @see specs/notification-api-scope/spec.md
+ */
+export interface CrossOrganizationConfig {
+    /** Whether cross-organization notifications are active. Defaults to `true` on enable. */
+    enabled?: boolean;
+    /** Allowlist of organization IDs to include. When omitted, all indexed orgs are eligible. */
+    organizationIds?: string[];
+    /** Organization IDs to exclude. The current organization is always excluded. */
+    excludeOrganizationIds?: string[];
+    /** Feeds the merge applies to. Only `'forYou'` is supported; `'all'` is ignored with a warning. */
+    feeds?: ('forYou' | 'all')[];
+}

package/app/models/data/page-info.model.d.ts

@@ -47,4 +47,13 @@ export declare class PageInfo {
      */
     screenWidth?: number;
     deviceInfo?: IDeviceInfo;
+    /**
+     * @param applyClientOverride when true (default), merges the CURRENT document's client page
+     *        info override at construction time — covers the bare `new PageInfo()` sites
+     *        (cursor / presence / selection). No-op when the client hasn't provided any, so the
+     *        default empty-page-info behavior is unchanged. `getPageInfo(documentId)` passes
+     *        `false` so it can apply a specific document's override itself, without the current
+     *        document's fields leaking onto a different document's page info.
+     */
+    constructor(applyClientOverride?: boolean);
 }

package/app/models/data/user.data.model.d.ts

@@ -1,4 +1,5 @@
 import { SetDocumentsContext } from "./document.data.model";
+import { ResolverEndpointConfig, ResolverResponse } from "./resolver.data.model";
 import { UserContact } from "./user-contact.data.model";
 import { UserPermissionAccessRole } from "./user-resolver.data.model";
 export declare class User {
@@ -145,6 +146,51 @@ export interface VeltPermissionProvider {
     isContextEnabled?: boolean;
     revokeAccessOn?: RevokeAccessOn[];
     forceRefresh?: boolean;
+    /**
+     * LOCAL-DEV ONLY. When `true`, the SDK resolves permissions in the browser
+     * (via {@link endpointConfig} or {@link resolvePermissions}) and relays the
+     * results to the backend, instead of relying on the server-to-server
+     * Real-Time Permission Provider. This lets a `localhost` permission endpoint
+     * be reached without an ngrok/Cloudflare tunnel during development.
+     *
+     * This flag is an ergonomic switch only — it is NOT a security boundary.
+     * The backend independently gates browser-resolved results to dev/test API
+     * keys; production keys always ignore them and fall back to the server-side
+     * provider. MUST NOT be relied on in production.
+     */
+    dev?: boolean;
+    /**
+     * URL-based client-side resolver. When set (and {@link dev} is `true`), the
+     * browser POSTs `{ data: { requests } }` to `url` — byte-for-byte identical
+     * to what the server-side permission provider sends — and expects the same
+     * `{ data: PermissionResult[], success, statusCode }` response. Takes
+     * precedence over {@link resolvePermissions} when both are provided.
+     */
+    endpointConfig?: ResolverEndpointConfig;
+    /**
+     * Callback-based client-side resolver. When set (and {@link dev} is `true`,
+     * and no {@link endpointConfig} URL is provided), it is invoked with the
+     * same `{ data: { requests } }` envelope and may return either a bare
+     * `PermissionResult[]` or a `ResolverResponse<PermissionResult[]>`.
+     */
+    resolvePermissions?: (request: PermissionResolverRequest) => Promise<PermissionResult[] | ResolverResponse<PermissionResult[]>>;
+    /**
+     * Optional per-call timeout (ms) for the client-side resolver. When the
+     * resolver does not settle within this window the check fails closed (deny).
+     */
+    resolveTimeout?: number;
+}
+/**
+ * The request envelope handed to a client-side permission resolver
+ * ({@link VeltPermissionProvider.endpointConfig} URL body or
+ * {@link VeltPermissionProvider.resolvePermissions} callback argument). The
+ * shape mirrors the server-side permission provider request byte-for-byte so a
+ * customer's existing handler works unchanged.
+ */
+export interface PermissionResolverRequest {
+    data: {
+        requests: PermissionQuery[];
+    };
 }
 export declare enum PermissionResourceType {
     FOLDER = "folder",

package/app/models/element/notification-element.model.d.ts

@@ -1,7 +1,6 @@
 // @ts-nocheck
 
-import { GetNotificationsDataQuery, Notification, NotificationInitialSettingsConfig, NotificationSettingsConfig, NotificationTabConfig } from "../data/notification.model";
-import { CrossOrganizationConfig } from "./cross-organization-config.model";
+import { CrossOrganizationConfig, GetNotificationsDataQuery, Notification, NotificationInitialSettingsConfig, NotificationSettingsConfig, NotificationTabConfig } from "../data/notification.model";
 
 export declare class NotificationElement {
     /**

package/app/utils/console.d.ts

@@ -0,0 +1,25 @@
+export declare class Console {
+    static log: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    static warn: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    static error: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    static debug: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    static info: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    static logsEnabled: boolean;
+    static catch: (message: string, error?: any) => void;
+    static showLogs(): boolean;
+}

package/app/utils/constants.d.ts

@@ -439,6 +439,7 @@ export declare class Constants {
         VELT_SKELETON_LOADER: string;
         VELT_SHADOW_DOM_INTERNAL: string;
         VELT_SINGLE_EDITOR_MODE_PANEL: string;
+        VELT_MULTI_THREAD_COMMENT_DIALOG: string;
         VELT_MULTI_THREAD_COMMENT_DIALOG_LIST: string;
         VELT_MULTI_THREAD_COMMENT_DIALOG_PANEL: string;
         VELT_MULTI_THREAD_COMMENT_DIALOG_COMPOSER_CONTAINER: string;

package/app/utils/page-info-store.d.ts

@@ -0,0 +1,29 @@
+import type { PageInfo } from "../models/data/page-info.model";
+/**
+ * Register a resolver that returns the current client document id.
+ * Used to pick the right per-document override when no explicit document id is passed.
+ */
+export declare const registerCurrentClientDocumentIdGetter: (getter: () => string | number | undefined | null) => void;
+/**
+ * Set client-provided page info.
+ * @param pageInfo page info provided by the client
+ * @param documentId optional client document id; when omitted, sets the global override
+ */
+export declare const setClientPageInfo: (pageInfo: Partial<PageInfo> | undefined | null, documentId?: string | number) => void;
+/**
+ * Clear client-provided page info.
+ * @param documentId optional client document id; when omitted, clears the global override
+ */
+export declare const clearClientPageInfo: (documentId?: string | number) => void;
+/**
+ * Get the client-provided page info that applies for the given (or current) document.
+ * Per-document override wins; otherwise falls back to the global override.
+ * @param documentId optional client document id; when omitted, resolves the current document
+ * @returns client page info, or undefined when the client has not provided any
+ */
+export declare const getClientPageInfo: (documentId?: string | number) => Partial<PageInfo> | undefined;
+/**
+ * Reset all client page info and the registered document-id resolver.
+ * Intended for tests.
+ */
+export declare const resetClientPageInfo: () => void;

package/environments/environment.d.ts

@@ -0,0 +1,45 @@
+export declare const environment: {
+    production: boolean;
+    staging: boolean;
+    firebaseLogLevel: string;
+    firebaseConfig: {
+        apiKey: string;
+        authDomain: string;
+        projectId: string;
+        storageBucket: string;
+        messagingSenderId: string;
+        appId: string;
+    };
+    firebaseNotificationsDatabaseURL: string;
+    segmentAnalyticsWriteKey: string;
+    useEmulators: boolean;
+    debugMode: boolean;
+    cloudFunction: {
+        sa: string;
+        getIceServers: string;
+        validateClient: string;
+        convertRecording: string;
+        chatgptCompletion: string;
+        rewriterAskAi: string;
+        whisperTranscription: string;
+        getPlanDetails: string;
+        getAllowedDocuments: string;
+        getNotificationsForDocuments: string;
+        videoBackend: string;
+        processRecording: string;
+        sdkProxy: string;
+        screenshot: string;
+        usCentral1: {
+            setEncryptedData: string;
+        };
+        asiaSouthEast1: {
+            setEncryptedData: string;
+        };
+        europeWest1: {
+            setEncryptedData: string;
+        };
+        asiaNorthEast1: {
+            setEncryptedData: string;
+        };
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@veltdev/sdk",
-    "version": "5.0.2-beta.33",
+    "version": "5.0.2-beta.35",
     "description": "Velt is an SDK to add collaborative features to your product within minutes. Example: Comments like Figma, Frame.io, Google docs or sheets, Recording like Loom, Huddles like Slack and much more.",
     "homepage": "https://velt.dev",
     "keywords": [