@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

package/tsconfig.json

@@ -1,28 +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",
-    "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/channel/events/onMemberAdded.d.ts

@@ -1,17 +0,0 @@
-/**
- * ```js
- * import { onMemberAdded } from '@amityco/ts-sdk'
- * const dispose = onMemberAdded(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-export declare const onMemberAdded: (callback: Amity.Listener<Amity.Channel>) => Amity.Unsubscriber;
-//# sourceMappingURL=onMemberAdded.d.ts.map

package/dist/channel/events/onMemberAdded.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onMemberAdded.d.ts","sourceRoot":"","sources":["../../../src/channel/events/onMemberAdded.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,aAAc,MAAM,QAAQ,CAAC,MAAM,OAAO,CAAC,uBAepE,CAAA"}

package/dist/channel/events/onMemberRemoved.d.ts

@@ -1,17 +0,0 @@
-/**
- * ```js
- * import { onMemberRemoved } from '@amityco/ts-sdk'
- * const dispose = onMemberRemoved(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-export declare const onMemberRemoved: (callback: Amity.Listener<Amity.Channel>) => Amity.Unsubscriber;
-//# sourceMappingURL=onMemberRemoved.d.ts.map

package/dist/channel/events/onMemberRemoved.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onMemberRemoved.d.ts","sourceRoot":"","sources":["../../../src/channel/events/onMemberRemoved.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,aAAc,MAAM,QAAQ,CAAC,MAAM,OAAO,CAAC,uBAetE,CAAA"}

package/dist/client/api/clearCache.d.ts

@@ -1,15 +0,0 @@
-/**
- * ```js
- * import { clearCache } from '@amityco/ts-sdk'
- * clearCache()
- * ```
- *
- * Resets the state of the given {@link Amity.Store} names within
- * the {@link Amity.Cache} object of a {@link Amity.Client} instance
- *
- * @param stores an array of the stores names to be wiped
- *
- * @category Client API
- */
-export declare const clearCache: (stores?: Amity.Domain[]) => void;
-//# sourceMappingURL=clearCache.d.ts.map

package/dist/client/api/clearCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clearCache.d.ts","sourceRoot":"","sources":["../../../src/client/api/clearCache.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,YACb,MAAM,MAAM,EAAE,SAMvB,CAAA"}

package/dist/client/api/enableCache.d.ts

@@ -1,15 +0,0 @@
-import { createCache } from '~/core/cache';
-/**
- * ```js
- * import { enableCache } from '@amityco/ts-sdk'
- * enableCache()
- * ```
- *
- * Adds a new {@link Amity.Cache} object to an {@link Amity.Client} instance
- *
- * @param stores a partial dictionary of stores to be used for caching
- *
- * @category Client API
- */
-export declare const enableCache: (stores?: Parameters<typeof createCache>[0]) => void;
-//# sourceMappingURL=enableCache.d.ts.map

package/dist/client/api/enableCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"enableCache.d.ts","sourceRoot":"","sources":["../../../src/client/api/enableCache.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG1C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,YACd,WAAW,kBAAkB,CAAC,CAAC,CAAC,CAAC,SAiB1C,CAAA"}

package/dist/community/api/addCommunityMembersRole.d.ts

@@ -1,18 +0,0 @@
-/**
- * ```js
- * import { addCommunityMembersRole } from '@amityco/ts-sdk'
- * const updated = await addCommunityMembersRole(communityId, 'foo', ['bar'])
- * ```
- *
- * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
- *
- * @param communityId The ID of the {@link Amity.Community} 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.Community}
- *
- * @category Community API
- * @async
- */
-export declare const addCommunityMembersRole: (communityId: Amity.Community['communityId'], roleId: Amity.Role['roleId'], userIds: Amity.User['userId'][]) => Promise<boolean>;
-//# sourceMappingURL=addCommunityMembersRole.d.ts.map

package/dist/community/api/addCommunityMembersRole.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addCommunityMembersRole.d.ts","sourceRoot":"","sources":["../../../src/community/api/addCommunityMembersRole.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,gBACrB,MAAM,SAAS,CAAC,aAAa,CAAC,UACnC,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,qBAkBhC,CAAA"}

package/dist/community/api/removeCommunityMembersRole.d.ts

