@amityco/ts-sdk 0.0.1-beta → 0.0.1-beta-34

package/core/query/paging.js

@@ -1,140 +0,0 @@
-import { encode, decode } from 'js-base64';
-import { getResolver } from '../model/idResolvers';
-/**
- * Type guard to find if the a given decoded backend token uses "skip/limit" pagination style
- *
- * @param json any json object as extracted from the backend
- * @returns success boolean if the token has either "skip" or "limit" props
- *
- * @hidden
- */
-export const isSkipLimit = (json) => (['skip', 'limit'].some(prop => prop in json));
-/**
- * Type guard to find if the a given decoded backend token uses "after/before" pagination style
- *
- * @param json any json object as extracted from the backend
- * @returns success boolean if the token has either "after" or "before" props
- *
- * @hidden
- */
-export const isAfterBefore = (json) => (['after', 'before', 'first', 'last'].some(prop => prop in json));
-/**
- * Type guard to find if the a given object is wrapped around Amity.Paged<>
- *
- * @param payload any object as passed from query functions
- * @returns success boolean if the object is an array shaped as [Record<string, Amity.Syncable>, Amity.Pages]
- *
- * @hidden
- */
-export const isPaged = (payload) => {
-    return ((payload === null || payload === void 0 ? void 0 : payload.hasOwnProperty('data'))
-        && (payload === null || payload === void 0 ? void 0 : payload.hasOwnProperty('nextPage'))
-        && (payload === null || payload === void 0 ? void 0 : payload.hasOwnProperty('prevPage')));
-};
-/**
- * Converts a paging object into a b64 string token
- *
- * @param paging the sdk-friendly paging object
- * @param style the style of token to produce
- * @returns a backend's b64 encoded token
- *
- * @hidden
- */
-export const toToken = (paging, style) => {
-    var _a;
-    if (!paging)
-        return;
-    let payload = {};
-    // TODO: refactor this clean
-    if (style === 'skiplimit') {
-        payload = {
-            skip: paging.after,
-            limit: paging.limit,
-        };
-    }
-    else if (style === 'afterbefore') {
-        if ('before' in paging) {
-            payload = {
-                before: paging.before,
-                last: paging.limit,
-            };
-        }
-        else if ('after' in paging) {
-            payload = {
-                after: (_a = paging.after) !== null && _a !== void 0 ? _a : 0,
-                first: paging.limit,
-            };
-        }
-    }
-    // don't try catch, let it throw
-    return encode(JSON.stringify(payload));
-};
-/**
- * Converts a b64 string token into a paging object
- *
- * @param token the backend's b64 encoded token
- * @returns a sdk-friendly paging object
- *
- * @hidden
- */
-export const toPage = (token) => {
-    if (!token)
-        return null;
-    // don't try catch, let it throw
-    const json = JSON.parse(decode(token));
-    if (isSkipLimit(json)) {
-        return {
-            after: json.skip,
-            limit: json.limit,
-        };
-    }
-    else if (isAfterBefore(json)) {
-        if ('before' in json) {
-            return {
-                before: json.before,
-                limit: json.last,
-            };
-        }
-        else if ('after' in json) {
-            return {
-                after: json.after,
-                limit: json.first,
-            };
-        }
-    }
-    return null;
-};
-/**
- * Slices a collection according to its paging
- *
- * @param type the type of collection (for unique id identification with after/before)
- * @param collection the collection to slice
- * @param paging the paging object
- * @returns the sliced collection according to the paging definition
- *
- * @hidden
- */
-export const sliceByPaging = (type, collection, page) => {
-    console.log('slice by paging', page);
-    if (!page)
-        return collection.slice();
-    const resolver = getResolver(type);
-    let start = 0;
-    let end = undefined;
-    // next page behavior
-    if (page.after) {
-        start = typeof page.after === 'string'
-            ? collection.findIndex(el => resolver(el) === page.after)
-            : page.after;
-        end = start + page.limit;
-        // prev page behavior
-    }
-    else if (page.before) {
-        end = typeof page.before === 'string'
-            ? collection.findIndex(el => resolver(el) === page.before) + 1
-            : page.before + 1;
-        start = end > page.limit ? end - page.limit : 0;
-    }
-    const paged = collection.slice(start, end);
-    return paged.length === page.limit ? paged : undefined;
-};

