@rentman/rm-core 2.0.7 → 2.0.8

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

@@ -1,25 +1,25 @@
-import { 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 = ApiResponseProcessor;
-export declare class RequestBuffer {
-    private promiseLibrary;
-    private apiRequestService;
-    private requestColumnExpansionFactory;
-    private serverCache;
-    private itemType;
-    private deferred;
-    private requestColumnExpansion;
-    private singleItemIds;
-    private queries;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, serverCache: ServerCache, itemType: ItemType);
-    containsId(itemId: ItemId): boolean;
-    containsQuery(queryString: string): boolean;
-    addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    addQuery(query: [object, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    flush(): PromiseInterface<RequestBufferResponse>;
-    getPromise(): PromiseInterface<RequestBufferResponse>;
-}
+import { 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 = ApiResponseProcessor;
+export declare class RequestBuffer {
+    private promiseLibrary;
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private serverCache;
+    private itemType;
+    private deferred;
+    private requestColumnExpansion;
+    private singleItemIds;
+    private queries;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, serverCache: ServerCache, itemType: ItemType);
+    containsId(itemId: ItemId): boolean;
+    containsQuery(queryString: string): boolean;
+    addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    addQuery(query: [object, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    flush(): PromiseInterface<RequestBufferResponse>;
+    getPromise(): PromiseInterface<RequestBufferResponse>;
+}

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

@@ -1,31 +1,31 @@
-import { RequestColumnExpansionFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
-import { ApiRequestService } from './ApiRequestService';
-import { ApiResponseProcessor } from './ApiResponseProcessor';
-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 errorHandler;
-    private pendingBufferMap;
-    private pendingTrueBufferMap;
-    private pendingQueryBufferMap;
-    private pendingTemplateBufferMap;
-    private serverCache;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, errorHandler: ErrorHandlerInterface);
-    setServerCache(serverCache: ServerCache): void;
-    containsId(itemType: ItemType, itemId: ItemId): boolean;
-    containsQuery(itemType: ItemType, queryString: string): boolean;
-    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>;
-    fetchByLocalId(itemType: ItemType, itemId?: ItemId | string, templateOptions?: any): PromiseInterface<ApiResponseProcessor>;
-    private constructBuffer;
-    private constructTemplateBuffer;
-}
+import { RequestColumnExpansionFactory } from '../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
+import { ApiResponseProcessor } from './ApiResponseProcessor';
+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 errorHandler;
+    private pendingBufferMap;
+    private pendingTrueBufferMap;
+    private pendingQueryBufferMap;
+    private pendingTemplateBufferMap;
+    private serverCache;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, errorHandler: ErrorHandlerInterface);
+    setServerCache(serverCache: ServerCache): void;
+    containsId(itemType: ItemType, itemId: ItemId): boolean;
+    containsQuery(itemType: ItemType, queryString: string): boolean;
+    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>;
+    fetchByLocalId(itemType: ItemType, itemId?: ItemId | string, templateOptions?: any): PromiseInterface<ApiResponseProcessor>;
+    private constructBuffer;
+    private constructTemplateBuffer;
+}

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

@@ -1,15 +1,15 @@
-import { ColumnSet, ColumnUtil } 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): void;
-    expand<T extends ColumnSet<ItemType>>(columnSet: T): void;
-    get(): RequestColumnMap;
-}
-export {};
+import { ColumnSet, ColumnUtil } 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): void;
+    expand<T extends ColumnSet<ItemType>>(columnSet: T): void;
+    get(): RequestColumnMap;
+}
+export {};

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

@@ -1,31 +1,31 @@
-import { ApiFormatter, ApiRequestService } from '../classes';
-import { RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
-import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionMatchResult, ItemType, SocketMessage } from '../types';
-import { RequestBufferManager } from './RequestBufferManager';
-export declare type SocketCollectionMap<ItemTypeType extends ItemType> = {
-    [itemId: number]: CollectionMatchResult<ItemTypeType>;
-};
-export declare class SocketMessageHandler {
-    private requestBufferManager;
-    private changesDeltaFactory;
-    private apiFormatter;
-    private errorHandler;
-    private transactionCacheFactory;
-    private promiseService;
-    private requestColumnExpansionFactory;
-    private apiRequestService;
-    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
-    onMessageReceived(message: SocketMessage): any;
-    private formatMessageValues;
-    private createCollectionMap;
-    private getRequestColumns;
-    private processMessage;
-    private processFunctionChangesResolve;
-    private isFunctionChangesResolveMessage;
-    private handleCreate;
-    private handleUpdate;
-    private handleDelete;
-    private handleLinkMove;
-}
+import { ApiFormatter, ApiRequestService } from '../classes';
+import { RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
+import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionMatchResult, ItemType, SocketMessage } from '../types';
+import { RequestBufferManager } from './RequestBufferManager';
+export declare type SocketCollectionMap<ItemTypeType extends ItemType> = {
+    [itemId: number]: CollectionMatchResult<ItemTypeType>;
+};
+export declare class SocketMessageHandler {
+    private requestBufferManager;
+    private changesDeltaFactory;
+    private apiFormatter;
+    private errorHandler;
+    private transactionCacheFactory;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    private apiRequestService;
+    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
+    onMessageReceived(message: SocketMessage): any;
+    private formatMessageValues;
+    private createCollectionMap;
+    private getRequestColumns;
+    private processMessage;
+    private processFunctionChangesResolve;
+    private isFunctionChangesResolveMessage;
+    private handleCreate;
+    private handleUpdate;
+    private handleDelete;
+    private handleLinkMove;
+}

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

