@sarafapp/iron_core 1.0.64 → 1.0.67

package/src/baseForm/InputControl.ts

@@ -1,182 +0,0 @@
-import { toRaw } from "vue";
-import type { Nullable } from "../types";
-import { InputControlData } from "./InputControlData";
-import { isEmpty } from "../Utils";
-import { type Validator } from "../validators";
-
-export class InputControl<T> {
-  private initialData: Nullable<InputControlData<T>> = null;
-  private data = new InputControlData<T>();
-  private _validators: Validator<T>[] = [];
-  private _id = Math.random();
-
-  constructor(name: string, value: Nullable<T>) {
-    this.data.value = value;
-    this.data.name = name;
-    if (this.shouldRunValidation()) {
-      this.runValidation(true);
-    }
-  }
-
-  private shouldRunValidation(): boolean {
-    if (this.data.hasCustomValidationCheck) return false;
-    if (this.data.isRequired) return true;
-    return !isEmpty(this.data.value);
-  }
-
-  public async runValidation(isBlur: boolean = false) {
-    for (const validator of this._validators) {
-      const validationMessage = await validator.validate(this.data.value);
-      if (validationMessage) {
-        this.setFormToInvalidState(isBlur, validationMessage);
-        return;
-      }
-    }
-    this.setFormToValidState();
-  }
-
-  private setFormToInvalidState(
-    isBlur: boolean,
-    validationMessage: string,
-  ) {
-    this.data.isValid = false;
-    if (this.data.isChangeSensitive || isBlur) {
-      this.setNotValidMessage(validationMessage);
-    }
-  }
-
-  private setFormToValidState() {
-    this.data.isValid = true;
-    this.setNotValidMessage('');
-  }
-
-  public reset() {
-    if (this.initialData) {
-      this.data = structuredClone(toRaw(this.initialData));
-    } else {
-      console.warn(
-        "The " +
-          this.data.name +
-          `input control has no initial data,
-          the initial data will be available after calling the [markAsInitial] method on this instance`,
-      );
-    }
-  }
-
-  public markAsInitial() {
-    this.initialData = structuredClone(toRaw(this.data));
-  }
-
-  public setValidators(validators: Validator<T>[]) {
-    this._validators = validators;
-  }
-
-  public getChangeSensitive() {
-    return this.data.isChangeSensitive;
-  }
-
-  public setChangeSensitive(isChangeSensitive: boolean) {
-    if (isChangeSensitive && this.data.shouldRemoveValidationMessageOnInteract) {
-        throw new Error("Input control " + this.getName() + " can not be both change sensitive and remove validation meessage on interact");
-    }
-
-    this.data.isChangeSensitive = isChangeSensitive;
-  }
-
-  public getIsBlurSensitive(): boolean {
-    return this.data.isBlurSensitive;
-  }
-
-  public setIsBlurSensitive(isBlurSensitive: boolean) {
-    this.data.isBlurSensitive = isBlurSensitive;
-  }
-
-  public getIsRequired(): boolean {
-    return this.data.isRequired;
-  }
-
-  public setIsRequired(isRequired: boolean) {
-    this.data.isRequired = isRequired;
-  }
-
-  public getIsValid() {
-    return this.data.isValid;
-  }
-
-  public setIsValid(isValid: boolean) {
-    this.data.isValid = isValid;
-  }
-
-  public getIsIncludeInRequestBody(): boolean {
-    return this.data.isIncludeInRequestBody;
-  }
-
-  public setIsIncludeInRequestBody(isIncludeInRequestBody: boolean) {
-    this.data.isIncludeInRequestBody = isIncludeInRequestBody;
-  }
-
-  public getNotValidMessage() {
-    return this.data.notValidMessage;
-  }
-
-  public setNotValidMessage(notValidMessage: string) {
-    this.data.notValidMessage = notValidMessage;
-  }
-
-  public getName() {
-    return this.data.name;
-  }
-
-  public setName(name: string) {
-    this.data.name = name;
-  }
-
-  public setId(id: number) {
-    this._id = id;
-  }
-
-  public getId(): number {
-    return this._id;
-  }
-
-  public getIsEmptySensitive(): boolean {
-    return this.data.isEmptySensitive;
-  }
-
-  public setIsEmptySensitive(value: boolean) {
-    this.data.isEmptySensitive = value;
-  }
-
-  public setHasCustomValidationCheck(hasCustomCheck: boolean) {
-    this.data.hasCustomValidationCheck = hasCustomCheck;
-  }
-
-  public setShouldRemoveValidationOnInteract(value: boolean) {
-    if (value && this.data.isChangeSensitive) {
-      throw new Error("Input control " + this.getName() + " can not be both change sensitive and remove validation meessage on interact");
-    }
-    this.data.shouldRemoveValidationMessageOnInteract = value;
-  }
-
-  public getShouldRemoveValidationOnInteract() {
-    return this.data.shouldRemoveValidationMessageOnInteract;
-  }
-
-  public hasCustomValidationCheck() {
-    return this.data.hasCustomValidationCheck;
-  }
-
-  public set value(value: Nullable<T>) {
-    this.data.value = value;
-    if (this.shouldRunValidation()) {
-      this.runValidation();
-    }
-    if (this.getShouldRemoveValidationOnInteract()) {
-      this.setNotValidMessage("");
-    }
-  }
-
-  public get value() {
-    return this.data.value;
-  }
-}

