@amityco/ts-sdk 0.0.1-beta.2 → 0.0.1-c58e50d.0

package/core/events.js

@@ -1,72 +0,0 @@
-import mitt from 'mitt';
-import { getActiveClient } from '../client/api';
-// need to sync up the list
-const EVENTS = [
-    'disconnected',
-    'v3.user.didUpdate',
-    'v3.channel.didUpdate',
-    'v3.channel.didUpdate',
-    'v3.channel.didJoin',
-    'v3.channel.didLeave',
-    'v3.channel.didAddUsers',
-    'v3.channel.didRemoveUsers',
-    'v3.channel.didBan',
-    'v3.channel.didUnban',
-    'v3.message.didCreate',
-    'v3.message.didUpdate',
-    'v3.message.didDelete',
-];
-/** @hidden */
-export const createEventEmitter = () => {
-    return mitt();
-};
-/**
- * Wraps the websocket events into the client's event emitter for
- * abstraction of transport.
- *
- * @param ws A websocket connection to listen from
- * @param emitter An event emitter to wire the events to
- *
- * @category Transport
- * @hidden
- */
-export const proxyWebsocketEvents = (ws, emitter) => {
-    EVENTS.forEach(event => {
-        ws.on(event, (param) => emitter.emit(event, param));
-    });
-};
-/**
- * Standardize the subscription of SSE through web sockets
- *
- * @param client The current client for which to subscribe the event to
- * @param namespace A unique name for the logger
- * @param event The websocket event name
- * @param fn A wrapper for the callback.
- * @returns A dispose function to unsubscribe to the event
- *
- * @category Transport
- * @hidden
- */
-export const createEventSubscriber = (client, namespace, event, fn) => {
-    const { log, emitter } = client;
-    const timestamp = Date.now();
-    log(`${namespace}(tmpid: ${timestamp}) > listen`);
-    const handler = (...payload) => {
-        log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload);
-        fn(...payload);
-    };
-    emitter.on(event, handler);
-    return () => {
-        log(`${namespace}(tmpid: ${timestamp}) > dispose`);
-        emitter.off(event, handler);
-    };
-};
-/**
- * Wrapper around dispatch event
- *
- * @hidden
- */
-export const fireEvent = (event, payload) => {
-    const { emitter } = getActiveClient();
-    setTimeout(() => { emitter.emit(event, payload); }, 0);
-};

package/core/model/createPayload.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=createPayload.d.ts.map

package/core/model/createPayload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createPayload.d.ts","sourceRoot":"","sources":["../../../src/core/model/createPayload.ts"],"names":[],"mappings":""}

package/core/model/createPayload.js

@@ -1 +0,0 @@
-"use strict";

package/core/model/idResolvers.d.ts

@@ -1,20 +0,0 @@
-/**
- * A resolver function is a function which, given a minimal version of a model T
- * can compute a string which is capable of identifying the given model uniquely
- * @hidden
- */
-declare type Resolver<T extends Amity.Domain> = (model: Amity.Minimal[T]) => string;
-/**
- * Retrieve the id resolver matching a domain name
- *
- * @param name the domain name for the resolve
- * @returns an idResolver for the given domain name
- */
-export declare const getResolver: <T extends keyof Amity.Model>(name: T) => Resolver<T>;
-/**
- * A map of v3 response keys to a store name.
- * @hidden
- */
-export declare const storeInterests: Record<string, Amity.Domain>;
-export {};
-//# sourceMappingURL=idResolvers.d.ts.map

package/core/model/idResolvers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"idResolvers.d.ts","sourceRoot":"","sources":["../../../src/core/model/idResolvers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,aAAK,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM,CAAA;AA6B3E;;;;;GAKG;AACH,eAAO,MAAM,WAAW,uDAEvB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAYvD,CAAA"}

package/core/model/idResolvers.js

