@acorex/core 3.0.21 → 3.0.25

package/src/lib/classes/datetime.class.ts

@@ -1,374 +0,0 @@
-import * as moment_ from 'jalali-moment';
-import { AXConfig } from '../services/config';
-const moment = moment_;
-
-export type TimeUnit = 'second' | 'minute' | 'minutes' | 'hour' | 'hours' | 'day' | 'days' | 'month' | 'year' | 'week';
-
-export type TimeDuration = 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'month' | 'years';
-
-export type TimeStep = 'Y' | 'M' | 'D' | 'YM' | 'YMD' | 'YMDh' | 'YMDhm' | 'YMDhms' | 'h' | 'm' | 's';
-
-export type AXCalendarType = 'jalali' | 'gregorian';
-
-export class AXDateTime {
-  static convert(value: any, type: AXCalendarType = AXConfig.get('dateTime.type') || 'gregorian'): AXDateTime {
-    let date: AXDateTime;
-    if (typeof value === 'string' || value instanceof String) {
-      date = new AXDateTime(value as string, type);
-    } else if (value instanceof Date) {
-      date = new AXDateTime(value as Date, type);
-    } else if (value instanceof AXDateTime) {
-      date = value;
-    }
-    return date;
-  }
-
-  private _date: Date;
-  get date(): Date {
-    return this._date;
-  }
-
-  private resolveUnit(unit: TimeUnit): any {
-    return this.type === 'jalali' ? 'j' + unit : unit;
-  }
-
-  private _moment: moment_.Moment;
-
-  // private get _moment(): moment_.Moment {
-  //     const m = moment(this.date);
-  //     if (this.type === 'jalali') {
-  //         m.locale('fa');
-  //     }
-  //     return m;
-  // }
-
-  constructor(value: Date | string = new Date(), public type: AXCalendarType = AXConfig.get('dateTime.type') || 'gregorian') {
-    if (value instanceof Date) {
-      this._date = value as Date;
-    } else {
-      this._date = new Date(value);
-    }
-    this._moment = moment(this.date);
-    if (this.type === 'jalali') {
-      this._moment.locale('fa');
-    }
-  }
-
-  clone(): AXDateTime {
-    return new AXDateTime(this.date, this.type);
-  }
-
-  get dayInMonth(): number {
-    return this._moment.date();
-  }
-
-  get dayOfYear(): number {
-    return this._moment.dayOfYear();
-  }
-
-  get dayInWeek(): number {
-    return this._moment.day();
-  }
-
-  get hour(): number {
-    return this._moment.hour();
-  }
-
-  get minute(): number {
-    return this._moment.minute();
-  }
-
-  get second(): number {
-    return this._moment.second();
-  }
-
-  get year(): number {
-    return this._moment.year();
-  }
-
-  get monthOfYear(): number {
-    return this._moment.month();
-  }
-
-  get month(): AXCalendarMonth {
-    return new AXCalendarMonth(this);
-  }
-
-  get firstDayOfWeek(): AXDateTime {
-    const a = moment(this.date);
-    if (this.type === 'jalali') {
-      this._moment.locale('fa');
-    }
-    return new AXDateTime(a.startOf('w').toDate(), this.type);
-  }
-
-  get endDayOfWeek(): AXDateTime {
-    const a = moment(this.date);
-    if (this.type === 'jalali') {
-      this._moment.locale('fa');
-    }
-    return new AXDateTime(moment(this.date).endOf('w').toDate(), this.type);
-  }
-
-  convertStringToJalali(date: string, format: string) {
-    return moment(date).locale('fa').format('YYYY/M/D');
-
-
-  }
-  convertStringToGregorian(date: string, format: string) {
-    return new Date((moment.from(date, 'fa', 'YYYY/MM/DD').format('YYYY/MM/DD')));
-  }
-
-  add(unit: TimeUnit = 'day', amount: number): AXDateTime {
-    return new AXDateTime(moment(this.date).add(amount, this.resolveUnit(unit)).toDate(), this.type);
-  }
-
-  addDay(amount: number): AXDateTime {
-    return new AXDateTime(moment(this.date).add(amount, 'd').toDate(), this.type);
-  }
-
-  addMonth(amount: number): AXDateTime {
-    return new AXDateTime(moment(this.date).add(amount, 'months').toDate(), this.type);
-  }
-  addHour(amount: number) {
-    return new AXDateTime(moment(this.date).add(amount, 'hours').toDate(), this.type);
-  }
-
-  set(unit: TimeUnit = 'day', value: number): AXDateTime {
-    return new AXDateTime(this._moment.set(unit, value).toDate(), this.type);
-  }
-
-  duration(end: AXDateTime, unit: TimeDuration = 'days'): number {
-    const duration = moment.duration(this._moment.diff(end._moment));
-    return Math.round(duration.as(unit));
-  }
-
-  startOf(unit: TimeUnit = 'day'): AXDateTime {
-    return new AXDateTime(moment(this.date).startOf(this.resolveUnit(unit)).toDate(), this.type);
-  }
-
-  endOf(unit: TimeUnit = 'day'): AXDateTime {
-    return new AXDateTime(moment(this.date).endOf(this.resolveUnit(unit)).toDate(), this.type);
-  }
-
-  format(format: string = AXConfig.get('dateTime.shortDateFormat') || (this.type === 'gregorian' ? 'DD-MM-YYYY' : 'YYYY-MM-DD')): string {
-    if (format === 'P') {
-      return this._moment.fromNow();
-    }
-    return this._moment.format(format);
-  }
-
-  toString(): string {
-    return this.format();
-  }
-
-  equal(value: AXDateTime, unit: TimeUnit = 'day') {
-    if (!value) {
-      return false;
-    }
-    return this._moment.isSame(moment(value.date), this.resolveUnit(unit));
-  }
-
-  convertToJalaliDate(value) {
-    const options = {
-      numberingSystem: 'latn',
-      year: 'numeric',
-      month: '2-digit',
-      day: '2-digit',
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit'
-    };
-    const jDate = new Date(value).toLocaleDateString('fa-IR', options);
-    const item: any = {};
-    item.year = jDate.slice(0, 4);
-    item.month = jDate.slice(5, 7);
-    item.day = jDate.slice(8, 10);
-    item.hour = jDate.slice(13, 15);
-    item.minutes = jDate.slice(16, 18);
-    item.seconds = jDate.slice(19, 21);
-    return item;
-  }
-
-  toJalaliString(value) {
-    const date = this.convertToJalaliDate(value);
-    let str = '';
-    str = date.year + '-' + date.month + '-' + date.day + 'T' + date.hour + ':' + date.minutes + ':' + date.seconds;
-    return str;
-  }
-
-  convertToGregorianDate(value) {
-    const options = {
-      numberingSystem: 'latn',
-      year: 'numeric',
-      month: '2-digit',
-      day: '2-digit',
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit'
-    };
-    const date = new Date(value).toLocaleString('en-us', options);
-    const item: any = {};
-    item.year = date.slice(6, 10);
-    item.month = date.slice(0, 2);
-    item.day = date.slice(3, 5);
-    item.hour = date.slice(12, 14);
-    item.minutes = date.slice(15, 17);
-    item.seconds = date.slice(18, 20);
-    return item;
-  }
-
-  toGregorianString(value) {
-    const date = this.convertToGregorianDate(value);
-    let str = '';
-    str = date.year + '-' + date.month + '-' + date.day + 'T' + date.hour + ':' + date.minutes + ':' + date.seconds;
-    return str;
-  }
-
-  compaireNew(value: AXDateTime, unit: TimeStep = 'YMD', type = 'jalali') {
-    const range = [0, 0];
-    let str1;
-    let str2;
-    if (type === 'jalali') {
-      str1 = this.toJalaliString(this.date);
-      str2 = this.toJalaliString(value.date ? value.date : value);
-    } else {
-      str1 = this.toGregorianString(this.date);
-      str2 = this.toGregorianString(value.date ? value.date : value);
-    }
-    switch (unit) {
-      case 'YMDhms':
-        range[0] = 0;
-        range[1] = 19;
-        break;
-      case 'YMDhm':
-        range[0] = 0;
-        range[1] = 16;
-        break;
-      case 'YMDh':
-        range[0] = 0;
-        range[1] = 13;
-        break;
-      case 'YMD':
-        range[0] = 0;
-        range[1] = 10;
-        break;
-
-      case 'YM':
-        range[0] = 0;
-        range[1] = 7;
-        break;
-
-      case 'h':
-        range[0] = 11;
-        range[1] = 13;
-        break;
-
-      case 'm':
-        range[0] = 14;
-        range[1] = 16;
-        break;
-
-      case 's':
-        range[0] = 17;
-        range[1] = 19;
-        break;
-      case 'D':
-        range[0] = 8;
-        range[1] = 10;
-        break;
-
-      case 'M':
-        range[0] = 5;
-        range[1] = 7;
-        break;
-
-      case 'Y':
-        range[0] = 0;
-        range[1] = 4;
-        break;
-    }
-
-    if (str1.slice(range[0], range[1]) === str2.slice(range[0], range[1])) {
-      return 0;
-    } else if (str1.slice(range[0], range[1]) > str2.slice(range[0], range[1])) {
-      return 1;
-    } else {
-      return -1;
-    }
-  }
-
-  compaire(value: AXDateTime, unit: TimeUnit = 'day') {
-    if (this._moment.isSame(moment(value.date), this.resolveUnit(unit))) {
-      return 0;
-    } else if (this._moment.isAfter(moment(value.date), this.resolveUnit(unit))) {
-      return 1;
-    } else {
-      return -1;
-    }
-  }
-
-  toISOString() {
-    return this._date.toISOString();
-  }
-}
-
-export class AXCalendarMonth {
-  private _moment: moment_.Moment;
-
-  private _range: AXDateTimeRange;
-  public get range(): AXDateTimeRange {
-    return this._range;
-  }
-  public set range(v: AXDateTimeRange) {
-    this._range = v;
-  }
-
-  constructor(date: AXDateTime) {
-    this._moment = moment(date.date);
-    this.index = date.date.getMonth();
-    this.name = this._moment.format('MMMM');
-    this.range = new AXDateTimeRange(
-      new AXDateTime(this._moment.startOf('month').toDate(), date.type),
-      new AXDateTime(this._moment.endOf('month').toDate(), date.type)
-    );
-  }
-
-  private readonly index: number;
-  private readonly name: string;
-}
-
-export class AXDateTimeRange {
-  constructor(public startTime: AXDateTime, public endTime: AXDateTime) { }
-
-  duration(unit: TimeDuration = 'days'): number {
-    const duration = moment.duration(moment(this.startTime.date).diff(moment(this.endTime.date)));
-    return duration.as(unit);
-  }
-
-  enumurate(unit: TimeUnit = 'day', type: AXCalendarType = AXConfig.get('dateTime.type') || 'jalali'): AXDateTime[] {
-    const result: AXDateTime[] = [];
-    for (let index = 0; this.startTime.add(unit, index).compaireNew(this.endTime, this.getViewCompaire(unit), type) <= 0; index++) {
-      result.push(this.startTime.add(unit, index));
-    }
-    return result;
-  }
-
-  includes(value: AXDateTime, unit: TimeUnit = 'day', type = 'jalali'): boolean {
-    return (
-      value.compaireNew(this.startTime, this.getViewCompaire(unit), type) >= 0 &&
-      value.compaireNew(this.endTime, this.getViewCompaire(unit), type) <= 0
-    );
-  }
-
-  getViewCompaire(view) {
-    switch (view) {
-      case 'day':
-        return 'YMD';
-      case 'month':
-        return 'YM';
-      case 'year':
-        return 'Y';
-    }
-  }
-}