@@ -1,63 +1,63 @@
-import { RequestColumnExpansionFactory, TemplateFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { Template } from '../models';
-import { EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
-import { ColumnHandler } from './ColumnHandler';
-import { ColumnUtil } from './ColumnUtil';
-import { RequestBufferManager } from './RequestBufferManager';
-export declare class TemplateCache {
-    private columnUtil;
-    private promiseService;
-    private requestBufferFactory;
-    private columnHandler;
-    private templateFactory;
-    private errorHandler;
-    private requestColumnExpansionFactory;
-    templates: {
-        [itemType: string]: Template<any>;
-    };
-    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, requestBufferFactory: RequestBufferManager, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
-    /**
-     * @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>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ItemType): PromiseInterface<Template<ItemTypeType>>;
-}
+import { RequestColumnExpansionFactory, TemplateFactory } from '../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { Template } from '../models';
+import { EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
+import { ColumnHandler } from './ColumnHandler';
+import { ColumnUtil } from './ColumnUtil';
+import { RequestBufferManager } from './RequestBufferManager';
+export declare class TemplateCache {
+    private columnUtil;
+    private promiseService;
+    private requestBufferFactory;
+    private columnHandler;
+    private templateFactory;
+    private errorHandler;
+    private requestColumnExpansionFactory;
+    templates: {
+        [itemType: string]: Template<any>;
+    };
+    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, requestBufferFactory: RequestBufferManager, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    /**
+     * @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>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ItemType): PromiseInterface<Template<ItemTypeType>>;
+}

package/dist/src/classes/Util.d.ts

@@ -1,28 +1,28 @@
-export declare function instantiateOptions(options: {
-    [key: string]: any;
-}, values: object): void;
-export declare function shallowMerge(object: any, defaults: any): any;
-export declare function hasProperties(object: any): boolean;
-export declare function getFirstProperty(object: any): string | null;
-export declare function inArray(needle: any, haystack: any): boolean;
-export declare function filterArray<T>(source: T[], callback: (elem: T) => boolean): boolean;
-export declare function emptyArray(array: any): void;
-export declare function pathExists(source: any, path: any): boolean;
-export declare function createPath<T>(object: any, path: Array<number | string>, defaults: any[]): T;
-export declare function getPath(object: {}, path: Array<number | string>, create?: boolean): any;
-export declare function extend(dst: any, ...args: any[]): any;
-export declare function merge(dst: any, ...args: any[]): any;
-export declare function isObject(value: any): boolean;
-export declare function isBlankObject(value: any): boolean;
-export declare function isString(value: any): boolean;
-export declare function isNumber(value: any): boolean;
-export declare function isDate(value: any): boolean;
-export declare const isArray: (arg: any) => arg is any[];
-export declare function isFunction<T>(value: any): value is T;
-export declare function isRegExp(value: any): boolean;
-export declare function isBoolean(value: any): boolean;
-export declare function isElement(node: any): boolean;
-export declare function isWindow(obj: any): boolean;
-export declare function isDefined(value: any): boolean;
-export declare function equals(o1: any, o2: any): boolean;
-export declare function copy(source: any, destination?: any, maxDepth?: any): any;
+export declare function instantiateOptions(options: {
+    [key: string]: any;
+}, values: object): void;
+export declare function shallowMerge(object: any, defaults: any): any;
+export declare function hasProperties(object: any): boolean;
+export declare function getFirstProperty(object: any): string | null;
+export declare function inArray(needle: any, haystack: any): boolean;
+export declare function filterArray<T>(source: T[], callback: (elem: T) => boolean): boolean;
+export declare function emptyArray(array: any): void;
+export declare function pathExists(source: any, path: any): boolean;
+export declare function createPath<T>(object: any, path: Array<number | string>, defaults: any[]): T;
+export declare function getPath(object: {}, path: Array<number | string>, create?: boolean): any;
+export declare function extend(dst: any, ...args: any[]): any;
+export declare function merge(dst: any, ...args: any[]): any;
+export declare function isObject(value: any): boolean;
+export declare function isBlankObject(value: any): boolean;
+export declare function isString(value: any): boolean;
+export declare function isNumber(value: any): boolean;
+export declare function isDate(value: any): boolean;
+export declare const isArray: (arg: any) => arg is any[];
+export declare function isFunction<T>(value: any): value is T;
+export declare function isRegExp(value: any): boolean;
+export declare function isBoolean(value: any): boolean;
+export declare function isElement(node: any): boolean;
+export declare function isWindow(obj: any): boolean;
+export declare function isDefined(value: any): boolean;
+export declare function equals(o1: any, o2: any): boolean;
+export declare function copy(source: any, destination?: any, maxDepth?: any): any;