package/src/baseForm/InputControlBuilder.ts

@@ -1,59 +0,0 @@
-import { InputControl } from "./InputControl";
-import type { Validator } from "../validators";
-
-export class InputControlBuilder<T> {
-  private _inputControl: InputControl<T>;
-
-  constructor(inputControl: InputControl<T>) {
-    this._inputControl = inputControl;
-  }
-
-  public setValidators(validators: Validator<T>[]) {
-    this._inputControl.setValidators(validators);
-    return this;
-  }
-
-  public setChangeSensitive() {
-    this._inputControl.setChangeSensitive(true);
-    return this;
-  }
-
-  public setRequired() {
-    this._inputControl.setIsRequired(true);
-    return this;
-  }
-
-  public setValid() {
-    this._inputControl.setIsValid(true);
-    return this;
-  }
-
-  public setBlurSensitive() {
-    this._inputControl.setIsBlurSensitive(true);
-    return this;
-  }
-
-  public setId(id: number) {
-    this._inputControl.setId(id);
-    return this;
-  }
-
-  public removeEmptySensitive() {
-    this._inputControl.setIsEmptySensitive(false);
-    return this;
-  }
-
-  public setHasCustomValidationCheck() {
-    this._inputControl.setHasCustomValidationCheck(true);
-    return this;
-  }
-
-  public removeErrorOnInteract() {
-    this._inputControl.setShouldRemoveValidationOnInteract(true);
-    return this;
-  }
-
-  public build(): InputControl<T> {
-    return this._inputControl;
-  }
-}

package/src/baseForm/InputControlData.ts

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

package/src/baseForm/RequestBodyFilter.ts

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

package/src/baseForm/TouchSensitiveForm.ts

@@ -1,47 +0,0 @@
-import type { DirectiveBinding } from "vue";
-import type { MountedDirective } from "../baseDirective";
-import type { BeforeUnMountDirective } from "../baseDirective";
-import { InputControl } from "./InputControl";
-
-export class TouchSensitiveControl
-    implements MountedDirective, BeforeUnMountDirective
-{
-
-  public mounted = (
-      element: HTMLInputElement,
-      binding: DirectiveBinding<InputControl<unknown>>,
-  ) => {
-    if (!binding.value) return;
-
-    if (!binding.value.getIsBlurSensitive()) return;
-
-    element.addEventListener('click', this.handleFocus.bind(this, binding.value))
-
-    element.addEventListener(
-        "blur",
-        this.handleBlur.bind(this, binding.value),
-        true,
-    );
-  };
-
-  public beforeUnMount = (
-      element: HTMLInputElement,
-      binding: DirectiveBinding<InputControl<unknown>>,
-  ) => {
-    element!.removeEventListener(
-        "blur",
-        this.handleBlur.bind(this, binding.value),
-    );
-    element!.removeEventListener('click', this.handleFocus.bind(this, binding.value))
-  };
-
-  private handleBlur(inputControl: InputControl<unknown>) {
-    inputControl!.runValidation(true);
-  }
-
-  private handleFocus(inputControl: InputControl<unknown>) {
-    if (inputControl.value || inputControl.getIsEmptySensitive()) return;
-
-    inputControl.setNotValidMessage('');
-  }
-}

