npm - @sarafapp/iron_core - Versions diffs - 1.0.63 → 1.0.64 - Mend

@sarafapp/iron_core 1.0.63 → 1.0.64

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (320) hide show

package/src/process/Proccess.ts ADDED Viewed

@@ -0,0 +1,21 @@
+import type { Nullable } from '../types/Global'
+import { ProcessManager } from './ProcessManager'
+export abstract class Process {
+  public name: string;
+  public next: Nullable<Process> = null;
+  constructor(name: string, next: Nullable<Process>) {
+    this.name = name
+    this.next = next
+  }
+  public addToManager(manager: ProcessManager) {
+    manager.setProcessToMap(this)
+    if (this.next) {
+      this.next.addToManager(manager)
+    }
+  }
+  public abstract execute(): Promise<void>
+}

package/src/process/ProcessManager.ts ADDED Viewed

@@ -0,0 +1,31 @@
+import { Process } from './Proccess';
+export class ProcessManager {
+  private mapProcesses = new Map<string, Process>()
+  private processes: Process
+  constructor(process: Process) {
+    this.processes = process
+    this.assignProcessManager()
+  }
+  private assignProcessManager() {
+    this.processes.addToManager(this)
+  }
+  public setProcessToMap(process: Process) {
+    this.mapProcesses.set(process.name, process)
+  }
+  public async start() {
+    await this.processes.execute()
+  }
+  public async startFrom(processName: string) {
+    const process = this.mapProcesses.get(processName)
+    if(!process) {
+      throw new Error(`Process ${processName} not found`)
+    }
+    await process.execute()
+  }
+}

package/src/process/index.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { ProcessManager } from './ProcessManager.ts';
2	+ export { Process } from './Proccess'

package/src/repository/Params.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { SortDetail } from "../sort";
+import { SortOrder } from "../constants";
+import { BaseModel } from "../BaseModel";
+export class Params {
+  pageNumber: number = 1;
+  itemCount: number = 20;
+  sortDetail: SortDetail<BaseModel> = new SortDetail("id", SortOrder.DESC);
+  filters: { key: string; value: unknown }[] = [];
+}

package/src/repository/Repository.ts ADDED Viewed

@@ -0,0 +1,44 @@
+import { BaseModel } from "../BaseModel";
+import { FetchListResponse } from "./model";
+import { type Nullable } from "../types";
+import type { SyncDetail } from "./SyncDetail";
+export interface Repository<Model extends BaseModel> {
+  /**
+   * Fetches a list of items based on optional query parameters.
+   * @param query - Optional query parameters.
+   * @returns A promise resolving to an array of items or undefined.
+   */
+  fetchList(query?: Record<string, unknown>): Promise<FetchListResponse<Model>>;
+  /**
+   * Fetches a single item by its ID.
+   * @param id - ID of the item to retrieve.
+   * @returns A promise resolving to the fetched item or undefined.
+   */
+  fetchItemById(id: number): Promise<Nullable<Model>>;
+  /**
+   * Creates a new item.
+   * @param body - Data for creating the item.
+   * @returns A promise resolving to the created item or undefined.
+   */
+  createItem<Body>(body: Body): Promise<Nullable<Model>>;
+  /**
+   * Updates an existing item by its ID.
+   * @param id - ID of the item to update.
+   * @param body - Updated data for the item.
+   * @returns A promise resolving to the updated item or undefined.
+   */
+  updateItem<Body>(id: number, body: Body): Promise<Nullable<Model>>;
+  /**
+   * Deletes an item by its ID.
+   * @param id - ID of the item to delete.
+   * @returns A promise resolving to a boolean indicating if the deletion was successful.
+   */
+  deleteItem(id: number): Promise<boolean>;
+  getSyncDetail(): SyncDetail;
+}

package/src/repository/SyncDetail.ts ADDED Viewed

@@ -0,0 +1,8 @@
+export class SyncDetail {
+  public shouldKeepSync: boolean;
+  public intervalInMillisecond: number;
+  constructor(shouldKeepSync: boolean, intervalInMillisecond: number) {
+    this.shouldKeepSync = shouldKeepSync;
+    this.intervalInMillisecond = intervalInMillisecond;
+  }
+}

