@amityco/ts-sdk 1.0.0-8aae813.0 → 6.0.0-beta01

package/src/utils/tests/liveObject.test.ts

@@ -0,0 +1,172 @@
+import { generatePost } from '~/utils/tests/dummy';
+import { pause } from '~/utils/tests/utils';
+import { connectClient, disconnectClient } from '~/utils/tests/client';
+import { disableCache, enableCache } from '~/cache/api';
+import { getFutureDate, getPastDate } from '~/core/model';
+import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { liveObject } from '../liveObject';
+
+describe('liveObject', () => {
+  let post: Amity.Post;
+  let fetcher: jest.Mock;
+  let callback: jest.Mock;
+  let eventCallback: Amity.Listener<Amity.Post>;
+  let eventUnsubscriber: jest.Mock;
+  const onEvent = (fn: Amity.Listener<Amity.Post>) => {
+    eventCallback = fn;
+    eventUnsubscriber = jest.fn();
+
+    return eventUnsubscriber;
+  };
+  let unsubscribe: Amity.Unsubscriber;
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(() => {
+    enableCache();
+
+    callback = jest.fn();
+    post = generatePost({ postId: 'my-post-id' });
+    fetcher = jest.fn().mockResolvedValue(post);
+  });
+
+  afterEach(() => {
+    disableCache();
+    unsubscribe();
+  });
+
+  test('it should show message if cache not enabled', () => {
+    /*
+     * NOTE: at the time of writing this test cache is disabled by default, but
+     * there is a proposal to enable cache by default. So I'm disabling cache
+     * here to ensure cache is disabled
+     */
+    disableCache();
+    jest.spyOn(global.console, 'log');
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, []);
+
+    expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  });
+
+  it('should fetch the model', async () => {
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, []);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ data: undefined, loading: true }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: post,
+        loading: false,
+      }),
+    );
+  });
+
+  it('should provide the error if fetch is failed', async () => {
+    const error = new Error('can not fetch');
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(
+      post.postId,
+      callback,
+      'postId',
+      () => {
+        return Promise.reject(error);
+      },
+      [onEvent],
+    );
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ data: undefined, loading: true }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: undefined,
+        error,
+        loading: false,
+      }),
+    );
+    expect(eventUnsubscriber).toHaveBeenCalledTimes(1);
+  });
+
+  it('should update the model on the event', async () => {
+    const update = {
+      ...post,
+      data: { text: 'new-text' },
+      updatedAt: getFutureDate(post.updatedAt),
+    };
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, [
+      onEvent,
+    ]);
+    await pause();
+    eventCallback(update);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+  });
+
+  it('should not update the model on the event if the model is already the latest', async () => {
+    const update = {
+      ...post,
+      data: { text: 'new-text' },
+      updatedAt: getPastDate(post.updatedAt),
+    };
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, [
+      onEvent,
+    ]);
+    await pause();
+    eventCallback(update);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+
+  it('should not update the model on the event if the model has different id', async () => {
+    const post2 = generatePost({
+      postId: 'my-post-id-2',
+      updatedAt: getFutureDate(post.updatedAt),
+    });
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, [
+      onEvent,
+    ]);
+    await pause();
+    eventCallback(post2);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+
+  it('should unsubscribe from events on liveObject disposing', async () => {
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, [
+      onEvent,
+    ]);
+    await pause();
+    unsubscribe();
+
+    expect(eventUnsubscriber).toHaveBeenCalledTimes(1);
+  });
+});

package/src/utils/tests/utils.ts

@@ -0,0 +1,18 @@
+import { encode } from 'js-base64';
+
+export const encodeJson = (value: Record<string, any>) => encode(JSON.stringify(value));
+
+/*
+ * Used instead of asserting an async request is completed, when the async
+ * request is not the API being tested. This util makes tests readable by moving
+ * all assertions to the end of the test
+ *
+ * Use 500ms by default on MacBook Pro Core-i5 2020. Lower than this is not enough
+ * to wait for async task before assertions.
+ */
+export const pause = (ms = 500) =>
+  new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+
+export const deepCopy = <T>(value: T): T => JSON.parse(JSON.stringify(value));

