@amityco/ts-sdk 7.32.1-d7637d9.0 → 7.32.1-e3468d0b.0

package/dist/index.esm.js

@@ -177,6 +177,7 @@ const PostContentType = Object.freeze({
     AUDIO: 'audio',
     ROOM: 'room',
     EVENT: 'event',
+    GIF: 'gif',
 });
 const PostStructureType = Object.freeze({
     TEXT: 'text',
@@ -186,6 +187,8 @@ const PostStructureType = Object.freeze({
     AUDIO: 'audio',
     MIXED: 'mixed',
     EVENT: 'event',
+    /** A post that holds only GIFs. GIFs beside other media make the post `mixed`. */
+    GIF: 'gif',
 });
 
 var InvitationTypeEnum;
@@ -1168,6 +1171,116 @@ const wipeCache = async (storageKey = 'amitySdk') => {
     return true;
 };
 
+// Indexes never enter persisted cache data. Replacing data (restore/wipe/enable) starts a new index.
+const indexes = new WeakMap();
+const prefixesFor = (key) => {
+    if (typeof key[0] !== 'string')
+        return [];
+    const prefixes = [JSON.stringify([key[0]])];
+    if (typeof key[1] === 'string')
+        prefixes.push(JSON.stringify([key[0], key[1]]));
+    return prefixes;
+};
+const removePropertyValue = (property, indexed) => {
+    const previous = property.previousValues.get(indexed.encodedKey);
+    if (previous === undefined)
+        return;
+    const matches = property.values.get(previous);
+    matches.delete(indexed);
+    if (!matches.size)
+        property.values.delete(previous);
+    property.previousValues.delete(indexed.encodedKey);
+};
+const addPropertyValue = (data, property, indexed) => {
+    var _a;
+    if (!partialMatch(property.prefix, indexed.key))
+        return;
+    const value = (_a = data[indexed.encodedKey].data) === null || _a === void 0 ? void 0 : _a[property.property];
+    if (typeof value !== 'string')
+        return;
+    let matches = property.values.get(value);
+    if (!matches) {
+        matches = new Set();
+        property.values.set(value, matches);
+    }
+    matches.add(indexed);
+    property.previousValues.set(indexed.encodedKey, value);
+};
+const addKey = (index, encodedKey) => {
+    const indexed = { encodedKey, key: decodeKey(encodedKey), order: index.nextOrder };
+    index.nextOrder += 1; // eslint-disable-line no-param-reassign
+    index.keys.set(encodedKey, indexed);
+    prefixesFor(indexed.key).forEach(prefix => {
+        let keys = index.prefixes.get(prefix);
+        if (!keys) {
+            keys = new Map();
+            index.prefixes.set(prefix, keys);
+        }
+        keys.set(encodedKey, indexed);
+    });
+    return indexed;
+};
+const getIndex = (data) => {
+    let index = indexes.get(data);
+    if (!index) {
+        index = { keys: new Map(), prefixes: new Map(), properties: new Map(), nextOrder: 0 };
+        Object.keys(data).forEach(encodedKey => addKey(index, encodedKey));
+        indexes.set(data, index);
+    }
+    return index;
+};
+const candidatesFor = (index, key) => {
+    var _a, _b;
+    const prefixes = prefixesFor(key);
+    if (!prefixes.length)
+        return index.keys.values();
+    return (_b = (_a = index.prefixes.get(prefixes[prefixes.length - 1])) === null || _a === void 0 ? void 0 : _a.values()) !== null && _b !== void 0 ? _b : [];
+};
+/** @hidden */
+const getMatchingCacheKeys = (data, key) => Array.from(candidatesFor(getIndex(data), key)).filter(indexed => partialMatch(key, indexed.key));
+/** Update only an index that has already been used; writes alone need no index build. @hidden */
+const updateCacheIndex = (data, encodedKey) => {
+    var _a;
+    const index = indexes.get(data);
+    if (!index)
+        return;
+    const indexed = (_a = index.keys.get(encodedKey)) !== null && _a !== void 0 ? _a : addKey(index, encodedKey);
+    index.properties.forEach(property => {
+        removePropertyValue(property, indexed);
+        addPropertyValue(data, property, indexed);
+    });
+};
+/** @hidden */
+const removeFromCacheIndex = (data, encodedKey) => {
+    const index = indexes.get(data);
+    const indexed = index === null || index === void 0 ? void 0 : index.keys.get(encodedKey);
+    if (!index || !indexed)
+        return;
+    index.properties.forEach(property => removePropertyValue(property, indexed));
+    prefixesFor(indexed.key).forEach(prefix => {
+        const keys = index.prefixes.get(prefix);
+        keys.delete(encodedKey);
+        if (!keys.size)
+            index.prefixes.delete(prefix);
+    });
+    index.keys.delete(encodedKey);
+};
+/** Index a string model property within one domain/operation, retaining cache insertion order. @hidden */
+const getCacheEntriesByProperty = (data, prefix, property, value) => {
+    var _a;
+    const index = getIndex(data);
+    const identity = JSON.stringify([prefix, property]);
+    let propertyIndex = index.properties.get(identity);
+    if (!propertyIndex) {
+        propertyIndex = { prefix, property, values: new Map(), previousValues: new Map() };
+        index.properties.set(identity, propertyIndex);
+        Array.from(candidatesFor(index, prefix)).forEach(indexed => addPropertyValue(data, propertyIndex, indexed));
+    }
+    return Array.from((_a = propertyIndex.values.get(value)) !== null && _a !== void 0 ? _a : [])
+        .sort((a, b) => a.order - b.order)
+        .map(({ encodedKey }) => data[encodedKey]);
+};
+
 /**
  * ```js
  * import { queryCache } from '@amityco/ts-sdk'
@@ -1188,12 +1301,7 @@ const queryCache = (key) => {
     if (!cache)
         return;
     log('cache/api/queryCache', { key });
-    return Object.keys(cache.data)
-        .filter(stringKey => {
-        const decodedKey = decodeKey(stringKey);
-        return partialMatch(key, decodedKey);
-    })
-        .map(stringKey => cache.data[stringKey]);
+    return getMatchingCacheKeys(cache.data, key).map(({ encodedKey }) => cache.data[encodedKey]);
 };
 
 /**
@@ -1249,6 +1357,7 @@ const pushToCache = (key, data, options = { cachedAt: Date.now() }) => {
     }
     const encodedKey = encodeKey(key);
     cache.data[encodedKey] = Object.assign({ key, data }, options);
+    updateCacheIndex(cache.data, encodedKey);
     return true;
 };
 
@@ -1333,15 +1442,14 @@ const dropFromCache = (key, exact = false) => {
         return false;
     log('cache/api/dropFromCache', { key, exact });
     if (!exact) {
-        return Object.keys(cache.data)
-            .map(stringKey => decodeKey(stringKey))
-            .filter(candidate => partialMatch(key, candidate))
-            .map(filteredKey => dropFromCache(filteredKey, true))
+        return getMatchingCacheKeys(cache.data, key)
+            .map(({ key: filteredKey }) => dropFromCache(filteredKey, true))
             .every(returned => returned);
     }
     const encodedKey = encodeKey(key);
     if (encodedKey in cache.data) {
         delete cache.data[encodedKey];
+        removeFromCacheIndex(cache.data, encodedKey);
         return true;
     }
     return false;
@@ -3746,13 +3854,20 @@ const getUserMarker = async () => {
     return { data: latestUserMarker, cachedAt };
 };
 
+/** Internal model lookup; deliberately excluded from the public Cache API. @hidden */
+const queryCacheByProperty = (prefix, property, value) => {
+    const { cache } = getActiveClient();
+    if (!cache)
+        return;
+    return getCacheEntriesByProperty(cache.data, prefix, property, value);
+};
+
 const getMessageFromMainDB = (messageId) => {
-    var _a, _b;
+    var _a, _b, _c;
     const message = (_a = pullFromCache(['message', 'get', messageId])) === null || _a === void 0 ? void 0 : _a.data;
     if (message)
         return message;
-    const messages = queryCache(['message', 'get']);
-    return (_b = messages === null || messages === void 0 ? void 0 : messages.find(({ data }) => data.messageId === messageId)) === null || _b === void 0 ? void 0 : _b.data;
+    return (_c = (_b = queryCacheByProperty(['message', 'get'], 'messageId', messageId)) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.data;
 };
 
 /** @hidden */
@@ -3894,7 +4009,8 @@ function convertFromRaw$2(_a) {
 
 const mergePayloadWithLocal = (payload) => {
     var _a, _b, _c;
-    const localMessage = (_b = (_a = queryCache(['message', 'get'])) === null || _a === void 0 ? void 0 : _a.find(({ data }) => data.messageId === payload.messageId)) === null || _b === void 0 ? void 0 : _b.data;
+    // Cache keys may be local referenceIds even after a server messageId is assigned.
+    const localMessage = (_b = (_a = queryCacheByProperty(['message', 'get'], 'messageId', payload.messageId)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.data;
     if (localMessage) {
         return Object.assign(Object.assign(Object.assign({}, localMessage), payload), { 
             // NOTE: referenceId is missing in the some payload event. If we have local message data with referenceId, use it instead.
@@ -5461,9 +5577,9 @@ const channelLinkedObject = (channel) => {
     var _a;
     let previewMembers = [];
     if (['conversation', 'community'].includes(channel.type)) {
-        const channelUsers = queryCache(['channelUsers', 'get']);
+        const channelUsers = queryCacheByProperty(['channelUsers', 'get'], 'channelId', channel.channelId);
         if (channelUsers && (channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.length) > 0) {
-            previewMembers = ((_a = channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.filter(({ data }) => data.channelId === channel.channelId && data.membership !== 'none')) !== null && _a !== void 0 ? _a : [])
+            previewMembers = ((_a = channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.filter(({ data }) => data.membership !== 'none')) !== null && _a !== void 0 ? _a : [])
                 // sort in ascending order by userInternalId
                 .sort((a, b) => a.data.userInternalId.localeCompare(b.data.userInternalId))
                 // Select only first 4 members
@@ -28116,13 +28232,13 @@ const deleteComment = async (commentId, permanent = false) => {
             permanent,
         },
     });
-    // to support hard deletion; the server empties a deleted comment's attachments
-    const deleted = Object.assign(Object.assign({}, comment.data), { isDeleted: true, attachments: [] });
+    // to support hard deletion
+    const deleted = Object.assign(Object.assign({}, comment.data), { isDeleted: true });
     if (permanent) {
         scheduleTask(() => pushToTombstone('comment', commentId));
     }
     else {
-        upsertInCache(['comment', 'get', commentId], { isDeleted: true, attachments: [] });
+        upsertInCache(['comment', 'get', commentId], { isDeleted: true });
     }
     if (comment.data.referenceType === 'story') {
         const story = await getStoryByStoryId$1(comment.data.referenceId);
@@ -30452,6 +30568,19 @@ getPostByIds.locally = (postIds) => {
     };
 };
 
+/*
+ * The `attachments` a post create or edit sends. A GIF goes with its known keys only and never
+ * with product tags (both a 400). A file takes its product tags from the map, as before.
+ */
+const preparePostAttachments = (attachments, attachmentProductTags) => attachments === null || attachments === void 0 ? void 0 : attachments.map(attachment => {
+    if (attachment.type === 'gif') {
+        return toGifAttachmentPayload(attachment);
+    }
+    if (!attachmentProductTags || !attachment.fileId)
+        return attachment;
+    return Object.assign(Object.assign({}, attachment), { productTags: attachmentProductTags.get(attachment.fileId) });
+});
+
 /* begin_public_function
   id: post.create.text_post, post.create.image_post, post.create.file_post, post.create.video_post, post.create.poll_post, post.create.livestream_post, post.create.custom_post
 */
@@ -30481,17 +30610,7 @@ const createPost = async (bundle) => {
         delete bundle.dataType;
     }
     const { attachments, attachmentProductTags } = bundle, rest = __rest(bundle, ["attachments", "attachmentProductTags"]);
-    const processedAttachments = attachments && attachments.length > 0 && bundle.attachmentProductTags
-        ? attachments.map(attachment => {
-            var _a;
-            /* c8 ignore next */
-            const productTags = (_a = bundle.attachmentProductTags) === null || _a === void 0 ? void 0 : _a.get(attachment.fileId);
-            if (productTags)
-                return Object.assign(Object.assign({}, attachment), { productTags });
-            /* c8 ignore next */
-            return attachment;
-        })
-        : attachments;
+    const processedAttachments = preparePostAttachments(attachments, attachmentProductTags);
     const { data: payload } = await client.http.post('/api/v4/posts', Object.assign(Object.assign({}, rest), { attachments: processedAttachments }));
     fireEvent('post.created', payload);
     const data = preparePostPayload(payload);
@@ -30517,7 +30636,9 @@ const createPost = async (bundle) => {
  * })
  * ```
  *
- * Updates an {@link Amity.Post}
+ * Updates an {@link Amity.Post}. `attachments` is the full list to keep: a GIF is matched by its
+ * `url`, so send each kept GIF back with its link and size as read from `childrenPosts`; an
+ * attachment left out is deleted, `[]` removes them all, and leaving `attachments` out keeps them.
  *
  * @param postId The ID of the {@link Amity.Post} to edit
  * @param patch The patch data to apply
@@ -30530,17 +30651,7 @@ const editPost = async (postId, patch) => {
     const client = getActiveClient();
     client.log('user/editPost', patch);
     const { attachments } = patch;
-    const processedAttachments = attachments && attachments.length > 0 && patch.attachmentProductTags
-        ? attachments.map(attachment => {
-            var _a;
-            /* c8 ignore next */
-            const productTags = (_a = patch.attachmentProductTags) === null || _a === void 0 ? void 0 : _a.get(attachment.fileId);
-            if (productTags)
-                return Object.assign(Object.assign({}, attachment), { productTags });
-            /* c8 ignore next */
-            return attachment;
-        })
-        : attachments;
+    const processedAttachments = preparePostAttachments(attachments, patch.attachmentProductTags);
     const { data: payload } = await client.http.put(`/api/v4/posts/${encodeURIComponent(postId)}`, Object.assign(Object.assign({}, patch), { attachments: processedAttachments }));
     const data = prepareMembershipPayload(payload, 'communityUsers');
     const cachedAt = client.cache && Date.now();
@@ -31024,11 +31135,14 @@ const createAudioPost = async (bundle) => {
  *     { fileId: "file1", type: "image" },
  *     { fileId: "file2", type: "video" },
  *     { fileId: "file3", type: "audio" },
- *     { fileId: "file4", type: "file" }
+ *     { fileId: "file4", type: "file" },
+ *     { type: "gif", url: "https://media.giphy.com/media/l0MYt5jPR6QX5pnqM/giphy.gif", width: 480, height: 270 }
  *   ],
  * })
  * ```
  *
+ * A post holds 1 to 10 attachments. A GIF is a link, not a file, and takes no product tags.
+ *
  * Creates an {@link Amity.Post}
  *
  * @param bundle The data necessary to create a new {@link Amity.Post}
@@ -31042,17 +31156,7 @@ const createMixedMediaPost = async (bundle) => {
     const client = getActiveClient();
     client.log('post/createMixedMediaPost', bundle);
     const { attachments, attachmentProductTags } = bundle, rest = __rest(bundle, ["attachments", "attachmentProductTags"]);
-    const processedAttachments = attachments && attachments.length > 0 && bundle.attachmentProductTags
-        ? attachments.map(attachment => {
-            var _a;
-            /* c8 ignore next */
-            const productTags = (_a = bundle.attachmentProductTags) === null || _a === void 0 ? void 0 : _a.get(attachment.fileId);
-            if (productTags)
-                return Object.assign(Object.assign({}, attachment), { productTags });
-            /* c8 ignore next */
-            return attachment;
-        })
-        : /* c8 ignore next */ attachments;
+    const processedAttachments = preparePostAttachments(attachments, attachmentProductTags);
     const { data: payload } = await client.http.post('/api/v4/posts', Object.assign(Object.assign({}, rest), { attachments: processedAttachments }));
     fireEvent('post.created', payload);
     const data = preparePostPayload(payload);
@@ -31569,6 +31673,10 @@ class PostLiveCollectionController extends LiveCollectionController {
  *
  * Observe all mutations on a list of {@link Amity.Post} for a given target object
  *
+ * GIF posts come back on every API version. This query is on v5, so `dataTypes: ['gif']` filters
+ * them; a post with GIFs beside other media is `mixed` and is hidden unless
+ * `includeMixedStructure` is `true`.
+ *
  * @param params.targetType the type of the target
  * @param params.targetId the ID of the target
  * @param callback the function to call when new data are available