package/src/repository/index.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export { Params } from "./Params";
+export { type Repository } from "./Repository";
+export { FetchListResponse } from './model'
+export { SyncDetail } from './SyncDetail'

package/src/repository/model.ts ADDED Viewed

@@ -0,0 +1,9 @@
+export class FetchListResponse<Model> {
+  public items: Model[]
+  public totalItems: number
+  constructor(items: Model[], totalItems: number) {
+    this.items = items
+    this.totalItems = totalItems
+  }
+}

package/src/routeGuard/RouteGuard.ts ADDED Viewed

@@ -0,0 +1,38 @@
+export abstract class RouteGuard {
+    protected constructor() {
+        this.checkAccessibility = this.checkAccessibility.bind(this);
+        this.isAccessible = this.isAccessible.bind(this);
+        this.getDestinationRouteName = this.getDestinationRouteName.bind(this);
+    }
+    public async checkAccessibility(to: unknown, from: unknown, next: CallableFunction) {
+        if (await this.isAccessible(to, from)) {
+            next();
+            return;
+        }
+        if (await this.getDestinationRouteName()) {
+            next({name: await this.getDestinationRouteName()})
+            return;
+        }
+        if (await this.getDestinationRouteLocation(to, from)) {
+            next(await this.getDestinationRouteLocation(to, from));
+            return;
+        }
+        next(false);
+    }
+    protected abstract isAccessible(to: unknown, from: unknown): Promise<boolean>
+    protected async getDestinationRouteName(): Promise<string> {
+        return ''
+    }
+    protected async getDestinationRouteLocation(to: unknown, from: unknown): Promise<unknown> {
+        return null
+    }
+}

package/src/routeGuard/index.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { RouteGuard } from './RouteGuard'

package/src/search/client/ClientArraySearch.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import { ClientSearch } from "./ClientSearch";
+import { Util } from "../../lib/Util";
+export class ClientArraySearch<T> extends ClientSearch {
+  public search(
+    items: T[],
+    phrase: string,
+    column: (item: T) => (string | number)[],
+  ) {
+    const matchedItems: T[] = [];
+    item: for (const item of items) {
+      for (const value of column(item)) {
+        if (
+          Util.removeSpacesFromString(String(value).toLowerCase()).indexOf(
+            Util.removeSpacesFromString(String(phrase).toLowerCase()),
+          ) > -1
+        ) {
+          matchedItems.push(item);
+          continue item;
+        }
+      }
+    }
+    return matchedItems;
+  }
+}

package/src/search/client/ClientSearch.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export abstract class ClientSearch {
+  abstract search(items: unknown, phrase: string, column: (item: unknown) => (string | number)[]): unknown
+}

package/src/search/index.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { ClientSearch } from './client/ClientSearch'
2	+ export { ClientArraySearch } from './client/ClientArraySearch'

package/src/sort/SortDetail.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import { SortOrder } from "../constants";
+export class SortDetail<T> {
+  public key: keyof T;
+  public order: SortOrder;
+  constructor(key: keyof T, order: SortOrder) {
+    this.key = key;
+    this.order = order;
+  }
+}

package/src/sort/client/Sorter.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { SortOrder } from "../../constants/Constants";
+import { SortStrategy } from "../strategies/SortStrategy";
+import { SimpleSort } from "../strategies/SimpleSort";
+export class Sorter {
+  public arrayOfObjectSort<T>(
+    items: T[],
+    by: keyof T,
+    order: SortOrder,
+    strategy: SortStrategy<T> = new SimpleSort(),
+  ): T[] {
+    if (order === SortOrder.ASC) {
+      return strategy.aSort(items, by);
+    }
+    return strategy.bSort(items, by);
+  }
+  public arraySort(
+    items: number[] | string[],
+    order: SortOrder,
+    strategy: SortStrategy<string | number> = new SimpleSort(),
+  ) {
+    if (order === SortOrder.ASC) {
+      return strategy.aSort(items);
+    }
+    return strategy.bSort(items);
+  }
+}

package/src/sort/index.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export { SortDetail } from './SortDetail';
+export * from './client/Sorter';
+export * from './strategies/SortStrategy';
+export * from './strategies/SimpleSort';

package/src/sort/strategies/SimpleSort.ts ADDED Viewed

