@sarafapp/iron_core 1.0.66 → 1.0.67

package/dist/core/src/BaseModel.d.ts

@@ -0,0 +1,45 @@
+export declare class Amount {
+    value: string;
+    symbol: string;
+    get tradeValueInNumber(): number;
+    get truncatedValue(): string;
+}
+export declare class BaseModel {
+    id: number | string;
+    protected getTable<Table>(): Table;
+}
+export declare class MinifiedSymbolModel extends BaseModel {
+    symbol: string;
+    enName: string;
+    faName: string;
+    image: string;
+}
+export declare class TradeDate {
+    requestedDate: number;
+    executedDate: number;
+    constructor(requestedDate: number, executedDate: number);
+    get requestedDateInJalali(): string;
+    get requestedTime(): string;
+    get executedDateInJalali(): string;
+    get executedDateTime(): string;
+}
+export declare class TradeAmount {
+    requestedAmount: Amount;
+    executedAmount: Amount;
+    constructor(requestedAmount: Amount, executedAmount: Amount);
+}
+export declare class SymbolPriceInTrade {
+    symobl: string;
+    symbolPrice: number;
+    USDTPrice: number;
+    symbolImage: string;
+    USDTImage: string;
+    constructor(symbolPrice: number, USDTPrice: number, symbol: string, symbolImage: string, USDTImage: string);
+    get truncatedSymbolPrice(): string;
+    get truncatedUSDTPrice(): string;
+}
+export declare class SymbolInTrade {
+    soldSymbol: MinifiedSymbolModel;
+    buySymbol: MinifiedSymbolModel;
+    constructor(soldSymbol: MinifiedSymbolModel, buySymbol: MinifiedSymbolModel);
+}

package/dist/core/src/Utils.d.ts

@@ -0,0 +1,4 @@
+export declare function isOnlyOneItem(total: number): boolean;
+export declare function isLastItem(total: number, index: number): boolean;
+export declare function isEmpty(value: unknown): boolean;
+export declare function setupStore(initializer: () => void): void;

package/dist/core/src/accessHandling/AccessControl.d.ts

@@ -0,0 +1,10 @@
+import { DirectiveBinding } from 'vue';
+import { MountedDirective, UpdateDirective } from '../baseDirective';
+export declare abstract class AccessControl implements MountedDirective, UpdateDirective {
+    protected accessService: any;
+    constructor();
+    mounted: (element: HTMLElement, binding: DirectiveBinding<string[]>) => void;
+    updated: (element: HTMLElement, binding: DirectiveBinding<string[]>) => void;
+    private checkAccess;
+    protected abstract hasAccess(accessLevels: string[]): boolean;
+}

package/dist/core/src/accessHandling/AccessLevel.d.ts

@@ -0,0 +1,13 @@
+import { Initializer } from '../initializer/Initializer';
+export declare class AccessLevel implements Initializer {
+    private static Instance;
+    private availableAccesses;
+    private constructor();
+    setAvailableAccesses(accessToAdd: string[]): void;
+    private setAccessListToStorage;
+    everyAccess(accessesToCheck: string[]): boolean;
+    someAccess(accessesToCheck: string[]): boolean;
+    clearAvailableAccesses(): void;
+    initialize(): void;
+    static GetInstance(): AccessLevel;
+}

package/dist/core/src/accessHandling/Accessible.d.ts

@@ -0,0 +1,3 @@
+export interface Accessible {
+    hasAccess(): boolean;
+}

package/dist/core/src/accessHandling/EveryDirectiveAccess.d.ts

@@ -0,0 +1,4 @@
+import { AccessControl } from './AccessControl';
+export declare class EveryAccess extends AccessControl {
+    protected hasAccess(accessLevels: string[]): boolean;
+}

package/dist/core/src/accessHandling/SSO/AuthorizationDirective.d.ts

