@sarafapp/iron_core 1.0.62 → 1.0.64

package/src/baseTable/TableAction.ts

@@ -0,0 +1,10 @@
+import type { 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/src/baseTable/TableHeaderSchema.ts

@@ -0,0 +1,44 @@
+import {
+  CellType,
+  HeaderType,
+  LoadingStatus,
+  SortOrder,
+  TableHeaderAlign,
+} from "../constants";
+import { TABLE_COLUMN_DEFAULT_VALUES } from "./Constants";
+import type { 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 function generateHeader<Model>(
+  header: TableHeaderSchema<Model>,
+): TableHeaderSchema<Model> {
+  return {
+    ...TABLE_COLUMN_DEFAULT_VALUES,
+    ...header,
+  };
+}

package/src/baseTable/TableLoader.ts

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

package/src/baseTable/TablePaginate.ts

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

package/src/baseTable/TableService.ts

@@ -0,0 +1,10 @@
+import { SortDetail } from "../sort";
+import { FetchListResponse } from '../repository/model'
+import type { 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/src/baseTable/TableSort.ts

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

package/src/baseTable/TableSummarySchema.ts

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

package/src/baseTable/generator/SelectableTableGenerator.ts

@@ -0,0 +1,65 @@
+import { TableGenerator } from "./TableGenerator";
+import { type TableSource } from "./TableSource";
+import { BehaviorSubject } from "../../observables";
+
+export class SelectableTableGenerator<T> extends TableGenerator<T> {
+  public selectedRows: BehaviorSubject<Map<number, T>> = new BehaviorSubject(
+    new Map(),
+  );
+
+  constructor(tableSource: TableSource<T>) {
+    super(tableSource);
+    this.selectRow = this.selectRow.bind(this);
+    this.selectAll = this.selectAll.bind(this);
+    this.isEveryRowSelected = this.isEveryRowSelected.bind(this);
+    this.clearAllSelectedItems = this.clearAllSelectedItems.bind(this);
+    this.getSelectedRowsAsArray = this.getSelectedRowsAsArray.bind(this);
+    this.getSelectedRowIds = this.getSelectedRowIds.bind(this);
+  }
+
+  public selectRow(row: T) {
+    const selectedRows = this.getSelectedRows();
+    if (selectedRows.has(row["id"])) {
+      selectedRows.delete(row["id"]);
+      this.selectedRows.next(this.selectedRows.getValue());
+    } else {
+      selectedRows.set(row["id"], row);
+      this.selectedRows.next(this.selectedRows.getValue());
+    }
+  }
+
+  public selectAll() {
+    if (this.isEveryRowSelected()) {
+      this.clearAllSelectedItems();
+    } else {
+      for (const row of this.rows.getValue()) {
+        this.selectedRows.getValue().set(row["id"], row);
+        this.selectedRows.next(this.selectedRows.getValue());
+      }
+    }
+  }
+
+  private isEveryRowSelected() {
+    return (
+      this.getSelectedRows().size === this.currentPageSize.getValue() ||
+      this.rows.getValue().length === this.getSelectedRows().size
+    );
+  }
+
+  public clearAllSelectedItems() {
+    this.getSelectedRows().clear();
+    this.selectedRows.next(this.selectedRows.getValue);
+  }
+
+  public getSelectedRows() {
+    return this.selectedRows.getValue();
+  }
+
+  public getSelectedRowsAsArray() {
+    return Array.from(this.selectedRows.getValue().values());
+  }
+
+  public getSelectedRowIds() {
+    return Array.from(this.selectedRows.getValue().keys());
+  }
+}

package/src/baseTable/generator/TableCellComponentRegistry.ts

@@ -0,0 +1,15 @@
+import { type Initializer } from "../../initializer";
+
+export abstract class TableCellComponentRegistry implements Initializer {
+  private registeredComponents: Map<string, unknown> = new Map();
+
+  public initialize(): void {
+    this.registerComponents();
+  }
+
+  protected abstract registerComponents(): void;
+
+  public getRegisteredComponents() {
+    return this.registeredComponents;
+  }
+}

package/src/baseTable/generator/TableConfig.ts

@@ -0,0 +1,18 @@
+import { TableCellComponentRegistry } from "./TableCellComponentRegistry";
+
+export class TableConfig {
+  private cellComponentRegistry: TableCellComponentRegistry;
+
+  constructor() {
+    this.setCellComponentRegistry = this.setCellComponentRegistry.bind(this);
+    this.getCellComponentRegistry = this.getCellComponentRegistry.bind(this);
+  }
+
+  public setCellComponentRegistry(registry: TableCellComponentRegistry) {
+    this.cellComponentRegistry = registry;
+  }
+
+  public getCellComponentRegistry() {
+    return this.cellComponentRegistry;
+  }
+}

package/src/baseTable/generator/TableGenerator.ts

@@ -0,0 +1,147 @@
+import { BehaviorSubject } from "../../observables";
+import { SortDetail } from "../../sort";
+import { SortOrder } from "../../constants";
+import { type TableHeaderSchema } from "../TableHeaderSchema";
+import { type Nullable } from "../../types";
+import { type TableSummarySchema } from "../TableSummarySchema";
+import { type TableSource } from "./TableSource";
+import { type Accessible, AccessLevel } from "../../accessHandling";
+import { type TableAction } from "../TableAction";
+
+export class TableGenerator<T> {
+  public rows: BehaviorSubject<T[]> = new BehaviorSubject<T[]>([]);
+  public headerSchema: BehaviorSubject<TableHeaderSchema<T>[]> =
+    new BehaviorSubject([]);
+
+  public currentPage: BehaviorSubject<number> = new BehaviorSubject<number>(1);
+  public currentPageSize: BehaviorSubject<number> = new BehaviorSubject(20);
+  public totalItems: BehaviorSubject<number> = new BehaviorSubject<number>(0);
+  protected currentSortDetail: BehaviorSubject<SortDetail<T>> =
+    new BehaviorSubject<SortDetail<T>>(new SortDetail("id", SortOrder.DESC));
+
+  public scrollDetail: BehaviorSubject<
+    Nullable<boolean | { x?: number; y?: number }>
+  > = new BehaviorSubject(null);
+
+  public isExpandable: BehaviorSubject<boolean> = new BehaviorSubject(false);
+
+  protected tableSource: TableSource<T>;
+  protected accessService: AccessLevel;
+
+  constructor(tableSource: TableSource<T>) {
+    this.tableSource = tableSource;
+    this.accessService = AccessLevel.GetInstance();
+    this.load = this.load.bind(this);
+    this.paginate = this.paginate.bind(this);
+    this.shouldSendSortRequest = this.shouldSendSortRequest.bind(this);
+    this.sort = this.sort.bind(this);
+    this.handleClick = this.handleClick.bind(this);
+    this.handleMetaClick = this.handleMetaClick.bind(this);
+    this.handleDoubleClick = this.handleDoubleClick.bind(this);
+    this.hasAnyAction = this.hasAnyAction.bind(this);
+    this.loadSummarySchema = this.loadSummarySchema.bind(this);
+    this.filterItemsBaseOnAccessLevel =
+      this.filterItemsBaseOnAccessLevel.bind(this);
+    this.paginate = this.paginate.bind(this);
+    this.shouldSendPaginationRequest =
+      this.shouldSendPaginationRequest.bind(this);
+    this.getRowActions = this.getRowActions.bind(this);
+    this.onDestroy = this.onDestroy.bind(this);
+  }
+
+  public async load(): Promise<void> {
+    this.rows.next(await this.tableSource.loadRows());
+
+    this.headerSchema.next(
+      this.filterItemsBaseOnAccessLevel(
+        await this.tableSource.loadHeaderSchema(),
+      ),
+    );
+  }
+
+  public async paginate(nextPage: number, pageSize: number): Promise<void> {
+    if (!this.shouldSendPaginationRequest(nextPage, pageSize)) return;
+
+    this.currentPage.next(nextPage);
+    this.currentPageSize.next(pageSize);
+
+    this.rows.next(await this.tableSource.paginate(nextPage, pageSize));
+  }
+
+  private shouldSendPaginationRequest(
+    nextPage: number,
+    pageSize: number,
+  ): boolean {
+    return (
+      this.currentPage.getValue() !== nextPage ||
+      this.currentPageSize.getValue() !== pageSize
+    );
+  }
+
+  public async sort(sortDetail: SortDetail<T>) {
+    if (!this.shouldSendSortRequest(sortDetail)) return;
+    this.currentSortDetail.next(sortDetail);
+    this.rows.next(await this.tableSource.sort(sortDetail));
+  }
+
+  private shouldSendSortRequest(sortDetail: SortDetail<T>): boolean {
+    return (
+      sortDetail.key !== this.currentSortDetail.getValue().key ||
+      sortDetail.order !== this.currentSortDetail.getValue().order
+    );
+  }
+
+  public async handleClick(row: T): Promise<void> {
+    if (this.tableSource["onRowClick"]) {
+      await this.tableSource["onRowClick"](row);
+    }
+  }
+
+  public async handleMetaClick(row: T): Promise<void> {
+    if (this.tableSource["onRowMetaClick"]) {
+      await this.tableSource["onRowMetaClick"](row);
+    }
+  }
+
+  public async handleDoubleClick(row: T): Promise<void> {
+    if (this.tableSource["onRowDoubleClick"]) {
+      await this.tableSource["onRowDoubleClick"](row);
+    }
+  }
+
+  public hasAnyAction() {
+    for (const row of this.rows.getValue()) {
+      if (this.getRowActions(row).length) return true;
+    }
+    return false;
+  }
+
+  public getRowActions(row: T): TableAction<T>[] {
+    return this.filterItemsBaseOnAccessLevel(
+      this.tableSource.loadRowActions(row),
+    );
+  }
+
+  public loadSummarySchema(): TableSummarySchema {
+    if (this.tableSource["loadSummarySchema"]) {
+      return this.tableSource["loadSummarySchema"]();
+    }
+    return {
+      summaryTitle: "",
+      summaryItems: [],
+    };
+  }
+
+  private filterItemsBaseOnAccessLevel<T>(items: Accessible[]): T[] {
+    return items.filter((item) => {
+      if (item.hasAccess) {
+        return item.hasAccess();
+      }
+      return true;
+    }) as T[];
+  }
+
+  public async onDestroy(): Promise<void> {
+    this.tableSource.onTableDestroy();
+  }
+}

package/src/baseTable/generator/TableSource.ts

@@ -0,0 +1,34 @@
+import { TableHeaderSchema } from "../TableHeaderSchema";
+import { SortDetail } from "../../sort";
+import { TableSummarySchema } from "../TableSummarySchema";
+import { TableAction } from "../TableAction";
+
+export interface TableSource<T> {
+  loadRows(): Promise<T[]>;
+
+  loadHeaderSchema(): Promise<TableHeaderSchema<T>[]>;
+
+  loadRowActions(row: T): TableAction<T>[];
+
+  paginate(nextPage: number, pageSize: number): Promise<T[]>;
+
+  sort(sortDetail: SortDetail<T>): Promise<T[]>;
+
+  onTableDestroy(): void;
+}
+
+export interface RowClick<T> extends TableSource<T> {
+  onRowClick(row: T): Promise<void>;
+}
+
+export interface RowMetaClick<T> extends TableSource<T> {
+  onRowMetaClick(row: T): Promise<void>;
+}
+
+export interface handleDoubleClick<T> extends TableSource<T> {
+  onRowDoubleClick(row: T): Promise<void>;
+}
+
+export interface TableSummary<T> extends TableSource<T> {
+  loadSummarySchema(): Promise<TableSummarySchema>;
+}

package/src/baseTable/index.ts

@@ -0,0 +1,43 @@
+export type { TableAction } from "./TableAction";
+export type { TableService } from "./TableService";
+export type { Destroy } from "./OnDestory";
+export type { RowActionSource } from "./RowActionSource";
+export type { TableLoader } from "./TableLoader";
+export type { TablePaginate } from "./TablePaginate";
+export {
+  TABLE_ACTION_COLUMN,
+  TABLE_COLUMN_DEFAULT_VALUES,
+  TABLE_COLUMN_DEFAULT_COLSPAN,
+  TABLE_COLUMN_DEFAULT_WIDTH,
+} from "./Constants";
+export { BaseTable } from "./BaseTable";
+export { SelectableTable } from "./SelectableTable";
+export {
+  type TableHeaderSchema,
+  type TableRenderingData,
+  generateHeader,
+} from "./TableHeaderSchema";
+export {
+  type TableSummaryItem,
+  type TableSummarySchema,
+} from "./TableSummarySchema";
+export { Column } from "./moduleConnection/Column";
+export { Table } from "./moduleConnection/Table";
+export { Action } from "./moduleConnection/Action";
+export { TableDestroy } from "./moduleConnection/TableDestroy";
+export { TableRowClick } from "./moduleConnection/TableRowClick";
+
+// Table Generator
+export {
+  type TableSource,
+  type TableSummary,
+  type RowClick,
+  type RowMetaClick,
+  type handleDoubleClick,
+} from "./generator/TableSource";
+export { SelectableTableGenerator } from "./generator/SelectableTableGenerator";
+export { TableGenerator } from "./generator/TableGenerator";
+export { TableConfig } from "./generator/TableConfig";
+export { TableCellComponentRegistry } from "./generator/TableCellComponentRegistry";
+export { GColumn } from "./moduleConnection/generator/GColumn";
+export { GTable } from "./moduleConnection/generator/GTable";

package/src/baseTable/moduleConnection/Action.ts

@@ -0,0 +1,12 @@
+import { type ActionDecorator } from '../TableAction'
+import type { BaseModel } from '../../BaseModel'
+
+export function Action<Model extends BaseModel>(actionDetail: Omit<ActionDecorator<Model>, 'handler'>) {
+  return function ActionDecorator(target: BaseModel, _propertyKey: string, propertyDescriptor: PropertyDescriptor) {
+    if (!target.constructor.prototype.actions) {
+      target.constructor.prototype.actions = []
+    }
+    (actionDetail as ActionDecorator<Model>).handler = propertyDescriptor.value
+    target.constructor.prototype.actions.push(actionDetail)
+  }
+}

package/src/baseTable/moduleConnection/Column.ts

@@ -0,0 +1,11 @@
+import type { TableHeaderSchema } from '../TableHeaderSchema'
+import type { BaseModel } from '../../BaseModel'
+
+export function Column<Model extends BaseModel>(header: TableHeaderSchema<Model>) {
+  return function ColumnDecorator(target: BaseModel, propertyKey: string) {
+    if (!target.constructor.prototype.headers) {
+      target.constructor.prototype.headers = []
+    }
+    target.constructor.prototype.headers.push({path: propertyKey, ...header });
+  }
+}

package/src/baseTable/moduleConnection/Table.ts

@@ -0,0 +1,49 @@
+import { BaseTable, type TableHeaderSchema } from "../index";
+import { type ActionDecorator, type TableAction } from "../TableAction";
+import type { BaseModel } from "../../BaseModel";
+import type { SelectableTable } from "../SelectableTable";
+
+export function Table<Model extends BaseModel>(
+  table: typeof BaseTable<Model> | typeof SelectableTable<Model>,
+) {
+  return function TableDecorator(constructor: Function) {
+    async function loadHeader(): Promise<TableHeaderSchema<Model>[]> {
+      constructor.prototype._table = this as BaseTable<Model>;
+      return constructor.prototype.headers;
+    }
+
+    function getActions(row: Model): TableAction<Model>[] {
+      const tableActions: TableAction<Model>[] = [];
+      const modelActions = (constructor.prototype.actions ||
+        []) as ActionDecorator<Model>[];
+
+      for (const action of modelActions) {
+        if (!action.isAvailable(row)) continue;
+        const actionToPush: TableAction<Model> = {
+          handler: action.handler.bind(row),
+          accessLevel: action.accessLevel,
+          actionName: action.actionName,
+        };
+        tableActions.push(actionToPush);
+      }
+      return tableActions;
+    }
+
+    async function rowClick(row: Model) {
+      if (constructor.prototype.rowClick) {
+        await constructor.prototype.rowClick.call(row);
+      }
+    }
+
+    async function onDestroy() {
+      if (constructor.prototype.tableDestroy) {
+        await constructor.prototype.tableDestroy();
+      }
+    }
+
+    table.prototype.loadHeader = loadHeader;
+    table.prototype.getActions = getActions;
+    table.prototype.handleClick = rowClick;
+    table.prototype.onDestroy = onDestroy;
+  };
+}

package/src/baseTable/moduleConnection/TableDestroy.ts

@@ -0,0 +1,7 @@
+import type { BaseModel } from '../../BaseModel'
+
+export function TableDestroy() {
+  return function TableDestroyDecorator(target: BaseModel, _propertyKey: string, descriptor: PropertyDescriptor) {
+    target.constructor.prototype.tableDestroy = descriptor.value;
+  }
+}

package/src/baseTable/moduleConnection/TableRowClick.ts

@@ -0,0 +1,7 @@
+import type { BaseModel } from '../../BaseModel'
+
+export function TableRowClick() {
+  return function TableRowClickDecorator(target: BaseModel, _propertyKey: string, descriptor: PropertyDescriptor) {
+    target.constructor.prototype.rowClick = descriptor.value;
+  }
+}

package/src/baseTable/moduleConnection/generator/GColumn.ts

@@ -0,0 +1,10 @@
+import { type TableHeaderSchema } from "../../index";
+
+export function GColumn<T>(header: TableHeaderSchema<T>) {
+  return function GColumnDecorator(target: T, propertyKey: string) {
+    if (!target.constructor.prototype.headers) {
+      target.constructor.prototype.headers = [];
+    }
+    target.constructor.prototype.headers.push({ path: propertyKey, ...header });
+  };
+}

package/src/baseTable/moduleConnection/generator/GTable.ts

@@ -0,0 +1,11 @@
+import { TableSource } from "../../generator/TableSource";
+
+export function GTable<T>(table: new (...args: any[]) => TableSource<T>) {
+  return function GTableDecorator(constructor: Function) {
+    async function loadHeaderSchema() {
+      return constructor.prototype.headers || [];
+    }
+
+    (table as any).prototype.loadHeaderSchema = loadHeaderSchema;
+  };
+}

package/src/composables/UseCrud.ts

@@ -0,0 +1,53 @@
+import { computed, type Ref, ref } from 'vue'
+import type { BaseModel } from '../BaseModel'
+
+export function useCrud<Entity extends BaseModel>() {
+  const entityItems: Ref<Map<string, Entity>> = ref(new Map<string, Entity>()) as Ref<Map<string, Entity>>
+  const totalCount = ref<number>(0);
+
+  const getTotalCount = computed<number>(() => {
+    return totalCount.value;
+  })
+
+  const entityItemsAsArray = computed<Entity[]>(() => {
+    return Array.from(entityItems.value.values()) as Entity[]
+  })
+
+  function setTotalCount(count: number) {
+    totalCount.value = count;
+  }
+
+  function addOrReplaceItems(items: Entity[]) {
+    for (const item of items) {
+      addOrReplaceItem(item)
+    }
+  }
+
+  function addOrReplaceItem(item: Entity) {
+    entityItems.value.set(String(item.id), item as Entity)
+  }
+
+  function removeById(id: string | number) {
+    const itemToRemove = getItemById(id)
+    entityItems.value.delete(String(id))
+    return itemToRemove
+  }
+
+  function getItemById(id: number | string) {
+    return entityItems.value.get(String(id)) || null
+  }
+
+  function clearItems() {
+    entityItems.value.clear()
+  }
+
+  return {
+    entityItemsAsArray,
+    addOrReplaceItems,
+    removeById,
+    getItemById,
+    clearItems,
+    setTotalCount,
+    getTotalCount
+  }
+}

package/src/composables/UseData.ts

@@ -0,0 +1,70 @@
+import { computed, type Ref, ref } from "vue";
+import { BaseModel } from "../BaseModel";
+import type { Nullable } from "../types";
+
+export function useData<Model extends BaseModel>() {
+  const items: Ref<Map<number, Model>> = ref<Map<number, Model>>(
+    new Map<number, Model>(),
+  ) as Ref<Map<number, Model>>;
+
+  const totalCount = ref<number>(0);
+  const currentItem = ref<Nullable<Model>>(null);
+
+  const itemsAsArray = computed<Model[]>(() => {
+    return Array.from(items.value.values()) as Model[];
+  });
+
+  function setTotalCount(totalItems: number) {
+    totalCount.value = totalItems;
+  }
+
+  function addOrReplaceItems(itemsToAdd: Model[]) {
+    for (const item of itemsToAdd) {
+      addOrReplaceItem(item);
+    }
+  }
+
+  function addOrReplaceItem(item: Model) {
+    items.value.set(item.id, item);
+  }
+
+  function getById(id: number): Nullable<Model> {
+    currentItem.value = items.value.get(id) || null;
+    return currentItem.value;
+  }
+
+  function removeById(id: number): boolean {
+    const removedItem = getById(id);
+
+    if (removedItem) {
+      items.value.delete(id);
+    }
+
+    return Boolean(removedItem);
+  }
+
+  function clearItems() {
+    items.value.clear();
+  }
+
+  function setCurrentItem(item: Nullable<Model>) {
+    currentItem.value = item;
+  }
+
+  function clearCurrentItem() {
+    currentItem.value = null;
+  }
+
+  return {
+    itemsAsArray,
+    totalCount,
+    currentItem,
+    setTotalCount,
+    addOrReplaceItems,
+    getById,
+    removeById,
+    clearItems,
+    setCurrentItem,
+    clearCurrentItem,
+  };
+}