@rentman/rm-core 5.0.0 → 6.0.0

package/dist/types/models/CollectionResource.d.ts

@@ -1,40 +1,53 @@
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ChangesDeltaResult } from '../classes/ChangesDeltaBase';
 import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResourceOptions, ItemEntry, ItemResource } from '../models';
-import { FieldMap, ItemId, ItemResourceItemIdMap, ItemType, PromiseInterface, QueryCallback, ResponseColumnItemTypeMap } from '../types';
+import { CollectionEntry, CollectionOptions, ItemEntry, ItemResource } from '../models';
+import { ApiRequestLimit, CompareFieldCallback, DeregFunction, FieldMap, ItemId, ItemResourceItemIdMap, ItemType, OnAddCallback, OnChangeCallback, OnRemoveCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../types';
 export declare class CollectionResource<ItemTypeType extends ItemType = any> {
     protected factory: CollectionResourceFactory;
-    entry: CollectionEntry<ItemTypeType>;
-    options: CollectionResourceOptions<ItemTypeType>;
+    options: CollectionOptions<ItemTypeType>;
     transaction: TransactionCache;
-    items: Array<ItemResource<ItemTypeType>>;
+    entry: CollectionEntry<ItemTypeType>;
     columns: ResponseColumnItemTypeMap;
+    items: Array<ItemResource<ItemTypeType>>;
     protected itemIdMap: ItemResourceItemIdMap<ItemResource<ItemTypeType>>;
     private fieldChangeDeregFns;
-    private readonly onChange;
-    constructor(factory: CollectionResourceFactory, entry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transaction: TransactionCache);
+    private readonly onChangeCallbacks;
+    private readonly onAddCallbacks;
+    private readonly onRemoveCallbacks;
+    /**
+     * @description
+     * We store the ItemIds of the items that were taking out the collections so that we can include those when doing a not-in when having a limit
+     */
+    private removedItemIds;
+    constructor(factory: CollectionResourceFactory, options: CollectionOptions<ItemTypeType>, transaction: TransactionCache, itemType: ItemTypeType, initialItemEntries: Array<ItemEntry<ItemTypeType>>);
     onConstruct(): void;
+    setLimit(newLimit: number | ApiRequestLimit): void;
+    onAdd(callback: OnAddCallback): DeregFunction;
+    onChange(callback: OnChangeCallback): DeregFunction;
+    onRemove(callback: OnRemoveCallback): DeregFunction;
+    __clear(): void;
     /**
      * @deprecated
      * Use {@link ChangesDelta.setItemMoved ChangesDelta.setItemMoved}
      */
     moveItems(itemEntries: Array<ItemEntry<ItemTypeType>>, destinationResource: CollectionResource<ItemTypeType>): void;
-    removeItems(idArray: ItemId[]): void;
-    removeItem(itemId: ItemId): void;
+    removeItems(idArray: ItemId[]): PromiseInterface<ChangesDeltaResult>;
+    removeItem(itemId: ItemId): PromiseInterface<ChangesDeltaResult>;
     addItems(valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
     addItem(values: FieldMap<ItemTypeType>): PromiseInterface<ChangesDeltaResult>;
     getIdArray(): ItemId[];
     getItemById(itemId: number): ItemResource<ItemTypeType>;
-    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, isInitialCall?: boolean): Array<ItemResource<ItemTypeType>>;
+    addItemResources(itemEntriesToBeAdded: Array<ItemEntry<ItemTypeType>>, isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): Array<ItemResource<ItemTypeType>>;
     /**
      * @description
      * Returns the {@link ItemResource ItemResources} that where removed from the {@link CollectionResource collection}.
      * Filters on {@link ItemResource ItemResource}.{@link ItemEntry entry} === {@link ItemEntry entry}
      */
-    removeItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemResource<ItemTypeType>>;
-    callOnAdd(itemResources: Array<ItemResource<ItemTypeType>>, isInitialCall?: boolean): void;
-    callOnRemove(itemResources: Array<ItemResource<ItemTypeType>>): void;
+    removeItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, isCalledAfterSocketUpdate: boolean): Array<ItemResource<ItemTypeType>>;
+    callOnAdd(itemResources: Array<ItemResource<ItemTypeType>>, isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): void;
+    callOnChange(itemEntry: ItemEntry<ItemTypeType>, compareField: CompareFieldCallback, fields: FieldMap<ItemTypeType>, isCalledAfterSocketUpdate: boolean, previous: FieldMap<ItemTypeType>): void;
+    callOnRemove(itemResources: Array<ItemResource<ItemTypeType>>, isCalledAfterSocketUpdate: boolean): void;
     forEach(callback: (itemResource: ItemResource<ItemTypeType>) => void): void;
     filter(callback: (itemResource: ItemResource<ItemTypeType>) => boolean): Array<ItemResource<ItemTypeType>>;
     first(callback: (itemResource: ItemResource<ItemTypeType>) => boolean): ItemResource<ItemTypeType> | null;
@@ -44,14 +57,6 @@ export declare class CollectionResource<ItemTypeType extends ItemType = any> {
     };
     map<U>(argument: string | ((itemResource: ItemResource<ItemTypeType>) => U)): U[];
     reduce<U>(callback: (itemResource: ItemResource<ItemTypeType>, value: U) => U, value: U): U;
-    /**
-     * @description
-     * Fetches new items and adds them to the collection
-     *
-     * @remarks
-     * - Used to return {@link ItemResource ItemResources}, but you should the {@link CollectionResource.onAdd onAdd) instead
-     */
-    extend(queryCallback: QueryCallback): PromiseInterface<CollectionEntry<ItemTypeType>>;
     /**
      * @description
      * Removes the reference to the {@link CollectionResource CollectionResource} from the {@link CollectionEntry CollectionEntry}
@@ -60,4 +65,8 @@ export declare class CollectionResource<ItemTypeType extends ItemType = any> {
      * - Doesn't revert changes on the items themselves
      */
     clearResource(): void;
+    private registerListeners;
+    private __registerCallback;
+    private limitAfterRemove;
+    private limitAfterAdd;
 }

