@rentman/rm-core 7.0.5 → 7.0.6

package/dist/types/classes/QueryMatcher.d.ts

@@ -1,18 +1,18 @@
-import { ApiFormatter } from '../classes';
-import { ApiQuery, EntryParentNull, FieldMap, ItemType } from '../types';
-export declare class QueryMatcher {
-    private apiFormatter;
-    itemType: ItemType;
-    fields: FieldMap;
-    parent: EntryParentNull;
-    constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
-    private compareValues;
-    /**
-     * @remark
-     * When changing this code also change {@link QueryLocallyMatchableParser QueryLocallyMatchableParser}
-     */
-    matchQuery(query: ApiQuery): boolean | 'maybe';
-    private matchLinkedToQuery;
-    private matchComplexQuery;
-    private matchSimpleQuery;
-}
+import { ApiFormatter } from '../classes';
+import { ApiQuery, EntryParentNull, FieldMap, ItemType } from '../types';
+export declare class QueryMatcher {
+    private apiFormatter;
+    itemType: ItemType;
+    fields: FieldMap;
+    parent: EntryParentNull;
+    constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
+    private compareValues;
+    /**
+     * @remark
+     * When changing this code also change {@link QueryLocallyMatchableParser QueryLocallyMatchableParser}
+     */
+    matchQuery(query: ApiQuery): boolean | 'maybe';
+    private matchLinkedToQuery;
+    private matchComplexQuery;
+    private matchSimpleQuery;
+}

package/dist/types/classes/QueryParser.d.ts

