@rentman/rm-core 11.0.2 → 11.0.4

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

@@ -1,17 +1,17 @@
-import { ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
-import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ItemIdConversionMap, QueryParserBase } from '../internal';
-declare type ReturnType = boolean;
-export declare class QueryParserIdUpdater extends QueryParserBase<ReturnType> {
-    private itemIdConversionMap;
-    constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
-    protected parseEmptyQuery(): ReturnType;
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): ReturnType;
-    protected parseSubFieldQuery(): ReturnType;
-    protected parseSearchQuery(): ReturnType;
-    protected parseCustomQuery(): ReturnType;
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value'], _comparator: T['comparator'], _not: T['not'], queryPart: T): ReturnType;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query?: T['query']): ReturnType;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
-    private parseConditions;
-}
-export {};
+import { ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ItemIdConversionMap, QueryParserBase } from '../internal';
+declare type ReturnType = boolean;
+export declare class QueryParserIdUpdater extends QueryParserBase<ReturnType> {
+    private itemIdConversionMap;
+    constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): ReturnType;
+    protected parseSubFieldQuery(): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator | ApiQueryConditionIn>(_key: T['key'], value: T['value'], comparator: T['comparator'], _not: T['not'], queryPart: T): ReturnType;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query?: T['query']): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
+    private parseConditions;
+}
+export {};

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

@@ -1,12 +1,12 @@
-import { ApiEnumItemType, ApiQueryConditionIn, ItemId } from '@rentman/backend-types';
-import { ApiQuery, EntryParentNull, KeyService } from '../internal';
-export declare class QueryService {
-    private keyService;
-    constructor(keyService: KeyService);
-    containsLinkedTo(query: ApiQuery, matchItemType: ApiEnumItemType, 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[]): ApiQueryConditionIn;
-}
+import { ApiEnumItemType, ApiQueryConditionIn, ItemId } from '@rentman/backend-types';
+import { ApiQuery, EntryParentNull, KeyService } from '../internal';
+export declare class QueryService {
+    private keyService;
+    constructor(keyService: KeyService);
+    containsLinkedTo(query: ApiQuery, matchItemType: ApiEnumItemType, 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[]): ApiQueryConditionIn;
+}

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

@@ -1,26 +1,26 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, ApiRequestService, ApiResponseProcessor, ChangesDeltaFactory, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, ServerCache } from '../internal';
-export declare type RequestBufferResponse<ItemTypeType extends ApiEnumItemType = any> = ApiResponseProcessor<ItemTypeType>;
-export declare class RequestBuffer<ItemTypeType extends ApiEnumItemType = 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: [ApiQuery, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    isPrivateBuffer(): boolean;
-    getFirstQueryString(): string | undefined;
-    private hasMultipleQueries;
-    private createAggregateQuery;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiQuery, ApiRequestColumns, ApiRequestService, ApiResponseProcessor, ChangesDeltaFactory, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, ServerCache } from '../internal';
+export declare type RequestBufferResponse<ItemTypeType extends ApiEnumItemType = any> = ApiResponseProcessor<ItemTypeType>;
+export declare class RequestBuffer<ItemTypeType extends ApiEnumItemType = 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: [ApiQuery, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    isPrivateBuffer(): boolean;
+    getFirstQueryString(): string | undefined;
+    private hasMultipleQueries;
+    private createAggregateQuery;
+}

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

