@sarafapp/iron_core 1.0.64 → 1.0.66

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();
-  }
-}

package/src/baseTable/TableAction.ts

@@ -1,10 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

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

package/src/baseTable/TablePaginate.ts

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

package/src/baseTable/TableService.ts

@@ -1,10 +0,0 @@
-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

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

package/src/baseTable/TableSummarySchema.ts

@@ -1,11 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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 });
-  };
-}