@@ -1,18 +0,0 @@
-/**
- * ```js
- * import { removeCommunityMembersRole } from '@amityco/ts-sdk'
- * const updated = await removeCommunityMembersRole(communityId,  'foo', ['bar'])
- * ```
- *
- * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Community}
- *
- * @param communityId The ID of the {@link Amity.Community} to perform
- * @param role 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 removed from list of {@link Amity.User} in the {@link Amity.Community}
- *
- * @category Community API
- * @async
- */
-export declare const removeCommunityMembersRole: (communityId: Amity.Community['communityId'], roleId: Amity.Role['roleId'], userIds: Amity.User['userId'][]) => Promise<boolean>;
-//# sourceMappingURL=removeCommunityMembersRole.d.ts.map

package/dist/community/api/removeCommunityMembersRole.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeCommunityMembersRole.d.ts","sourceRoot":"","sources":["../../../src/community/api/removeCommunityMembersRole.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B,gBACxB,MAAM,SAAS,CAAC,aAAa,CAAC,UACnC,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,qBAkBhC,CAAA"}

package/dist/core/cache/drop.d.ts

@@ -1,11 +0,0 @@
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param keys A collection of unique keys for the store
- * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
- *
- * @category Cache
- */
-export declare const dropFromCache: <T extends keyof Amity.Model>(name: T, partial: Amity.Minimal[T] & Partial<Amity.Model[T]>) => never[] | undefined;
-//# sourceMappingURL=drop.d.ts.map

package/dist/core/cache/drop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../src/core/cache/drop.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,oHAWzB,CAAA"}

package/dist/core/cache/index.d.ts

@@ -1,19 +0,0 @@
-export * from './pull';
-export * from './push';
-export * from './drop';
-export * from './sync';
-export * from './ingest';
-export * from './mutate';
-export * from './merge';
-/**
- * Creates a cache instance. The cache instance will handle stores
- * given to it as input, and will be used as the first source of cached data
- * in the SDK.
- *
- * @param stores A partial collection of stores
- * @returns A cache instance
- *
- * @category Cache
- */
-export declare const createCache: (stores: Partial<Amity.StoreCollection<Amity.Domain[]>>) => Amity.Cache;
-//# sourceMappingURL=index.d.ts.map

package/dist/core/cache/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/cache/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,QAAQ,CAAA;AACtB,cAAc,QAAQ,CAAA;AACtB,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AAEvB;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,WACd,QAAQ,MAAM,eAAe,CAAC,MAAM,MAAM,EAAE,CAAC,CAAC,KACrD,WAGF,CAAA"}

package/dist/core/cache/ingest.d.ts

@@ -1,10 +0,0 @@
-/**
- * Ingest a payload (v3) into the cache
- *
- * @param payload a "backend v3" payload object
- * @param order the order of the keys to process (in case of need)
- *
- * @category Cache
- */
-export declare const ingestInCache: (payload?: Record<string, any[]>, order?: string[]) => void;
-//# sourceMappingURL=ingest.d.ts.map

package/dist/core/cache/ingest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ingest.d.ts","sourceRoot":"","sources":["../../../src/core/cache/ingest.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,aACf,OAAO,MAAM,EAAE,GAAG,EAAE,CAAC,2BAU/B,CAAA"}

package/dist/core/cache/merge.d.ts

@@ -1,10 +0,0 @@
-/**
- * Apply partial mutation to objects in the cache
- *
- * @param name The name of the store to query
- * @param mutation A partial view of the object to update
- *
- * @category Cache
- */
-export declare const mergeInCache: <T extends keyof Amity.Model>(name: T, mutation: Amity.Minimal[T] & Partial<Amity.Model[T]>) => void;
-//# sourceMappingURL=merge.d.ts.map

package/dist/core/cache/merge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/core/cache/merge.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,sGAMxB,CAAA"}

package/dist/core/cache/mutate.d.ts

@@ -1,10 +0,0 @@
-/**
- * Apply partial mutation to objects in the cache
- *
- * @param name The name of the store to query
- * @param mutation A partial view of the object to update
- *
- * @category Cache
- */
-export declare const mutateCache: <T extends keyof Amity.Model>(name: T, key: string, mutator: (model: Amity.Model[T]) => Amity.Model[T] | undefined) => Amity.Model[T] | undefined;
-//# sourceMappingURL=mutate.d.ts.map

package/dist/core/cache/mutate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutate.d.ts","sourceRoot":"","sources":["../../../src/core/cache/mutate.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,8CAEjB,MAAM,+FAWZ,CAAA"}