@@ -1,21 +1,21 @@
-import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
-import { ApiRequestColumns, ApiRequestService, ChangesDeltaFactory, KeyService, PromiseInterface, PromiseLibraryInterface, RequestBufferResponse, RequestColumnExpansionFactory, ServerCache } from '../internal';
-export declare class RequestBufferManager {
-    private promiseLibrary;
-    private apiRequestService;
-    private requestColumnExpansionFactory;
-    private keyService;
-    private changesDeltaFactory;
-    private pendingBufferMap;
-    private pendingTrueBufferMap;
-    private pendingPrivateBufferMap;
-    private serverCache;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
-    setServerCache(serverCache: ServerCache): void;
-    fetchByIds(itemType: ApiEnumItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchById(itemType: ApiEnumItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchByQuery(itemType: ApiEnumItemType, query: [ApiQuery, string], requestColumns: ApiRequestColumns, usePrivateBuffer: boolean): PromiseInterface<RequestBufferResponse>;
-    private constructPrivateBuffer;
-    private constructBuffer;
-    private _constructBuffer;
-}
+import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumns, ApiRequestService, ChangesDeltaFactory, KeyService, PromiseInterface, PromiseLibraryInterface, RequestBufferResponse, RequestColumnExpansionFactory, ServerCache } from '../internal';
+export declare class RequestBufferManager {
+    private promiseLibrary;
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private keyService;
+    private changesDeltaFactory;
+    private pendingBufferMap;
+    private pendingTrueBufferMap;
+    private pendingPrivateBufferMap;
+    private serverCache;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
+    setServerCache(serverCache: ServerCache): void;
+    fetchByIds(itemType: ApiEnumItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchById(itemType: ApiEnumItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchByQuery(itemType: ApiEnumItemType, query: [ApiQuery, string], requestColumns: ApiRequestColumns, usePrivateBuffer: boolean): PromiseInterface<RequestBufferResponse>;
+    private constructPrivateBuffer;
+    private constructBuffer;
+    private _constructBuffer;
+}

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

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

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

@@ -1,34 +1,34 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiFormatter, ApiRequestService, CachedQueryItem, ChangesDeltaFactory, ErrorHandlerInterface, PromiseLibraryInterface, QueryMatcherFactory, RequestBufferManager, RequestColumnExpansionFactory, SocketMessage, TransactionCacheFactory } from '../internal';
-export declare type CachedQueryMatchingResult<ItemTypeType extends ApiEnumItemType> = {
-    fitting: CachedQueryItem<ItemTypeType>[];
-    notfitting: CachedQueryItem<ItemTypeType>[];
-    maybe: CachedQueryItem<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 getCollectionsWithLimitByItemType;
-    /**
-     * @description
-     * When an item is created or updated, we should check if it fits in any of the cached queries (using the values provided by the socket message)
-     * If we think it fits (or maybe) we should fetch the complete item with the superset of columns (the socket message might not have all values)
-     */
-    private processMessage;
-    private processFunctionChangesResolve;
-    private isFunctionChangesResolveMessage;
-    private handleCreate;
-    private handleUpdate;
-    private handleDelete;
-    private handleLinkMove;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiFormatter, ApiRequestService, CachedQueryItem, ChangesDeltaFactory, ErrorHandlerInterface, PromiseLibraryInterface, QueryMatcherFactory, RequestBufferManager, RequestColumnExpansionFactory, SocketMessage, TransactionCacheFactory } from '../internal';
+export declare type CachedQueryMatchingResult<ItemTypeType extends ApiEnumItemType> = {
+    fitting: CachedQueryItem<ItemTypeType>[];
+    notfitting: CachedQueryItem<ItemTypeType>[];
+    maybe: CachedQueryItem<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 getCollectionsWithLimitByItemType;
+    /**
+     * @description
+     * When an item is created or updated, we should check if it fits in any of the cached queries (using the values provided by the socket message)
+     * If we think it fits (or maybe) we should fetch the complete item with the superset of columns (the socket message might not have all values)
+     */
+    private processMessage;
+    private processFunctionChangesResolve;
+    private isFunctionChangesResolveMessage;
+    private handleCreate;
+    private handleUpdate;
+    private handleDelete;
+    private handleLinkMove;
+}

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

@@ -1,64 +1,64 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiRequestService, ApiResponse, ColumnHandler, ColumnUtil, EntryParentNull, ErrorHandlerInterface, ItemTypeColumnIds, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, Template, TemplateFactory } from '../internal';
-export declare class TemplateCache {
-    private columnUtil;
-    private promiseService;
-    private columnHandler;
-    private templateFactory;
-    private errorHandler;
-    private requestColumnExpansionFactory;
-    private apiRequestService;
-    private pendingTemplateBufferMap;
-    templateResponses: {
-        [itemType: string]: ApiResponse;
-    };
-    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
-    /**
-     * @description
-     * Fetches a {@link Template template}, use {@link ItemCreateService.createItemsFromValues createItemsFromValues} to easily create new items from a set of values.
-     * The best way to process the template's values is to call {@link ItemCreateService.processTemplate processTemplate}
-     *
-     * @param itemType The {@link ApiEnumItemType 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 ApiEnumItemType 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.getFields(),
-     *                      template.columns,
-     *                      parent,
-     *                  );
-     *              }
-     *
-     *              return transaction.applyChangesDelta(changesDelta);
-     *          );
-     *  ```
-     */
-    fetchTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ApiEnumItemType): PromiseInterface<Template<ItemTypeType, ColumnIds>>;
-    private expandWithLinkedItemTypesDefaultColumns;
-    private fetchTemplateById;
-    private constructTemplateBuffer;
-    private expandWithDefaultRequestColumns;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestService, ApiResponse, ColumnHandler, ColumnUtil, EntryParentNull, ErrorHandlerInterface, ItemTypeColumnIds, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, Template, TemplateFactory } from '../internal';
+export declare class TemplateCache {
+    private columnUtil;
+    private promiseService;
+    private columnHandler;
+    private templateFactory;
+    private errorHandler;
+    private requestColumnExpansionFactory;
+    private apiRequestService;
+    private pendingTemplateBufferMap;
+    templateResponses: {
+        [itemType: string]: ApiResponse;
+    };
+    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
+    /**
+     * @description
+     * Fetches a {@link Template template}, use {@link ItemCreateService.createItemsFromValues createItemsFromValues} to easily create new items from a set of values.
+     * The best way to process the template's values is to call {@link ItemCreateService.processTemplate processTemplate}
+     *
+     * @param itemType The {@link ApiEnumItemType 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 ApiEnumItemType 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.getFields(),
+     *                      template.columns,
+     *                      parent,
+     *                  );
+     *              }
+     *
+     *              return transaction.applyChangesDelta(changesDelta);
+     *          );
+     *  ```
+     */
+    fetchTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ApiEnumItemType): PromiseInterface<Template<ItemTypeType, ColumnIds>>;
+    private expandWithLinkedItemTypesDefaultColumns;
+    private fetchTemplateById;
+    private constructTemplateBuffer;
+    private expandWithDefaultRequestColumns;
+}

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