@@ -1,24 +1,24 @@
-import { ApiQuery } from '../types';
-import { COMPARATORS, OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
-export declare enum CONSTANTS {
-    OBJ = 0,
-    STR = 1,
-    SEP = ":"
-}
-export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
-export declare class QueryParser extends QueryParserBase<[object, string]> {
-    constructor(query: ApiQuery);
-    protected parseEmptyQuery(): [object, string];
-    protected parseSubQuery(key: string, subQuery: object, not?: boolean): [object, string];
-    protected parseSubFieldQuery(key: string | undefined, itemType: string | undefined, field: string | undefined, query: ApiQuery, not?: boolean): [object, string];
-    protected parseSearchQuery(value: any, not?: boolean): [object, string];
-    protected parseCustomQuery(custom: string, parameters: any, not?: boolean): [object, string];
-    protected parseCustomParameters(parameters: any): [object, string];
-    protected parseSimpleQuery(key: string, value: any, comparator?: COMPARATORS_TYPE, not?: boolean): [object, string];
-    protected parseLinkedToQuery(linkedTo: any, query?: ApiQuery, reverse?: boolean, not?: boolean): [object, string];
-    protected parseComplexQuery(conditions: any[], operator?: OPERATORS_TYPE, not?: boolean): [object, string];
-    private parseConditions;
-    private formatValue;
-    private processValue;
-    private compareParsedQueries;
-}
+import { ApiQuery } from '../types';
+import { COMPARATORS, OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare enum CONSTANTS {
+    OBJ = 0,
+    STR = 1,
+    SEP = ":"
+}
+export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
+export declare class QueryParser extends QueryParserBase<[object, string]> {
+    constructor(query: ApiQuery);
+    protected parseEmptyQuery(): [object, string];
+    protected parseSubQuery(key: string, subQuery: object, not?: boolean): [object, string];
+    protected parseSubFieldQuery(key: string | undefined, itemType: string | undefined, field: string | undefined, query: ApiQuery, not?: boolean): [object, string];
+    protected parseSearchQuery(value: any, not?: boolean): [object, string];
+    protected parseCustomQuery(custom: string, parameters: any, not?: boolean): [object, string];
+    protected parseCustomParameters(parameters: any): [object, string];
+    protected parseSimpleQuery(key: string, value: any, comparator?: COMPARATORS_TYPE, not?: boolean): [object, string];
+    protected parseLinkedToQuery(linkedTo: any, query?: ApiQuery, reverse?: boolean, not?: boolean): [object, string];
+    protected parseComplexQuery(conditions: any[], operator?: OPERATORS_TYPE, not?: boolean): [object, string];
+    private parseConditions;
+    private formatValue;
+    private processValue;
+    private compareParsedQueries;
+}

package/dist/types/classes/QueryParserBase.d.ts

@@ -1,29 +1,29 @@
-import { ApiQuery, ItemType } from '../types';
-export declare enum OPERATORS {
-    OR = "OR",
-    AND = "AND"
-}
-export declare type OPERATORS_TYPE = 'OR' | 'AND' | 'or' | 'and' | OPERATORS;
-export declare enum COMPARATORS {
-    EQUALS = "=",
-    NOT_EQUALS = "!=",
-    LESS_THAN = "<",
-    MORE_THAN = ">",
-    LESS_OR_EQUAL_THAN = "<=",
-    EQUAL_OR_MORE_THAN = ">=",
-    IN = "IN"
-}
-export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
-export declare abstract class QueryParserBase<ReturnType extends any> {
-    protected query: ApiQuery;
-    protected constructor(query: ApiQuery);
-    parse(query?: ApiQuery): ReturnType;
-    protected abstract parseEmptyQuery(): ReturnType;
-    protected abstract parseSubQuery(key: string, subQuery: object, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseSubFieldQuery(key: string, itemType: ItemType, field: string, query: ApiQuery, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseSearchQuery(value: any, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseCustomQuery(custom: string, parameters: any, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseSimpleQuery(key: string, value: any, comparator: COMPARATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseLinkedToQuery(linkedTo: any, query: ApiQuery, reverse: boolean, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseComplexQuery(conditions: any[], operator: OPERATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
-}
+import { ApiQuery, ItemType } from '../types';
+export declare enum OPERATORS {
+    OR = "OR",
+    AND = "AND"
+}
+export declare type OPERATORS_TYPE = 'OR' | 'AND' | 'or' | 'and' | OPERATORS;
+export declare enum COMPARATORS {
+    EQUALS = "=",
+    NOT_EQUALS = "!=",
+    LESS_THAN = "<",
+    MORE_THAN = ">",
+    LESS_OR_EQUAL_THAN = "<=",
+    EQUAL_OR_MORE_THAN = ">=",
+    IN = "IN"
+}
+export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
+export declare abstract class QueryParserBase<ReturnType extends any> {
+    protected query: ApiQuery;
+    protected constructor(query: ApiQuery);
+    parse(query?: ApiQuery): ReturnType;
+    protected abstract parseEmptyQuery(): ReturnType;
+    protected abstract parseSubQuery(key: string, subQuery: object, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseSubFieldQuery(key: string, itemType: ItemType, field: string, query: ApiQuery, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseSearchQuery(value: any, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseCustomQuery(custom: string, parameters: any, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseSimpleQuery(key: string, value: any, comparator: COMPARATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseLinkedToQuery(linkedTo: any, query: ApiQuery, reverse: boolean, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseComplexQuery(conditions: any[], operator: OPERATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
+}

package/dist/types/classes/QueryParserIdUpdater.d.ts

@@ -1,16 +1,16 @@
-import { ApiQuery, ItemIdConversionMap, ItemType } from '../types';
-import { COMPARATORS_TYPE } from './QueryParser';
-import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
-export declare class QueryParserIdUpdater extends QueryParserBase<void> {
-    private itemIdConversionMap;
-    constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
-    protected parseEmptyQuery(): void;
-    protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): void;
-    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): void;
-    protected parseSearchQuery(_value: any, _not: boolean): void;
-    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): void;
-    protected parseSimpleQuery(_key: string, value: any, _comparator: COMPARATORS_TYPE, _not: boolean, queryPart: ApiQuery): void;
-    protected parseLinkedToQuery(_linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, _not?: boolean): void;
-    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): void;
-    private parseConditions;
-}
+import { ApiQuery, ItemIdConversionMap, ItemType } from '../types';
+import { COMPARATORS_TYPE } from './QueryParser';
+import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare class QueryParserIdUpdater extends QueryParserBase<void> {
+    private itemIdConversionMap;
+    constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
+    protected parseEmptyQuery(): void;
+    protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): void;
+    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): void;
+    protected parseSearchQuery(_value: any, _not: boolean): void;
+    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): void;
+    protected parseSimpleQuery(_key: string, value: any, _comparator: COMPARATORS_TYPE, _not: boolean, queryPart: ApiQuery): void;
+    protected parseLinkedToQuery(_linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, _not?: boolean): void;
+    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): void;
+    private parseConditions;
+}

package/dist/types/classes/QueryService.d.ts

@@ -1,18 +1,18 @@
-import { ApiQuery, EntryParentNull, ItemId, ItemType } from '../types';
-import { KeyService } from './KeyService';
-import { COMPARATORS } from './QueryParserBase';
-export declare class QueryService {
-    private keyService;
-    constructor(keyService: KeyService);
-    containsLinkedTo(query: ApiQuery, matchItemType: ItemType, matchItemId: ItemId): boolean;
-    containsLocalId(query: ApiQuery): boolean;
-    addAndCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
-    addOrCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
-    addParentCondition(query: ApiQuery, parent: EntryParentNull): ApiQuery;
-    createNotIn(idArray: ItemId[]): {
-        comparator: COMPARATORS;
-        key: string;
-        value: number[];
-        not: boolean;
-    };
-}
+import { ApiQuery, EntryParentNull, ItemId, ItemType } from '../types';
+import { KeyService } from './KeyService';
+import { COMPARATORS } from './QueryParserBase';
+export declare class QueryService {
+    private keyService;
+    constructor(keyService: KeyService);
+    containsLinkedTo(query: ApiQuery, matchItemType: ItemType, matchItemId: ItemId): boolean;
+    containsLocalId(query: ApiQuery): boolean;
+    addAndCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
+    addOrCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
+    addParentCondition(query: ApiQuery, parent: EntryParentNull): ApiQuery;
+    createNotIn(idArray: ItemId[]): {
+        comparator: COMPARATORS;
+        key: string;
+        value: number[];
+        not: boolean;
+    };
+}

package/dist/types/classes/RequestBuffer.d.ts

@@ -1,28 +1,28 @@
-import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
-import { PromiseLibraryInterface } from '../interfaces';
-import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
-import { ApiRequestService } from './ApiRequestService';
-import { ApiResponseProcessor } from './ApiResponseProcessor';
-import { ServerCache } from './cache/server/ServerCache';
-export declare type RequestBufferResponse<ItemTypeType extends ItemType = any> = ApiResponseProcessor<ItemTypeType>;
-export declare class RequestBuffer<ItemTypeType extends ItemType = any> {
-    private promiseLibrary;
-    private apiRequestService;
-    private requestColumnExpansionFactory;
-    private changesDeltaFactory;
-    private serverCache;
-    private itemType;
-    private deferred;
-    private requestColumnExpansion;
-    private singleItemIds;
-    private queries;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, serverCache: ServerCache, itemType: ItemTypeType);
-    containsId(itemId: ItemId): boolean;
-    containsQuery(queryString: string): boolean;
-    addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    addQuery(query: [object, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    private hasMultipleQueries;
-    private getFirstQueryString;
-}
+import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
+import { PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
+import { ApiResponseProcessor } from './ApiResponseProcessor';
+import { ServerCache } from './cache/server/ServerCache';
+export declare type RequestBufferResponse<ItemTypeType extends ItemType = any> = ApiResponseProcessor<ItemTypeType>;
+export declare class RequestBuffer<ItemTypeType extends ItemType = any> {
+    private promiseLibrary;
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private changesDeltaFactory;
+    private serverCache;
+    private itemType;
+    private deferred;
+    private requestColumnExpansion;
+    private singleItemIds;
+    private queries;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, serverCache: ServerCache, itemType: ItemTypeType);
+    containsId(itemId: ItemId): boolean;
+    containsQuery(queryString: string): boolean;
+    addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    addQuery(query: [object, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    private hasMultipleQueries;
+    private getFirstQueryString;
+}

package/dist/types/classes/RequestBufferManager.d.ts

@@ -1,25 +1,25 @@
-import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
-import { PromiseLibraryInterface } from '../interfaces';
-import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
-import { ApiRequestService } from './ApiRequestService';
-import { ServerCache } from './cache/server/ServerCache';
-import { KeyService } from './KeyService';
-import { RequestBufferResponse } from './RequestBuffer';
-export declare class RequestBufferManager {
-    private promiseLibrary;
-    private apiRequestService;
-    private requestColumnExpansionFactory;
-    private keyService;
-    private changesDeltaFactory;
-    private pendingBufferMap;
-    private pendingTrueBufferMap;
-    private serverCache;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
-    setServerCache(serverCache: ServerCache): void;
-    fetchByIds(itemType: ItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchById(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchByQuery(itemType: ItemType, query: [object, string], // queryParser result
-    requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    private constructBuffer;
-    private _constructBuffer;
-}
+import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
+import { PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
+import { ServerCache } from './cache/server/ServerCache';
+import { KeyService } from './KeyService';
+import { RequestBufferResponse } from './RequestBuffer';
+export declare class RequestBufferManager {
+    private promiseLibrary;
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private keyService;
+    private changesDeltaFactory;
+    private pendingBufferMap;
+    private pendingTrueBufferMap;
+    private serverCache;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
+    setServerCache(serverCache: ServerCache): void;
+    fetchByIds(itemType: ItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchById(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchByQuery(itemType: ItemType, query: [object, string], // queryParser result
+    requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    private constructBuffer;
+    private _constructBuffer;
+}

package/dist/types/classes/RequestColumnExpansion.d.ts

@@ -1,15 +1,15 @@
-import { ColumnSet, ColumnUtil, RequestColumnMergeResult } from '../classes';
-import { ApiRequestColumns, ItemType } from '../types';
-declare type RequestColumnMap = {
-    [itemType: string]: ApiRequestColumns;
-};
-export declare class RequestColumnExpansion {
-    private columnUtil;
-    private columns;
-    private columnSetIdMap;
-    constructor(columnUtil: ColumnUtil);
-    expandWithRequestColumns(itemType: ItemType, requestColumns: ApiRequestColumns): RequestColumnMergeResult;
-    expand<T extends ColumnSet<ItemType>>(columnSet: T): void;
-    get(): RequestColumnMap;
-}
-export {};
+import { ColumnSet, ColumnUtil, RequestColumnMergeResult } from '../classes';
+import { ApiRequestColumns, ItemType } from '../types';
+declare type RequestColumnMap = {
+    [itemType: string]: ApiRequestColumns;
+};
+export declare class RequestColumnExpansion {
+    private columnUtil;
+    private columns;
+    private columnSetIdMap;
+    constructor(columnUtil: ColumnUtil);
+    expandWithRequestColumns(itemType: ItemType, requestColumns: ApiRequestColumns): RequestColumnMergeResult;
+    expand<T extends ColumnSet<ItemType>>(columnSet: T): void;
+    get(): RequestColumnMap;
+}
+export {};

package/dist/types/classes/SocketMessageHandler.d.ts

@@ -1,39 +1,39 @@
-import { ApiFormatter, ApiRequestService } from '../classes';
-import { QueryMatcherFactory, RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
-import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemType, SocketMessage } from '../types';
-import { CachedQueryItem } from './cache/CachedQueryHandlerBase';
-import { RequestBufferManager } from './RequestBufferManager';
-export declare type CachedQueryMatchingResult<ItemTypeType extends ItemType> = {
-    fitting: Array<CachedQueryItem<ItemTypeType>>;
-    notfitting: Array<CachedQueryItem<ItemTypeType>>;
-    maybe: Array<CachedQueryItem<ItemTypeType>>;
-};
-export declare type CachedQueryMatchingResultItemIdMap<ItemTypeType extends ItemType> = {
-    [itemId: number]: CachedQueryMatchingResult<ItemTypeType>;
-};
-export declare class SocketMessageHandler {
-    private requestBufferManager;
-    private changesDeltaFactory;
-    private apiFormatter;
-    private errorHandler;
-    private transactionCacheFactory;
-    private promiseService;
-    private requestColumnExpansionFactory;
-    private apiRequestService;
-    private queryMatcherFactory;
-    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory);
-    onMessageReceived(message: SocketMessage): any;
-    private formatMessageValues;
-    private createQueriesWithFittingItemsMap;
-    private getCachedQueriesByFittingItem;
-    private getRequestColumns;
-    private processMessage;
-    private processFunctionChangesResolve;
-    private isFunctionChangesResolveMessage;
-    private handleCreate;
-    private handleUpdate;
-    private handleDelete;
-    private handleLinkMove;
-}
+import { ApiFormatter, ApiRequestService } from '../classes';
+import { QueryMatcherFactory, RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
+import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemType, SocketMessage } from '../types';
+import { CachedQueryItem } from './cache/CachedQueryHandlerBase';
+import { RequestBufferManager } from './RequestBufferManager';
+export declare type CachedQueryMatchingResult<ItemTypeType extends ItemType> = {
+    fitting: Array<CachedQueryItem<ItemTypeType>>;
+    notfitting: Array<CachedQueryItem<ItemTypeType>>;
+    maybe: Array<CachedQueryItem<ItemTypeType>>;
+};
+export declare type CachedQueryMatchingResultItemIdMap<ItemTypeType extends ItemType> = {
+    [itemId: number]: CachedQueryMatchingResult<ItemTypeType>;
+};
+export declare class SocketMessageHandler {
+    private requestBufferManager;
+    private changesDeltaFactory;
+    private apiFormatter;
+    private errorHandler;
+    private transactionCacheFactory;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    private apiRequestService;
+    private queryMatcherFactory;
+    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory);
+    onMessageReceived(message: SocketMessage): any;
+    private formatMessageValues;
+    private createQueriesWithFittingItemsMap;
+    private getCachedQueriesByFittingItem;
+    private getRequestColumns;
+    private processMessage;
+    private processFunctionChangesResolve;
+    private isFunctionChangesResolveMessage;
+    private handleCreate;
+    private handleUpdate;
+    private handleDelete;
+    private handleLinkMove;
+}

package/dist/types/classes/TemplateCache.d.ts

@@ -1,66 +1,66 @@
-import { RequestColumnExpansionFactory, TemplateFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { Template } from '../models';
-import { ColumnIdTypeMap, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
-import { ApiRequestService } from './ApiRequestService';
-import { ColumnHandler } from './ColumnHandler';
-import { ColumnUtil } from './ColumnUtil';
-export declare class TemplateCache {
-    private columnUtil;
-    private promiseService;
-    private columnHandler;
-    private templateFactory;
-    private errorHandler;
-    private requestColumnExpansionFactory;
-    private apiRequestService;
-    private pendingTemplateBufferMap;
-    templates: {
-        [itemType: string]: Template<any>;
-    };
-    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
-    /**
-     * @description
-     * Fetches a {@link Template template}, {@link TransactionItemHandler.createItems TransactionItemHandler.createItems} is a convenience function for this
-     *
-     * @param itemType The {@link ItemType ItemType} of the template item
-     * @param itemId Used for caching, multiple concurrent template calls for the same itemId will return the same template
-     * @param templateOptions
-     * @param templateColumns Additional columns to be fetched, will be stored in the template - warning - the Template won't have values for those columns
-     * @param entryParentOrParentItemType An optional {@link EntryParentNull entry parent} or {@link ItemType parent itemType}, if the parent is passed the templateColumns will be expanded with the proper link columns (Through {@link ColumnUtil.getColumnsFromLink ColumnUtil.getColumnsFromLink})
-     *
-     * @example
-     * ```
-     *  const parent: EntryParent = {
-     *      itemType: 'Functie',
-     *      itemId: 10,
-     *  };
-     *
-     *  return core.templateCache
-     *      .fetchTemplate(
-     *          'Planningpersoneel',
-     *          undefined,
-     *          {},
-     *          {},
-     *          parent,
-     *      )
-     *      .then(
-     *          (template: Template<'Planningpersoneel'>) => {
-     *              const changesDelta = transaction.createChangesDelta();
-     *
-     *              for (const itemResource of selectedItems) {
-     *                  changesDelta.setItemCreated(
-     *                      core.keyService.getLocalId(),
-     *                      template.fields,
-     *                      template.columns,
-     *                      parent,
-     *                  );
-     *              }
-     *
-     *              transaction.applyChangesDelta(changesDelta);
-     *          );
-     *  ```
-     */
-    fetchTemplate<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ItemType): PromiseInterface<Template<ItemTypeType, Fields>>;
-    private fetchTemplateById;
-    private constructTemplateBuffer;
-}
+import { RequestColumnExpansionFactory, TemplateFactory } from '../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { Template } from '../models';
+import { ColumnIdTypeMap, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
+import { ColumnHandler } from './ColumnHandler';
+import { ColumnUtil } from './ColumnUtil';
+export declare class TemplateCache {
+    private columnUtil;
+    private promiseService;
+    private columnHandler;
+    private templateFactory;
+    private errorHandler;
+    private requestColumnExpansionFactory;
+    private apiRequestService;
+    private pendingTemplateBufferMap;
+    templates: {
+        [itemType: string]: Template<any>;
+    };
+    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
+    /**
+     * @description
+     * Fetches a {@link Template template}, {@link TransactionItemHandler.createItems TransactionItemHandler.createItems} is a convenience function for this
+     *
+     * @param itemType The {@link ItemType ItemType} of the template item
+     * @param itemId Used for caching, multiple concurrent template calls for the same itemId will return the same template
+     * @param templateOptions
+     * @param templateColumns Additional columns to be fetched, will be stored in the template - warning - the Template won't have values for those columns
+     * @param entryParentOrParentItemType An optional {@link EntryParentNull entry parent} or {@link ItemType parent itemType}, if the parent is passed the templateColumns will be expanded with the proper link columns (Through {@link ColumnUtil.getColumnsFromLink ColumnUtil.getColumnsFromLink})
+     *
+     * @example
+     * ```
+     *  const parent: EntryParent = {
+     *      itemType: 'Functie',
+     *      itemId: 10,
+     *  };
+     *
+     *  return core.templateCache
+     *      .fetchTemplate(
+     *          'Planningpersoneel',
+     *          undefined,
+     *          {},
+     *          {},
+     *          parent,
+     *      )
+     *      .then(
+     *          (template: Template<'Planningpersoneel'>) => {
+     *              const changesDelta = transaction.createChangesDelta();
+     *
+     *              for (const itemResource of selectedItems) {
+     *                  changesDelta.setItemCreated(
+     *                      core.keyService.getLocalId(),
+     *                      template.fields,
+     *                      template.columns,
+     *                      parent,
+     *                  );
+     *              }
+     *
+     *              transaction.applyChangesDelta(changesDelta);
+     *          );
+     *  ```
+     */
+    fetchTemplate<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ItemType): PromiseInterface<Template<ItemTypeType, Fields>>;
+    private fetchTemplateById;
+    private constructTemplateBuffer;
+}