package/src/baseForm/UseForm.ts

@@ -1,32 +0,0 @@
-import { reactive, ref, watch } from "vue";
-import { FormManager } from "./FormManager";
-import { FormValidationStatus } from "../constants";
-
-export function useForm(form: FormManager, hasCustomValidation = false) {
-  const reactiveForm = reactive<FormManager>(form);
-  const validationStatus = ref<FormValidationStatus>(
-    FormValidationStatus.Invalid,
-  );
-
-  watch(
-    () => reactiveForm.getInputControlsAsArray(),
-    () => {
-      if (hasCustomValidation) return;
-      reactiveForm.runValidation();
-      if (reactiveForm.getIsValid()) {
-        validationStatus.value = FormValidationStatus.Valid;
-      } else {
-        validationStatus.value = FormValidationStatus.Invalid;
-      }
-    },
-    {
-      immediate: true,
-      deep: true,
-    },
-  );
-
-  return {
-    reactiveForm,
-    validationStatus,
-  };
-}

package/src/baseForm/index.ts

@@ -1,8 +0,0 @@
-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/src/baseSchedule/Schedule.ts

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

package/src/baseSchedule/Scheduler.ts

@@ -1,29 +0,0 @@
-import type { Nullable } from '../types'
-import type { Schedule } from './Schedule'
-
-export class Scheduler {
-  private timerId: Nullable<ReturnType<typeof setTimeout>> = null
-  private readonly schedule: Schedule;
-
-  constructor(scheduler: Schedule) {
-    this.setupInterval = this.setupInterval.bind(this);
-    this.schedule = scheduler;
-  }
-
-  public setupInterval(intervalInMilliseconds: number) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const thisReference = this;
-    this.timerId = setTimeout(async function autoRefresh() {
-      await thisReference.schedule.runAction()
-      thisReference.timerId = setTimeout(() => {
-        autoRefresh()
-      }, intervalInMilliseconds);
-    }, intervalInMilliseconds);
-  }
-
-  public clearInterval() {
-    if (this.timerId) {
-      clearInterval(this.timerId);
-    }
-  }
-}

package/src/baseSchedule/index.ts

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

package/src/baseTable/BaseTable.ts