package/src/lib/classes/menu.class.ts

@@ -1,37 +0,0 @@
-export class AXBaseMenuItem {
-  uid?: string = new Date().getTime().toString();
-  id?: string;
-  name?: string;
-  text?: string;
-  tooltip?: string;
-  tooltipPlacement?: 'top' | 'right' | 'bottom' | 'left';
-  icon?: string;
-  visible?: boolean = true;
-  disable?: boolean = false;
-  selected?: boolean = false;
-  groupName?: string;
-  data?: any;
-  style?: string = 'ax light';
-  orderIndex?: number = 0;
-  endIcon?: string;
-  startIcon?: string;
-  onClick?: (e?: any) => void;
-}
-
-export class AXMenuItem extends AXBaseMenuItem {
-  items?: AXMenuItem[];
-  parentId?: string;
-  divider?: boolean = false;
-}
-
-export class AXButtonItem extends AXBaseMenuItem {
-  dropdown?: boolean = false;
-  submitBehavior?: boolean = false;
-  cancelBehavior?: boolean = false;
-}
-
-export class AXCheckItem {
-  text?: string;
-  value?: any;
-  selected?: boolean;
-}

package/src/lib/classes/promise.class.ts

@@ -1,25 +0,0 @@
-export class AXPromise<T> {
-
-    private _executor: (then?: (e?: T) => void) => void;
-    private thenAction?: (e?: T) => void;
-
-    static resolve<T>(value: T): AXPromise<T> {
-        const r = new AXPromise<T>(z => {
-            z(value);
-        }).then(() => { });
-        return r;
-    }
-
-    constructor(executor: (then?: (e?: T) => void) => void) {
-        this._executor = executor;
-        setTimeout(() => {
-            this._executor(this.thenAction);
-        }, 50);
-    }
-
-
-    then(action?: (e?: T) => void): AXPromise<T> {
-        this.thenAction = action;
-        return this;
-    }
-}