@@ -1,36 +0,0 @@
-/**
- * Dictionary of resolver functions for each model
- * @hidden
- */
-const idResolvers = {
-    user: ({ userId }) => userId,
-    file: ({ fileId }) => fileId,
-    channel: ({ channelId }) => channelId,
-    message: ({ messageId }) => messageId,
-    community: ({ communityId }) => communityId,
-    post: ({ postId }) => postId,
-    comment: ({ commentId }) => commentId,
-    stream: ({ streamId }) => streamId,
-};
-/**
- * Retrieve the id resolver matching a domain name
- *
- * @param name the domain name for the resolve
- * @returns an idResolver for the given domain name
- */
-export const getResolver = (name) => idResolvers[name];
-/**
- * A map of v3 response keys to a store name.
- * @hidden
- */
-export const storeInterests = {
-    users: 'user',
-    files: 'file',
-    channels: 'channel',
-    //  channelUsers: 'membership',
-    messages: 'message',
-    communities: 'community',
-    posts: 'post',
-    postChildren: 'post',
-    comments: 'comment',
-};

package/core/model/identifyModel.d.ts

@@ -1,8 +0,0 @@
-/**
- * Finds the name of the store for a given unknown model
- *
- * @param model one of the {@link Amity.Model} to identify
- * @returns the name of the corresponding store
- */
-export declare const identifyModel: (model: Amity.Model[Amity.Domain]) => keyof Amity.Model | undefined;
-//# sourceMappingURL=identifyModel.d.ts.map

