@amityco/ts-sdk 6.17.3-beac0a2.0 → 6.17.3-e382dbe.0

package/dist/index.cjs.js

@@ -1233,6 +1233,10 @@ const sortBySegmentNumber = ({ segmentNumber: a }, { segmentNumber: b }) => a -
  * Sorting a collection by its oldest items
  */
 const sortByFirstCreated = ({ createdAt: a }, { createdAt: b }) => new Date(a).valueOf() - new Date(b).valueOf();
+/**
+ * Sorting a story-collection by its localSortingDate
+ */
+const sortByLocalSortingDate = ({ localSortingDate: a }, { localSortingDate: b }) => new Date(b).getTime() - new Date(a).getTime();
 /**
  * Sorting a collection by its newest items
  */
@@ -5021,55 +5025,125 @@ const userLinkedObject = (user) => {
         } });
 };
 
-const calculateHasUnseenFlag = (params) => {
-    const cacheStoryExpireTime = pullFromCache([
-        "story-expire" /* STORY_KEY_CACHE.EXPIRE */,
-        params.targetId,
-    ]);
-    const cacheStoreSeenTime = pullFromCache([
-        "story-last-seen" /* STORY_KEY_CACHE.LAST_SEEN */,
-        params.targetId,
-    ]);
-    const now = new Date().getTime();
-    const lastStoryExpiresAt = params.lastStoryExpiresAt
-        ? new Date(params.lastStoryExpiresAt).getTime()
-        : 0;
-    const lastStorySeenExpiresAt = params.lastStorySeenExpiresAt
-        ? new Date(params.lastStorySeenExpiresAt).getTime()
-        : 0;
-    const localLastStoryExpires = (cacheStoryExpireTime === null || cacheStoryExpireTime === void 0 ? void 0 : cacheStoryExpireTime.data)
-        ? new Date(cacheStoryExpireTime === null || cacheStoryExpireTime === void 0 ? void 0 : cacheStoryExpireTime.data).getTime()
-        : 0;
-    const localLastStorySeenExpiresAt = (cacheStoreSeenTime === null || cacheStoreSeenTime === void 0 ? void 0 : cacheStoreSeenTime.data)
-        ? new Date(cacheStoreSeenTime === null || cacheStoreSeenTime === void 0 ? void 0 : cacheStoreSeenTime.data).getTime()
-        : 0;
-    const highestSeen = Math.max(lastStorySeenExpiresAt, localLastStorySeenExpiresAt);
-    const currentSyncingState = pullFromCache([
-        "story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */,
-        params.targetId,
-    ]);
-    if (currentSyncingState === null || currentSyncingState === void 0 ? void 0 : currentSyncingState.data) {
-        if (["syncing" /* Amity.SyncState.Syncing */, "error" /* Amity.SyncState.Error */].includes(currentSyncingState.data)) {
-            return localLastStoryExpires > now && localLastStoryExpires > highestSeen;
+class StoryComputedValue {
+    constructor(targetId, lastStoryExpiresAt, lastStorySeenExpiresAt) {
+        this._syncingStoriesCount = 0;
+        this._syncedStoriesCount = 0;
+        this._errorStoriesCount = 0;
+        this._targetId = targetId;
+        this._lastStoryExpiresAt = lastStoryExpiresAt;
+        this._lastStorySeenExpiresAt = lastStorySeenExpiresAt;
+        this.cacheStoryExpireTime = pullFromCache([
+            "story-expire" /* STORY_KEY_CACHE.EXPIRE */,
+            this._targetId,
+        ]);
+        this.cacheStoreSeenTime = pullFromCache([
+            "story-last-seen" /* STORY_KEY_CACHE.LAST_SEEN */,
+            this._targetId,
+        ]);
+        this.getTotalStoryByStatus();
+    }
+    get lastStoryExpiresAt() {
+        return this._lastStoryExpiresAt ? new Date(this._lastStoryExpiresAt).getTime() : 0;
+    }
+    get lastStorySeenExpiresAt() {
+        return this._lastStorySeenExpiresAt ? new Date(this._lastStorySeenExpiresAt).getTime() : 0;
+    }
+    get localLastStoryExpires() {
+        var _a, _b;
+        return ((_a = this.cacheStoryExpireTime) === null || _a === void 0 ? void 0 : _a.data)
+            ? new Date((_b = this.cacheStoryExpireTime) === null || _b === void 0 ? void 0 : _b.data).getTime()
+            : 0;
+    }
+    get localLastStorySeenExpiresAt() {
+        var _a, _b;
+        return ((_a = this.cacheStoreSeenTime) === null || _a === void 0 ? void 0 : _a.data) ? new Date((_b = this.cacheStoreSeenTime) === null || _b === void 0 ? void 0 : _b.data).getTime() : 0;
+    }
+    get isContainUnSyncedStory() {
+        const currentSyncingState = pullFromCache([
+            "story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */,
+            this._targetId,
+        ]);
+        if (!(currentSyncingState === null || currentSyncingState === void 0 ? void 0 : currentSyncingState.data))
+            return false;
+        return ["syncing" /* Amity.SyncState.Syncing */, "error" /* Amity.SyncState.Error */].includes(currentSyncingState.data);
+    }
+    getLocalLastSortingDate() {
+        if (this.isContainUnSyncedStory) {
+            return this.localLastStoryExpires;
         }
+        return this.lastStoryExpiresAt;
+    }
+    getHasUnseenFlag() {
+        const now = new Date().getTime();
+        const highestSeen = Math.max(this.lastStorySeenExpiresAt, this.localLastStorySeenExpiresAt);
+        pullFromCache([
+            "story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */,
+            this._targetId,
+        ]);
+        if (this.isContainUnSyncedStory) {
+            return this.localLastStoryExpires > now && this.localLastStoryExpires > highestSeen;
+        }
+        return this.lastStoryExpiresAt > now && this.lastStoryExpiresAt > highestSeen;
+    }
+    getTotalStoryByStatus() {
+        const stories = queryCache(["story" /* STORY_KEY_CACHE.STORY */, 'get']);
+        if (!stories) {
+            this._errorStoriesCount = 0;
+            this._syncedStoriesCount = 0;
+            this._syncingStoriesCount = 0;
+            return;
+        }
+        const groupByType = stories.reduce((acc, story) => {
+            const { data: { targetId, syncState }, } = story;
+            if (targetId === this._targetId) {
+                acc[syncState] += 1;
+            }
+            return acc;
+        }, {
+            syncing: 0,
+            error: 0,
+            synced: 0,
+        });
+        this._errorStoriesCount = groupByType.error;
+        this._syncedStoriesCount = groupByType.synced;
+        this._syncingStoriesCount = groupByType.syncing;
     }
-    return lastStoryExpiresAt > now && lastStoryExpiresAt > highestSeen;
-};
+    get syncedStoriesCount() {
+        return this._syncedStoriesCount;
+    }
+    get syncingStoriesCount() {
+        return this._syncingStoriesCount;
+    }
+    get failedStoriesCount() {
+        return this._errorStoriesCount;
+    }
+}
 
 const storyTargetLinkedObject = (storyTarget) => {
-    const { targetType, targetId, lastStoryExpiresAt, lastStorySeenExpiresAt, targetUpdatedAt } = storyTarget;
+    const { targetType, targetId, lastStoryExpiresAt, lastStorySeenExpiresAt, targetUpdatedAt, localFilter, } = storyTarget;
+    const computedValue = new StoryComputedValue(targetId, lastStoryExpiresAt, lastStorySeenExpiresAt);
     return {
         targetType,
         targetId,
+        lastStoryExpiresAt,
         updatedAt: targetUpdatedAt,
-        hasUnseen: calculateHasUnseenFlag({ targetId, lastStoryExpiresAt, lastStorySeenExpiresAt }),
+        // Additional data
+        hasUnseen: computedValue.getHasUnseenFlag(),
+        syncedStoriesCount: computedValue.syncedStoriesCount,
+        syncingStoriesCount: computedValue.syncingStoriesCount,
+        failedStoriesCount: computedValue.failedStoriesCount,
+        localFilter,
+        localLastExpires: computedValue.localLastStoryExpires,
+        localLastSeen: computedValue.localLastStorySeenExpiresAt,
+        localSortingDate: computedValue.getLocalLastSortingDate(),
     };
 };
 
 const storyLinkedObject = (story) => {
     const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
     const storyTargetCache = pullFromCache([
-        'storyTarget',
+        "storyTarget" /* STORY_KEY_CACHE.STORY_TARGET */,
         'get',
         story.targetId,
     ]);
@@ -7117,6 +7191,40 @@ const hasPermission$1 = (permission) => {
     };
 };
 
+/**
+ * Validate a list of urls
+ * @param urls  array of strings to validate (max 10 items)
+ *
+ * @category Client API
+ */
+const validateUrls = async (urls) => {
+    const client = getActiveClient();
+    client.log('channel/markerSync');
+    if (urls.length === 0)
+        return false;
+    const { data: payload } = await client.http.post('/api/v3/allowlists/verify', {
+        data: urls,
+    });
+    return payload.success;
+};
+
+/**
+ * Validate a list of texts
+ * @param texts array of strings to validate (max 10 items)
+ *
+ * @category Client API
+ */
+const validateTexts = async (texts) => {
+    const client = getActiveClient();
+    client.log('channel/markerSync');
+    if (texts.length === 0)
+        return false;
+    const { data: payload } = await client.http.post('/api/v3/blocklists/verify', {
+        data: texts,
+    });
+    return payload.success;
+};
+
 /**
  * ```js
  * import { getFeedSettings } from '@amityco/ts-sdk'
@@ -8654,6 +8762,8 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
         accessTokenExpiryWatcher,
         sessionHandler,
         hasPermission: hasPermission$1,
+        validateUrls,
+        validateTexts,
         getFeedSettings,
         getSocialSettings,
         getMessagePreviewSetting,
@@ -16169,7 +16279,8 @@ class ChannelQueryStreamController extends QueryStreamController {
             const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
             if (!collection)
                 return;
-            if (this.paginationController instanceof ChannelPaginationController) {
+            if (this.paginationController instanceof ChannelPaginationController &&
+                action === 'onCreate') {
                 collection.data = [...new Set([payload.channelId, ...collection.data])];
                 pushToCache(this.cacheKey, collection);
             }
@@ -16357,7 +16468,22 @@ class ChannelLiveCollectionController extends LiveCollectionController {
             { fn: onChannelUpdated, action: 'onUpdate' },
             { fn: onChannelMuted, action: 'onMute' },
             { fn: onChannelJoined, action: 'onJoin' },
-            { fn: onChannelLeft, action: 'onLeft' },
+            {
+                fn: (reactor) => {
+                    const callback = (channel, member) => {
+                        var _a, _b;
+                        const { userId } = getActiveClient();
+                        // if query for channel member and user is not a member, remove channelId from curren collection
+                        if (this.query.membership === 'member' && userId === member.userId) {
+                            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: (_b = collection === null || collection === void 0 ? void 0 : collection.data.filter(c => c !== channel.channelId)) !== null && _b !== void 0 ? _b : [] }));
+                        }
+                        return reactor(channel);
+                    };
+                    return onChannelLeft(callback);
+                },
+                action: 'onLeft',
+            },
             { fn: onChannelMemberAdded, action: 'onMemberAdded' },
             { fn: onChannelMemberRemoved, action: 'onMemberRemoved' },
             {
@@ -22175,7 +22301,10 @@ const createImageStory = async (targetType, targetId, formData, metadata = {}, i
         targetId,
         metadata,
     };
+    const date = new Date();
     pushToCache(["story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */, targetId], "syncing" /* Amity.SyncState.Syncing */);