package/dist/core/cache/pull.d.ts

@@ -1,11 +0,0 @@
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param keys A collection of unique keys for the store
- * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
- *
- * @category Cache
- */
-export declare const pullFromCache: <K extends keyof Amity.Model>(name: K, ...keys: string[]) => Amity.Model[K][] | undefined;
-//# sourceMappingURL=pull.d.ts.map

package/dist/core/cache/pull.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../../src/core/cache/pull.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,kDAA8C,MAAM,EAAE,iCAmB/E,CAAA"}

package/dist/core/cache/push.d.ts

@@ -1,10 +0,0 @@
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param models A collection of models t store
- *
- * @category Cache
- */
-export declare const pushToCache: <T extends keyof Amity.Model>(name: T, ...models: Amity.Model[T][]) => void;
-//# sourceMappingURL=push.d.ts.map

package/dist/core/cache/push.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../../../src/core/cache/push.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,6EA4BvB,CAAA"}

package/dist/core/cache/sync.d.ts

@@ -1,10 +0,0 @@
-/**
- * Sync-up local ids of objects in the cache
- *
- * @param original The object holding the localId to keep
- * @param replacement The object holding the localId to discard
- *
- * @category Cache
- */
-export declare const syncInCache: <T extends keyof Amity.Model>(original: Amity.Model[T], replacement: Amity.Model[T]) => void;
-//# sourceMappingURL=sync.d.ts.map

package/dist/core/cache/sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../src/core/cache/sync.ts"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,8FAyBvB,CAAA"}

package/dist/core/model/toRecord.d.ts

@@ -1,10 +0,0 @@
-/**
- * converts an array looking collection to an object collection, grouped by localId
- *
- * @param array array of {@link Amity.Syncable}
- * @returns array converted to object, grouped by localId
- *
- * @hidden
- */
-export declare const toRecord: <T extends Amity.Syncable>(array: T[]) => Record<string, T>;
-//# sourceMappingURL=toRecord.d.ts.map

package/dist/core/model/toRecord.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toRecord.d.ts","sourceRoot":"","sources":["../../../src/core/model/toRecord.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,6DAEpB,CAAA"}

package/dist/core/query/decorate.d.ts

@@ -1,23 +0,0 @@
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param timestamp the given timestamp
- */
-export declare const decoratePayload: (payload: Record<string, object[]>, timestamp?: number, keyMapping?: Record<string, Amity.Domain>) => void;
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param timestamp the given timestamp
- */
-export declare const decorateModels: <T extends Amity.User | Amity.File<any> | Amity.Role | Amity.Channel<any> | Amity.Membership<"channel"> | Amity.Message<any> | Amity.Community | Amity.Membership<"community"> | Amity.Post<any> | Amity.Comment<any> | Amity.Stream>(models: T[], timestamp?: number, type?: keyof Amity.Model | undefined) => void;
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param syncedAt the given timestamp
- * @param type An opportunity to manually pass the type. If undefined, it will be smartly computed
- */
-export declare const decorateModel: <T extends Amity.User | Amity.File<any> | Amity.Role | Amity.Channel<any> | Amity.Membership<"channel"> | Amity.Message<any> | Amity.Community | Amity.Membership<"community"> | Amity.Post<any> | Amity.Comment<any> | Amity.Stream>(model: T, timestamp?: number, type?: keyof Amity.Model | undefined) => void;
-//# sourceMappingURL=decorate.d.ts.map

package/dist/core/query/decorate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decorate.d.ts","sourceRoot":"","sources":["../../../src/core/query/decorate.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,YACjB,OAAO,MAAM,EAAE,MAAM,EAAE,CAAC,cACtB,MAAM,eACL,OAAO,MAAM,EAAE,MAAM,MAAM,CAAC,SAQzC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,iQAEd,MAAM,+CAIlB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,8PAEb,MAAM,+CAWlB,CAAA"}

package/dist/core/stores/index.d.ts

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

package/dist/core/stores/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/stores/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA"}

package/dist/core/stores/memory.d.ts

