@amityco/ts-sdk-react-native 6.30.2-bc5ef81.0 → 6.30.3-cae094b.0

package/dist/index.esm.js

@@ -88,8 +88,8 @@ const PostContentType = Object.freeze({
 
 function getVersion() {
     try {
-        // the string ''v6.30.1-esm'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v6.30.1-esm';
+        // the string ''v6.30.2-esm'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v6.30.2-esm';
     }
     catch (error) {
         return '__dev__';
@@ -1150,33 +1150,18 @@ const filterByCommunityMembership = (collection, membership, userId) => {
  * @hidden
  */
 const filterByPostDataTypes = (collection, dataTypes) => {
-    const postIds = [];
     return collection.reduce((acc, post) => {
         var _a;
-        // A text post with no children is just a text post
-        if (post.dataType === 'text' && !post.children.length)
-            return acc;
-        // Skip if post is already in the collection
-        if (postIds.includes(post.postId))
-            return acc;
         // Check dataType for current post
         if (dataTypes === null || dataTypes === void 0 ? void 0 : dataTypes.includes(post.dataType)) {
-            acc.push(post);
+            return [...acc, post];
         }
-        // Check dataType for child post. this function will return all child posts in a same level of parent post (flatten)
-        if (!post.children.length)
-            return acc;
-        const childPost = (_a = pullFromCache(['post', 'get', post.children[0]])) === null || _a === void 0 ? void 0 : _a.data;
-        if (!childPost)
+        if (((post === null || post === void 0 ? void 0 : post.children) || []).length > 0) {
+            const childPost = (_a = pullFromCache(['post', 'get', post.children[0]])) === null || _a === void 0 ? void 0 : _a.data;
+            if (!(dataTypes === null || dataTypes === void 0 ? void 0 : dataTypes.includes(childPost === null || childPost === void 0 ? void 0 : childPost.dataType)))
+                return [...acc, post];
             return acc;
-        // Prevent to insert a duplicate record
-        if (postIds.includes(childPost.postId))
-            return acc;
-        if (!(dataTypes === null || dataTypes === void 0 ? void 0 : dataTypes.includes(childPost === null || childPost === void 0 ? void 0 : childPost.dataType)))
-            return acc;
-        postIds.push(childPost.postId);
-        // @ts-ignore
-        acc.push(childPost);
+        }
         return acc;
     }, []);
 };
@@ -29614,7 +29599,8 @@ const prepareCommunityRequest = (params) => {
         allowCommentInStory: typeof (storySetting === null || storySetting === void 0 ? void 0 : storySetting.enableComment) === 'boolean' ? storySetting.enableComment : true });
 };
 
-const preparePostPayload = (postPayload) => {
+const preparePostPayload = (payload) => {
+    const { posts: postsData } = payload, postPayload = __rest(payload, ["posts"]);
     // Unpack community payload by mapping payload field to postSetting value.
     const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
     // map users with community
@@ -29624,12 +29610,17 @@ const preparePostPayload = (postPayload) => {
     });
     const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
     // feed type
-    const posts = postPayload.posts.map(post => {
+    const posts = postsData.map(post => {
         var _a;
         const feedType = (_a = postPayload.feeds.find(feed => feed.feedId === post.feedId)) === null || _a === void 0 ? void 0 : _a.feedType;
         return Object.assign(Object.assign({}, post), { feedType });
     });
     return Object.assign(Object.assign({}, postPayload), { posts, communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
+};
+const prepareSemanticSearchPostPayload = (_a) => {
+    var { searchResult, polls } = _a, postPayload = __rest(_a, ["searchResult", "polls"]);
+    const processedPostPayload = preparePostPayload(postPayload);
+    return Object.assign(Object.assign({}, processedPostPayload), { polls });
 };
 
 const createPostEventSubscriber = (event, callback) => {
@@ -37684,6 +37675,7 @@ const deletePost = async (postId, permanent = false) => {
         files: [],
         postChildren: [],
         users: [],
+        videoStreamings: [],
     });
     return LinkedObject.post(deleted);
 };
@@ -38097,6 +38089,7 @@ const createComment = async (bundle) => {
                 files: data.files,
                 postChildren: [],
                 users: data.users,
+                videoStreamings: [],
             });
         }
     }
@@ -38302,6 +38295,7 @@ const deleteComment = async (commentId, permanent = false) => {
                 files: [],
                 postChildren: [],
                 users: [],
+                videoStreamings: [],
             });
         }
     }
@@ -39563,6 +39557,239 @@ const getPinnedPosts = (params, callback, config) => {
     };
 };
 