package/dist/types/models/index.d.ts

@@ -1,8 +1,7 @@
 export * from './ItemEntryOptions';
 export * from './ItemEntry';
 export * from './ItemResource';
-export * from './CollectionEntryOptions';
-export * from './CollectionResourceOptions';
+export * from './CollectionOptions';
 export * from './CollectionEntry';
 export * from './CollectionResource';
 export * from './Template';

package/dist/types/types/ItemTypesCollection.d.ts

@@ -1,5 +1,9 @@
-import { ApiResponseProcessor, CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
-import { CollectionEntry, CollectionEntryOptions, CollectionEntryOptionsInterface, CollectionResource, CollectionResourceOptions, CollectionResourceOptionsInterface, ItemEntry, ItemEntryOptionsInterface, ItemResource } from '../models';
+import { ApiResponseProcessor, ColumnSet, RequestColumnExpansion } from '../classes';
+import { CollectionResource, ItemEntry, ItemEntryOptionsInterface, ItemResource } from '../models';
+import { CollectionOptions } from '../models/CollectionOptions';
+export declare type ParentIdMap<T> = {
+    [parentId: number]: T;
+};
 export declare type EntryParent = {
     itemType: string;
     itemId: number;
@@ -13,13 +17,9 @@ export declare type FieldMap<_ItemTypeType extends ItemType = any> = {
     [key: string]: any;
 };
 export declare type ItemOptionsInterface = ItemEntryOptionsInterface;
-export declare type CollectionOptionsInterface<ItemTypeType extends ItemType = any> = CollectionEntryOptionsInterface & CollectionResourceOptionsInterface<ItemTypeType>;
 export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
     itemType: ItemTypeType;
-    options: {
-        entry: CollectionEntryOptions;
-        resource: CollectionResourceOptions<ItemTypeType>;
-    };
+    options: CollectionOptions;
 }
 export interface LinkCollectionDefinition<ItemTypeType extends ItemType = any> extends CollectionDefinition<ItemTypeType> {
     linkField: string;
@@ -129,9 +129,7 @@ export declare type ItemMap<T> = {
     };
 };
 export declare type ItemEntryMap<ItemTypeType extends ItemType> = ItemMap<ItemEntry<ItemTypeType>>;
-export declare type ItemEntryParentIdMap<ItemTypeType extends ItemType> = {
-    [parentId: number]: Array<ItemEntry<ItemTypeType>>;
-};
+export declare type ItemEntryParentIdMap<ItemTypeType extends ItemType> = ParentIdMap<Array<ItemEntry<ItemTypeType>>>;
 export declare type ConversionMap = {
     [itemId: number]: number;
 };
@@ -142,29 +140,11 @@ export declare type CreateRequestParameterMap<T = any> = ItemMap<T>;
 export declare type ItemError = {
     message: string;
 };
-export declare type QueryParams = any;
 export declare type CollectionQuery = {
     object: object;
     string: string;
 };
-export declare type QueryCallback = (queryParams: QueryParams) => QueryParams;
-export declare type CollectionEntryParentIdMap<ItemTypeType extends ItemType> = {
-    [parentId: number]: CollectionEntry<ItemTypeType>;
-};
-export declare type CollectionResourceParentIdMap<ItemTypeType extends ItemType = any> = {
-    [parentId: number]: CollectionResource<ItemTypeType>;
-};
-export declare type CollectionMatchResult<ItemTypeType extends ItemType> = {
-    fitting: Array<CollectionEntry<ItemTypeType>>;
-    notfitting: Array<CollectionEntry<ItemTypeType>>;
-    maybe: Array<CollectionEntry<ItemTypeType>>;
-};
-export interface ExtendedCollectionMatchResult<ItemTypeType extends ItemType> extends CollectionMatchResult<ItemTypeType> {
-    collection: CollectionEntry<ItemTypeType>;
-}
-export interface GroupedExtendedCollectionMatchResult<ItemTypeType extends ItemType> {
-    [collectionId: number]: ExtendedCollectionMatchResult<ItemTypeType>;
-}
+export declare type CollectionResourceParentIdMap<ItemTypeType extends ItemType = any> = ParentIdMap<CollectionResource<ItemTypeType>>;
 export declare type ResponseColumn = any;
 export declare type ResponseColumnMap = {
     [columnId: string]: ResponseColumn;
@@ -212,7 +192,6 @@ export declare type ApiRequestColumnMap = {
 export declare type ApiRequestLimit = {
     field: string;
     limit: number;
-    offset?: number;
     order?: 'desc' | 'asc';
 };
 export declare type ApiRequestMoveItems = {
@@ -231,7 +210,6 @@ export declare type CreateRequestEntry<ItemTypeType extends ItemType> = {
     };
     columns: RequestColumnExpansion;
     items: ItemEntryMap<ItemTypeType>;
-    collections: CollectionMatcher;
 };
 export declare enum ApiLinkTreeType {
     ITEMTABLE = "itemtable",
@@ -259,5 +237,27 @@ export declare type ModifyFieldsCallback = <ItemTypeType extends ItemType>(itemT
  * Returns 'false' if the field changed
  */
 export declare type CompareFieldCallback<ItemTypeType extends ItemType = any> = (field: keyof FieldMap<ItemTypeType>) => boolean;
-export declare type FieldChangeCallback<ItemTypeType extends ItemType = any> = (itemEntry: ItemEntry<ItemTypeType>, compareField: CompareFieldCallback, fields: FieldMap<ItemTypeType>, isCalledAfterSocketUpdate: boolean, previous: FieldMap<ItemTypeType>) => void;
+export declare type FieldChangeCallbackArgs<ItemTypeType extends ItemType = any> = {
+    itemEntry: ItemEntry<ItemTypeType>;
+    compareField: CompareFieldCallback;
+    fields: FieldMap<ItemTypeType>;
+    isCalledAfterSocketUpdate: boolean;
+    previous: FieldMap<ItemTypeType>;
+};
+export declare type FieldChangeCallback<ItemTypeType extends ItemType = any> = (args: FieldChangeCallbackArgs<ItemTypeType>) => void;
 export declare type DeregFunction = () => void;
+export declare type OnChangeCallbackArgs<ItemTypeType extends ItemType = any> = FieldChangeCallbackArgs<ItemTypeType>;
+export declare type OnChangeCallback<ItemTypeType extends ItemType = any> = FieldChangeCallback<ItemTypeType>;
+export declare type OnAddCallbackArgs<ItemTypeType extends ItemType = any> = {
+    itemResources: Array<ItemResource<ItemTypeType>>;
+    collectionResource: CollectionResource<ItemTypeType>;
+    isInitialCall: boolean;
+    isCalledAfterSocketUpdate: boolean;
+};
+export declare type OnAddCallback<ItemTypeType extends ItemType = any> = (args: OnAddCallbackArgs<ItemTypeType>) => void;
+export declare type OnRemoveCallbackArgs<ItemTypeType extends ItemType = any> = {
+    itemResources: Array<ItemResource<ItemTypeType>>;
+    collectionResource: CollectionResource<ItemTypeType>;
+    isCalledAfterSocketUpdate: boolean;
+};
+export declare type OnRemoveCallback<ItemTypeType extends ItemType = any> = (args: OnRemoveCallbackArgs<ItemTypeType>) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/types/index.d.ts",

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

@@ -1,38 +0,0 @@
-import { QueryMatcherFactory } from '../factories';
-import { CollectionEntry, CollectionResource } from '../models';
-import { CollectionMatchResult, CollectionQuery, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
-import { AbstractCache } from './cache/AbstractCache';
-export declare class CollectionCache {
-    private queryMatcherFactory;
-    private transaction;
-    private entries;
-    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
-    getByEntryId(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
-    contains(collectionEntry: CollectionEntry<any>): boolean;
-    some(callback: (entry: CollectionEntry<any>) => boolean): boolean;
-    forEach(callback: (entry: CollectionEntry<any>) => void): void;
-    toArray(): CollectionEntry<any>[];
-    add<T extends CollectionEntry<any>>(collectionEntry: T): T;
-    clear(collectionEntry?: CollectionEntry<any>): boolean;
-    getByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): CollectionEntry<ItemTypeType>[];
-    matchParent(collectionEntry: CollectionEntry<any>, itemType: string, itemId: ItemId): boolean;
-    getByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): CollectionEntry<ItemTypeType> | null;
-    getCollectionsByParent(parentType: ItemType, parentId: ItemId): CollectionEntry<any>[];
-    /**
-     * @description
-     * Gets {@link CollectionEntry CollectionEntries} which contain the item with the passed ItemType/ItemId
-     */
-    getByContainingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId): CollectionEntry<ItemTypeType>[];
-    /**
-     * @description
-     * Checks if the passed fields would fit in the collections using the {@link QueryMatcher QueryMatcher}
-     */
-    getByFittingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult<ItemTypeType>;
-    getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): CollectionEntry<ItemTypeType> | null;
-    getByQueryString<ItemTypeType extends ItemType>(itemType: ItemTypeType, queryString: string): CollectionEntry<ItemTypeType> | null;
-    getByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, entryKey: string): Array<CollectionEntry<ItemTypeType>>;
-    /**
-     * @deprecated
-     */
-    getResourceByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, resourceKey: string): Array<CollectionResource<ItemTypeType>>;
-}

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

@@ -1,9 +0,0 @@
-import { QueryMatcherFactory } from '../factories';
-import { CollectionEntry } from '../models';
-import { ItemType } from '../types';
-import { AbstractCache } from './cache/AbstractCache';
-import { CollectionMatcherBase } from './CollectionMatcherBase';
-export declare class CollectionMatcher extends CollectionMatcherBase {
-    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollectionEntries: (itemType: ItemType) => CollectionEntry[]);
-    getCollectionsWithFittingItems(): CollectionEntry[];
-}