@@ -0,0 +1,17 @@
+import { MountedDirective, UpdateDirective } from '../../baseDirective';
+import { AuthorizationService } from './AuthorizationService';
+export declare abstract class AuthorizationDirective implements MountedDirective, UpdateDirective {
+    protected _authorizationService: AuthorizationService;
+    constructor();
+    mounted(element: HTMLElement, binding: {
+        arg: string;
+        modifiers: Record<PropertyKey, boolean>;
+    }, _vnode: unknown): void;
+    updated(element: HTMLElement, binding: {
+        arg: string;
+        modifiers: Record<PropertyKey, boolean>;
+    }, _vnode: unknown): void;
+    private manageElement;
+    private getAccessLevels;
+    protected abstract hasAccess(scope: string, levels: string[]): boolean;
+}

package/dist/core/src/accessHandling/SSO/AuthorizationService.d.ts

@@ -0,0 +1,17 @@
+import { Initializer } from '../../initializer/Initializer';
+export declare class AuthorizationService implements Initializer {
+    private static _instance;
+    private _accessLevels;
+    private constructor();
+    initialize(): void;
+    setAccessLevels(levels: Record<PropertyKey, string[]>): void;
+    private setAccessLevelsToStorage;
+    private getAccessLevelsFromStorage;
+    getAccessLevelsOfScope(scope: string): Set<string>;
+    private setAccessLevelFromStorage;
+    everyAccess(scope: string, levels: string[]): boolean;
+    someAccess(scope: string, levels: string[]): boolean;
+    hasScope(scope: string): boolean;
+    clear(): void;
+    static GetInstance(): AuthorizationService;
+}

package/dist/core/src/accessHandling/SSO/EveryLevelAuthorizationDirective.d.ts

@@ -0,0 +1,4 @@
+import { AuthorizationDirective } from './AuthorizationDirective';
+export declare class EveryLevelAuthorizationDirective extends AuthorizationDirective {
+    protected hasAccess(scope: string, levels: string[]): boolean;
+}

package/dist/core/src/accessHandling/SSO/SomeLevelsAuthorizationDirective.d.ts

@@ -0,0 +1,4 @@
+import { AuthorizationDirective } from './AuthorizationDirective';
+export declare class SomeLevelsAuthorizationDirective extends AuthorizationDirective {
+    protected hasAccess(scope: string, levels: string[]): boolean;
+}

package/dist/core/src/accessHandling/SomeDirectiveAccess.d.ts

@@ -0,0 +1,4 @@
+import { AccessControl } from './AccessControl';
+export declare class SomeAccess extends AccessControl {
+    protected hasAccess(accessLevels: string[]): boolean;
+}

package/dist/core/src/accessHandling/index.d.ts

@@ -0,0 +1,9 @@
+export { AccessLevel } from './AccessLevel';
+export { AccessControl } from './AccessControl';
+export type { Accessible } from './Accessible';
+export { EveryAccess } from './EveryDirectiveAccess';
+export { SomeAccess } from './SomeDirectiveAccess';
+export * from './SSO/AuthorizationDirective';
+export * from './SSO/AuthorizationService';
+export * from './SSO/EveryLevelAuthorizationDirective';
+export * from './SSO/SomeLevelsAuthorizationDirective';

package/dist/core/src/baseDirective/BeforeMountDirective.d.ts

@@ -0,0 +1,3 @@
+export interface BeforeMountDirective {
+    beforeMount(el: unknown, binding: unknown, vnode: unknown): void;
+}

package/dist/core/src/baseDirective/BeforeUnMountDirective.d.ts