@@ -1,30 +0,0 @@
-/**
- * Minimal store implementation.
- *
- * Beware, the state is mutable! it is your responsibility
- * handle the state's mutations correctly. We do so in
- * order for users with mutable/observable stacks to be able
- * to decorate the state with their favorite libraries.
- *
- * @param defaultValue the hydration state value of the store
- * @returns A store instance with an "in memory" storage strategy
- *
- * @category Storage
- * @hidden
- */
-export declare const memoryStore: <T extends {}>(defaultValue?: Record<string, T>) => Amity.Store<T>;
-/**
- * ```js
- * import { memoryStores } from '@amityco/core/cache/store/volatile'
- * const stores = imemoryStores('user', 'file')
- * ```
- *
- * Builds a collection of in memory stores based on the available store names
- *
- * @param names collection of store names
- * @returns a dictionary of { storeName: storeInstance } according to the given names
- *
- * @category Storage
- */
-export declare const memoryStores: <T extends (keyof Amity.Model)[]>(...names: T) => Amity.StoreCollection<T>;
-//# sourceMappingURL=memory.d.ts.map

package/dist/core/stores/memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/core/stores/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,oEAsBvB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,4EAOxB,CAAA"}

package/dist/core/stores/persistent.d.ts

@@ -1,13 +0,0 @@
-/**
- * Persistent store implementation.
- *
- * @param persistentKey the name of the store in persistent storage
- * @param defaultValue the hydration state value of the store
- * @param debounceTime a delay to avoid spamming the persistent storage while writing,
- * @returns A store instance with an "persistent" storage strategy
- *
- * @category Storage
- * @hidden
- */
-export declare const persistentStore: <T extends {}>(persistentKey: string, defaultValue?: Record<string, T>, debounceTime?: number) => Promise<Amity.Store<T>>;
-//# sourceMappingURL=persistent.d.ts.map

package/dist/core/stores/persistent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"persistent.d.ts","sourceRoot":"","sources":["../../../src/core/stores/persistent.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,gCACX,MAAM,qFA4CtB,CAAA"}

package/dist/core/transports.d.ts

@@ -1,49 +0,0 @@
-/// <reference types="socket.io-client" />
-/**
- * Creates a pre-configured axios instance
- *
- * @param endpoint The ASC rest api server's URL
- * @returns A pre-configured axios instance
- *
- * @category Transport
- * @hidden
- */
-export declare const createHttpTransport: (endpoint?: string) => import("axios").AxiosInstance;
-/**
- * Creates a pre-configured socket.io instance
- *
- * @param endpoint The socket.io server's URL
- * @returns A pre-configured (non-connected) socket.io client instance
- *
- * @category Transport
- * @hidden
- */
-export declare const createWebsocketTransport: (endpoint?: string) => SocketIOClient.Socket;
-/**
- * Unwraps v3 server payload (for error handling and type extraction)
- *
- * @param response A typical "v3" response (related to backend's service strategy)
- *
- * @returns The data returned by the backend
- * @throws An error related to backend's rejection
- *
- * @category Transport
- * @hidden
- */
-export declare const unwrapPayload: <T>(response: Amity.Response<T>) => T;
-/**
- * Promisify a websocket event emission - resulting in a synchronous http-like XHR (ws legacy)
- *
- * @param client The current client for which to send the event with
- * @param event The websocket event name
- * @param data The event's payload
- *
- * @returns The data returned by the backend
- * @throws An error related to backend's rejection
- *
- * @category Transport
- * @async
- * @hidden
- */
-export declare const synchronousWSCall: <T>(client: Amity.Client, event: string, data?: Object | undefined) => Promise<T | undefined>;
-//# sourceMappingURL=transports.d.ts.map

package/dist/core/transports.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transports.d.ts","sourceRoot":"","sources":["../../src/core/transports.ts"],"names":[],"mappings":";AAgCA;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,cAAc,MAAM,kCA2BnD,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,cAAc,MAAM,0BAmBxD,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,uCAWzB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,cACpB,MAAM,MAAM,SACb,MAAM,sDAgBd,CAAA"}

package/src/@types/core/store.ts

@@ -1,52 +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]>
-    }
-  }
-}

package/src/channel/events/onMemberAdded.ts

@@ -1,37 +0,0 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-
-/**
- * ```js
- * import { onMemberAdded } from '@amityco/ts-sdk'
- * const dispose = onMemberAdded(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-export const onMemberAdded = (callback: Amity.Listener<Amity.Channel>) => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.ChannelPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.channels[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'onMemberAdded',
-    'v3.channel.didAddUsers',
-    filter
-  )
-}