package/core/model/identifyModel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"identifyModel.d.ts","sourceRoot":"","sources":["../../../src/core/model/identifyModel.ts"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,eAAO,MAAM,aAAa,UAAW,MAAM,KAAK,CAAC,MAAM,MAAM,CAAC,kCAG7D,CAAA"}

package/core/model/identifyModel.js

@@ -1,28 +0,0 @@
-/** hidden */
-/** @hidden */
-const CRITERIAS = {
-    'file': ['fileId', 'attributes'],
-    'user': ['userId', 'avatarFileId'],
-    'channel': ['channelId', 'rateLimit'],
-    'message': ['messageId'],
-    'community': ['communityId', 'onlyAdminCanPost'],
-    'post': ['postId', 'feedId'],
-    'comment': ['commentId', 'referenceId'],
-    'stream': ['streamId'],
-};
-/** @hidden */
-const hasKeys = (object, needles) => {
-    const haystack = Object.keys(object);
-    return needles.every(needle => haystack.includes(needle));
-};
-/**
- * Finds the name of the store for a given unknown model
- *
- * @param model one of the {@link Amity.Model} to identify
- * @returns the name of the corresponding store
- */
-export const identifyModel = (model) => {
-    var _a;
-    const criterias = Object.entries(CRITERIAS);
-    return (_a = criterias.find(([_, keys]) => hasKeys(model, keys))) === null || _a === void 0 ? void 0 : _a[0];
-};

package/core/model/index.d.ts

@@ -1,4 +0,0 @@
-export * from './identifyModel';
-export * from './idResolvers';
-export * from './toRecord';
-//# sourceMappingURL=index.d.ts.map

package/core/model/index.js

@@ -1,3 +0,0 @@
-export * from './identifyModel';
-export * from './idResolvers';
-export * from './toRecord';

package/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/core/model/toRecord.js

@@ -1,9 +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 const toRecord = (array) => (array.reduce((acc, item) => (Object.assign(Object.assign({}, acc), { [item.localId]: item })), {}));

package/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.Channel<any> | Amity.Stream | Amity.Community | Amity.Post<any> | Amity.Comment<any> | Amity.Message<any>>(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.Channel<any> | Amity.Stream | Amity.Community | Amity.Post<any> | Amity.Comment<any> | Amity.Message<any>>(model: T, timestamp?: number, type?: keyof Amity.Model | undefined) => void;
-//# sourceMappingURL=decorate.d.ts.map

package/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,sLAEd,MAAM,+CAIlB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,mLAEb,MAAM,+CAWlB,CAAA"}

package/core/query/decorate.js

@@ -1,40 +0,0 @@
-import { uuid } from '../../core/uuid';
-import { getActiveClient } from '../../client/api';
-import { getResolver, identifyModel, storeInterests, } from '../model';
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param timestamp the given timestamp
- */
-export const decoratePayload = (payload, timestamp = Date.now(), keyMapping = storeInterests) => {
-    Object.fromEntries(Object.entries(payload)
-        .map(([key, models]) => ([
-        key, decorateModels(models, timestamp, keyMapping[key])
-    ])));
-};
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param timestamp the given timestamp
- */
-export const decorateModels = (models, timestamp = Date.now(), type) => {
-    models.forEach(model => decorateModel(model, timestamp, type));
-};
-/**
- * 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 const decorateModel = (model, timestamp = Date.now(), type = identifyModel(model)) => {
-    var _a, _b;
-    (_a = model.syncedAt) !== null && _a !== void 0 ? _a : (model.syncedAt = timestamp);
-    const { cache } = getActiveClient();
-    if (type) {
-        const modelId = getResolver(type)(model);
-        model.localId = (_b = cache === null || cache === void 0 ? void 0 : cache.lookup[`${type}#${modelId}`]) !== null && _b !== void 0 ? _b : uuid();
-    }
-};

package/core/query/filtering.d.ts

@@ -1,12 +0,0 @@
-/**
- * Filter a given collection with strict equality against a param
- *
- * @param collection the collection to filter
- * @param key the key of the collection's items to challenge
- * @param value the expected value
- * @returns a filtered collection with items only matching the criteria
- *
- * @hidden
- */
-export declare const filterByPropEquality: <T = {}>(collection: T[], key: keyof T, value: any) => T[];
-//# sourceMappingURL=filtering.d.ts.map

package/core/query/filtering.js

@@ -1,14 +0,0 @@
-// Note:
-// this file should contain a suite of filtering utilities to help the
-// local version of the query functions.
-/**
- * Filter a given collection with strict equality against a param
- *
- * @param collection the collection to filter
- * @param key the key of the collection's items to challenge
- * @param value the expected value
- * @returns a filtered collection with items only matching the criteria
- *
- * @hidden
- */
-export const filterByPropEquality = (collection, key, value) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);

package/core/query/index.d.ts

@@ -1,6 +0,0 @@
-export * from './query';
-export * from './decorate';
-export * from './filtering';
-export * from './sorting';
-export * from './paging';
-//# sourceMappingURL=index.d.ts.map

package/core/query/index.js

@@ -1,5 +0,0 @@
-export * from './query';
-export * from './decorate';
-export * from './filtering';
-export * from './sorting';
-export * from './paging';

package/core/query/paging.d.ts

@@ -1,58 +0,0 @@
-/**
- * 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 declare const isSkipLimit: (json: Object) => json is Amity.SkipLimitPagination;
-/**
- * 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 declare const isAfterBefore: (json: Object) => json is Amity.AfterBeforePagination;
-/**
- * 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 declare const isPaged: (payload: any) => payload is Amity.Paged<any>;
-/**
- * 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 declare const toToken: (paging: Amity.Page | undefined, style: 'skiplimit' | 'afterbefore') => Amity.Token | undefined;
-/**
- * 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 declare const toPage: (token?: string | undefined) => Amity.Page | 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 declare const sliceByPaging: <K extends keyof Amity.Model, T extends Amity.Model[K]>(type: K, collection: T[], page?: Amity.Page | undefined) => T[] | undefined;
-//# sourceMappingURL=paging.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"paging.d.ts","sourceRoot":"","sources":["../../../src/core/query/paging.ts"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,SAAU,MAAM,sCAEvC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,SAAU,MAAM,wCAEzC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,YAAa,GAAG,gCAMnC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,WACV,MAAM,IAAI,GAAG,SAAS,SACvB,WAAW,GAAG,aAAa,KAEjC,MAAM,KAAK,GAAG,SA6BhB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,kCAA0B,MAAM,IAAI,GAAG,IA0BzD,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,qIA8BzB,CAAA"}

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 || !Object.keys(paging).length)
-        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"}