@@ -0,0 +1,35 @@
+import { SortStrategy } from "./SortStrategy";
+export class SimpleSort<T> implements SortStrategy<T> {
+  aSort(items: T[], by?: keyof T): T[] {
+    return items.sort((a: T, b: T) => {
+      const aItem = a[by as keyof T] ?? a;
+      const bItem = b[by as keyof T] ?? b;
+      if (typeof aItem === "string" && typeof bItem === "string") {
+        return aItem.localeCompare(bItem);
+      }
+      if (typeof aItem === "number" && typeof bItem === "number") {
+        return aItem - bItem;
+      }
+      throw new Error("Not supported data type");
+    });
+  }
+  bSort(items: T[], by?: keyof T): T[] {
+    return items.sort((a: T, b: T) => {
+      const aItem = a[by as keyof T] ?? a;
+      const bItem = b[by as keyof T] ?? b;
+      if (typeof aItem === "string" && typeof bItem === "string") {
+        return bItem.localeCompare(aItem);
+      }
+      if (typeof aItem === "number" && typeof bItem === "number") {
+        return bItem - aItem;
+      }
+      throw new Error("Not supported data type");
+    });
+  }
+}

package/src/sort/strategies/SortStrategy.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export interface SortStrategy<T> {
+  aSort(items: T[], by?: keyof T): T[];
+  bSort(items: T[], by?: keyof T): T[];
+}

package/src/types/Global.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export type Nullable<T> = T \| null;

package/src/types/index.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export * from "./Global";

package/src/validators/Validator.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import { type Nullable } from "../types";
+export interface Validator<T> {
+  validate(value: Nullable<T>): string | Promise<string>;
+}

package/src/validators/index.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { type Validator } from "./Validator";

package/src/webSocket/Constants.ts ADDED Viewed

@@ -0,0 +1,6 @@
+export const enum WebSocketEvents {
+  CLOSE = "wsClose",
+  OPEN = "wsOpen",
+  ERROR = "wsError",
+  TIMEOUT = "wsTimeout",
+}

package/src/webSocket/Model.ts ADDED Viewed

@@ -0,0 +1,16 @@
+export class WebSocketPostMessage<T> {
+  private type: string;
+  private data: T;
+  constructor(type: string, data: T) {
+    this.type = type;
+    this.data = data;
+  }
+  public getPayload() {
+    return JSON.stringify({
+      type: this.type,
+      data: this.data,
+    });
+  }
+}

package/src/webSocket/WebSocketService.ts ADDED Viewed