@@ -0,0 +1,3 @@
+export interface BeforeUnMountDirective {
+    beforeUnMount(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/dist/core/src/baseDirective/BeforeUpdateDirective.d.ts

@@ -0,0 +1,3 @@
+export interface BeforeUpdateDirective {
+    beforeUpdate(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/dist/core/src/baseDirective/CreatedDirective.d.ts

@@ -0,0 +1,3 @@
+export interface CreatedDirective {
+    created(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/dist/core/src/baseDirective/MountedDirective.d.ts

@@ -0,0 +1,3 @@
+export interface MountedDirective {
+    mounted(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/dist/core/src/baseDirective/UnMountedDirective.d.ts

@@ -0,0 +1,3 @@
+export interface UnMountedDirective {
+    unMounted(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/dist/core/src/baseDirective/UpdateDirective.d.ts

@@ -0,0 +1,3 @@
+export interface UpdateDirective {
+    updated(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/dist/core/src/baseDirective/index.d.ts

@@ -0,0 +1,7 @@
+export type { BeforeMountDirective } from './BeforeMountDirective';
+export type { BeforeUnMountDirective } from './BeforeUnMountDirective';
+export type { BeforeUpdateDirective } from './BeforeUpdateDirective';
+export type { CreatedDirective } from './CreatedDirective';
+export type { MountedDirective } from './MountedDirective';
+export type { UnMountedDirective } from './UnMountedDirective';
+export type { UpdateDirective } from './UpdateDirective';

package/dist/core/src/baseForm/BaseRequestBodyFilter.d.ts

@@ -0,0 +1,4 @@
+import { RequestBodyFilter } from './RequestBodyFilter';
+export declare class BaseRequestBodyFilter implements RequestBodyFilter<unknown> {
+    shouldBeInRequestBody(_value: unknown): boolean;
+}

package/dist/core/src/baseForm/FormManager.d.ts

@@ -0,0 +1,18 @@
+import { InputControl } from './InputControl';
+import { BaseRequestBodyFilter } from './BaseRequestBodyFilter';
+export declare class FormManager {
+    private _inputControls;
+    private _isValid;
+    private _id;
+    getInputControlsAsArray(): InputControl<unknown>[];
+    runValidation(shouldValidateInputControls?: boolean): Promise<void>;
+    addInputControls(inputControls: InputControl<unknown>[]): void;
+    getInputControl<T>(inputControlName: string): InputControl<T>;
+    resetControls(inputControlNames: string[]): void;
+    resetAll(): void;
+    createRequestBody<T>(requestBodyFilter?: BaseRequestBodyFilter): T;
+    setIsValid(isValid: boolean): void;
+    getIsValid(): boolean;
+    setId(id: number): void;
+    getId(): number;
+}

package/dist/core/src/baseForm/InputControl.d.ts

@@ -0,0 +1,40 @@
+import { Nullable } from '../types';
+import { Validator } from '../validators';
+export declare class InputControl<T> {
+    private initialData;
+    private data;
+    private _validators;
+    private _id;
+    constructor(name: string, value: Nullable<T>);
+    private shouldRunValidation;
+    runValidation(isBlur?: boolean): Promise<void>;
+    private setFormToInvalidState;
+    private setFormToValidState;
+    reset(): void;
+    markAsInitial(): void;
+    setValidators(validators: Validator<T>[]): void;
+    getChangeSensitive(): boolean;
+    setChangeSensitive(isChangeSensitive: boolean): void;
+    getIsBlurSensitive(): boolean;
+    setIsBlurSensitive(isBlurSensitive: boolean): void;
+    getIsRequired(): boolean;
+    setIsRequired(isRequired: boolean): void;
+    getIsValid(): boolean;
+    setIsValid(isValid: boolean): void;
+    getIsIncludeInRequestBody(): boolean;
+    setIsIncludeInRequestBody(isIncludeInRequestBody: boolean): void;
+    getNotValidMessage(): string;
+    setNotValidMessage(notValidMessage: string): void;
+    getName(): string;
+    setName(name: string): void;
+    setId(id: number): void;
+    getId(): number;
+    getIsEmptySensitive(): boolean;
+    setIsEmptySensitive(value: boolean): void;
+    setHasCustomValidationCheck(hasCustomCheck: boolean): void;
+    setShouldRemoveValidationOnInteract(value: boolean): void;
+    getShouldRemoveValidationOnInteract(): boolean;
+    hasCustomValidationCheck(): boolean;
+    set value(value: Nullable<T>);
+    get value(): Nullable<T>;
+}

package/dist/core/src/baseForm/InputControlBuilder.d.ts

@@ -0,0 +1,16 @@
+import { InputControl } from './InputControl';
+import { Validator } from '../validators';
+export declare class InputControlBuilder<T> {
+    private _inputControl;
+    constructor(inputControl: InputControl<T>);
+    setValidators(validators: Validator<T>[]): this;
+    setChangeSensitive(): this;
+    setRequired(): this;
+    setValid(): this;
+    setBlurSensitive(): this;
+    setId(id: number): this;
+    removeEmptySensitive(): this;
+    setHasCustomValidationCheck(): this;
+    removeErrorOnInteract(): this;
+    build(): InputControl<T>;
+}

package/dist/core/src/baseForm/InputControlData.d.ts

@@ -0,0 +1,15 @@
+import { Nullable } from '../types';
+export declare class InputControlData<T> {
+    value: Nullable<T>;
+    initialValue: Nullable<T>;
+    name: string;
+    isValid: boolean;
+    isBlurSensitive: boolean;
+    isRequired: boolean;
+    isIncludeInRequestBody: boolean;
+    isChangeSensitive: boolean;
+    notValidMessage: string;
+    isEmptySensitive: boolean;
+    hasCustomValidationCheck: boolean;
+    shouldRemoveValidationMessageOnInteract: boolean;
+}

package/dist/core/src/baseForm/RequestBodyFilter.d.ts

@@ -0,0 +1,3 @@
+export interface RequestBodyFilter<T> {
+    shouldBeInRequestBody(value: T): boolean;
+}

package/dist/core/src/baseForm/TouchSensitiveForm.d.ts

@@ -0,0 +1,9 @@
+import { DirectiveBinding } from 'vue';
+import { MountedDirective, BeforeUnMountDirective } from '../baseDirective';
+import { InputControl } from './InputControl';
+export declare class TouchSensitiveControl implements MountedDirective, BeforeUnMountDirective {
+    mounted: (element: HTMLInputElement, binding: DirectiveBinding<InputControl<unknown>>) => void;
+    beforeUnMount: (element: HTMLInputElement, binding: DirectiveBinding<InputControl<unknown>>) => void;
+    private handleBlur;
+    private handleFocus;
+}

package/dist/core/src/baseForm/UseForm.d.ts

@@ -0,0 +1,18 @@
+import { FormManager } from './FormManager';
+import { FormValidationStatus } from '../constants';
+export declare function useForm(form: FormManager, hasCustomValidation?: boolean): {
+    reactiveForm: {
+        getInputControlsAsArray: () => import('./InputControl').InputControl<unknown>[];
+        runValidation: (shouldValidateInputControls?: boolean) => Promise<void>;
+        addInputControls: (inputControls: import('./InputControl').InputControl<unknown>[]) => void;
+        getInputControl: <T>(inputControlName: string) => import('./InputControl').InputControl<T>;
+        resetControls: (inputControlNames: string[]) => void;
+        resetAll: () => void;
+        createRequestBody: <T>(requestBodyFilter?: import('./BaseRequestBodyFilter').BaseRequestBodyFilter) => T;
+        setIsValid: (isValid: boolean) => void;
+        getIsValid: () => boolean;
+        setId: (id: number) => void;
+        getId: () => number;
+    };
+    validationStatus: import('vue').Ref<FormValidationStatus, FormValidationStatus>;
+};

package/dist/core/src/baseForm/index.d.ts

@@ -0,0 +1,8 @@
+export { InputControl } from './InputControl';
+export { InputControlBuilder } from './InputControlBuilder';
+export { InputControlData } from './InputControlData';
+export { TouchSensitiveControl } from './TouchSensitiveForm';
+export { FormManager } from './FormManager';
+export { useForm } from './UseForm';
+export { BaseRequestBodyFilter } from './BaseRequestBodyFilter';
+export { type RequestBodyFilter } from './RequestBodyFilter';

package/dist/core/src/baseSchedule/Schedule.d.ts

@@ -0,0 +1,3 @@
+export interface Schedule {
+    runAction: () => Promise<unknown>;
+}

package/dist/core/src/baseSchedule/Scheduler.d.ts

@@ -0,0 +1,8 @@
+import { Schedule } from './Schedule';
+export declare class Scheduler {
+    private timerId;
+    private readonly schedule;
+    constructor(scheduler: Schedule);
+    setupInterval(intervalInMilliseconds: number): void;
+    clearInterval(): void;
+}

package/dist/core/src/baseSchedule/index.d.ts

@@ -0,0 +1,2 @@
+export { type Schedule } from './Schedule';
+export { Scheduler } from './Scheduler';

package/dist/core/src/baseTable/BaseTable.d.ts

@@ -0,0 +1,47 @@
+import { SortDetail } from '../sort';
+import { BaseModel } from '../BaseModel';
+import { LoadingStatus } from '../constants';
+import { Accessible } from '../accessHandling';
+import { TableHeaderSchema } from './TableHeaderSchema';
+import { TableService } from './TableService';
+import { TableAction } from './TableAction';
+import { Nullable } from '../types';
+import { TableSummarySchema } from './TableSummarySchema.ts';
+export declare abstract class BaseTable<Model extends BaseModel> {
+    protected service: TableService<Model>;
+    private accessService;
+    protected currentPage: number;
+    protected currentPageSize: number;
+    private currentSortDetail;
+    protected loadedRows: Model[];
+    headerSchema: TableHeaderSchema<Model>[];
+    protected constructor(service: TableService<Model>);
+    addHeader(schema: TableHeaderSchema<Model>): void;
+    load(): Promise<void>;
+    protected filterItemsBaseOnAccessLevel<T>(items: Accessible[]): T[];
+    sort(sortDetail: SortDetail<Model>): Promise<void>;
+    private shouldSendSortRequest;
+    paginate(nextPage: number, pageSize: number): Promise<void>;
+    private shouldSendPaginationRequest;
+    protected loadRows(): Promise<Model[]>;
+    getData(): import('./TableHeaderSchema').TableRenderingData<Model>;
+    protected handleSort(sortDetail: SortDetail<Model>): Promise<import('../repository').FetchListResponse<Model>>;
+    protected handlePagination(nextPage: number, pageSize: number): Promise<import('../repository').FetchListResponse<Model>>;
+    getItemCountPerPage(): number;
+    isLoading(): boolean;
+    protected getLoadingStatuses(): Set<LoadingStatus>;
+    hasAnyAction(): boolean;
+    getAccessedActions(row: Model): TableAction<Model>[];
+    protected getActions(row: Model): TableAction<Model>[];
+    getScrollDetail(): Nullable<boolean | {
+        x?: number;
+        y?: number;
+    }>;
+    isExpandable(): boolean;
+    handleClick(row: Model): Promise<void>;
+    handleMetaClick(row: Model): Promise<void>;
+    handleDoubleClick(row: Model): Promise<void>;
+    onDestroy(): Promise<void>;
+    loadHeader(): Promise<TableHeaderSchema<Model>[]>;
+    loadSummarySchema(): TableSummarySchema;
+}

package/dist/core/src/baseTable/Constants.d.ts

@@ -0,0 +1,13 @@
+import { TableHeaderSchema } from './TableHeaderSchema';
+import { BaseModel } from '../BaseModel';
+import { CellType, HeaderType, TableHeaderAlign } from '../constants';
+export declare const TABLE_COLUMN_DEFAULT_WIDTH = "150px";
+export declare const TABLE_COLUMN_DEFAULT_COLSPAN = 2;
+export declare const TABLE_ACTION_COLUMN: TableHeaderSchema<BaseModel>;
+export declare const TABLE_COLUMN_DEFAULT_VALUES: {
+    width: string;
+    align: TableHeaderAlign;
+    headerType: HeaderType;
+    cellType: CellType;
+    colspan: number;
+};

package/dist/core/src/baseTable/OnDestory.d.ts

@@ -0,0 +1,3 @@
+export interface Destroy {
+    onDestroy(): Promise<void>;
+}

package/dist/core/src/baseTable/RowActionSource.d.ts

@@ -0,0 +1,4 @@
+import { TableAction } from './TableAction';
+export interface RowActionSource<Model, A> {
+    getActions(): TableAction<Model, A>[];
+}

package/dist/core/src/baseTable/RowClick.d.ts

@@ -0,0 +1,3 @@
+export interface RowClick<Model> {
+    handleClick(row: Model): Promise<void>;
+}

package/dist/core/src/baseTable/RowDoubleClick.d.ts

@@ -0,0 +1,3 @@
+export interface RowDoubleClick<Model> {
+    handleDoubleClick(row: Model): Promise<void>;
+}

package/dist/core/src/baseTable/RowMetaClick.d.ts

@@ -0,0 +1,3 @@
+export interface RowMetaClick<Model> {
+    handleMetaClick(row: Model): Promise<void>;
+}

package/dist/core/src/baseTable/SelectableTable.d.ts

@@ -0,0 +1,19 @@
+import { BaseTable } from './BaseTable';
+import { BehaviorSubject } from '../observables/BehaviorSubject';
+import { SortDetail } from '../sort';
+import { BaseModel } from '../BaseModel';
+import { TableService } from './TableService';
+export declare abstract class SelectableTable<Model extends BaseModel> extends BaseTable<Model> {
+    selectedRows: BehaviorSubject<Map<number, Model>>;
+    constructor(service: TableService<Model>);
+    rowSelect(row: Model): void;
+    selectAll(): void;
+    private isEveryRowSelected;
+    protected handlePagination(nextPage: number, pageSize: number): Promise<import('../repository').FetchListResponse<Model>>;
+    protected handleSort(sortDetail: SortDetail<Model>): Promise<import('../repository').FetchListResponse<Model>>;
+    clearAllSelectedItems(): void;
+    getSelectedRows(): BehaviorSubject<Map<number, Model>>;
+    getSelectedRowsAsArray(): Model[];
+    getSelectedRowIds(): number[];
+    getSelectedRowsValue(): Map<number, Model>;
+}

package/dist/core/src/baseTable/TableAction.d.ts

@@ -0,0 +1,8 @@
+import { Accessible } from '../accessHandling';
+export interface TableAction<Model> extends Accessible {
+    readonly actionName: string;
+    handler(row: Model): Promise<void>;
+}
+export interface ActionDecorator<Model> extends TableAction<Model> {
+    isAvailable(model: Model): boolean;
+}

package/dist/core/src/baseTable/TableHeaderSchema.d.ts

@@ -0,0 +1,27 @@
+import { CellType, HeaderType, LoadingStatus, SortOrder, TableHeaderAlign } from '../constants';
+import { Accessible } from '../accessHandling';
+export interface TableHeaderSchema<Model> extends Accessible {
+    path?: keyof Model;
+    title: string;
+    getProps?: (row: Model) => Record<string, unknown>;
+    key: keyof Model;
+    cellType?: CellType | string;
+    align?: TableHeaderAlign;
+    headerType?: HeaderType;
+    colspan?: number;
+    width?: string | number;
+    ellipsis?: boolean;
+    maxWidth?: number;
+    minWidth?: number;
+    resizable?: boolean;
+    sortOrder?: SortOrder;
+    sorter?: boolean;
+}
+export interface TableRenderingData<Model> {
+    totalItems: number;
+    currentPage: number;
+    rows: Model[];
+    loadingStatus: Set<LoadingStatus>;
+    currentPageItems: Model[];
+}
+export declare function generateHeader<Model>(header: TableHeaderSchema<Model>): TableHeaderSchema<Model>;

package/dist/core/src/baseTable/TableLoader.d.ts

@@ -0,0 +1,3 @@
+export interface TableLoader<Model> {
+    loadRows(): Promise<Model>;
+}

package/dist/core/src/baseTable/TablePaginate.d.ts

@@ -0,0 +1,3 @@
+export interface TablePaginate {
+    handlePagination(nextPage: number, pageSize: number): Promise<void>;
+}

package/dist/core/src/baseTable/TableService.d.ts

@@ -0,0 +1,9 @@
+import { SortDetail } from '../sort';
+import { FetchListResponse } from '../repository/model';
+import { TableRenderingData } from './TableHeaderSchema';
+export interface TableService<Model> {
+    fetchRows(): Promise<FetchListResponse<Model>>;
+    paginate(nextPage: number, pageSize: number): Promise<FetchListResponse<Model>>;
+    sort(sortDetail: SortDetail<Model>): Promise<FetchListResponse<Model>>;
+    getData(): TableRenderingData<Model>;
+}

package/dist/core/src/baseTable/TableSort.d.ts

@@ -0,0 +1,4 @@
+import { SortDetail } from '../sort';
+export interface TableSort<Model> {
+    handleSort(sortDetail: SortDetail<Model>): Promise<void>;
+}

package/dist/core/src/baseTable/TableSummarySchema.d.ts

@@ -0,0 +1,9 @@
+import { TableHeaderAlign } from '../constants';
+export interface TableSummaryItem {
+    data: string | number;
+    align: TableHeaderAlign;
+}
+export interface TableSummarySchema {
+    summaryTitle: string;
+    summaryItems: TableSummaryItem[];
+}

package/dist/core/src/baseTable/generator/SelectableTableGenerator.d.ts

@@ -0,0 +1,14 @@
+import { TableGenerator } from './TableGenerator';
+import { TableSource } from './TableSource';
+import { BehaviorSubject } from '../../observables';
+export declare class SelectableTableGenerator<T> extends TableGenerator<T> {
+    selectedRows: BehaviorSubject<Map<number, T>>;
+    constructor(tableSource: TableSource<T>);
+    selectRow(row: T): void;
+    selectAll(): void;
+    private isEveryRowSelected;
+    clearAllSelectedItems(): void;
+    getSelectedRows(): Map<number, T>;
+    getSelectedRowsAsArray(): T[];
+    getSelectedRowIds(): number[];
+}

package/dist/core/src/baseTable/generator/TableCellComponentRegistry.d.ts

@@ -0,0 +1,7 @@
+import { Initializer } from '../../initializer';
+export declare abstract class TableCellComponentRegistry implements Initializer {
+    private registeredComponents;
+    initialize(): void;
+    protected abstract registerComponents(): void;
+    getRegisteredComponents(): Map<string, unknown>;
+}

package/dist/core/src/baseTable/generator/TableConfig.d.ts

@@ -0,0 +1,7 @@
+import { TableCellComponentRegistry } from './TableCellComponentRegistry';
+export declare class TableConfig {
+    private cellComponentRegistry;
+    constructor();
+    setCellComponentRegistry(registry: TableCellComponentRegistry): void;
+    getCellComponentRegistry(): TableCellComponentRegistry;
+}

package/dist/core/src/baseTable/generator/TableGenerator.d.ts

@@ -0,0 +1,37 @@
+import { BehaviorSubject } from '../../observables';
+import { SortDetail } from '../../sort';
+import { TableHeaderSchema } from '../TableHeaderSchema';
+import { Nullable } from '../../types';
+import { TableSummarySchema } from '../TableSummarySchema';
+import { TableSource } from './TableSource';
+import { AccessLevel } from '../../accessHandling';
+import { TableAction } from '../TableAction';
+export declare class TableGenerator<T> {
+    rows: BehaviorSubject<T[]>;
+    headerSchema: BehaviorSubject<TableHeaderSchema<T>[]>;
+    currentPage: BehaviorSubject<number>;
+    currentPageSize: BehaviorSubject<number>;
+    totalItems: BehaviorSubject<number>;
+    protected currentSortDetail: BehaviorSubject<SortDetail<T>>;
+    scrollDetail: BehaviorSubject<Nullable<boolean | {
+        x?: number;
+        y?: number;
+    }>>;
+    isExpandable: BehaviorSubject<boolean>;
+    protected tableSource: TableSource<T>;
+    protected accessService: AccessLevel;
+    constructor(tableSource: TableSource<T>);
+    load(): Promise<void>;
+    paginate(nextPage: number, pageSize: number): Promise<void>;
+    private shouldSendPaginationRequest;
+    sort(sortDetail: SortDetail<T>): Promise<void>;
+    private shouldSendSortRequest;
+    handleClick(row: T): Promise<void>;
+    handleMetaClick(row: T): Promise<void>;
+    handleDoubleClick(row: T): Promise<void>;
+    hasAnyAction(): boolean;
+    getRowActions(row: T): TableAction<T>[];
+    loadSummarySchema(): TableSummarySchema;
+    private filterItemsBaseOnAccessLevel;
+    onDestroy(): Promise<void>;
+}