+    // Update local story expires time
+    pushToCache(["story-expire" /* STORY_KEY_CACHE.EXPIRE */, targetId], new Date(date.setFullYear(date.getFullYear() + 1)));
     // Fire optimistic event
     createOptimisticEvent({ payload, formData }, optimisticData => {
         fireEvent('local.story.created', optimisticData);
@@ -22236,7 +22365,10 @@ const createVideoStory = async (targetType, targetId, formData, metadata = {}, i
         targetId,
         metadata,
     };
+    const date = new Date();
     pushToCache(["story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */, targetId], "syncing" /* Amity.SyncState.Syncing */);
+    // Update local story expires time
+    pushToCache(["story-expire" /* STORY_KEY_CACHE.EXPIRE */, targetId], new Date(date.setFullYear(date.getFullYear() + 1)));
     // Fire optimistic event
     createOptimisticEvent({ payload, formData, isVideo: true }, optimisticData => {
         fireEvent('local.story.created', optimisticData);
@@ -22824,7 +22956,6 @@ class StoryQueryStreamController extends QueryStreamController {
     }
 }
 
-/* eslint-disable no-use-before-define */
 class StoryPaginationNoPageController extends PaginationNoPageController {
     async getRequest(queryParams) {
         const { data: queryResponse } = await this.http.get('/api/v4/stories-by-targets', {
@@ -22919,6 +23050,219 @@ const getStoriesByTargetIds = (params, callback, config) => {
     };
 };
 
+const updateLocalList = (cacheKey, targetIds) => {
+    var _a, _b;
+    const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+    const storyTargets = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+    pushToCache(cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...storyTargets, ...targetIds])] }));
+};
+class GlobalStoryQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, paginationController) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.paginationController = paginationController;
+        // Fix ESLint, "Expected 'this' to be used by class method"
+        this.preparePayload = payload => payload;
+    }
+    saveToMainDB(response) {
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        // Fix Eslint error for "Expected 'this' to be used by class method"
+        const data = this.preparePayload(response);
+        if (client.cache) {
+            ingestInCache(data, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.storyTargets.map(({ targetId }) => targetId),
+            });
+        }
+        else {
+            updateLocalList(this.cacheKey, response.storyTargets.map(({ targetId }) => targetId));
+        }
+    }
+    reactor(actionType) {
+        return (payload) => {
+            if (actionType === "onCreate" /* Amity.StoryActionType.OnCreate */ &&
+                this.query.seenState !== "seen" /* Amity.StorySeenQuery.SEEN */) {
+                updateLocalList(this.cacheKey, payload.map(({ targetId }) => targetId));
+            }
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+const mergeResult = (resultA, resultB) => {
+    return {
+        categories: resultA.categories.concat(resultB.categories),
+        communities: resultA.communities.concat(resultB.communities),
+        communityUsers: resultA.communityUsers.concat(resultB.communityUsers),
+        files: resultA.files.concat(resultB.files),
+        storyTargets: resultA.storyTargets.concat(resultB.storyTargets),
+        users: resultA.users.concat(resultB.users),
+        paging: resultB.paging,
+    };
+};
+const addFlagLocalFilter = (payload, filter) => {
+    return Object.assign(Object.assign({}, payload), { storyTargets: payload.storyTargets.map(item => (Object.assign(Object.assign({}, item), { localFilter: filter }))) || [] });
+};
+class GlobalStoryPageController extends PaginationController {
+    constructor() {
+        super(...arguments);
+        this.smartFilterState = "unseen" /* Amity.StorySeenQuery.UNSEEN */;
+    }
+    async getRequest(queryParams, token) {
+        var _a;
+        // Apply default values for parameters
+        const { limit = 10, seenState = "unseen" /* Amity.StorySeenQuery.UNSEEN */ } = queryParams;
+        const result = await this.createRequest({
+            seenState: seenState === "smart" /* Amity.StorySeenQuery.SMART */ ? this.smartFilterState : seenState,
+            limit,
+            token,
+        });
+        // Use Early return to reduce condition complexity
+        if ((_a = result.paging) === null || _a === void 0 ? void 0 : _a.next)
+            return result;
+        if (seenState !== "smart" /* Amity.StorySeenQuery.SMART */)
+            return result;
+        if (this.smartFilterState === "seen" /* Amity.StorySeenQuery.SEEN */)
+            return result;
+        this.smartFilterState = "seen" /* Amity.StorySeenQuery.SEEN */;
+        const additionalResult = await this.createRequest({
+            seenState: this.smartFilterState,
+            limit,
+        });
+        return mergeResult(result, additionalResult);
+    }
+    async createRequest(params) {
+        const { data: queryResponse } = await this.http.get('/api/v5/me/global-story-targets', {
+            params,
+        });
+        return addFlagLocalFilter(queryResponse, params.seenState);
+    }
+}
+
+class GlobalStoryLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ["story-global-feed" /* STORY_KEY_CACHE.STORY_GLOBAL_FEED */, 'collection', queryStreamId];
+        const paginationController = new GlobalStoryPageController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new GlobalStoryQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), paginationController);
+        this.paginationController = paginationController;
+        this.callback = callback.bind(this);
+        this.loadPage(true);
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    persistModel(response) {
+        this.queryStreamController.saveToMainDB(response);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        let data = collection.data
+            .map(targetId => pullFromCache(["storyTarget" /* STORY_KEY_CACHE.STORY_TARGET */, 'get', targetId]))
+            .filter(Boolean)
+            .map(storyTarget => LinkedObject.storyTarget(storyTarget.data));
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        data = this.applyFilter(data);
+        this.callback({
+            onNextPage: () => this.loadPage(false, "next" /* Amity.LiveCollectionPageDirection.NEXT */),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    applyFilter(data) {
+        if (this.query.seenState !== "smart" /* Amity.StorySeenQuery.SMART */) {
+            return data
+                .filter(({ hasUnseen }) => {
+                if (this.query.seenState === "all" /* Amity.StorySeenQuery.ALL */)
+                    return true;
+                if (this.query.seenState === "seen" /* Amity.StorySeenQuery.SEEN */ && !hasUnseen)
+                    return true;
+                return this.query.seenState === "unseen" /* Amity.StorySeenQuery.UNSEEN */ && hasUnseen;
+            })
+                .sort(sortByLocalSortingDate);
+        }
+        // Smart Filter - Apply local sorting on each list of data
+        const result = data.reduce((acc, storyTarget) => {
+            if (storyTarget.localFilter === "unseen" /* Amity.StorySeenQuery.UNSEEN */) {
+                acc.unseen.push(storyTarget);
+            }
+            else if (storyTarget.localFilter === "seen" /* Amity.StorySeenQuery.SEEN */) {
+                acc.seen.push(storyTarget);
+            }
+            else {
+                acc.unknown.push(storyTarget);
+            }
+            return acc;
+        }, { unseen: [], seen: [], unknown: [] });
+        const sortedUnknown = result.unknown.sort(sortByLocalSortingDate) || [];
+        const sortedUnseen = result.unseen.sort(sortByLocalSortingDate) || [];
+        const sortedSeen = result.seen.sort(sortByLocalSortingDate) || [];
+        // Merge all status and remove internal fields
+        return sortedUnknown
+            .concat(sortedUnseen, sortedSeen)
+            .map((_a) => {
+            var rest = __rest(_a, ["localFilter", "localLastExpires", "localLastSeen", "localSortingDate"]);
+            return rest;
+        });
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            { fn: onStoryCreated, action: "onCreate" /* Amity.StoryActionType.OnCreate */ },
+            { fn: onStoryUpdated, action: "onUpdate" /* Amity.StoryActionType.OnUpdate */ },
+            { fn: onStoryDeleted, action: "onDelete" /* Amity.StoryActionType.OnDelete */ },
+            { fn: onStoryCreatedLocal, action: "onCreate" /* Amity.StoryActionType.OnCreate */ },
+            { fn: onStoryUpdatedLocal, action: "onUpdate" /* Amity.StoryActionType.OnUpdate */ },
+            { fn: onStoryDeletedLocal, action: "onDelete" /* Amity.StoryActionType.OnDelete */ },
+            { fn: onStoryError, action: "onError" /* Amity.StoryActionType.OnError */ },
+        ]);
+    }
+}
+
+const getGlobalStoryTargets = (params, callback, config) => {
+    const { log, cache, userId } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getGlobalStoryTarget(tmpid: ${timestamp}) > listen`);
+    const storyLiveCollection = new GlobalStoryLiveCollectionController(params, callback);
+    const disposers = storyLiveCollection.startSubscription();
+    const cacheKey = storyLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getGlobalStoryTarget(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createImageStory: createImageStory,
@@ -22929,7 +23273,8 @@ var index = /*#__PURE__*/Object.freeze({
   getStoryByStoryId: getStoryByStoryId,
   getTargetById: getTargetById,
   getTargetsByTargetIds: getTargetsByTargetIds,
-  getStoriesByTargetIds: getStoriesByTargetIds
+  getStoriesByTargetIds: getStoriesByTargetIds,
+  getGlobalStoryTargets: getGlobalStoryTargets
 });
 
 /**
@@ -23052,6 +23397,7 @@ exports.sortByFirstUpdated = sortByFirstUpdated;
 exports.sortByLastActivity = sortByLastActivity;
 exports.sortByLastCreated = sortByLastCreated;
 exports.sortByLastUpdated = sortByLastUpdated;
+exports.sortByLocalSortingDate = sortByLocalSortingDate;
 exports.sortByName = sortByName;
 exports.sortBySegmentNumber = sortBySegmentNumber;
 exports.subscribeTopic = subscribeTopic;