package/src/version.ts

@@ -0,0 +1,10 @@
+function getVersion(): string {
+  try {
+    // the string 'process.env.VERSION' should be replaced by actual value by @rollup/plugin-replace
+    return process.env.VERSION!;
+  } catch (error) {
+    return '__dev__';
+  }
+}
+
+export const VERSION = getVersion();

package/tsconfig.json

@@ -1,29 +1,30 @@
 {
-  "extends": "../../tsconfig.json",
+	"extends": "../../tsconfig.json",
 
-  "include": ["./src"],
-  "exclude": ["node_modules"],
+	"include": ["./src"],
+	"exclude": ["node_modules", "**/*.spec.ts"],
 
-  "compilerOptions": {
-    "baseUrl": "./src",
-    "paths": {
-      "~/*": ["./*"],
-    },
+	"compilerOptions": {
+		"baseUrl": "./src",
+		"paths": {
+			"~/*": ["./*"]
+		},
 
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "declaration": true,
-    "declarationDir": "./dist",
-    "noEmit": true, // by rollup
+		"rootDir": "./src",
+		"outDir": "./dist",
+		"declaration": true,
+		"declarationDir": "./dist",
+		"noEmit": true,
 
-    "module": "es2020",
-    "target": "es2017",
+		"module": "es2020",
+		"target": "es2017",
 
-    "lib": [
-      "esnext",
-      "es7",
-      "es6",
-      "dom",
-    ],
-  }
+		"lib": [
+			"esnext",
+			"es7",
+			"es6",
+			"dom"
+		],
+		"resolveJsonModule": true
+	}
 }

package/dist/@types/core/store.d.ts

@@ -1,46 +0,0 @@
-export {};
-declare global {
-    namespace Amity {
-        /**
-         * Represents what needs to be done to read the state of a store
-         * @hidden
-         */
-        type StateReader<T extends {}> = () => Record<string, T>;
-        /**
-         * Represents what needs to be done to write in the state of a store.
-         * @hidden
-         */
-        type StateWriter<T extends {}> = (payload: Record<string, T>) => void;
-        /**
-         * Represents what needs to be done to erase records in the state of a store.
-         * @hidden
-         */
-        type StateEraser = (...payload: string[]) => void;
-        /**
-         * Every object which has a read:StateReader function and a write:StateWriter function can be
-         * considered as a valid store. This opens the door for open and generic storage implementations.
-         * We can imagine linking this to React Context, Redux, MobX, VueX, any local database...
-         *
-         * Below "defaultStore" is a minimal "in memory + mutable" storage implementation, which is the
-         * bare minimum required to make the cache implementation working.
-         *
-         * Further storage strategies (offline, immutables, etc...) could be provided as
-         * core or community plugins.
-         * @hidden
-         */
-        type Store<T extends {} = any> = {
-            read: StateReader<T>;
-            write: StateWriter<T>;
-            erase: StateEraser;
-        };
-        /**
-         * Manually computed type to output a dictionary of { StoreName: Amity.Store<Model> }
-         * with proper typing based on T
-         * @hidden
-         */
-        type StoreCollection<T extends Amity.Domain[]> = {
-            [K in T[number]]: Store<Amity.Model[K]>;
-        };
-    }
-}
-//# sourceMappingURL=store.d.ts.map