package/dist/types/classes/cache/CollectionHandlerBase.d.ts

@@ -1,68 +0,0 @@
-import { CollectionCacheFactory, RequestColumnExpansionFactory } from '../../factories';
-import { CollectionEntry, CollectionEntryOptions, ItemEntry } from '../../models';
-import { ApiQuery, ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, PromiseInterface, QueryCallback } from '../../types';
-import { CollectionCache } from '../CollectionCache';
-import { CollectionEntryService } from '../CollectionEntryService';
-import { CollectionMatcher } from '../CollectionMatcher';
-import { ColumnUtil } from '../ColumnUtil';
-import { AbstractCache } from './AbstractCache';
-export declare abstract class CollectionHandlerBase {
-    protected collectionEntryService: CollectionEntryService;
-    protected columnUtil: ColumnUtil;
-    protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    protected transaction: AbstractCache;
-    entries: CollectionCache;
-    collectionChanges: {
-        [itemType: string]: {
-            [queryString: string]: ItemEntry[];
-        };
-    };
-    protected constructor(collectionEntryService: CollectionEntryService, columnUtil: ColumnUtil, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionCacheFactory: CollectionCacheFactory, transaction: AbstractCache);
-    setCollectionChanges<ItemTypeType extends ItemType>(itemType: ItemTypeType, queryString: string, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
-    getCollectionChanges<ItemTypeType extends ItemType>(itemType: ItemTypeType, queryString: string): undefined | Array<ItemEntry<ItemTypeType>>;
-    /**
-     * @description
-     * Creates a new {@link CollectionEntry CollectionEntry} and stores it in this transaction's {@link CollectionCache CollectionCache}
-     */
-    createCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): CollectionEntry<ItemTypeType>;
-    /**
-     * @description
-     * Creates a {@link CollectionMatcher CollectionMatcher} with the transaction's collections
-     */
-    abstract getCollectionMatcher(): CollectionMatcher;
-    /**
-     * @description
-     * Fetches a {@link CollectionEntry CollectionEntry} with the given options
-     */
-    abstract fetchCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntry<ItemTypeType>>;
-    /**
-     * @description
-     * Fetches collections linked to the passed parents
-     */
-    abstract fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
-    /**
-     * @description
-     * Expands the items in the collections with the passed columns
-     */
-    abstract expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    /**
-     * @description
-     * Extends the collections' {@link CollectionEntry.queryParams queryParams} and {@link CollectionEntry.query queries} and fetches the {@link ItemEntry ItemEntries} with the new queries
-     */
-    abstract extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
-    /**
-     * @description
-     * Adds the passed {@link ItemEntry ItemEntries} to the collection's changes on the transaction,
-     * will skip the ItemEntry if the `skipEntryFilterFn` callback returns `true`
-     */
-    protected _addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean, isCalledAfterSocketUpdate: boolean): void;
-    protected abstract handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
-    removeItemEntriesFromCollectionChanges(collectionEntry: CollectionEntry, idArray: ItemId[], isCalledAfterSocketUpdate?: boolean): void | never[];
-    protected abstract handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
-    /**
-     * @description
-     * Expands the option's {@link CollectionEntryOptions.columns columns} with the columns required for the {@link CollectionMatcher CollectionMatcher} to function.
-     * Data fetched for a parent transaction might also fit in a child transaction, so those {@link CollectionEntryOptions.queryColumns queryColumns} should also be taken into account
-     */
-    protected expandColumnsWithQueryColumns(itemType: ItemType, options: CollectionEntryOptions, query: ApiQuery): void;
-}