package/core/query/query.d.ts

@@ -1,121 +0,0 @@
-/**
- * Type guard to check and cast that a given async function is has the ".locally" property
- *
- * @param func any SDK APi function
- * @returns success boolean if the function has a 'locally' twin
- *
- * @hidden
- */
-export declare const isFetcher: <Args extends any[], Returned extends unknown>(func: Amity.AsyncFunc<Args, Returned>) => func is Amity.FetcherFunc<Args, Returned>;
-/**
- * Type guard to check and cast that a given async function is has the ".optimistically" property
- *
- * @param func any SDK APi function
- * @returns success boolean if the function has an 'optimistically' twin
- *
- * @hidden
- */
-export declare const isMutator: <Args extends any[], Returned extends unknown>(func: Amity.AsyncFunc<Args, Returned>) => func is Amity.MutatorFunc<Args, Returned>;
-/**
- * Type guard to check and cast that a given async function is has
- * the ".locally" or ".optimistically" property
- *
- * @param func any SDK APi function
- * @returns success boolean if the function has an offline twin
- *
- * @hidden
- */
-export declare const isOffline: <Args extends any[], Returned extends unknown>(func: Amity.AsyncFunc<Args, Returned>) => func is Amity.OfflineFunc<Args, Returned>;
-/**
- * Type guard to check and cast that a given object has the "syncedAt" property
- *
- * @param model any object to check on
- * @returns success boolean if the object has property "syncedAt"
- *
- * @hidden
- */
-export declare const isSyncable: (model: any) => model is Amity.Syncable;
-/**
- * Checks if a model is considered local (syncedAt === -1)
- *
- * @param model any syncable object to check
- * @returns success boolean if the object is marked as local
- *
- * @hidden
- */
-export declare const isLocal: (model?: any) => model is Amity.Syncable;
-/**
- * Checks if a model is considered fresh
- *
- * @param model any syncable object to check
- * @param lifeSpan the supposedly duration for which the object is considered synced
- * @returns success boolean if the object is below the given lifespan
- *
- * @hidden
- */
-export declare const isFresh: (model?: Amity.Syncable | undefined, lifeSpan?: number) => boolean;
-/**
- * Checks if a model is considered synced
- *
- * @param model any syncable object to check
- * @param lifeSpan the supposedly duration for which the object is considered synced
- * @returns success boolean if the object is local or below the given lifespan
- *
- * @hidden
- */
-export declare const isSynced: (model?: any, lifeSpan?: number) => boolean;
-/**
- * ```js
- * import { createQuery, getUser } from '@amityco/ts-sdk'
- * const query = createQuery(getUser, 'foobar')
- * ```
- *
- * Creates a wrapper for the API call you wish to call.
- * This wrapper is necessary to create for optimistically calls
- *
- *
- * @param fn A compatible API function from the ts sdk
- * @param args The arguments to pass to the function passed as `fn`
- * @returns A wrapper containing both the function and its future arguments
- *
- * @category Query
- */
-export declare const createQuery: <Args extends any[], Returned extends unknown>(func: Amity.AsyncFunc<Args, Returned> | Amity.OfflineFunc<Args, Returned>, ...args: Args) => {
-    func: Amity.AsyncFunc<Args, Returned> | Amity.OfflineFunc<Args, Returned>;
-    args: Args;
-};
-/**
- * ```js
- * import { queryOptions } from '@amityco/ts-sdk'
- * const options = queryOptions('no_fetch', lifeSpan)
- * ```
- *
- * Creates a query options object based on the query policy passed
- *
- * @param policy The policy to apply to a query
- * @returns A properly set query options object
- *
- * @category Query
- */
-export declare const queryOptions: (policy: Amity.QueryPolicy, lifeSpan?: number) => Amity.QueryOptions;
-/**
- * ```js
- * import { createQuery, getUser, runQuery } from '@amityco/ts-sdk'
- * const query = createQuery(getUser, client, 'foobar')
- * runQuery(query,  user => console.log(user))
- * ```
- *
- * Calls an API function wrapped around a Amity.Query, and executes the callback whenever
- * a value is available. The value can be picked either from the local cache and/or
- * from the server afterwards depending on the query options passed
- *
- * @param query A query object wrapping the call to be made
- * @param callback A function to execute when a value is available
- * @param options the query options
- *
- * @category Query
- */
-export declare const runQuery: <Args extends any[], Returned extends unknown>({ func, args }: Amity.Query<Args, Returned>, callback?: ((args: ({
-    data?: undefined;
-} & Amity.QueryMetadata) | Amity.QueryResult<Returned>) => void) | undefined, options?: Amity.QueryOptions) => void;
-//# sourceMappingURL=query.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/core/query/query.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,oIAIrB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,oIAIrB,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,oIAE4D,CAAA;AAElF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,UAAW,GAAG,4BAEpC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,WAAY,GAAG,4BAElC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,kDAAsC,MAAM,YAE/D,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,WAAY,GAAG,aAAY,MAAM,YAErD,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;;;CAGH,CAAA;AAGrB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,WACf,MAAM,WAAW,aAAY,MAAM,KAC1C,MAAM,YAOR,CAAA;AAoED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ;;2DAE2C,IAAI,yBACzD,MAAM,YAAY,SA+B5B,CAAA"}

