@sarafapp/iron_core 1.0.63 → 1.0.64

package/dist/IronCore.js

@@ -1037,7 +1037,9 @@ class ut {
   getAccessLevels(e, s) {
     var n;
     let r = Object.keys(s);
-    return r.length || (r = Array.from(((n = this._authorizationService.getAccessLevelsOfScope(e)) == null ? void 0 : n.values()) ?? [])), r;
+    return r.length || (r = Array.from(
+      ((n = this._authorizationService.getAccessLevelsOfScope(e)) == null ? void 0 : n.values()) ?? []
+    )), r;
   }
 }
 class Js extends ut {
@@ -1264,13 +1266,17 @@ class sr {
   getInputControl(e) {
     const s = this._inputControls.get(e);
     if (!s)
-      throw new Error(`The provided input name (${e}}) has no controls.`);
+      throw new Error(
+        `The provided input name (${e}}) has no controls.`
+      );
     return s;
   }
   resetControls(e) {
     for (const s of e) {
       const r = this._inputControls.get(s);
-      r ? r.reset() : console.warn(`Provided input name ${s} has no controllers in this form`);
+      r ? r.reset() : console.warn(
+        `Provided input name ${s} has no controllers in this form`
+      );
     }
   }
   resetAll() {
@@ -2376,7 +2382,9 @@ class Nr {
     }), this.repository = e, this.crudDataManagement = s, this.syncDetail = this.repository.getSyncDetail(), this.paramManager = r, this.syncListWithApi();
   }
   async fetchList() {
-    const e = await this.repository.fetchList(this.paramManager.getRequestParams());
+    const e = await this.repository.fetchList(
+      this.paramManager.getRequestParams()
+    );
     return this.crudDataManagement.addOrReplaceItems(e.items), this.crudDataManagement.setTotalCount(e.totalItems), e;
   }
   async fetchItemById(e) {
@@ -2424,7 +2432,9 @@ class jr extends gs {
     const n = [];
     e: for (const i of e)
       for (const a of r(i))
-        if (Q.removeSpacesFromString(String(a).toLowerCase()).indexOf(Q.removeSpacesFromString(String(s).toLowerCase())) > -1) {
+        if (Q.removeSpacesFromString(String(a).toLowerCase()).indexOf(
+          Q.removeSpacesFromString(String(s).toLowerCase())
+        ) > -1) {
           n.push(i);
           continue e;
         }

package/dist/core/index.d.ts

@@ -0,0 +1,31 @@
+export * from './src/lib';
+export * from './src/accessHandling';
+export * from './src/baseDirective';
+export * from './src/baseForm';
+export * from './src/baseSchedule';
+export * from './src/baseTable';
+export * from './src/composables';
+export * from './src/constants';
+export * from './src/dateHandling';
+export * from './src/debounce';
+export * from './src/errorHandling';
+export * from './src/feedbackHandling';
+export * from './src/httpClient';
+export * from './src/initializer';
+export * from './src/json';
+export { useDialogService, ToastType, useDrawerService, ToastLocation, ToastMessage, } from './src/layout';
+export * from './src/lib';
+export * from './src/observables';
+export * from './src/process';
+export * from './src/repository';
+export * from './src/routeGuard';
+export * from './src/sort';
+export * from './src/types';
+export * from './src/validators';
+export * from './src/Utils';
+export * from './src/crudService';
+export * from './src/search';
+export * from './src/deviceManagement';
+export * from './src/BaseModel';
+export * from './src/eventSystem';
+export * from './src/webSocket';

package/dist/{src → core/src}/BaseModel.d.ts

@@ -18,10 +18,10 @@ export declare class TradeDate {
     requestedDate: number;
     executedDate: number;
     constructor(requestedDate: number, executedDate: number);
-    get requestedDateInJalali(): any;
-    get requestedTime(): any;
-    get executedDateInJalali(): any;
-    get executedDateTime(): any;
+    get requestedDateInJalali(): string;
+    get requestedTime(): string;
+    get executedDateInJalali(): string;
+    get executedDateTime(): string;
 }
 export declare class TradeAmount {
     requestedAmount: Amount;

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/{src → core/src}/baseTable/BaseTable.d.ts

@@ -1,5 +1,6 @@
 import { SortDetail } from '../sort';
 import { BaseModel } from '../BaseModel';
+import { LoadingStatus } from '../constants';
 import { Accessible } from '../accessHandling';
 import { TableHeaderSchema } from './TableHeaderSchema';
 import { TableService } from './TableService';
@@ -24,8 +25,8 @@ export declare abstract class BaseTable<Model extends BaseModel> {
     private shouldSendPaginationRequest;
     protected loadRows(): Promise<Model[]>;
     getData(): import('./TableHeaderSchema').TableRenderingData<Model>;
-    protected handleSort(sortDetail: SortDetail<Model>): Promise<import('../repository/model').FetchListResponse<Model>>;
-    protected handlePagination(nextPage: number, pageSize: number): Promise<import('../repository/model').FetchListResponse<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>;

package/dist/{src → core/src}/baseTable/Constants.d.ts

@@ -1,12 +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: any;
-    headerType: any;
-    cellType: any;
+    align: TableHeaderAlign;
+    headerType: HeaderType;
+    cellType: CellType;
     colspan: number;
 };

package/dist/{src → core/src}/baseTable/SelectableTable.d.ts

@@ -9,8 +9,8 @@ export declare abstract class SelectableTable<Model extends BaseModel> extends B
     rowSelect(row: Model): void;
     selectAll(): void;
     private isEveryRowSelected;
-    protected handlePagination(nextPage: number, pageSize: number): Promise<import('../repository/model').FetchListResponse<Model>>;
-    protected handleSort(sortDetail: SortDetail<Model>): Promise<import('../repository/model').FetchListResponse<Model>>;
+    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[];

package/dist/{src → core/src}/baseTable/generator/SelectableTableGenerator.d.ts

@@ -8,7 +8,7 @@ export declare class SelectableTableGenerator<T> extends TableGenerator<T> {
     selectAll(): void;
     private isEveryRowSelected;
     clearAllSelectedItems(): void;
-    getSelectedRows(): any;
-    getSelectedRowsAsArray(): unknown[];
-    getSelectedRowIds(): unknown[];
+    getSelectedRows(): Map<number, T>;
+    getSelectedRowsAsArray(): T[];
+    getSelectedRowIds(): number[];
 }

package/dist/{src → core/src}/baseTable/moduleConnection/Table.d.ts

@@ -1,4 +1,4 @@
-import { BaseTable } from '../../baseTable';
+import { BaseTable } from '../index';
 import { BaseModel } from '../../BaseModel';
 import { SelectableTable } from '../SelectableTable';
 export declare function Table<Model extends BaseModel>(table: typeof BaseTable<Model> | typeof SelectableTable<Model>): (constructor: Function) => void;

package/dist/{src → core/src}/baseTable/moduleConnection/generator/GColumn.d.ts

@@ -1,2 +1,2 @@
-import { TableHeaderSchema } from '../..';
+import { TableHeaderSchema } from '../../index';
 export declare function GColumn<T>(header: TableHeaderSchema<T>): (target: T, propertyKey: string) => void;

package/dist/{src → core/src}/composables/UseCrud.d.ts

@@ -1,10 +1,10 @@
 import { BaseModel } from '../BaseModel';
 export declare function useCrud<Entity extends BaseModel>(): {
-    entityItemsAsArray: any;
+    entityItemsAsArray: import('vue').ComputedRef<Entity[]>;
     addOrReplaceItems: (items: Entity[]) => void;
-    removeById: (id: string | number) => any;
-    getItemById: (id: number | string) => any;
+    removeById: (id: string | number) => Entity;
+    getItemById: (id: number | string) => Entity;
     clearItems: () => void;
     setTotalCount: (count: number) => void;
-    getTotalCount: any;
+    getTotalCount: import('vue').ComputedRef<number>;
 };

package/dist/{src → core/src}/composables/UseData.d.ts

@@ -1,9 +1,10 @@
+import { Ref } from 'vue';
 import { BaseModel } from '../BaseModel';
 import { Nullable } from '../types';
 export declare function useData<Model extends BaseModel>(): {
-    itemsAsArray: any;
-    totalCount: any;
-    currentItem: any;
+    itemsAsArray: import('vue').ComputedRef<Model[]>;
+    totalCount: Ref<number, number>;
+    currentItem: [Model] extends [Ref<any, any>] ? import('@vue/shared').IfAny<Model, Ref<Model, Model>, Model> : Ref<import('vue').UnwrapRef<Model>, Model | import('vue').UnwrapRef<Model>>;
     setTotalCount: (totalItems: number) => void;
     addOrReplaceItems: (itemsToAdd: Model[]) => void;
     getById: (id: number) => Nullable<Model>;

package/dist/core/src/composables/UseLoadingStatus.d.ts

@@ -0,0 +1,15 @@
+import { LoadingStatus } from '../constants';
+export declare function useLoadingStatus(): {
+    loadingStatus: import('vue').Ref<Set<LoadingStatus> & Omit<Set<LoadingStatus>, keyof Set<any>>, Set<LoadingStatus> | (Set<LoadingStatus> & Omit<Set<LoadingStatus>, keyof Set<any>>)>;
+    isFetchingList: import('vue').ComputedRef<boolean>;
+    isFetchingItem: import('vue').ComputedRef<boolean>;
+    isFetchingLastItems: import('vue').ComputedRef<boolean>;
+    isFetchingPreviousItems: import('vue').ComputedRef<boolean>;
+    isCreating: import('vue').ComputedRef<boolean>;
+    isUpdating: import('vue').ComputedRef<boolean>;
+    isDeleting: import('vue').ComputedRef<boolean>;
+    isSearching: import('vue').ComputedRef<boolean>;
+    isSorting: import('vue').ComputedRef<boolean>;
+    setStatus: (status: LoadingStatus) => void;
+    removeStatus: (status: LoadingStatus) => void;
+};

package/dist/{src → core/src}/composables/UseParams.d.ts

@@ -1,7 +1,9 @@
+import { Ref } from 'vue';
 import { SortDetail } from '../sort';
 import { BaseModel } from '../BaseModel';
+import { Params } from '../repository';
 export declare function useParams(): {
-    params: Ref<Params>;
+    params: Ref<Params, Params>;
     setNextPage: () => void;
     setPreventPage: () => void;
     setPageNumber: (pageNumber: number) => void;

package/dist/core/src/composables/UseRepository.d.ts

@@ -0,0 +1,67 @@
+import { Repository } from '../repository';
+import { LoadingStatus } from '../constants';
+import { SortDetail } from '../sort';
+import { BaseModel } from '../BaseModel';
+import { TableRenderingData, TableService } from '../baseTable';
+export declare function useRepository<Model extends BaseModel>(repository: Repository<Model>): {
+    loadingStatusManager: {
+        loadingStatus: import('vue').Ref<Set<LoadingStatus> & Omit<Set<LoadingStatus>, keyof Set<any>>, Set<LoadingStatus> | (Set<LoadingStatus> & Omit<Set<LoadingStatus>, keyof Set<any>>)>;
+        isFetchingList: import('vue').ComputedRef<boolean>;
+        isFetchingItem: import('vue').ComputedRef<boolean>;
+        isFetchingLastItems: import('vue').ComputedRef<boolean>;
+        isFetchingPreviousItems: import('vue').ComputedRef<boolean>;
+        isCreating: import('vue').ComputedRef<boolean>;
+        isUpdating: import('vue').ComputedRef<boolean>;
+        isDeleting: import('vue').ComputedRef<boolean>;
+        isSearching: import('vue').ComputedRef<boolean>;
+        isSorting: import('vue').ComputedRef<boolean>;
+        setStatus: (status: LoadingStatus) => void;
+        removeStatus: (status: LoadingStatus) => void;
+    };
+    dataManger: {
+        itemsAsArray: import('vue').ComputedRef<BaseModel[]>;
+        totalCount: import('vue').Ref<number, number>;
+        currentItem: import('vue').Ref<{
+            id: number | string;
+        }, BaseModel | {
+            id: number | string;
+        }>;
+        setTotalCount: (totalItems: number) => void;
+        addOrReplaceItems: (itemsToAdd: BaseModel[]) => void;
+        getById: (id: number) => BaseModel;
+        removeById: (id: number) => boolean;
+        clearItems: () => void;
+        setCurrentItem: (item: BaseModel) => void;
+        clearCurrentItem: () => void;
+    };
+    paramsManager: {
+        params: import('vue').Ref<import('../repository').Params, import('../repository').Params>;
+        setNextPage: () => void;
+        setPreventPage: () => void;
+        setPageNumber: (pageNumber: number) => void;
+        setItemCount: (itemCount: number) => void;
+        setSortDetail: (sortDetail: SortDetail<BaseModel>) => void;
+        setFilter: (key: string, value: unknown) => void;
+        removeFilter: (key: string) => void;
+        getRequestParams: () => Record<string, unknown>;
+        clearParam: () => void;
+        setFiltersBaseOnRequestBody: (filters: Record<string, unknown>) => void;
+    };
+    tableRenderingData: import('vue').ComputedRef<TableRenderingData<Model>>;
+    fetchList: (loadingStatus?: LoadingStatus) => Promise<import('../repository').FetchListResponse<Model>>;
+    fetchWithAutoRefresh: () => Promise<void>;
+    setupAutoRefresh: () => void;
+    stopAutoRefresh: () => void;
+    fetchItemById: (id: number, shouldRemoveItem?: boolean) => Promise<Model>;
+    createItem: <Body>(body: Body) => Promise<Model>;
+    updateItem: <Body>(id: number, body: Body) => Promise<Model>;
+    deleteItem: (id: number) => Promise<boolean>;
+    fetchLastItems: () => Promise<import('../repository').FetchListResponse<Model>>;
+    fetchPreviousItems: () => Promise<import('../repository').FetchListResponse<Model>>;
+    fetchItemsByPageNumber: (pageNumber: number) => Promise<import('../repository').FetchListResponse<Model>>;
+    search: (searchedValue: string) => Promise<import('../repository').FetchListResponse<Model>>;
+    sort: (sortDetail: SortDetail<Model>) => Promise<import('../repository').FetchListResponse<Model>>;
+    clearFilters: () => Promise<import('../repository').FetchListResponse<Model>>;
+    tableService: import('vue').ComputedRef<TableService<Model>>;
+    currentPageItems: import('vue').ComputedRef<Model[]>;
+};

package/dist/core/src/composables/UseStaticTableService.d.ts

@@ -0,0 +1,5 @@
+import { TableService } from '../baseTable';
+export declare function useStaticTableService<Model>(initialRows: Model[]): {
+    tableRows: import('vue').Ref<import('@vue/reactivity').UnwrapRefSimple<Model>[], Model[] | import('@vue/reactivity').UnwrapRefSimple<Model>[]>;
+    staticTableService: import('vue').ComputedRef<TableService<Model>>;
+};

package/dist/{src → core/src}/crudService/CrudService.d.ts

@@ -1,20 +1,20 @@
-import { SyncDetail, useParams, useCrud, Repository } from '../../index';
+import { Scheduler, SyncDetail, useParams, useCrud, Repository } from '../../index';
 import { BaseModel } from '../BaseModel';
 export declare class CrudService<Entity extends BaseModel> {
     protected repository: Repository<Entity>;
     protected crudDataManagement: ReturnType<typeof useCrud>;
-    protected scheduler: any;
+    protected scheduler: Scheduler;
     protected syncDetail: SyncDetail;
     paramManager: any;
     constructor(repository: Repository<Entity>, crudDataManagement: ReturnType<typeof useCrud>, paramManager: ReturnType<typeof useParams>);
-    fetchList(): Promise<any>;
-    fetchItemById(id: number): Promise<any>;
-    createItem<Body>(body: Body): Promise<any>;
+    fetchList(): Promise<import('../repository').FetchListResponse<Entity>>;
+    fetchItemById(id: number): Promise<Entity>;
+    createItem<Body>(body: Body): Promise<Entity>;
     protected shouldRefreshListAfterCreate(): boolean;
-    deleteItem(id: number): Promise<any>;
-    updateItem<Body>(id: number, body: Body): Promise<any>;
+    deleteItem(id: number): Promise<BaseModel>;
+    updateItem<Body>(id: number, body: Body): Promise<BaseModel>;
     protected shouldRefreshListAfterUpdate(): boolean;
-    removeItem(id: number): Promise<any>;
+    removeItem(id: number): Promise<BaseModel>;
     protected shouldRefreshListAfterDelete(): boolean;
     private syncListWithApi;
     onDestroy(): void;

package/dist/{src → core/src}/dateHandling/Converter.d.ts

@@ -1,5 +1,5 @@
 export declare class DateConverter {
     static standardToUnix(dateToConvert: string): number;
     static unixToStandard(dateToConvert: number): string;
-    static getUnixEndOfDayInUnix(unix: number): any;
+    static getUnixEndOfDayInUnix(unix: number): number;
 }

package/dist/{src → core/src}/httpClient/ErrorHandlerRegistry.d.ts

@@ -4,7 +4,7 @@ export declare class APIErrorHandlerRegistry {
     private static handlers;
     private static instance;
     private constructor();
-    static GetInstance(): Nullable<APIErrorHandlerRegistry>;
+    static GetInstance(): APIErrorHandlerRegistry;
     static registerHandler(statusCode: number, handler: ErrorHandler): void;
     handle(error: AxiosError): void;
 }

package/dist/{src → core/src}/json/JsonMapper.d.ts

@@ -14,5 +14,5 @@ export declare class JsonMapper {
     tryDeserialize(object: object, models: {
         new (): any;
     }[]): any;
-    static GetInstance(): Nullable<JsonMapper>;
+    static GetInstance(): JsonMapper;
 }