@@ -1,28 +1,28 @@
-import { PromiseInterface } from '../internal';
-export declare function findIndex<T>(haystack: T[], callback: (item: T) => boolean): number;
-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: string[]): boolean;
-export declare function createPath<T>(object: any, path: (number | string)[], defaults: any[]): T;
-export declare function getPath(object: {}, path: (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 isPromiseLike<T = any>(obj: any): obj is PromiseInterface<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: object, destination?: object, maxDepth?: any): any;
+import { PromiseInterface } from '../internal';
+export declare function findIndex<T>(haystack: T[], callback: (item: T) => boolean): number;
+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: string[]): boolean;
+export declare function createPath<T>(object: any, path: (number | string)[], defaults: any[]): T;
+export declare function getPath(object: {}, path: (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 isPromiseLike<T = any>(obj: any): obj is PromiseInterface<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: object, destination?: object, maxDepth?: any): any;

package/dist/types/src/classes/cache/AbstractCache.d.ts

@@ -1,86 +1,86 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { RmCore } from '../../core';
-import { AbstractCacheDependencyInterface, ApiRequestColumn, CachedQueryItem, ChangesDelta, ChangesDeltaBase, ChangesDeltaResult, CollectionQuery, CollectionResourceParentIdMap, EntryParentNull, FieldMap, InternalChangesDelta, ItemCache, ItemEntry, ItemEntryChangesTuple, ItemHandlerBase, ItemIdConversionMap, OnAfterCreateCallback, ParentChangesDelta, PromiseInterface, ServerCache, ServerCachedQueryHandler, TransactionCache, TransactionCachedQueryHandler, TransactionValidatorFactory } from '../../internal';
-export declare type TransactionOptions = {
-    /**
-     * @description
-     * Sets the TransactionCache to 'transparent' mode, whenever {@link AbstractCache.createChild createChild} is called it will actually be called on the parent
-     */
-    transparent: boolean;
-};
-export declare abstract class AbstractCache {
-    dependencies: AbstractCacheDependencyInterface;
-    core: RmCore;
-    children: TransactionCache[];
-    readonly itemHandler: ItemHandlerBase;
-    readonly cachedQueryHandler: TransactionCachedQueryHandler | ServerCachedQueryHandler;
-    parent: AbstractCache | null;
-    protected constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore);
-    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
-    onChildDestroy(cache: TransactionCache): void;
-    /**
-     * @description
-     * Expands the items in the collections with the passed columns
-     *
-     * todo[limit] move to TransactionCache ?
-     */
-    abstract expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    /**
-     * @description
-     * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
-     */
-    abstract getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
-    /**
-     * @description
-     * Returns this transaction and all parents
-     */
-    getTransactionChain(includeServerCache: false): TransactionCache[];
-    getTransactionChain(includeServerCache?: true): AbstractCache[];
-    /**
-     * @description
-     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
-     */
-    getCurrentItemEntryCache(): ItemCache;
-    abstract getServerCache(): ServerCache;
-    abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
-    abstract getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
-    /**
-     * @description
-     * Applies changes from a child transaction to a parent
-     */
-    abstract applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
-    /**
-     * @description
-     * Called by a parent transaction, propagates changes downwards to all child caches
-     *
-     * @remarks
-     * - Should only be used by the core
-     *
-     * todo[cache] Should we refetch derived values just like in applyChangesDelta ?
-     *
-     * @internal
-     */
-    abstract applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate: boolean): void;
-    abstract getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
-    abstract getItemChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id'], copyFields?: boolean): FieldMap<ItemTypeType>;
-    abstract getLocalItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id']): ItemEntryChangesTuple<ItemTypeType>;
-    abstract applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
-    protected getParentFromFields<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields?: FieldMap<ItemTypeType>): EntryParentNull;
-    /**
-     * @description
-     * Called by applyChangesDelta from ServerCache and TransactionCache. Applies creates, updates and moves, doesn't apply deletes
-     *
-     * @private
-     */
-    protected _applyChangesDelta(changesDelta: ChangesDelta | InternalChangesDelta): {
-        result: ChangesDeltaResult;
-        parentChangesDelta: ParentChangesDelta;
-        matchingDelta: ParentChangesDelta;
-        undoFunctions: ((changesDelta: InternalChangesDelta) => void)[];
-    };
-    /**
-     * @description
-     * Ensures that for all updated items in the delta the required derived values are present
-     */
-    protected fetchUpdatedDerivedValuesFromDelta(changesDelta: ChangesDeltaBase): PromiseInterface<void>;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { RmCore } from '../../core';
+import { AbstractCacheDependencyInterface, ApiRequestColumn, CachedQueryItem, ChangesDelta, ChangesDeltaBase, ChangesDeltaResult, CollectionQuery, CollectionResourceParentIdMap, EntryParentNull, FieldMap, InternalChangesDelta, ItemCache, ItemEntry, ItemEntryChangesTuple, ItemHandlerBase, ItemIdConversionMap, OnAfterCreateCallback, ParentChangesDelta, PromiseInterface, ServerCache, ServerCachedQueryHandler, TransactionCache, TransactionCachedQueryHandler, TransactionValidatorFactory } from '../../internal';
+export declare type TransactionOptions = {
+    /**
+     * @description
+     * Sets the TransactionCache to 'transparent' mode, whenever {@link AbstractCache.createChild createChild} is called it will actually be called on the parent
+     */
+    transparent: boolean;
+};
+export declare abstract class AbstractCache {
+    dependencies: AbstractCacheDependencyInterface;
+    core: RmCore;
+    children: TransactionCache[];
+    readonly itemHandler: ItemHandlerBase;
+    readonly cachedQueryHandler: TransactionCachedQueryHandler | ServerCachedQueryHandler;
+    parent: AbstractCache | null;
+    protected constructor(dependencies: AbstractCacheDependencyInterface, core: RmCore);
+    abstract createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    onChildDestroy(cache: TransactionCache): void;
+    /**
+     * @description
+     * Expands the items in the collections with the passed columns
+     *
+     * todo[limit] move to TransactionCache ?
+     */
+    abstract expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    /**
+     * @description
+     * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
+     */
+    abstract getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
+    /**
+     * @description
+     * Returns this transaction and all parents
+     */
+    getTransactionChain(includeServerCache: false): TransactionCache[];
+    getTransactionChain(includeServerCache?: true): AbstractCache[];
+    /**
+     * @description
+     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
+     */
+    getCurrentItemEntryCache(): ItemCache;
+    abstract getServerCache(): ServerCache;
+    abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
+    abstract getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    /**
+     * @description
+     * Applies changes from a child transaction to a parent
+     */
+    abstract applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
+    /**
+     * @description
+     * Called by a parent transaction, propagates changes downwards to all child caches
+     *
+     * @remarks
+     * - Should only be used by the core
+     *
+     * todo[cache] Should we refetch derived values just like in applyChangesDelta ?
+     *
+     * @internal
+     */
+    abstract applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate: boolean): void;
+    abstract getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    abstract getItemChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id'], copyFields?: boolean): FieldMap<ItemTypeType>;
+    abstract getLocalItemEntryChangesTuple<ItemTypeType extends ApiEnumItemType>(itemEntryId: ItemEntry<ItemTypeType>['id']): ItemEntryChangesTuple<ItemTypeType>;
+    abstract applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
+    protected getParentFromFields<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields?: FieldMap<ItemTypeType>): EntryParentNull;
+    /**
+     * @description
+     * Called by applyChangesDelta from ServerCache and TransactionCache. Applies creates, updates and moves, doesn't apply deletes
+     *
+     * @private
+     */
+    protected _applyChangesDelta(changesDelta: ChangesDelta | InternalChangesDelta): {
+        result: ChangesDeltaResult;
+        parentChangesDelta: ParentChangesDelta;
+        matchingDelta: ParentChangesDelta;
+        undoFunctions: ((changesDelta: InternalChangesDelta) => void)[];
+    };
+    /**
+     * @description
+     * Ensures that for all updated items in the delta the required derived values are present
+     */
+    protected fetchUpdatedDerivedValuesFromDelta(changesDelta: ChangesDeltaBase): PromiseInterface<void>;
+}