package/core/query/query.js

@@ -1,221 +0,0 @@
-import { syncInCache } from '../cache';
-import { isPaged } from './paging';
-/**
- * Type guard to check and cast that a given async function is has the ".locally" property
- *
- * @param func any SDK APi function
- * @returns success boolean if the function has a 'locally' twin
- *
- * @hidden
- */
-export const isFetcher = (func) => ('locally' in func);
-/**
- * Type guard to check and cast that a given async function is has the ".optimistically" property
- *
- * @param func any SDK APi function
- * @returns success boolean if the function has an 'optimistically' twin
- *
- * @hidden
- */
-export const isMutator = (func) => ('optimistically' in func);
-/**
- * Type guard to check and cast that a given async function is has
- * the ".locally" or ".optimistically" property
- *
- * @param func any SDK APi function
- * @returns success boolean if the function has an offline twin
- *
- * @hidden
- */
-export const isOffline = (func) => isFetcher(func) || isMutator(func);
-/**
- * Type guard to check and cast that a given object has the "syncedAt" property
- *
- * @param model any object to check on
- * @returns success boolean if the object has property "syncedAt"
- *
- * @hidden
- */
-export const isSyncable = (model) => (model === null || model === void 0 ? void 0 : model.hasOwnProperty('syncedAt'));
-/**
- * Checks if a model is considered local (syncedAt === -1)
- *
- * @param model any syncable object to check
- * @returns success boolean if the object is marked as local
- *
- * @hidden
- */
-export const isLocal = (model) => {
-    return isSyncable(model) && (model === null || model === void 0 ? void 0 : model.syncedAt) === -1;
-};
-/**
- * Checks if a model is considered fresh
- *
- * @param model any syncable object to check
- * @param lifeSpan the supposedly duration for which the object is considered synced
- * @returns success boolean if the object is below the given lifespan
- *
- * @hidden
- */
-export const isFresh = (model, lifeSpan = 0) => {
-    var _a;
-    return Date.now() - ((_a = model === null || model === void 0 ? void 0 : model.syncedAt) !== null && _a !== void 0 ? _a : 0) <= lifeSpan;
-};
-/**
- * Checks if a model is considered synced
- *
- * @param model any syncable object to check
- * @param lifeSpan the supposedly duration for which the object is considered synced
- * @returns success boolean if the object is local or below the given lifespan
- *
- * @hidden
- */
-export const isSynced = (model, lifeSpan = 0) => {
-    return isLocal(model) || isFresh(model, lifeSpan);
-};
-/**
- * ```js
- * import { createQuery, getUser } from '@amityco/ts-sdk'
- * const query = createQuery(getUser, 'foobar')
- * ```
- *
- * Creates a wrapper for the API call you wish to call.
- * This wrapper is necessary to create for optimistically calls
- *
- *
- * @param fn A compatible API function from the ts sdk
- * @param args The arguments to pass to the function passed as `fn`
- * @returns A wrapper containing both the function and its future arguments
- *
- * @category Query
- */
-export const createQuery = (func, ...args) => ({ func, args });
-/**
- * ```js
- * import { queryOptions } from '@amityco/ts-sdk'
- * const options = queryOptions('no_fetch', lifeSpan)
- * ```
- *
- * Creates a query options object based on the query policy passed
- *
- * @param policy The policy to apply to a query
- * @returns A properly set query options object
- *
- * @category Query
- */
-export const queryOptions = (policy, lifeSpan = 2 * 60 * 1000) => {
-    if (policy === 'cache_only')
-        return { lifeSpan: Infinity };
-    else if (policy === 'server_only')
-        return { lifeSpan: 0 };
-    return { lifeSpan };
-};
-/**
- * Checks if an unknown shaped payload is considered empty or not.
- * Since the payload can be wrapped around [] or {} (query or get many),
- * we need a smarter definition of what's considered "empty".
- *
- * @param local the unknown object to check for emptiness
- * @returns true if the mixed-shape "local" content is considered empty
- *
- * @hidden
- */
-const isEmpty = (local) => {
-    // if it's supposed to be a single object, it'd be undefined
-    if (!local)
-        return true;
-    // it's a paged query, the 1st cell of the array would be empty
-    else if (isPaged(local) && isEmpty(local.data)) {
-        return true;
-    }
-    // if it's a item collection, it'd have no keys
-    else if (!Object.keys(local).length)
-        return true;
-    return false;
-};
-/**
- * Checks if an unknown shaped payload is considered synced or not.
- * The object will first be identified by 3 types of shapes:
- *
- * 1. Amity.Paged<Amity.Syncable>
- * 2. Amity.Syncable
- * 3. Record<string, Amity.Syncable>
- *
- * then the "Syncable" component will be extracted and evaluated against
- * the query options' lifeSpan value.
- *
- * @param local the unknown object to check for freshness
- * @param options query options (for lifeSpan checking)
- * @returns true if the mixed-shape "local" content is considered fresh
- *
- * @hidden
- */
-const shouldAbort = (local, options) => {
-    // it's a paged query
-    if (isPaged(local) && shouldAbort(local.data, options)) {
-        return true;
-    }
-    // if it's object let's try to see if it's Amity.Syncable first
-    else if (isSynced(local, options.lifeSpan)) {
-        return true;
-    }
-    // otherwise consider as Record<string, Amity.Syncable>
-    else if (Object.values(local).length > 0 &&
-        Object.values(local).every(item => isSynced(item, options.lifeSpan))) {
-        return true;
-    }
-    return false;
-};
-/**
- * ```js
- * import { createQuery, getUser, runQuery } from '@amityco/ts-sdk'
- * const query = createQuery(getUser, client, 'foobar')
- * runQuery(query,  user => console.log(user))
- * ```
- *
- * Calls an API function wrapped around a Amity.Query, and executes the callback whenever
- * a value is available. The value can be picked either from the local cache and/or
- * from the server afterwards depending on the query options passed
- *
- * @param query A query object wrapping the call to be made
- * @param callback A function to execute when a value is available
- * @param options the query options
- *
- * @category Query
- */
-export const runQuery = ({ func, args }, callback, options = queryOptions('cache_then_server')) => {
-    if (!isOffline(func) || options.lifeSpan === 0) {
-        callback === null || callback === void 0 ? void 0 : callback(wrap(undefined, { loading: true }));
-        func(...args)
-            .then(fresh => callback === null || callback === void 0 ? void 0 : callback(wrap(fresh)))
-            .catch(error => callback === null || callback === void 0 ? void 0 : callback(wrap(undefined, { error })));
-        return;
-    }
-    const local = isMutator(func)
-        ? func.optimistically(...args)
-        : func.locally(...args);
-    !isEmpty(local) && (callback === null || callback === void 0 ? void 0 : callback(wrap(local)));
-    if (local && isFetcher(func) && shouldAbort(local, options))
-        return;
-    callback === null || callback === void 0 ? void 0 : callback(wrap(local, { loading: true }));
-    func(...args)
-        .then(fresh => {
-        // @ts-ignore i know.
-        isLocal(local) && syncInCache(local, fresh);
-        callback === null || callback === void 0 ? void 0 : callback(wrap(fresh));
-    })
-        .catch(error => {
-        callback === null || callback === void 0 ? void 0 : callback(wrap(local, { error }));
-    });
-};
-/**
- *
- * @param data
- * @param meta
- * @returns
- */
-const wrap = (data, meta = {}) => {
-    if (isPaged(data))
-        return Object.assign(Object.assign({}, data), meta);
-    return Object.assign({ data }, meta);
-};