@@ -0,0 +1,153 @@
+import { Nullable } from "../types";
+import { CustomEventDispatcher } from "../eventSystem/CustomEventDispatcher";
+import { WebSocketEvents } from "./Constants";
+import { WebSocketEvent } from "../eventSystem";
+import { WebSocketPostMessage } from "./Model";
+export class WebSocketService {
+  private webSocket: Nullable<WebSocket> = null;
+  private retry: number = 3;
+  private url: string = "";
+  private protocols: string[] = [];
+  private delayTimeInMillieSeconds: number = 500;
+  private baseUrl: string = "";
+  private intervalId: Nullable<ReturnType<typeof setInterval>> = null;
+  constructor(
+    private readonly customEventDispatcher: CustomEventDispatcher,
+    baseUrl: string,
+  ) {
+    this.onOpen = this.onOpen.bind(this);
+    this.onMessage = this.onMessage.bind(this);
+    this.onError = this.onError.bind(this);
+    this.onClose = this.onClose.bind(this);
+    this.checkHealth = this.checkHealth.bind(this);
+    this.sendPing = this.sendPing.bind(this);
+    this.reconnect = this.reconnect.bind(this);
+    this.fakeWait = this.fakeWait.bind(this);
+    this.isClosing = this.isClosing.bind(this);
+    this.isClosed = this.isClosed.bind(this);
+    this.connect = this.connect.bind(this);
+    this.registerPingPontInterval = this.registerPingPontInterval.bind(this);
+    this.closeConnection = this.closeConnection.bind(this);
+    this.isConnectionOpen = this.isConnectionOpen.bind(this);
+    this.isConnecting = this.isConnecting.bind(this);
+    this.send = this.send.bind(this);
+    this.setBaseUrl = this.setBaseUrl.bind(this);
+    this.setBaseUrl(baseUrl);
+  }
+  public connect(url: string, protocols: string[] = [], retry: number = 3) {
+    if (this.webSocket) {
+      this.webSocket.removeEventListener("open", this.onOpen);
+      this.webSocket.removeEventListener("close", this.onClose);
+      this.webSocket.removeEventListener("error", this.onError);
+    }
+    this.webSocket = new WebSocket(this.baseUrl + url, protocols);
+    this.retry = retry;
+    this.url = url;
+    this.protocols = protocols;
+    this.webSocket.addEventListener("error", this.onError);
+    this.webSocket.addEventListener("close", this.onClose);
+    this.webSocket.addEventListener("open", this.onOpen);
+    this.checkHealth();
+  }
+  private async checkHealth() {
+    try {
+      await this.fakeWait(this.delayTimeInMillieSeconds);
+      if (!this.isClosed() && !this.isClosing() && !this.isConnectionOpen()) {
+        this.sendPing();
+      }
+    } catch (_error) {
+      this.reconnect();
+    }
+  }
+  private sendPing() {
+    this.webSocket!.send("PING");
+  }
+  private reconnect() {
+    if (this.retry === 0) {
+      this.customEventDispatcher.dispatchOnWindow(WebSocketEvents.TIMEOUT);
+    }
+    if (this.retry > 0) {
+      this.delayTimeInMillieSeconds = this.delayTimeInMillieSeconds * 2;
+      this.connect(this.url, this.protocols, --this.retry);
+    }
+  }
+  private fakeWait(timeInMilleSeconds: number) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(null);
+      }, timeInMilleSeconds);
+    });
+  }
+  private onError() {
+    this.customEventDispatcher.dispatchOnWindow(WebSocketEvents.ERROR);
+    this.closeConnection();
+  }
+  private onOpen() {
+    this.webSocket!.addEventListener("message", this.onMessage);
+    this.customEventDispatcher.dispatchOnWindow(WebSocketEvents.OPEN);
+    this.registerPingPontInterval();
+  }
+  private registerPingPontInterval() {
+    this.intervalId = setInterval(() => {
+      this.sendPing();
+    }, 10_000);
+  }
+  private onMessage(message: MessageEvent) {
+    const webSocketEvent = new WebSocketEvent<unknown>(message);
+    this.customEventDispatcher.dispatchWebSocketOnWindow(webSocketEvent);
+  }
+  private onClose() {
+    this.customEventDispatcher.dispatchOnWindow(WebSocketEvents.CLOSE);
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+    }
+  }
+  public closeConnection() {
+    if (!this.webSocket) {
+      console.warn("No connection to close");
+      return;
+    }
+    this.webSocket.close();
+  }
+  public isConnectionOpen() {
+    return this.webSocket?.readyState === 1;
+  }
+  public isConnecting() {
+    return this.webSocket?.readyState === 0;
+  }
+  public isClosing() {
+    return this.webSocket?.readyState === 2;
+  }
+  public isClosed() {
+    return this.webSocket?.readyState === 3;
+  }
+  public send(data: WebSocketPostMessage<unknown>) {
+    if (!this.webSocket) throw new Error("NO webSocket to send data");
+    this.webSocket.send(data.getPayload());
+  }
+  private setBaseUrl(baseUrl: string) {
+    this.baseUrl = baseUrl;
+  }
+}

package/src/webSocket/index.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export { WebSocketPostMessage } from "./Model";
+export { WebSocketService } from "./WebSocketService";
+export { WebSocketEvents } from "./Constants";

package/vite.config.ts ADDED Viewed

@@ -0,0 +1,55 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+import dts from "vite-plugin-dts";
+import * as path from "node:path";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export default defineConfig({
+  plugins: [dts({ insertTypesEntry: true })],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "packages/core/src"),
+    },
+  },
+  build: {
+    lib: {
+      entry: resolve(__dirname, "index.ts"),
+      name: "IronCore",
+      // the proper extensions will be added
+      fileName: "IronCore",
+    },
+    rollupOptions: {
+      // make sure to externalize deps that shouldn't be bundled
+      // into your library
+      external: [
+        "vue",
+        "json2typescript",
+        "axios",
+        "dayjs",
+        "jalaliday",
+        "pinia",
+      ],
+      output: {
+        // Provide global variables to use in the UMD build
+        // for externalized deps
+        globals: {
+          vue: "Vue",
+          json2typescript: "json2typescript",
+          axios: "axios",
+          dayjs: "dayjs",
+          jalaliday: "jalaliday",
+          pinia: "pinia",
+          "jalali-plugin-dayjs": "jalali-plugin-dayjs",
+        },
+      },
+    },
+    terserOptions: {
+      compress: {
+        dead_code: false,
+        conditionals: false,
+      },
+    },
+  },
+});