package/dist/types/classes/cache/CollectionMatcherCacheProcessor.d.ts

@@ -1,26 +0,0 @@
-import { QueryMatcherFactory } from '../../factories';
-import { CollectionEntry, ItemEntry } from '../../models';
-import { ItemId, ItemType } from '../../types';
-import { ApiRequestService } from '../ApiRequestService';
-import { CollectionMatcher } from '../CollectionMatcher';
-import { AbstractCache } from './AbstractCache';
-export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType> = {
-    fitting: Array<ItemEntry<ItemTypeType>>;
-    notFitting: ItemId[];
-    maybe: Array<ItemEntry<ItemTypeType>>;
-};
-/**
- * @description
- * Processes a delta and adds the items to the right collections, this is the ONLY class that should change collection items
- *
- * ------
- *
- * @remark
- * The CollectionMatcherCacheProcessor is allowed to directly access/modify the transaction because it's ONLY called from applyChangesFromParent
- */
-export declare class CollectionMatcherCacheProcessor extends CollectionMatcher {
-    private apiRequestService;
-    constructor(apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollectionEntries: (itemType: ItemType) => CollectionEntry[]);
-    removeFromAndAddToCollections(isCalledAfterSocketUpdate?: boolean): void;
-    private groupItemEntries;
-}