package/core/query/sorting.d.ts

@@ -1,33 +0,0 @@
-declare type SortingFunc<T = Object> = (a: T, b: T) => number;
-/**
- * Alphabetic sorting of objects having a displayName
- */
-export declare const sortByDisplayName: SortingFunc<{
-    displayName: string;
-}>;
-/**
- * Sorting a collection by their apparition order (oldest first)
- */
-export declare const sortByChannelSegment: SortingFunc<{
-    channelSegment: number;
-}>;
-/**
- * Sorting a collection by its oldest items
- */
-export declare const sortByFirstCreated: SortingFunc<{
-    createdAt: Date | number | string;
-}>;
-/**
- * Sorting a collection by its newest items
- */
-export declare const sortByLastCreated: SortingFunc<{
-    createdAt: Date | number | string;
-}>;
-/**
- * Sorting a collection by the items with most recent activity
- */
-export declare const sortByLastActivity: SortingFunc<{
-    lastActivity: Date | number | string;
-}>;
-export {};
-//# sourceMappingURL=sorting.d.ts.map

package/core/query/sorting.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorting.d.ts","sourceRoot":"","sources":["../../../src/core/query/sorting.ts"],"names":[],"mappings":"AAIA,aAAK,WAAW,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;AAErD;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAKlE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAE/D,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC;IAAE,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE,CAEhC,CAAA;AAElD;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC;IAAE,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE,CAE/B,CAAA;AAElD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC;IAAE,YAAY,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE,CAEnC,CAAA"}