@@ -1,162 +0,0 @@
-import { SortDetail } from "../sort";
-import { BaseModel } from "../BaseModel";
-import { LoadingStatus, SortOrder, TableConstants } from "../constants";
-import { type Accessible, AccessLevel } from "../accessHandling";
-import type { TableHeaderSchema } from "./TableHeaderSchema";
-import type { TableService } from "./TableService";
-import type { TableAction } from "./TableAction";
-import type { Nullable } from "../types";
-import type { TableSummarySchema } from "./TableSummarySchema.ts";
-
-export abstract class BaseTable<Model extends BaseModel> {
-  protected service: TableService<Model>;
-  private accessService: AccessLevel;
-  protected currentPage: number = 1;
-  protected currentPageSize: number = 20;
-  private currentSortDetail: SortDetail<Model> = new SortDetail(
-    "id",
-    SortOrder.DESC,
-  );
-  protected loadedRows: Model[] = [];
-  public headerSchema: TableHeaderSchema<Model>[] = [];
-
-  protected constructor(service: TableService<Model>) {
-    this.service = service;
-    this.accessService = AccessLevel.GetInstance();
-  }
-
-  public addHeader(schema: TableHeaderSchema<Model>) {
-    this.headerSchema.push(schema);
-  }
-
-  public async load() {
-    this.headerSchema = this.filterItemsBaseOnAccessLevel(
-      await this.loadHeader(),
-    );
-    await this.loadRows();
-  }
-
-  protected filterItemsBaseOnAccessLevel<T>(items: Accessible[]): T[] {
-    return items.filter((item) => {
-      if (item.hasAccess) {
-        return item.hasAccess();
-      }
-      return true;
-    }) as T[];
-  }
-
-  public async sort(sortDetail: SortDetail<Model>) {
-    if (!this.shouldSendSortRequest(sortDetail)) return;
-    this.currentSortDetail = sortDetail;
-    this.loadedRows = (await this.handleSort(this.currentSortDetail)).items;
-  }
-
-  private shouldSendSortRequest(sortDetail: SortDetail<Model>): boolean {
-    return (
-      sortDetail.key !== this.currentSortDetail.key ||
-      sortDetail.order !== this.currentSortDetail.order
-    );
-  }
-
-  public async paginate(nextPage: number, pageSize: number) {
-    if (!this.shouldSendPaginationRequest(nextPage, pageSize)) return;
-    this.currentPage = nextPage;
-    this.currentPageSize = pageSize;
-    this.loadedRows = (
-      await this.handlePagination(this.currentPage, this.currentPageSize)
-    ).items;
-  }
-
-  private shouldSendPaginationRequest(
-    nextPage: number,
-    pageSize: number,
-  ): boolean {
-    return this.currentPage !== nextPage || this.currentPageSize !== pageSize;
-  }
-
-  protected async loadRows() {
-    this.loadedRows = (await this.service.fetchRows()).items;
-    return this.loadedRows;
-  }
-
-  public getData() {
-    return this.service.getData();
-  }
-
-  protected async handleSort(sortDetail: SortDetail<Model>) {
-    return await this.service.sort(sortDetail);
-  }
-
-  protected async handlePagination(nextPage: number, pageSize: number) {
-    return await this.service.paginate(nextPage, pageSize);
-  }
-
-  public getItemCountPerPage(): number {
-    return TableConstants.DEFAULT_ITEM_COUNT_PER_PAGE;
-  }
-
-  public isLoading() {
-    const loadingStatuses = this.getLoadingStatuses();
-    return (
-      loadingStatuses.has(LoadingStatus.Search) ||
-      loadingStatuses.has(LoadingStatus.FetchList) ||
-      loadingStatuses.has(LoadingStatus.Sort) ||
-      loadingStatuses.has(LoadingStatus.FetchLastItems) ||
-      loadingStatuses.has(LoadingStatus.FetchPreviousItems)
-    );
-  }
-
-  protected getLoadingStatuses() {
-    return this.getData().loadingStatus;
-  }
-
-  public hasAnyAction() {
-    for (const row of this.loadedRows) {
-      if (this.getAccessedActions(row).length) return true;
-    }
-    return false;
-  }
-
-  public getAccessedActions(row: Model): TableAction<Model>[] {
-    return this.filterItemsBaseOnAccessLevel(this.getActions(row));
-  }
-
-  protected getActions(row: Model): TableAction<Model>[] {
-    return [];
-  }
-
-  public getScrollDetail(): Nullable<boolean | { x?: number; y?: number }> {
-    return null;
-  }
-
-  public isExpandable() {
-    return false;
-  }
-
-  public async handleClick(row: Model) {
-    return;
-  }
-
-  public async handleMetaClick(row: Model) {
-    return;
-  }
-
-  public async handleDoubleClick(row: Model) {
-    return;
-  }
-
-  public async onDestroy() {
-    return;
-  }
-
-  public async loadHeader(): Promise<TableHeaderSchema<Model>[]> {
-    throw new Error("No header provided for the table.");
-  }
-
-  public loadSummarySchema(): TableSummarySchema {
-    return {
-      summaryTitle: "",
-      summaryItems: [],
-    };
-  }
-}

package/src/baseTable/Constants.ts