+class SemanticSearchPostPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const baseOptions = {
+            type: queryParams.limit ? 'pagination' : undefined,
+        };
+        const options = token ? Object.assign(Object.assign({}, baseOptions), { token }) : Object.assign(Object.assign({}, baseOptions), { limit });
+        const { data: queryResponse } = await this.http.get(`/api/v1/semantic-search/posts`, {
+            params: Object.assign(Object.assign({}, params), { options }),
+        });
+        return queryResponse;
+    }
+}
+
+function preparePostResponse(response) {
+    return response.posts.map(post => {
+        const postScore = response.searchResult.find(result => result.postId === post.postId);
+        return `${post.postId}:${postScore.score}`;
+    });
+}
+function getPostIdsFromCache(cacheData) {
+    return (cacheData !== null && cacheData !== void 0 ? cacheData : []).map(postIdWithScore => {
+        return postIdWithScore.split(':')[0];
+    });
+}
+
+class SemanticSearchPostQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: preparePostResponse(response),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const posts = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...posts, ...preparePostResponse(response)])] }));
+        }
+    }
+    reactor(action) {
+        return (post) => {
+            var _a, _b;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (post.parentPostId && post.isDeleted) {
+                const parentSemanticSearchPost = (_b = pullFromCache([
+                    'post',
+                    'get',
+                    post.parentPostId,
+                ])) === null || _b === void 0 ? void 0 : _b.data;
+                if (!parentSemanticSearchPost || (parentSemanticSearchPost === null || parentSemanticSearchPost === void 0 ? void 0 : parentSemanticSearchPost.targetId) !== this.query.targetId)
+                    return;
+                parentSemanticSearchPost.children = parentSemanticSearchPost.children.filter(childId => childId !== post.postId);
+                pushToCache(['post', 'get', parentSemanticSearchPost.postId], parentSemanticSearchPost);
+            }
+            else {
+                if (this.query.targetId !== post.targetId)
+                    return;
+                if (this.query.targetType !== post.targetType)
+                    return;
+            }
+            if (action === EnumPostActions.OnPostDeclined) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
+                collection.data = [...new Set([post.postId, ...collection.data])];
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+class SemanticSearchPostLiveCollectionController extends LiveCollectionController {
+    constructor(inputQuery, callback) {
+        const query = Object.assign(Object.assign({}, inputQuery), { matchingOnlyParentPost: inputQuery.matchingOnlyParentPost == null ? true : inputQuery.matchingOnlyParentPost, dataTypes: inputQuery.dataTypes == null ? ['text', 'image'] : inputQuery.dataTypes });
+        const queryStreamId = hash(query);
+        const cacheKey = ['posts', 'collection', queryStreamId];
+        const paginationController = new SemanticSearchPostPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new SemanticSearchPostQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareSemanticSearchPostPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: 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: {},
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
+            { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
+            { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
+            {
+                fn: onPostUnflagged,
+                action: EnumPostActions.OnPostUnflagged,
+            },
+            { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
+            { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
+            {
+                fn: onPostReactionAdded,
+                action: EnumPostActions.OnPostReactionAdded,
+            },
+            {
+                fn: onPostReactionRemoved,
+                action: EnumPostActions.OnPostReactionRemoved,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    return onCommentCreated(async (comment) => {
+                        const collectionCache = pullFromCache(this.cacheKey);
+                        const currentCollectionPostIds = getPostIdsFromCache(collectionCache === null || collectionCache === void 0 ? void 0 : collectionCache.data);
+                        if (currentCollectionPostIds.includes(comment.referenceId))
+                            return;
+                        await getPost$2(comment.referenceId);
+                        callback(comment);
+                    });
+                }, 'referenceId', 'post'),
+                action: EnumPostActions.OnPostUpdated,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    return onCommentDeleted(async (comment) => {
+                        const collectionCache = pullFromCache(this.cacheKey);
+                        const currentCollectionPostIds = getPostIdsFromCache(collectionCache === null || collectionCache === void 0 ? void 0 : collectionCache.data);
+                        if (currentCollectionPostIds.includes(comment.referenceId))
+                            return;
+                        await getPost$2(comment.referenceId);
+                        callback(comment);
+                    });
+                }, 'referenceId', 'post'),
+                action: EnumPostActions.OnPostUpdated,
+            },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = this.applyFilter((_b = collection.data
+            .map(postIdWithScore => {
+            const [postId, score] = postIdWithScore.split(':');
+            return {
+                postId,
+                score: parseFloat(score),
+            };
+        })
+            .sort((a, b) => b.score - a.score)
+            .map(({ postId }) => pullFromCache(['post', 'get', postId]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.post);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    applyFilter(data) {
+        let posts = data;
+        if (this.query.targetType) {
+            posts = posts.filter(post => post.targetType === this.query.targetType);
+        }
+        if (this.query.targetId) {
+            posts = posts.filter(post => post.targetId === this.query.targetId);
+        }
+        if (this.query.dataTypes && this.query.dataTypes.length > 0) {
+            posts = filterByPostDataTypes(posts, this.query.dataTypes);
+        }
+        return posts;
+    }
+}
+
+/**
+ * search posts by semantic search
+ *
+ * @returns the associated pinned post(s)
+ *
+ * @category Posts Live Collection
+ *
+ */
+const semanticSearchPosts = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`semanticSearchPosts(tmpid: ${timestamp}) > listen`);
+    const semanticSearchPostLiveCollection = new SemanticSearchPostLiveCollectionController(params, callback);
+    const disposers = semanticSearchPostLiveCollection.startSubscription();
+    const cacheKey = semanticSearchPostLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`semanticSearchPosts(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 var index$5 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getPostByIds: getPostByIds,
@@ -39590,7 +39817,8 @@ var index$5 = /*#__PURE__*/Object.freeze({
   observePost: observePost,
   getPost: getPost$1,
   getPosts: getPosts,
-  getPinnedPosts: getPinnedPosts
+  getPinnedPosts: getPinnedPosts,
+  semanticSearchPosts: semanticSearchPosts
 });
 
 /* begin_public_function