package/dist/src/baseForm/UseForm.d.ts DELETED Viewed

@@ -1,5 +0,0 @@
-import { FormManager } from './FormManager';
-export declare function useForm(form: FormManager, hasCustomValidation?: boolean): {
-    reactiveForm: any;
-    validationStatus: any;
-};

package/dist/src/composables/UseLoadingStatus.d.ts DELETED Viewed

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

package/dist/src/composables/UseRepository.d.ts DELETED Viewed

@@ -1,63 +0,0 @@
-import { computed } from 'vue';
-import { Repository } from '../repository';
-import { LoadingStatus } from '../constants';
-import { SortDetail } from '../sort';
-import { BaseModel } from '../BaseModel';
-export declare function useRepository<Model extends BaseModel>(repository: Repository<Model>): {
-    loadingStatusManager: {
-        loadingStatus: any;
-        isFetchingList: any;
-        isFetchingItem: any;
-        isFetchingLastItems: any;
-        isFetchingPreviousItems: any;
-        isCreating: any;
-        isUpdating: any;
-        isDeleting: any;
-        isSearching: any;
-        isSorting: any;
-        setStatus: (status: LoadingStatus) => void;
-        removeStatus: (status: LoadingStatus) => void;
-    };
-    dataManger: {
-        itemsAsArray: any;
-        totalCount: any;
-        currentItem: any;
-        setTotalCount: (totalItems: number) => void;
-        addOrReplaceItems: (itemsToAdd: BaseModel[]) => void;
-        getById: (id: number) => computed<BaseModel>;
-        removeById: (id: number) => boolean;
-        clearItems: () => void;
-        setCurrentItem: (item: computed<BaseModel>) => void;
-        clearCurrentItem: () => void;
-    };
-    paramsManager: {
-        params: Ref<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: any;
-    fetchList: (loadingStatus?: LoadingStatus) => Promise<any>;
-    fetchWithAutoRefresh: () => Promise<void>;
-    setupAutoRefresh: () => void;
-    stopAutoRefresh: () => void;
-    fetchItemById: (id: number, shouldRemoveItem?: boolean) => Promise<any>;
-    createItem: <Body>(body: Body) => Promise<any>;
-    updateItem: <Body>(id: number, body: Body) => Promise<any>;
-    deleteItem: (id: number) => Promise<boolean>;
-    fetchLastItems: () => Promise<any>;
-    fetchPreviousItems: () => Promise<any>;
-    fetchItemsByPageNumber: (pageNumber: number) => Promise<any>;
-    search: (searchedValue: string) => Promise<any>;
-    sort: (sortDetail: SortDetail<Model>) => Promise<any>;
-    clearFilters: () => Promise<any>;
-    tableService: any;
-    currentPageItems: any;
-};

package/dist/src/composables/UseStaticTableService.d.ts DELETED Viewed

@@ -1,4 +0,0 @@
-export declare function useStaticTableService<Model>(initialRows: Model[]): {
-    tableRows: any;
-    staticTableService: any;
-};

package/dist/src/layout/DialogService.d.ts DELETED Viewed

	@@ -1 +0,0 @@
1	- export declare const useDialogService: any;

package/dist/src/layout/DrawerService.d.ts DELETED Viewed

	@@ -1 +0,0 @@
1	- export declare const useDrawerService: any;

package/dist/vite.config.d.ts DELETED Viewed

	@@ -1,2 +0,0 @@
1	- declare const _default: any;
2	- export default _default;

/package/dist/{src → core/src}/Utils.d.ts RENAMED Viewed

File without changes

/package/dist/{src → core/src}/accessHandling/AccessControl.d.ts RENAMED Viewed

File without changes