package/dist/@types/core/store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/@types/core/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAA;AAET,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,KAAK,CAAC;QACd;;;WAGG;QACH,KAAK,WAAW,CAAC,CAAC,SAAS,EAAE,IAAI,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;QAExD;;;WAGG;QACH,KAAK,WAAW,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,IAAI,CAAA;QAErE;;;WAGG;QACH,KAAK,WAAW,GAAG,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAA;QAEjD;;;;;;;;;;;WAWG;QACH,KAAK,KAAK,CAAC,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI;YAC/B,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;YACpB,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;YACrB,KAAK,EAAE,WAAW,CAAA;SACnB,CAAA;QAED;;;;WAIG;QACH,KAAK,eAAe,CAClB,CAAC,SAAS,KAAK,CAAC,MAAM,EAAE,IACtB;aACD,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SACxC,CAAA;KACF;CACF"}

package/dist/category/api/getCategory.d.ts

@@ -1,16 +0,0 @@
-/**
- * ```js
- * import { getCategory } from '@amityco/ts-sdk'
- * const category = await getCategory('foo')
- * ```
- *
- * Fetches a {@link Amity.Category} object
- *
- * @param categoryId the ID of the {@link Amity.Category} to fetch
- * @returns the associated {@link Amity.Category} object
- *
- * @category Category API
- * @async
- */
-export declare const getCategory: (categoryId: Amity.Category['categoryId']) => Promise<Amity.Category>;
-//# sourceMappingURL=getCategory.d.ts.map

package/dist/category/api/getCategory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getCategory.d.ts","sourceRoot":"","sources":["../../../src/category/api/getCategory.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,eACV,MAAM,QAAQ,CAAC,YAAY,CAAC,4BAczC,CAAA"}

package/dist/category/api/index.d.ts

@@ -1,3 +0,0 @@
-export * from './queryCategories';
-export * from './getCategory';
-//# sourceMappingURL=index.d.ts.map

package/dist/category/api/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/category/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,eAAe,CAAA"}

package/dist/category/api/queryCategories.d.ts

@@ -1,23 +0,0 @@
-/**
- * ```js
- * import { queryCategories } from '@amityco/ts-sdk'
- * const categories = await queryCategories()
- * ```
- *
- * Queries a paginable list of {@link Amity.Category} objects
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Category} objects
- *
- * @category Community API
- * @async
- **/
-export declare const queryCategories: (query?: {
-    sortBy?: "lastCreated" | "firstCreated" | "name" | undefined;
-    isDeleted?: Amity.Category['isDeleted'];
-    page?: Amity.Page | undefined;
-} | undefined) => Promise<readonly [Record<string, Amity.Category>, {
-    readonly prevPage: Amity.Page | null;
-    readonly nextPage: Amity.Page | null;
-}]>;
-//# sourceMappingURL=queryCategories.d.ts.map

package/dist/category/api/queryCategories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryCategories.d.ts","sourceRoot":"","sources":["../../../src/category/api/queryCategories.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;IAaI;AACJ,eAAO,MAAM,eAAe;;gBAEd,MAAM,QAAQ,CAAC,WAAW,CAAC;;;;;GA0BxC,CAAA"}

package/dist/channel/api/addChannelMembers.d.ts

@@ -1,17 +0,0 @@
-/**
- * ```js
- * import { addChannelMembers } from '@amityco/ts-sdk'
- * const updated = await addChannelMembers(channelId, ['foo', 'bar'])
- * ```
- *
- * Adds a list of {@link Amity.User} to a {@link Amity.Channel}
- *
- * @param channelId The ID of the {@link Amity.Channel} to perform
- * @param userIds The list of IDs {@link Amity.User} to add
- * @returns A success boolean if the {@link Amity.User} were added to the {@link Amity.Channel}
- *
- * @category Channel API
- * @async
- */
-export declare const addChannelMembers: (channelId: Amity.Channel['channelId'], userIds: Amity.User['userId'][]) => Promise<boolean>;
-//# sourceMappingURL=addChannelMembers.d.ts.map

package/dist/channel/api/addChannelMembers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addChannelMembers.d.ts","sourceRoot":"","sources":["../../../src/channel/api/addChannelMembers.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,cACjB,MAAM,OAAO,CAAC,WAAW,CAAC,WAC5B,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,qBAqBhC,CAAA"}