package/src/lib/classes/select.class.ts

@@ -1,7 +0,0 @@
-export class AXSelectItem {
-  id: string;
-  name?: string;
-  text: string;
-  visible?: boolean;
-  disable?: boolean;
-}

package/src/lib/core.module.ts

@@ -1,21 +0,0 @@
-import { NgModule } from '@angular/core';
-import { AXDateTimePipe } from './pipe/datetime.pipe';
-import { AXEventService } from './services/event.service';
-import { AXStorageService } from './services/storage.service';
-import { AXScrollModule } from './utils/scroll/scroll.module';
-import { AXTranslatorModule } from './translator/translator.module';
-
-const PIPES = [AXDateTimePipe];
-const MODULES = [AXScrollModule, AXTranslatorModule];
-const SERVICES = [AXEventService,
-  AXStorageService
-];
-
-
-@NgModule({
-  declarations: [...PIPES],
-  imports: [...MODULES],
-  exports: [...PIPES],
-  providers: [...SERVICES]
-})
-export class AXCoreModule { }

package/src/lib/error/error.module.ts

@@ -1,13 +0,0 @@
-import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { AXErrorService } from './error.service';
-
-@NgModule({
-    declarations: [],
-    imports: [CommonModule],
-    exports: [],
-    providers: [AXErrorService],
-})
-export class AXErrorModule {
-
-}