package/dist/types/classes/cache/server/ServerCollectionHandler.d.ts

@@ -1,44 +0,0 @@
-import { CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ApiQuery, ApiRequestColumns, ApiRequestService, CollectionEntryOptions, CollectionMatcher, ColumnUtil, ItemEntryOptions, PromiseInterface } from '../../../index';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { CollectionEntry, ItemEntry } from '../../../models';
-import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
-import { CollectionEntryService, QueryService } from '../../index';
-import { RequestBufferManager } from '../../RequestBufferManager';
-import { CollectionHandlerBase } from '../CollectionHandlerBase';
-import { ServerCache } from './ServerCache';
-import { ServerItemHandler } from './ServerItemHandler';
-export declare class ServerCollectionHandler extends CollectionHandlerBase {
-    private columnSubsetCacheFactory;
-    private requestBufferManager;
-    private columnExpansionFactory;
-    private apiRequestService;
-    private collectionMatcherFactory;
-    private errorHandler;
-    private itemHandler;
-    private promiseService;
-    private queryService;
-    protected transaction: ServerCache;
-    constructor(columnSubsetCacheFactory: ColumnSubsetCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, columnExpansionFactory: ColumnExpansionFactory, apiRequestService: ApiRequestService, collectionCacheFactory: CollectionCacheFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, queryService: QueryService, columnUtil: ColumnUtil, transaction: ServerCache);
-    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    getCollectionMatcher(): CollectionMatcher;
-    fetchCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntry<ItemTypeType>>;
-    fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
-    extendCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, queryCallback: QueryCallback): PromiseInterface<CollectionEntryType>;
-    expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
-    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate?: boolean): void;
-    /**
-     * @description
-     * Expands the columns of the items in the collection
-     */
-    expandCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
-    protected handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    protected handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    /**
-     * @description
-     * Fetches the data for the passed ItemType/options, will do nothing if the requested CollectionEntry/columns are already cached.
-     * Will create a new {@link CollectionEntry CollectionEntry} if the CollectionEntry didn't exist yet
-     */
-    private fetchCollectionData;
-}