@@ -1,26 +0,0 @@
-import type { TableHeaderSchema } from "./TableHeaderSchema";
-import { BaseModel } from "../BaseModel";
-import { CellType, HeaderType, TableHeaderAlign } from "../constants";
-
-export const TABLE_COLUMN_DEFAULT_WIDTH = "150px";
-export const TABLE_COLUMN_DEFAULT_COLSPAN = 2;
-
-export const TABLE_ACTION_COLUMN: TableHeaderSchema<BaseModel> = {
-  path: "id",
-  key: "id",
-  title: "عملیات",
-  colspan: TABLE_COLUMN_DEFAULT_COLSPAN,
-  width: TABLE_COLUMN_DEFAULT_WIDTH,
-  cellType: CellType.ACTION,
-  align: TableHeaderAlign.Center,
-  headerType: HeaderType.Text,
-  accessLevel: null,
-};
-
-export const TABLE_COLUMN_DEFAULT_VALUES = {
-  width: TABLE_COLUMN_DEFAULT_WIDTH,
-  align: TableHeaderAlign.Center,
-  headerType: HeaderType.Text,
-  cellType: CellType.Text,
-  colspan: TABLE_COLUMN_DEFAULT_COLSPAN,
-};

package/src/baseTable/OnDestory.ts

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

package/src/baseTable/RowActionSource.ts

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

package/src/baseTable/RowClick.ts

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

package/src/baseTable/RowDoubleClick.ts

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

package/src/baseTable/RowMetaClick.ts

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

package/src/baseTable/SelectableTable.ts

@@ -1,86 +0,0 @@
-import { BaseTable } from './BaseTable'
-import { BehaviorSubject } from '../observables/BehaviorSubject'
-import { type SortDetail } from '../sort'
-import type { BaseModel } from '../BaseModel'
-import type { TableService } from './TableService'
-
-export abstract class SelectableTable<
-  Model extends BaseModel,
-> extends BaseTable<Model> {
-  public selectedRows: BehaviorSubject<Map<number, Model>> =
-    new BehaviorSubject(new Map<number, Model>());
-
-  constructor(service: TableService<Model>) {
-    super(service);
-    this.rowSelect = this.rowSelect.bind(this);
-    this.selectAll = this.selectAll.bind(this);
-    this.isEveryRowSelected = this.isEveryRowSelected.bind(this);
-    this.handlePagination = this.handlePagination.bind(this);
-    this.clearAllSelectedItems = this.clearAllSelectedItems.bind(this);
-    this.getSelectedRows = this.getSelectedRows.bind(this);
-    this.getSelectedRowsAsArray = this.getSelectedRowsAsArray.bind(this);
-    this.getSelectedRowIds = this.getSelectedRowIds.bind(this);
-  }
-
-  public rowSelect(row: Model) {
-    if (this.getSelectedRowsValue().has(row.id)) {
-      this.getSelectedRowsValue().delete(row.id);
-      this.selectedRows.next(this.selectedRows.getValue());
-    } else {
-      this.selectedRows.getValue().set(row.id, row);
-      this.selectedRows.next(this.selectedRows.getValue());
-    }
-  }
-
-  public selectAll() {
-    if (this.isEveryRowSelected()) {
-      this.clearAllSelectedItems();
-    } else {
-      for (const row of this.loadedRows) {
-        this.selectedRows.getValue().set(row.id, row);
-        this.selectedRows.next(this.selectedRows.getValue());
-      }
-    }
-  }
-
-  private isEveryRowSelected() {
-    return (
-      this.getSelectedRowsValue().size === this.currentPageSize ||
-      this.loadedRows.length === this.getSelectedRowsValue().size
-    );
-  }
-
-  protected override async handlePagination(
-    nextPage: number,
-    pageSize: number,
-  ) {
-    this.clearAllSelectedItems();
-    return await super.handlePagination(nextPage, pageSize);
-  }
-
-  protected override async handleSort(sortDetail: SortDetail<Model>) {
-    this.clearAllSelectedItems();
-    return await super.handleSort(sortDetail);
-  }
-
-  public clearAllSelectedItems() {
-    this.selectedRows.getValue().clear();
-    this.selectedRows.next(this.selectedRows.getValue());
-  }
-
-  public getSelectedRows() {
-    return this.selectedRows;
-  }
-
-  public getSelectedRowsAsArray() {
-    return Array.from(this.selectedRows.getValue().values());
-  }
-
-  public getSelectedRowIds() {
-    return Array.from(this.selectedRows.getValue().keys());
-  }
-
-  public getSelectedRowsValue() {
-    return this.selectedRows.getValue();
-  }
-}