package/src/lib/error/error.service.ts

@@ -1,23 +0,0 @@
-import { InjectionToken, Injectable, Injector } from '@angular/core';
-
-export const  AX_ERROR_DISPLAY_INTERCEPTOR = new InjectionToken<AXErrorDisplayInterceptor>('ax.error');
-
-export interface AXErrorDisplayInterceptor {
-    show(message: string);
-}
-
-@Injectable({providedIn: 'root'})
-export class AXErrorService {
-
-    constructor(private injector: Injector) {
-
-    }
-
-    handle(message: string) {
-        const instance = this.injector.get(AX_ERROR_DISPLAY_INTERCEPTOR);
-        if (instance) {
-            instance.show(message);
-        }
-    }
-
-}

package/src/lib/error/index.ts

@@ -1,3 +0,0 @@
-export * from './error.class';
-export * from './error.service';
-export * from './error.module';

package/src/lib/http/http-result.class.ts

@@ -1,34 +0,0 @@
-import { IHttpError } from './http-error.class';
-
-export class HttpResult<T> {
-    private _executor: (result: (e?: T) => void, error: (e?: IHttpError) => void, complete: () => void) => void;
-    constructor(
-        executor: (
-            result: (e?: T) => void,
-            error: (e?: IHttpError) => void,
-            complete: () => void
-        ) => void
-    ) {
-        this._executor = executor;
-        setTimeout(() => {
-            this._executor(this.resultAction, this.errorAction, this.completeAction);
-        }, 50);
-    }
-
-    private resultAction: (e?: T) => void;
-    private errorAction: (e?: IHttpError) => void;
-    private completeAction: () => void;
-
-    result(action: (e?: T) => void): HttpResult<T> { 
-        this.resultAction = action;
-        return this;
-    }
-    error(action: (e?: IHttpError) => void): HttpResult<T> {
-        this.errorAction = action;
-        return this;
-    }
-    complete(action: () => void): HttpResult<T> {
-        this.completeAction = action;
-        return this;
-    }
-}

package/src/lib/http/http.module.ts

@@ -1,25 +0,0 @@
-import { NgModule, ModuleWithProviders } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { HttpClientModule } from '@angular/common/http';
-import { AXHttpService } from './http.service';
-
-
-@NgModule({
-  declarations: [],
-  imports: [
-    CommonModule,
-    HttpClientModule
-  ],
-  exports: [HttpClientModule],
-  providers: [
-    AXHttpService
-  ]
-})
-export class AXHttpModule {
-  static forRoot(): ModuleWithProviders {
-    return {
-      ngModule: AXHttpModule,
-      providers: [AXHttpService]
-    };
-  }
-}