package/dist/types/factories/CollectionCacheFactory.d.ts

@@ -1,8 +0,0 @@
-import { CollectionCache } from '../classes';
-import { AbstractCache } from '../classes/cache/AbstractCache';
-import { QueryMatcherFactory } from '../factories';
-export declare class CollectionCacheFactory {
-    private queryMatcherFactory;
-    constructor(queryMatcherFactory: QueryMatcherFactory);
-    construct(transaction: AbstractCache): CollectionCache;
-}

package/dist/types/models/CollectionEntryOptions.d.ts

@@ -1,13 +0,0 @@
-import { ApiQuery, ApiRequestColumns, ApiRequestLimit, EntryParentNull } from '../types';
-export declare type CollectionEntryOptionsInterface = Partial<CollectionEntryOptions>;
-export declare class CollectionEntryOptions {
-    columns: ApiRequestColumns;
-    query: ApiQuery | null;
-    queryParams: any;
-    queryColumns: ApiRequestColumns;
-    parent: EntryParentNull;
-    deferRequest: boolean;
-    limit: ApiRequestLimit | null;
-    entryKey: string | null;
-    constructor(values: CollectionEntryOptionsInterface);
-}

package/dist/types/models/CollectionResourceOptions.d.ts

@@ -1,21 +0,0 @@
-import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { FieldChangeCallback, ItemType } from '../types';
-export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>) => void;
-export declare type CollectionResourceOnAddCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>, isInitialCall: boolean) => void;
-export declare type CollectionResourceInitialCallback<ItemTypeType extends ItemType> = (itemEntries: Array<ItemEntry<ItemTypeType>>, collectionEntry: CollectionEntry<ItemTypeType>) => void;
-export declare type CollectionResourceOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionResourceOptions<ItemTypeType>>;
-export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
-    callOnAddWithInitialItems: boolean;
-    /**
-     * @deprecated
-     * You should use register a {@link TransactionCache.registerFieldChangeCallback field change callback} and compare previous.id with fields.id
-     */
-    onAdd: CollectionResourceOnAddCallback<ItemTypeType>;
-    onRemove: CollectionResourceCallback<ItemTypeType>;
-    onChange: FieldChangeCallback;
-    onAddInitial: CollectionResourceInitialCallback<ItemTypeType>;
-    onRemoveInitial: CollectionResourceInitialCallback<ItemTypeType>;
-    resourceKey: string | null;
-    custom: any;
-    constructor(values: CollectionResourceOptionsInterface<ItemTypeType>);
-}