@rentman/rm-core 2.3.0 → 3.0.0

package/dist/src/factories/ItemResourceFactory.d.ts

@@ -1,32 +0,0 @@
-import { ApiFormatter, ColumnUtil, LockService } from '../classes';
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
-import { EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
-import { ItemOptionsInterface, ItemType } from '../types';
-export declare type ResourceConstructor<ItemTypeType extends ItemType, T extends ItemResource<ItemTypeType>> = (itemEntry: ItemEntry<ItemTypeType>) => T;
-export declare class ItemResourceFactory {
-    apiFormatter: ApiFormatter;
-    lockService: LockService;
-    errorHandler: ErrorHandlerInterface;
-    promiseService: PromiseLibraryInterface;
-    exceptionHandler: ExceptionHandlerInterface;
-    columnUtil: ColumnUtil;
-    linkTreeService: LinkTreeServiceInterface;
-    constructor(apiFormatter: ApiFormatter, lockService: LockService, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, columnUtil: ColumnUtil, linkTreeService: LinkTreeServiceInterface);
-    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
-        edit: true;
-    }, transaction: TransactionCache): ResourceConstructor<ItemTypeType, EditResource<ItemTypeType>>;
-    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
-        remote: true;
-    }, transaction: TransactionCache): ResourceConstructor<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface, transaction: TransactionCache): ResourceConstructor<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
-        edit: true;
-    }, transaction: TransactionCache, isNew?: boolean): EditResource<ItemTypeType>;
-    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
-        remote: true;
-    }, transaction: TransactionCache, isNew?: boolean): LocalViewResource<ItemTypeType>;
-    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, transaction: TransactionCache, isNew?: boolean): RemoteViewResource<ItemTypeType>;
-    private constructWithOptions;
-}

package/dist/src/models/CollectionEditResource.d.ts

@@ -1,17 +0,0 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ChangesDeltaResult } from '../classes/ChangesDeltaBase';
-import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemEntry, ItemResource, LocalViewResource } from '../models';
-import { FieldMap, ItemId, ItemType, PromiseInterface } from '../types';
-export declare class CollectionEditResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
-    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transactionCache: TransactionCache);
-    /**
-     * @deprecated
-     * Use {@link ChangesDelta.setItemMoved ChangesDelta.setItemMoved}
-     */
-    moveItems(itemEntries: Array<ItemEntry<ItemTypeType>>, destinationResource: CollectionResource<ItemTypeType>): void;
-    removeItems(idArray: ItemId[]): void;
-    removeItem(itemId: ItemId): void;
-    addItems(valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
-    addItem(values: FieldMap<ItemTypeType>): PromiseInterface<ChangesDeltaResult>;
-}

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

@@ -1,52 +0,0 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResourceOptions, ItemEntry, ItemResource, LocalViewResource } from '../models';
-import { ItemId, ItemResourceItemIdMap, ItemType, PromiseInterface, QueryCallback, ResponseColumnItemTypeMap } from '../types';
-export declare abstract class CollectionResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> {
-    protected factory: CollectionResourceFactory;
-    entry: CollectionEntry<ItemTypeType>;
-    options: CollectionResourceOptions<ItemTypeType>;
-    transaction: TransactionCache;
-    items: Readonly<T[]>;
-    columns: ResponseColumnItemTypeMap;
-    protected itemIdMap: ItemResourceItemIdMap<T>;
-    private readonly onChange;
-    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transaction: TransactionCache);
-    onConstruct(): void;
-    getIdArray(): ItemId[];
-    getItemById(itemId: number): T;
-    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, isInitialCall?: boolean): T[];
-    /**
-     * @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>>): T[];
-    callOnAdd(itemResources: T[], isInitialCall?: boolean): void;
-    callOnRemove(itemResources: T[]): void;
-    forEach(callback: (itemResource: T) => void): void;
-    filter(callback: (itemResource: T) => boolean): T[];
-    first(callback: (itemResource: T) => boolean): T | null;
-    some(callback: (itemResource: T) => boolean): boolean;
-    groupBy(argument: string | ((itemResource: T) => string | null)): {
-        [key: string]: T[];
-    };
-    map<U>(argument: string | ((itemResource: T) => U)): U[];
-    reduce<U>(callback: (itemResource: T, 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}
-     *
-     * @remarks
-     * - Doesn't revert changes on the items themselves
-     */
-    clearResource(clearItems?: boolean): void;
-}

package/dist/src/models/CollectionViewResource.d.ts

@@ -1,7 +0,0 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
-import { ItemType } from '../types';
-export declare class CollectionViewResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
-    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transactionCache: TransactionCache);
-}

package/dist/src/models/EditResource.d.ts

@@ -1,16 +0,0 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
-import { FieldMap, ItemType, PromiseInterface } from '../types';
-export declare class EditResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
-    protected localCopies: Array<FieldMap<ItemTypeType>>;
-    fields: FieldMap<ItemTypeType>;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, transaction: TransactionCache);
-    isNew(): boolean;
-    copyFields(destination?: FieldMap<ItemTypeType>): FieldMap<ItemTypeType>;
-    /**
-     * @description
-     * Updates the fields of the item and calls onChange, when updating many fields of many items it's better to create a {@link ChangesDelta ChangesDelta} yourself so all changes can be applied at once
-     */
-    setFields(values: FieldMap<ItemTypeType>): PromiseInterface<this>;
-}

package/dist/src/models/ItemResourceOptions.d.ts

@@ -1,9 +0,0 @@
-import { OnChangeFunction } from '../types';
-import { ItemResource } from './ItemResource';
-export declare type ItemResourceOptionsInterface<ItemResourceType extends ItemResource<any> = ItemResource<any>> = Partial<ItemResourceOptions<ItemResourceType>>;
-export declare class ItemResourceOptions<ItemResourceType extends ItemResource<any> = ItemResource<any>> {
-    edit: boolean;
-    remote: boolean;
-    onChange: OnChangeFunction<ItemResourceType>;
-    constructor(values: ItemResourceOptionsInterface<ItemResourceType>);
-}

package/dist/src/models/LocalViewResource.d.ts

@@ -1,7 +0,0 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
-import { ItemType } from '../types';
-export declare class LocalViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, transaction: TransactionCache);
-}

package/dist/src/models/RemoteViewResource.d.ts

@@ -1,7 +0,0 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
-import { ItemType } from '../types';
-export declare class RemoteViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<RemoteViewResource<ItemTypeType>>, isNew: boolean, transaction: TransactionCache);
-}

package/dist/src/models/ViewResource.d.ts

@@ -1,8 +0,0 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
-import { FieldMap, ItemType } from '../types';
-export declare abstract class ViewResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
-    fields: Readonly<FieldMap<ItemTypeType>>;
-    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ViewResource<ItemTypeType>>, isNew: boolean, transaction: TransactionCache);
-}