package/dist/channel/api/addChannelMembersRole.d.ts

@@ -1,18 +0,0 @@
-/**
- * ```js
- * import { addChannelMembersRole } from '@amityco/ts-sdk'
- * const updated = await addChannelMembersRole(channelId, 'foo', ['bar'])
- * ```
- *
- * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Channel}
- *
- * @param channelId The ID of the {@link Amity.Channel} to perform
- * @param roleId The ID of the {@link Amity.Role} to apply
- * @param userId Array of IDs of the {@link Amity.User} to perform
- * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Channel}
- *
- * @category Channel API
- * @async
- */
-export declare const addChannelMembersRole: (channelId: Amity.Channel['channelId'], roleId: Amity.Role['roleId'], userIds: Amity.User['userId'][]) => Promise<boolean>;
-//# sourceMappingURL=addChannelMembersRole.d.ts.map

package/dist/channel/api/addChannelMembersRole.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addChannelMembersRole.d.ts","sourceRoot":"","sources":["../../../src/channel/api/addChannelMembersRole.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,cACrB,MAAM,OAAO,CAAC,WAAW,CAAC,UAC7B,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,qBAkBhC,CAAA"}

package/dist/channel/api/createChannel.d.ts

@@ -1,19 +0,0 @@
-/**
- * ```js
- * import { createChannel } from '@amityco/ts-sdk'
- * const created = await createChannel({ channelId: 'foobar', displayName: 'foobar' })
- * ```
- *
- * Creates an {@link Amity.Channel}
- *
- * @param bundle The data necessary to create a new {@link Amity.Channel}
- * @returns The newly created {@link Amity.Channel}
- *
- * @category Channel API
- * @async
- */
-export declare const createChannel: <T extends Amity.ChannelType>(bundle: {
-    type: T;
-    userIds?: string | undefined;
-} & Pick<Amity.Channel<T>, "displayName" | "avatarFileId" | "tags" | "metadata">) => Promise<Amity.Channel<any>>;
-//# sourceMappingURL=createChannel.d.ts.map

package/dist/channel/api/createChannel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createChannel.d.ts","sourceRoot":"","sources":["../../../src/channel/api/createChannel.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa;;;gHAiBzB,CAAA"}

package/dist/channel/api/deleteChannel.d.ts

@@ -1,16 +0,0 @@
-/**
- * ```js
- * import { deleteChannel } from '@amityco/ts-sdk'
- * const success = await deleteChannel('foobar')
- * ```
- *
- * Deletes a {@link Amity.Channel}
- *
- * @param channelId The {@link Amity.Channel} ID to delete
- * @return A success boolean if the {@link Amity.Channel} was deleted
- *
- * @category Channel API
- * @async
- */
-export declare const deleteChannel: (channelId: Amity.Channel['channelId']) => Promise<Amity.Channel<any>>;
-//# sourceMappingURL=deleteChannel.d.ts.map

package/dist/channel/api/deleteChannel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deleteChannel.d.ts","sourceRoot":"","sources":["../../../src/channel/api/deleteChannel.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,cACb,MAAM,OAAO,CAAC,WAAW,CAAC,gCActC,CAAA"}

package/dist/channel/api/getChannel.d.ts

@@ -1,32 +0,0 @@
-/**
- * ```js
- * import { getChannel } from '@amityco/ts-sdk'
- * const channel = await getChannel('foobar')
- * ```
- *
- * Fetches a {@link Amity.Channel} object
- *
- * @param channelId the ID of the {@link Amity.Channel} to fetch
- * @returns the associated {@link Amity.Channel} object
- *
- * @category Channel API
- * @async
- */
-export declare const getChannel: {
-    (channelId: Amity.Channel['channelId']): Promise<Amity.Channel<any>>;
-    /**
-     * ```js
-     * import { getChannel } from '@amityco/ts-sdk'
-     * const channel = getChannel.locally('foobar')
-     * ```
-     *
-     * Fetches a {@link Amity.Channel} object from cache
-     *
-     * @param channelId the ID of the {@link Amity.Channel} to fetch
-     * @returns the associated {@link Amity.Channel} object
-     *
-     * @category Channel API
-     */
-    locally(channelId: Amity.Channel['channelId']): Amity.Channel<any>;
-};
-//# sourceMappingURL=getChannel.d.ts.map