package/core/query/sorting.js

@@ -1,27 +0,0 @@
-// Note:
-// this file should contain a suite of sorting utilities to help the
-// local version of the query functions.
-/**
- * Alphabetic sorting of objects having a displayName
- */
-export const sortByDisplayName = ({ displayName: a }, { displayName: b }) => {
-    if (a === b)
-        return 0;
-    return a < b ? -1 : 1;
-};
-/**
- * Sorting a collection by their apparition order (oldest first)
- */
-export const sortByChannelSegment = ({ channelSegment: a }, { channelSegment: b }) => a - b;
-/**
- * Sorting a collection by its oldest items
- */
-export const sortByFirstCreated = ({ createdAt: a }, { createdAt: b }) => new Date(a).valueOf() - new Date(b).valueOf();
-/**
- * Sorting a collection by its newest items
- */
-export const sortByLastCreated = ({ createdAt: a }, { createdAt: b }) => new Date(b).valueOf() - new Date(a).valueOf();
-/**
- * Sorting a collection by the items with most recent activity
- */
-export const sortByLastActivity = ({ lastActivity: a }, { lastActivity: b }) => new Date(b).valueOf() - new Date(a).valueOf();

package/core/stores/index.d.ts

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

package/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/core/stores/index.js

@@ -1,2 +0,0 @@
-export * from './memory';
-export * from './persistent';

package/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/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,oEAmBvB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,4EAOxB,CAAA"}

package/core/stores/memory.js

@@ -1,47 +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 const memoryStore = (defaultValue = {}) => {
-    const state = defaultValue;
-    /* default read operation is just to return the state */
-    const read = () => state;
-    /* default write operation is just to mutate the state */
-    const write = (payload) => {
-        Object.assign(state, payload);
-    };
-    /* default write operation is just to mutate the state */
-    const erase = (...keys) => {
-        keys.forEach(key => delete state[key]);
-    };
-    return { read, write, erase };
-};
-/**
- * ```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 const memoryStores = (...names) => {
-    return names.reduce((acc, name) => {
-        const store = memoryStore();
-        return Object.assign(Object.assign({}, acc), { [name]: store });
-    }, {});
-};

package/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/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"}