stream-chat 9.11.0 → 9.12.0

package/dist/cjs/index.browser.cjs

@@ -178,6 +178,7 @@ __export(index_exports, {
   DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS: () => DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS,
   DEFAULT_COMPOSER_CONFIG: () => DEFAULT_COMPOSER_CONFIG,
   DEFAULT_LINK_PREVIEW_MANAGER_CONFIG: () => DEFAULT_LINK_PREVIEW_MANAGER_CONFIG,
+  DEFAULT_LOCATION_COMPOSER_CONFIG: () => DEFAULT_LOCATION_COMPOSER_CONFIG,
   DEFAULT_PAGINATION_OPTIONS: () => DEFAULT_PAGINATION_OPTIONS,
   DEFAULT_REMINDER_MANAGER_CONFIG: () => DEFAULT_REMINDER_MANAGER_CONFIG,
   DEFAULT_STOP_REFRESH_BOUNDARY_MS: () => DEFAULT_STOP_REFRESH_BOUNDARY_MS,
@@ -193,6 +194,8 @@ __export(index_exports, {
   JWTUserToken: () => JWTUserToken,
   LinkPreviewStatus: () => LinkPreviewStatus,
   LinkPreviewsManager: () => LinkPreviewsManager,
+  LiveLocationManager: () => LiveLocationManager,
+  LocationComposer: () => LocationComposer,
   MAX_POLL_OPTIONS: () => MAX_POLL_OPTIONS,
   MODERATION_ENTITY_TYPES: () => MODERATION_ENTITY_TYPES,
   MaxPriority: () => MaxPriority,
@@ -229,6 +232,7 @@ __export(index_exports, {
   Thread: () => Thread,
   ThreadManager: () => ThreadManager,
   TokenManager: () => TokenManager,
+  UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT: () => UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT,
   UserFromToken: () => UserFromToken,
   UserSearchSource: () => UserSearchSource,
   VALID_MAX_VOTES_VALUE_REGEX: () => VALID_MAX_VOTES_VALUE_REGEX,
@@ -259,6 +263,7 @@ __export(index_exports, {
   createMentionsMiddleware: () => createMentionsMiddleware,
   createMessageComposerStateCompositionMiddleware: () => createMessageComposerStateCompositionMiddleware,
   createPollComposerStateMiddleware: () => createPollComposerStateMiddleware,
+  createSharedLocationCompositionMiddleware: () => createSharedLocationCompositionMiddleware,
   createTextComposerCompositionMiddleware: () => createTextComposerCompositionMiddleware,
   createTextComposerPreValidationMiddleware: () => createTextComposerPreValidationMiddleware,
   decodeBase64: () => decodeBase64,
@@ -295,6 +300,7 @@ __export(index_exports, {
   isOwnUser: () => isOwnUser,
   isPatch: () => isPatch,
   isScrapedContent: () => isScrapedContent,
+  isSharedLocationResponse: () => isSharedLocationResponse,
   isTargetedOptionTextUpdate: () => isTargetedOptionTextUpdate,
   isUploadedAttachment: () => isUploadedAttachment,
   isVideoAttachment: () => isVideoAttachment,
@@ -4019,6 +4025,7 @@ var isLocalVoiceRecordingAttachment = (attachment) => isVoiceRecordingAttachment
 var isVideoAttachment = (attachment, supportedVideoFormat = []) => attachment.type === "video" || !!(attachment.mime_type && supportedVideoFormat.indexOf(attachment.mime_type) !== -1);
 var isLocalVideoAttachment = (attachment) => isVideoAttachment(attachment) && isLocalAttachment(attachment);
 var isUploadedAttachment = (attachment) => isAudioAttachment(attachment) || isFileAttachment(attachment) || isImageAttachment(attachment) || isVideoAttachment(attachment) || isVoiceRecordingAttachment(attachment);
+var isSharedLocationResponse = (location) => !!location.latitude && !!location.longitude && !!location.channel_cid;
 
 // src/messageComposer/fileUtils.ts
 var isFile2 = (fileLike) => !!fileLike.lastModified && !("uri" in fileLike);
@@ -5061,10 +5068,15 @@ var DEFAULT_TEXT_COMPOSER_CONFIG = {
   enabled: true,
   publishTypingEvents: true
 };
+var DEFAULT_LOCATION_COMPOSER_CONFIG = {
+  enabled: true,
+  getDeviceId: () => generateUUIDv4()
+};
 var DEFAULT_COMPOSER_CONFIG = {
   attachments: DEFAULT_ATTACHMENT_MANAGER_CONFIG,
   drafts: { enabled: false },
   linkPreviews: DEFAULT_LINK_PREVIEW_MANAGER_CONFIG,
+  location: DEFAULT_LOCATION_COMPOSER_CONFIG,
   text: DEFAULT_TEXT_COMPOSER_CONFIG
 };
 
@@ -5320,6 +5332,54 @@ _LinkPreviewsManager.getPreviewData = (preview) => {
 };
 var LinkPreviewsManager = _LinkPreviewsManager;
 
+// src/messageComposer/LocationComposer.ts
+var MIN_LIVE_LOCATION_SHARE_DURATION = 60 * 1e3;
+var initState4 = ({
+  message
+}) => ({
+  location: message?.shared_location ?? null
+});
+var LocationComposer = class {
+  constructor({ composer, message }) {
+    this.initState = ({ message } = {}) => {
+      this.state.next(initState4({ message }));
+    };
+    this.setData = (data) => {
+      if (!this.config.enabled) return;
+      if (!data.latitude || !data.longitude) return;
+      this.state.partialNext({
+        location: {
+          ...data,
+          message_id: this.composer.id,
+          created_by_device_id: this.deviceId
+        }
+      });
+    };
+    this.composer = composer;
+    this.state = new StateStore(initState4({ message }));
+    this._deviceId = this.config.getDeviceId();
+  }
+  get config() {
+    return this.composer.config.location;
+  }
+  get deviceId() {
+    return this._deviceId;
+  }
+  get location() {
+    return this.state.getLatestValue().location;
+  }
+  get validLocation() {
+    const { durationMs, ...location } = this.location ?? {};
+    if (!!location?.created_by_device_id && location.message_id && location.latitude && location.longitude && (typeof durationMs === "undefined" || durationMs >= MIN_LIVE_LOCATION_SHARE_DURATION)) {
+      return {
+        ...location,
+        end_at: durationMs && new Date(Date.now() + durationMs).toISOString()
+      };
+    }
+    return null;
+  }
+};
+
 // src/utils/concurrency.ts
 var withoutConcurrency = createRunner(wrapWithContinuationTracking);
 var withCancellation = createRunner(wrapWithCancellation);
@@ -6003,9 +6063,8 @@ var createCompositionValidationMiddleware = (composer) => ({
     }) => {
       const { maxLengthOnSend } = composer.config.text ?? {};
       const inputText = state.message.text ?? "";
-      const isEmptyMessage = textIsEmpty(inputText) && !state.message.attachments?.length && !state.message.poll_id;
       const hasExceededMaxLength = typeof maxLengthOnSend === "number" && inputText.length > maxLengthOnSend;
-      if (isEmptyMessage || hasExceededMaxLength) {
+      if (composer.compositionIsEmpty || hasExceededMaxLength) {
         return await discard();
       }
       return await forward();
@@ -6285,6 +6344,40 @@ var createPollOnlyCompositionMiddleware = (composer) => ({
   }
 });
 
+// src/messageComposer/middleware/messageComposer/sharedLocation.ts
+var createSharedLocationCompositionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/shared-location",
+  handlers: {
+    compose: ({
+      state,
+      next,
+      forward
+    }) => {
+      const { locationComposer } = composer;
+      const location = locationComposer.validLocation;
+      if (!locationComposer || !location || !composer.client.user) return forward();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      return next({
+        ...state,
+        localMessage: {
+          ...state.localMessage,
+          shared_location: {
+            ...location,
+            channel_cid: composer.channel.cid,
+            created_at: timestamp,
+            updated_at: timestamp,
+            user_id: composer.client.user.id
+          }
+        },
+        message: {
+          ...state.message,
+          shared_location: location
+        }
+      });
+    }
+  }
+});
+
 // src/messageComposer/middleware/messageComposer/MessageComposerMiddlewareExecutor.ts
 var MessageComposerMiddlewareExecutor = class extends MiddlewareExecutor {
   constructor({ composer }) {
@@ -6295,6 +6388,7 @@ var MessageComposerMiddlewareExecutor = class extends MiddlewareExecutor {
       createTextComposerCompositionMiddleware(composer),
       createAttachmentsCompositionMiddleware(composer),
       createLinkPreviewsCompositionMiddleware(composer),
+      createSharedLocationCompositionMiddleware(composer),
       createMessageComposerStateCompositionMiddleware(composer),
       createCustomDataCompositionMiddleware(composer),
       createCompositionValidationMiddleware(composer),
@@ -7336,7 +7430,7 @@ var textIsEmpty = (text) => {
   const trimmedText = text.trim();
   return trimmedText === "" || trimmedText === ">" || trimmedText === "``````" || trimmedText === "``" || trimmedText === "**" || trimmedText === "____" || trimmedText === "__" || trimmedText === "****";
 };
-var initState4 = ({
+var initState5 = ({
   composer,
   message
 }) => {
@@ -7361,7 +7455,7 @@ var initState4 = ({
 var TextComposer = class {
   constructor({ composer, message }) {
     this.initState = ({ message } = {}) => {
-      this.state.next(initState4({ composer: this.composer, message }));
+      this.state.next(initState5({ composer: this.composer, message }));
     };
     this.upsertMentionedUser = (user) => {
       const mentionedUsers = [...this.mentionedUsers];
@@ -7489,7 +7583,7 @@ var TextComposer = class {
       this.state.next(output.state);
     };
     this.composer = composer;
-    this.state = new StateStore(initState4({ composer, message }));
+    this.state = new StateStore(initState5({ composer, message }));
     this.middlewareExecutor = new TextComposerMiddlewareExecutor({ composer });
   }
   get channel() {
@@ -8062,7 +8156,7 @@ var initEditingAuditState = (composition) => {
     }
   };
 };
-var initState5 = (composition) => {
+var initState6 = (composition) => {
   if (!composition) {
     return {
       draftId: null,
@@ -8100,6 +8194,9 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     client
   }) {
     super();
+    this.refreshId = () => {
+      this.state.partialNext({ id: _MessageComposer.generateId() });
+    };
     this.initState = ({
       composition
     } = {}) => {
@@ -8107,10 +8204,11 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
       const message = typeof composition === "undefined" ? composition : compositionIsDraftResponse(composition) ? composition.message : formatMessage(composition);
       this.attachmentManager.initState({ message });
       this.linkPreviewsManager.initState({ message });
+      this.locationComposer.initState({ message });
       this.textComposer.initState({ message });
       this.pollComposer.initState();
       this.customDataManager.initState({ message });
-      this.state.next(initState5(composition));
+      this.state.next(initState6(composition));
       if (composition && !compositionIsDraftResponse(composition) && message && isLocalMessage(message)) {
         this.editedMessage = message;
       }
@@ -8150,6 +8248,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
         this.addUnsubscribeFunction(this.subscribeTextComposerStateChanged());
         this.addUnsubscribeFunction(this.subscribeAttachmentManagerStateChanged());
         this.addUnsubscribeFunction(this.subscribeLinkPreviewsManagerStateChanged());
+        this.addUnsubscribeFunction(this.subscribeLocationComposerStateChanged());
         this.addUnsubscribeFunction(this.subscribePollComposerStateChanged());
         this.addUnsubscribeFunction(this.subscribeCustomDataManagerStateChanged());
         this.addUnsubscribeFunction(this.subscribeMessageComposerStateChanged());
@@ -8246,6 +8345,14 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
         return;
       }
     });
+    this.subscribeLocationComposerStateChanged = () => this.locationComposer.state.subscribe((_, previousValue) => {
+      if (typeof previousValue === "undefined") return;
+      this.logStateUpdateTimestamp();
+      if (this.compositionIsEmpty) {
+        this.deleteDraft();
+        return;
+      }
+    });
     this.subscribeLinkPreviewsManagerStateChanged = () => this.linkPreviewsManager.state.subscribe((_, previousValue) => {
       if (typeof previousValue === "undefined") return;
       this.logStateUpdateTimestamp();
@@ -8466,10 +8573,32 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
         throw error;
       }
     };
+    this.sendLocation = async () => {
+      const location = this.locationComposer.validLocation;
+      if (this.threadId || !location) return;
+      try {
+        await this.channel.sendSharedLocation(location);
+        this.refreshId();
+        this.locationComposer.initState();
+      } catch (error) {
+        this.client.notifications.addError({
+          message: "Failed to share the location",
+          origin: {
+            emitter: "MessageComposer",
+            context: { composer: this }
+          },
+          options: {
+            type: "api:location:create:failed",
+            metadata: {
+              reason: error.message
+            },
+            originalError: error instanceof Error ? error : void 0
+          }
+        });
+        throw error;
+      }
+    };
     this.compositionContext = compositionContext;
-    this.configState = new StateStore(
-      mergeWith(DEFAULT_COMPOSER_CONFIG, config ?? {})
-    );
     if (compositionContext instanceof Channel) {
       this.channel = compositionContext;
     } else if (compositionContext instanceof Thread) {
@@ -8482,6 +8611,21 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
         "MessageComposer requires composition context pointing to channel (channel or context.cid)"
       );
     }
+    const mergeChannelConfigCustomizer = (originalVal, channelConfigVal, key) => typeof originalVal === "object" ? void 0 : originalVal === false && key === "enabled" ? false : ["string", "number", "bigint", "boolean", "symbol"].includes(
+      // prevent enabling features that are disabled server-side
+      typeof channelConfigVal
+    ) ? channelConfigVal : originalVal;
+    this.configState = new StateStore(
+      mergeWith(
+        mergeWith(DEFAULT_COMPOSER_CONFIG, config ?? {}),
+        {
+          location: {
+            enabled: this.channel.getConfig()?.shared_locations
+          }
+        },
+        mergeChannelConfigCustomizer
+      )
+    );
     let message = void 0;
     if (compositionIsDraftResponse(composition)) {
       message = composition.message;
@@ -8491,13 +8635,14 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     }
     this.attachmentManager = new AttachmentManager({ composer: this, message });
     this.linkPreviewsManager = new LinkPreviewsManager({ composer: this, message });
+    this.locationComposer = new LocationComposer({ composer: this, message });
     this.textComposer = new TextComposer({ composer: this, message });
     this.pollComposer = new PollComposer({ composer: this });
     this.customDataManager = new CustomDataManager({ composer: this, message });
     this.editingAuditState = new StateStore(
       this.initEditingAuditState(composition)
     );
-    this.state = new StateStore(initState5(composition));
+    this.state = new StateStore(initState6(composition));
     this.compositionMiddlewareExecutor = new MessageComposerMiddlewareExecutor({
       composer: this
     });
@@ -8572,10 +8717,10 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     if (this.client.offlineDb) {
       return !this.compositionIsEmpty;
     }
-    return !!(!this.attachmentManager.uploadsInProgressCount && (!this.textComposer.textIsEmpty || this.attachmentManager.successfulUploadsCount > 0) || this.pollId);
+    return !!(!this.attachmentManager.uploadsInProgressCount && (!this.textComposer.textIsEmpty || this.attachmentManager.successfulUploadsCount > 0) || this.pollId || !!this.locationComposer.validLocation);
   }
   get compositionIsEmpty() {
-    return !this.quotedMessage && this.textComposer.textIsEmpty && !this.attachmentManager.attachments.length && !this.pollId;
+    return !this.quotedMessage && this.textComposer.textIsEmpty && !this.attachmentManager.attachments.length && !this.pollId && !this.locationComposer.validLocation;
   }
   get lastChangeOriginIsLocal() {
     const initiatedWithoutDraft = this.lastChange.draftUpdate === null;
@@ -9102,6 +9247,30 @@ var Channel = class {
     this.data = data.channel;
     return data;
   }
+  async sendSharedLocation(location, userId) {
+    const result = await this.sendMessage({
+      id: location.message_id,
+      shared_location: location,
+      user: userId ? { id: userId } : void 0
+    });
+    if (location.end_at) {
+      this.getClient().dispatchEvent({
+        message: result.message,
+        type: "live_location_sharing.started"
+      });
+    }
+    return result;
+  }
+  async stopLiveLocationSharing(payload) {
+    const location = await this.getClient().updateLocation({
+      ...payload,
+      end_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.getClient().dispatchEvent({
+      live_location: location,
+      type: "live_location_sharing.stopped"
+    });
+  }
   /**
    * delete - Delete the channel. Messages are permanently removed.
    *
@@ -12348,7 +12517,8 @@ var ChannelManager = class extends WithSubscriptions {
   constructor({
     client,
     eventHandlerOverrides = {},
-    options = {}
+    options = {},
+    queryChannelsOverride
   }) {
     super();
     this.eventHandlers = /* @__PURE__ */ new Map();
@@ -12388,6 +12558,9 @@ var ChannelManager = class extends WithSubscriptions {
         Object.entries(truthyEventHandlerOverrides)
       );
     };
+    this.setQueryChannelsRequest = (queryChannelsRequest) => {
+      this.queryChannelsRequest = queryChannelsRequest;
+    };
     this.setOptions = (options = {}) => {
       this.options = { ...DEFAULT_CHANNEL_MANAGER_OPTIONS, ...options };
     };
@@ -12398,7 +12571,7 @@ var ChannelManager = class extends WithSubscriptions {
         ...options
       };
       try {
-        const channels = await this.client.queryChannels(
+        const channels = await this.queryChannelsRequest(
           filters,
           sort,
           options,
@@ -12514,7 +12687,7 @@ var ChannelManager = class extends WithSubscriptions {
         this.state.partialNext({
           pagination: { ...pagination, isLoading: false, isLoadingNext: true }
         });
-        const nextChannels = await this.client.queryChannels(
+        const nextChannels = await this.queryChannelsRequest(
           filters,
           sort,
           options,
@@ -12757,6 +12930,7 @@ var ChannelManager = class extends WithSubscriptions {
     });
     this.setEventHandlerOverrides(eventHandlerOverrides);
     this.setOptions(options);
+    this.queryChannelsRequest = queryChannelsOverride ?? ((...params) => this.client.queryChannels(...params));
     this.eventHandlers = new Map(
       Object.entries({
         channelDeletedHandler: this.channelDeletedHandler,
@@ -13458,8 +13632,14 @@ var StreamChat = class _StreamChat {
      */
     this.createChannelManager = ({
       eventHandlerOverrides = {},
-      options = {}
-    }) => new ChannelManager({ client: this, eventHandlerOverrides, options });
+      options = {},
+      queryChannelsOverride
+    }) => new ChannelManager({
+      client: this,
+      eventHandlerOverrides,
+      options,
+      queryChannelsOverride
+    });
     /**
      * Creates a new WebSocket connection with the current user. Returns empty promise, if there is an active connection
      */
@@ -15563,7 +15743,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.11.0";
+    const version = "9.12.0";
     const clientBundle = "browser-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -16655,9 +16835,9 @@ var StreamChat = class _StreamChat {
   /**
    * updateLocation - Updates a location
    *
-   * @param location UserLocation the location data to update
+   * @param location SharedLocationRequest the location data to update
    *
-   * @returns {Promise<APIResponse>} The server response
+   * @returns {Promise<SharedLocationResponse>} The server response
    */
   async updateLocation(location) {
     return await this.put(
@@ -16778,6 +16958,8 @@ var EVENT_MAP = {
   "connection.recovered": true,
   "transport.changed": true,
   "capabilities.changed": true,
+  "live_location_sharing.started": true,
+  "live_location_sharing.stopped": true,
   // Reminder events
   "reminder.created": true,
   "reminder.updated": true,
@@ -17633,6 +17815,200 @@ var AbstractOfflineDB = class {
   }
 };
 
+// src/LiveLocationManager.ts
+var isExpiredLocation = (location) => {
+  const endTimeTimestamp = new Date(location.end_at).getTime();
+  return endTimeTimestamp < Date.now();
+};
+function isValidLiveLocationMessage(message) {
+  if (!message || message.type === "deleted" || !message.shared_location?.end_at)
+    return false;
+  return !isExpiredLocation(message.shared_location);
+}
+var UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT = 3e3;
+var _LiveLocationManager = class _LiveLocationManager extends WithSubscriptions {
+  constructor({
+    client,
+    getDeviceId,
+    watchLocation
+  }) {
+    if (!client.userID) {
+      throw new Error("Live-location sharing is reserved for client-side use only");
+    }
+    super();
+    this.registerSubscriptions = () => {
+      this.incrementRefCount();
+      if (this.hasSubscriptions) return;
+      this.addUnsubscribeFunction(this.subscribeLiveLocationSharingUpdates());
+      this.addUnsubscribeFunction(this.subscribeTargetMessagesChange());
+    };
+    this.unregisterSubscriptions = () => super.unregisterSubscriptions();
+    this.client = client;
+    this.state = new StateStore({
+      messages: /* @__PURE__ */ new Map(),
+      ready: false
+    });
+    this._deviceId = getDeviceId();
+    this.getDeviceId = getDeviceId;
+    this.watchLocation = watchLocation;
+  }
+  async init() {
+    await this.assureStateInit();
+    this.registerSubscriptions();
+  }
+  get messages() {
+    return this.state.getLatestValue().messages;
+  }
+  get stateIsReady() {
+    return this.state.getLatestValue().ready;
+  }
+  get deviceId() {
+    if (!this._deviceId) {
+      this._deviceId = this.getDeviceId();
+    }
+    return this._deviceId;
+  }
+  async assureStateInit() {
+    if (this.stateIsReady) return;
+    const { active_live_locations } = await this.client.getSharedLocations();
+    this.state.next({
+      messages: new Map(
+        active_live_locations.filter((location) => !isExpiredLocation(location)).map((location) => [
+          location.message_id,
+          {
+            ...location,
+            stopSharingTimeout: setTimeout(
+              () => {
+                this.unregisterMessages([location.message_id]);
+              },
+              new Date(location.end_at).getTime() - Date.now()
+            )
+          }
+        ])
+      ),
+      ready: true
+    });
+  }
+  subscribeTargetMessagesChange() {
+    let unsubscribeWatchLocation = null;
+    const unsubscribe = this.state.subscribeWithSelector(
+      ({ messages }) => ({ messages }),
+      ({ messages }) => {
+        if (!messages.size) {
+          unsubscribeWatchLocation?.();
+          unsubscribeWatchLocation = null;
+        } else if (messages.size && !unsubscribeWatchLocation) {
+          unsubscribeWatchLocation = this.subscribeWatchLocation();
+        }
+      }
+    );
+    return () => {
+      unsubscribe();
+      unsubscribeWatchLocation?.();
+    };
+  }
+  subscribeWatchLocation() {
+    let nextAllowedUpdateCallTimestamp = Date.now();
+    const unsubscribe = this.watchLocation(({ latitude, longitude }) => {
+      if (Date.now() < nextAllowedUpdateCallTimestamp) return;
+      nextAllowedUpdateCallTimestamp = Date.now() + UPDATE_LIVE_LOCATION_REQUEST_MIN_THROTTLE_TIMEOUT;
+      withCancellation(_LiveLocationManager.symbol, async () => {
+        const promises = [];
+        await this.assureStateInit();
+        const expiredLocations = [];
+        for (const [messageId, location] of this.messages) {
+          if (isExpiredLocation(location)) {
+            expiredLocations.push(location.message_id);
+            continue;
+          }
+          if (location.latitude === latitude && location.longitude === longitude)
+            continue;
+          const promise = this.client.updateLocation({
+            created_by_device_id: location.created_by_device_id,
+            message_id: messageId,
+            latitude,
+            longitude
+          });
+          promises.push(promise);
+        }
+        this.unregisterMessages(expiredLocations);
+        if (promises.length > 0) {
+          await Promise.allSettled(promises);
+        }
+      });
+    });
+    return unsubscribe;
+  }
+  subscribeLiveLocationSharingUpdates() {
+    const subscriptions = [
+      ...[
+        "live_location_sharing.started",
+        "message.updated",
+        "message.deleted"
+      ].map(
+        (eventType) => this.client.on(eventType, (event) => {
+          if (!event.message) return;
+          if (event.type === "live_location_sharing.started") {
+            this.registerMessage(event.message);
+          } else if (event.type === "message.updated") {
+            const isRegistered = this.messages.has(event.message.id);
+            if (isRegistered && !isValidLiveLocationMessage(event.message)) {
+              this.unregisterMessages([event.message.id]);
+            }
+            this.registerMessage(event.message);
+          } else {
+            this.unregisterMessages([event.message.id]);
+          }
+        })
+      ),
+      this.client.on("live_location_sharing.stopped", (event) => {
+        if (!event.live_location) return;
+        this.unregisterMessages([event.live_location?.message_id]);
+      })
+    ];
+    return () => subscriptions.forEach((subscription) => subscription.unsubscribe());
+  }
+  registerMessage(message) {
+    if (!this.client.userID || message?.user?.id !== this.client.userID || !isValidLiveLocationMessage(message))
+      return;
+    this.state.next((currentValue) => {
+      const messages = new Map(currentValue.messages);
+      messages.set(message.id, {
+        ...message.shared_location,
+        stopSharingTimeout: setTimeout(
+          () => {
+            this.unregisterMessages([message.id]);
+          },
+          new Date(message.shared_location.end_at).getTime() - Date.now()
+        )
+      });
+      return {
+        ...currentValue,
+        messages
+      };
+    });
+  }
+  unregisterMessages(messageIds) {
+    const messages = this.messages;
+    const removedMessages = new Set(messageIds);
+    const newMessages = new Map(
+      Array.from(messages).filter(([messageId, location]) => {
+        if (removedMessages.has(messageId) && location.stopSharingTimeout) {
+          clearTimeout(location.stopSharingTimeout);
+          location.stopSharingTimeout = null;
+        }
+        return !removedMessages.has(messageId);
+      })
+    );
+    if (newMessages.size === messages.size) return;
+    this.state.partialNext({
+      messages: newMessages
+    });
+  }
+};
+_LiveLocationManager.symbol = Symbol(_LiveLocationManager.name);
+var LiveLocationManager = _LiveLocationManager;
+
 // src/utils/FixedSizeQueueCache.ts
 var FixedSizeQueueCache = class {
   constructor(size, options) {