package/dist/channel/api/getChannel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getChannel.d.ts","sourceRoot":"","sources":["../../../src/channel/api/getChannel.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU;gBACV,MAAM,OAAO,CAAC,WAAW,CAAC;IAiBvC;;;;;;;;;;;;OAYG;uBAEU,MAAM,OAAO,CAAC,WAAW,CAAC;CAhBtC,CAAA"}

package/dist/channel/api/getChannels.d.ts

@@ -1,32 +0,0 @@
-/**
- * ```js
- * import { getChannels } from '@amityco/ts-sdk'
- * const channels = await getChannels(['foo', 'bar'])
- * ```
- *
- * Fetches a collection of {@link Amity.Channel} objects
- *
- * @param channelIds the IDs of the {@link Amity.Channel} to fetch
- * @returns the associated collection of {@link Amity.Channel} objects
- *
- * @category Channel API
- * @async
- */
-export declare const getChannels: {
-    (channelIds: Amity.Channel['channelId'][]): Promise<Record<string, Amity.Channel<any>>>;
-    /**
-     * ```js
-     * import { getChannels } from '@amityco/ts-sdk'
-     * const channels = getChannels.locally(['foo', 'bar']) ?? []
-     * ```
-     *
-     * Fetches a collection of {@link Amity.Channel} objects from cache
-     *
-     * @param channelIds the IDs of the {@link Amity.Channel} to fetch
-     * @returns the associated collection of {@link Amity.Channel} objects
-     *
-     * @category Channel API
-     */
-    locally(channelIds: Amity.Channel['channelId'][]): Record<string, Amity.Channel<any>> | undefined;
-};
-//# sourceMappingURL=getChannels.d.ts.map

package/dist/channel/api/getChannels.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getChannels.d.ts","sourceRoot":"","sources":["../../../src/channel/api/getChannels.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW;iBACV,MAAM,OAAO,CAAC,WAAW,CAAC,EAAE;IAkB1C;;;;;;;;;;;;OAYG;wBAEW,MAAM,OAAO,CAAC,WAAW,CAAC,EAAE;CAhBzC,CAAA"}

package/dist/channel/api/index.d.ts

@@ -1,14 +0,0 @@
-export * from './queryChannels';
-export * from './getChannels';
-export * from './getChannel';
-export * from './createChannel';
-export * from './updateChannel';
-export * from './deleteChannel';
-export * from './joinChannel';
-export * from './leaveChannel';
-export * from './queryChannelMembers';
-export * from './addChannelMembers';
-export * from './removeChannelMembers';
-export * from './addChannelMembersRole';
-export * from './removeChannelMembersRole';
-//# sourceMappingURL=index.d.ts.map

package/dist/channel/api/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/channel/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA;AAE5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAE/B,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAE9B,cAAc,uBAAuB,CAAA;AAErC,cAAc,qBAAqB,CAAA;AACnC,cAAc,wBAAwB,CAAA;AAEtC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA"}

package/dist/channel/api/joinChannel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"joinChannel.d.ts","sourceRoot":"","sources":["../../../src/channel/api/joinChannel.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,cAAqB,MAAM,OAAO,CAAC,WAAW,CAAC,qBAkBtE,CAAA"}

package/dist/channel/api/leaveChannel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"leaveChannel.d.ts","sourceRoot":"","sources":["../../../src/channel/api/leaveChannel.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,cAAqB,MAAM,OAAO,CAAC,WAAW,CAAC,qBAkBvE,CAAA"}

package/dist/channel/api/queryChannelMembers.d.ts

@@ -1,42 +0,0 @@
-/**
- * ```js
- * import { queryChannelMembers } from '@amityco/ts-sdk'
- * const channelMembers = await queryChannelMembers({ channelId: 'foo' })
- * ```
- *
- * Queries a paginable list of {@link Amity.ChannelUser} objects
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.ChannelUser} objects
- *
- * @category Channel API
- * @async
- **/
-export declare const queryChannelMembers: {
-    (query: {
-        channelId: string;
-        membership?: 'all' | 'muted' | 'banned' | 'member&banned';
-        roles?: string[];
-        sortBy?: 'firstCreated' | 'lastCreated';
-        page?: Amity.Page;
-    }): Promise<{
-        data: Record<string, Amity.Membership<"channel">>;
-        nextPage: Amity.Page | null;
-        prevPage: Amity.Page | null;
-    }>;
-    /**
-     * ```js
-     * import { queryChannelMembers } from '@amityco/ts-sdk'
-     * const channelMembers = await queryChannelMembers(query)
-     * ```
-     *
-     * Queries a paginable list of {@link Amity.Post} objects from cache
-     *
-     * @param query The query parameters
-     * @returns posts
-     *
-     * @category Post API
-     */
-    locally(query: Parameters<typeof queryChannelMembers>[0]): void;
-};
-//# sourceMappingURL=queryChannelMembers.d.ts.map

package/dist/channel/api/queryChannelMembers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryChannelMembers.d.ts","sourceRoot":"","sources":["../../../src/channel/api/queryChannelMembers.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;IAaI;AACJ,eAAO,MAAM,mBAAmB;YAAiB;QAC/C,SAAS,EAAE,MAAM,CAAA;QACjB,UAAU,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,eAAe,CAAA;QACzD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;QAChB,MAAM,CAAC,EAAE,cAAc,GAAG,aAAa,CAAA;QACvC,IAAI,CAAC,EAAE,MAAM,IAAI,CAAA;KAClB;;;;;IA+BD;;;;;;;;;;;;OAYG;mBAEM,WAAW,0BAA0B,CAAC,CAAC,CAAC,CAAC;CAhBjD,CAAA"}

package/dist/channel/api/queryChannels.d.ts

@@ -1,43 +0,0 @@
-/**
- * ```js
- * import { queryChannels } from '@amityco/ts-sdk'
- * const channels = await queryChannels()
- * ```
- *
- * Queries a paginable list of {@link Amity.Channel} objects
- * Search is performed by displayName such as `.startsWith(search)`
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Channel} objects
- *
- * @category Channel API
- * @async
- */
-export declare const queryChannels: {
-    (query?: {
-        displayName?: string | undefined;
-        membership?: "all" | "member" | "notMember" | undefined;
-        sortBy?: "displayName" | "firstCreated" | "lastCreated" | undefined;
-        types?: Amity.ChannelType | undefined;
-        page?: Amity.Page | undefined;
-    } | undefined): Promise<{
-        data: Record<string, Amity.Channel<any>>;
-        prevPage: Amity.Page | null;
-        nextPage: Amity.Page | null;
-    }>;
-    /**
-     * ```js
-     * import { queryChannels } from '@amityco/ts-sdk'
-     * const channels = queryChannels.locally()
-     * ```
-     *
-     * Queries a paginable list of {@link Amity.Channel} objects from cache
-     *
-     * @param query The query parameters
-     * @returns channels
-     *
-     * @category Channel API
-     */
-    locally(query: Parameters<typeof queryChannels>[0]): void;
-};
-//# sourceMappingURL=queryChannels.d.ts.map

package/dist/channel/api/queryChannels.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryChannels.d.ts","sourceRoot":"","sources":["../../../src/channel/api/queryChannels.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;IA8C1B;;;;;;;;;;;;OAYG;mBAEM,WAAW,oBAAoB,CAAC,CAAC,CAAC,CAAC;CAhB3C,CAAA"}