@acorex/core 7.0.19 → 7.0.20

package/dateTime/src/datetime.class.ts

@@ -0,0 +1,449 @@
+import * as _ from 'lodash';
+import { AXConfig } from '@acorex/core/config';
+
+export type TimeUnit =
+  | 'ms'
+  | 'second'
+  | 'minute'
+  | 'hour'
+  | 'day'
+  | 'month'
+  | 'year'
+  | 'week';
+
+
+
+
+
+export interface AXDateValue {
+  year: number,
+  month: number,
+  date: number,
+  hours?: number,
+  minutes?: number,
+  seconds?: number,
+  ms?: number
+  calendar: string;
+}
+
+
+export interface AXCalendar {
+  monthNames: string[];
+
+  monthShortNames: string[];
+
+  dayNames: string[];
+
+  dayShortNames: string[];
+
+  name(): string;
+
+  dayOfMonth(date: Date): number;
+
+  dayOfYear(date: Date): number;
+
+  dayOfWeek(date: Date): number;
+
+  monthOfYear(date: Date): number;
+
+  weekOfYear(date: Date): number;
+
+  year(date: Date): number;
+
+  add(date: Date, unit: TimeUnit, amount: number): AXDateTime;
+
+  set(date: Date, unit: TimeUnit, value: number): AXDateTime;
+
+  startOf(date: Date, unit: TimeUnit): AXDateTime;
+
+  endOf(date: Date, unit: TimeUnit): AXDateTime;
+
+  create(value: AXDateValue): AXDateTime;
+  
+}
+
+
+
+
+// @dynamic
+export class AXDateTime {
+  static convert(
+    value: Date | AXDateTime | string,
+    calendar: string = AXConfig.get('dateTime.calendar')
+  ): AXDateTime {
+    let date: AXDateTime;
+    if (typeof value === 'string' || value instanceof String) {
+      date = new AXDateTime(value as string, calendar);
+    } else if (value instanceof Date) {
+      date = new AXDateTime(value as Date, calendar);
+    } else if (value instanceof AXDateTime) {
+      date = new AXDateTime(value.date, calendar);
+    }
+    return date!;
+  }
+
+  static from(value: AXDateValue = {
+    calendar: AXConfig.get('dateTime.calendar'),
+    year: 1,
+    month: 1,
+    date: 1,
+    hours: 0,
+    minutes: 0,
+    seconds: 0,
+    ms: 0
+  }): AXDateTime {
+    return AXDateTime.resolveCalendar(value.calendar).create(value);
+  }
+
+
+  static resolveCalendar(calendar: string | AXCalendar): AXCalendar {
+    return typeof calendar == 'string'
+      ? AXConfig.get(`dateTime.calendars.${calendar}.class`)
+      : calendar;
+  }
+
+
+  private _date: Date;
+
+  get date(): Date {
+    return this._date;
+  }
+
+  private _calendar: AXCalendar;
+  get calendar(): AXCalendar {
+    return this._calendar;
+  }
+
+
+
+  constructor(
+    value: Date | string = new Date(),
+    calendar: string | AXCalendar = AXConfig.get(`dateTime.calendar`)
+  ) {
+    this._calendar = AXDateTime.resolveCalendar(calendar);
+    if (value instanceof Date) {
+      this._date = value as Date;
+    } else {
+      //TODO: parse jalali
+      this._date = new Date(value);
+    }
+  }
+
+  clone(): AXDateTime {
+    return new AXDateTime(this.date, this.calendar);
+  }
+
+  get dayOfMonth(): number {
+    return this._calendar.dayOfMonth(this.date);
+  }
+
+  get dayOfYear(): number {
+    return this._calendar.dayOfYear(this.date);
+  }
+
+  get dayOfWeek(): number {
+    return this._calendar.dayOfWeek(this.date);
+  }
+
+  get hour(): number {
+    return this._date.getHours();
+  }
+
+  get minute(): number {
+    return this._date.getMinutes();
+  }
+
+  get second(): number {
+    return this._date.getSeconds();
+  }
+
+  get year(): number {
+    return this._calendar.year(this.date);
+  }
+
+  get monthOfYear(): number {
+    return this._calendar.monthOfYear(this.date);
+  }
+
+  get weekOfYear(): number {
+    return this._calendar.weekOfYear(this.date);
+  }
+
+  get month(): AXCalendarMonth {
+    return new AXCalendarMonth(this);
+  }
+
+  add(unit: TimeUnit, amount: number): AXDateTime {
+    return this._calendar.add(this.date, unit, amount);
+  }
+
+  set(unit: TimeUnit = 'day', value: number): AXDateTime {
+    return this._calendar.set(this.date, unit, value);
+  }
+
+  duration(
+    end: Date | AXDateTime,
+    unit: TimeUnit = 'day'
+  ): AXTimeSpan {
+    const range = new AXDateTimeRange(
+      this,
+      AXDateTime.convert(end, this.calendar.name())
+    );
+    return range.duration();
+  }
+
+  startOf(unit: TimeUnit = 'day'): AXDateTime {
+    return this._calendar.startOf(this.date, unit);
+  }
+
+  endOf(unit: TimeUnit = 'day'): AXDateTime {
+    return this._calendar.endOf(this.date, unit);
+  }
+
+  private _formatKeys = {
+    ss: () => this.pad(this.date.getSeconds(), 2),
+    s: () => this.date.getSeconds().toString(),
+    //
+    dd: () => this.pad(this.calendar.dayOfMonth(this.date), 2),
+    d: () => this.calendar.dayOfMonth(this.date).toString(),
+    //
+    mm: () => this.pad(this.date.getMinutes(), 2),
+    m: () => this.date.getMinutes().toString(),
+    //
+    MMMM: () => this.calendar.monthNames[this.calendar.monthOfYear(this.date) - 1],
+    MMM: () => this.calendar.monthShortNames[this.calendar.monthOfYear(this.date) - 1],
+    MM: () => this.pad(this.calendar.monthOfYear(this.date), 2),
+    //
+    DDDD: () => this.calendar.dayNames[this.calendar.dayOfWeek(this.date) - 1],
+    DDD: () => this.calendar.dayShortNames[this.calendar.dayOfWeek(this.date) - 1],
+    //
+    yyyy: () => this.calendar.year(this.date).toString(),
+    YYYY: () => this.calendar.year(this.date).toString(),
+    yy: () => this.calendar.year(this.date).toString().substring(2),
+    YY: () => this.calendar.year(this.date).toString().substring(2),
+    //
+    HH: () => this.pad(this.date.getHours(), 2),
+    H: () => this.date.getHours().toString(),
+    //
+    hh: () => this.pad((this.date.getHours() % 12 || 12), 2),
+    h: () => (this.date.getHours() % 12 || 12).toString(),
+    //
+    A: () => (this.date.getHours() < 12) ? 'am' : 'pm',
+    a: () => (this.date.getHours() < 12) ? 'am' : 'pm',
+  };
+
+  format(
+    format: string = AXConfig.get('dateTime.shortDateFormat')
+  ): string {
+    const re = new RegExp(_.orderBy(Object.keys(this._formatKeys), c => c.length, ['desc']).join("|"), "gi");
+    return format.replace(re, (matched) => {
+      return this._formatKeys[matched]();
+    });
+  }
+
+  private pad(n, width, z = '0') {
+    n = n + '';
+    return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
+  }
+
+  toString(format: string = AXConfig.get('dateTime.shortDateFormat')): string {
+    return this.format(format);
+  }
+
+  equal(value: Date | AXDateTime, unit: TimeUnit = 'day') {
+    return this.compare(value, unit) == 0;
+  }
+
+  compare(value: Date | AXDateTime, unit: TimeUnit = 'day') {
+    const val = AXDateTime.convert(value, this.calendar.name());
+    const func = (v1: number, v2: number) => {
+      if (v1 == v2) {
+        return 0;
+      } else if (v1 > v2) {
+        return 1;
+      } else {
+        return -1;
+      }
+    }
+    let p = 0;
+    switch (unit) {
+      case 'year':
+        return func(this.year, val.year);
+      case 'week':
+        p = this.compare(val, 'year');
+        return p == 0 ? func(this.weekOfYear, val.weekOfYear) : p;
+      case 'month':
+        p = this.compare(val, 'year');
+        return p == 0 ? func(this.monthOfYear, val.monthOfYear) : p;
+      case 'day':
+        p = this.compare(val, 'year');
+        return p == 0 ? func(this.dayOfYear, val.dayOfYear) : p;
+      case 'hour':
+        p = this.compare(val, 'day');
+        return p == 0 ? func(this.hour, val.hour) : p;
+      case 'minute':
+        p = this.compare(val, 'hour');
+        return p == 0 ? func(this.minute, val.minute) : p;
+      case 'second':
+        p = this.compare(val, 'minute');
+        return p == 0 ? func(this.second, val.second) : p;
+      default:
+        return func(this.date.getTime(), val.date.getTime());
+    }
+
+  }
+
+  convert(calendar: string) {
+    return AXDateTime.convert(this, calendar);
+  }
+}
+
+export class AXCalendarMonth {
+  private _range: AXDateTimeRange;
+  public get range(): AXDateTimeRange {
+    return this._range;
+  }
+  public set range(v: AXDateTimeRange) {
+    this._range = v;
+  }
+
+  constructor(date: AXDateTime) {
+    this.index = date.date.getMonth();
+    this.name = date.format('MMMM');
+    this.range = new AXDateTimeRange(
+      new AXDateTime(date.startOf('month').date, date.calendar),
+      new AXDateTime(date.endOf('month').date, date.calendar)
+    );
+  }
+
+  private readonly index: number;
+  private readonly name: string;
+}
+
+export interface AXTimeSpanTotal {
+  miliseconds: number;
+  seconds: number;
+  minutes: number;
+  hours: number;
+  days: number;
+  weeks: number;
+  months: number;
+  years: number;
+}
+
+export interface AXTimeSpan {
+  miliseconds: number;
+  seconds: number;
+  minutes: number;
+  hours: number;
+  days: number;
+  months: number;
+  years: number;
+  total: AXTimeSpanTotal;
+}
+
+export class AXDateTimeRange {
+  private _startTime: AXDateTime;
+  private _endTime: AXDateTime;
+
+  public get startTime(): AXDateTime {
+    return this._startTime;
+  }
+
+  public get endTime(): AXDateTime {
+    return this._endTime;
+  }
+
+  constructor(startTime: AXDateTime, endTime: AXDateTime) {
+    this._startTime = startTime;
+    this._endTime = endTime;
+  }
+
+  duration(): AXTimeSpan {
+    const result: AXTimeSpan = {
+      miliseconds: 0,
+      seconds: 0,
+      minutes: 0,
+      hours: 0,
+      days: 0,
+      months: 0,
+      years: 0,
+      total: {
+        miliseconds: 0,
+        seconds: 0,
+        minutes: 0,
+        hours: 0,
+        days: 0,
+        weeks: 0,
+        months: 0,
+        years: 0,
+      },
+    };
+
+    const one_second = 1000;
+    const one_min = one_second * 60;
+    const one_hour = one_min * 60;
+    const one_day = one_hour * 24;
+    const one_week = one_day * 7;
+    const one_year = 365.25 * one_day;
+    const one_month = one_year / 12;
+    const startTime = this._startTime.date.getTime();
+    const endTime = this._endTime.date.getTime();
+    const diff = Math.abs(endTime - startTime);
+    //
+    result.total.miliseconds = diff;
+    result.total.seconds = Number((diff / one_second).toFixed(2));
+    result.total.minutes = Number((diff / one_min).toFixed(2));
+    result.total.hours = Number((diff / one_hour).toFixed(2));
+    result.total.days = Number((diff / one_day).toFixed(2));
+    result.total.weeks = Number((diff / one_week).toFixed(2));
+    //
+    // let months = (this.endTime.year - this.startTime.year) * 12;
+    // months += this.endTime.monthOfYear - this.startTime.monthOfYear + 1;
+    // if (this.endTime.dayOfYear < this.startTime.dayOfYear) {
+    //     months--;
+    // }
+    // result.total.months = Math.abs(months);
+    // TODO: review
+    result.total.months = Number((diff / one_month).toFixed(2));
+    result.total.years = Number((diff / one_year).toFixed(2));
+    //
+    result.miliseconds = result.total.miliseconds % 1000;
+    result.seconds = Number((result.total.seconds % 60).toFixed(0));
+    result.minutes = Number((result.total.minutes % 60).toFixed(0));
+    result.hours = Number((result.total.hours % 24).toFixed(0));
+    // TODO: review
+    result.days = Number((result.total.days % 30.4).toFixed(0));
+    result.months = Number((result.total.months % 12).toFixed(0));
+    result.years = Number(result.total.years.toFixed(0));
+    return result;
+  }
+
+  enumurate(unit: TimeUnit = 'day', amount: number = 1): AXDateTime[] {
+    const result: AXDateTime[] = [];
+    let item = this._startTime.clone();
+    while (item.compare(this._endTime, unit) < 1) {
+      if (!result.some(c => c.equal(item, unit))) {
+        result.push(item);
+      }
+      item = item.add(unit, amount)
+    }
+    return result;
+  }
+
+  includes(value: AXDateTime, unit: TimeUnit = 'day'): boolean {
+    // TODO: ??
+    return true;
+  }
+
+  // getViewCompaire(view) {
+  //     switch (view) {
+  //         case 'day':
+  //             return 'YMD';
+  //         case 'month':
+  //             return 'YM';
+  //         case 'year':
+  //             return 'Y';
+  //     }
+  // }
+}

package/dateTime/src/datetime.module.ts

@@ -0,0 +1,35 @@
+import { NgModule } from '@angular/core';
+import { AXConfig } from '@acorex/core/config';
+import { AXDateTimePipe } from './datetime.pipe';
+import { GeorgianCalendar } from './georgian.calendar';
+import { JalaliCalendar } from './jalali.calendar';
+
+
+@NgModule({
+    imports: [],
+    exports: [AXDateTimePipe],
+    declarations: [AXDateTimePipe],
+    providers: [],
+})
+export class AXDateTimeModule {
+
+    constructor() {
+        AXConfig.set({
+            dateTime: {
+                calendars: {
+                    jalali: {
+                        "class": new JalaliCalendar(),
+                        weekend: [6, 7]
+                    },
+                    gregorian: {
+                        "class": new GeorgianCalendar(),
+                        weekend: [7, 1]
+                    }
+                },
+                calendar: 'gregorian',
+                shortDateFormat: 'DDDD, d MMM yyyy'
+            }
+        });
+
+    }
+}

package/dateTime/src/datetime.pipe.ts

@@ -0,0 +1,21 @@
+import { PipeTransform, Pipe } from '@angular/core';
+import { AXConfig } from '@acorex/core/config';
+import { AXDateTime } from './datetime.class';
+
+@Pipe({ name: 'axDate' })
+export class AXDateTimePipe implements PipeTransform {
+    constructor() { }
+
+    transform(value: any, format?: string, calendar?: string): string {
+        if (value == null) {
+            return '';
+        }
+        const date: AXDateTime = value instanceof AXDateTime ? value.clone() : AXDateTime.convert(value, calendar);
+        if (!format) {
+            return date.format(AXConfig.get('dateTime.shortDateFormat'));
+        }
+        else {
+            return date.format(format);
+        }
+    }
+}

package/dateTime/src/georgian.calendar.ts

@@ -0,0 +1,205 @@
+import { AXCalendar, AXDateTime, AXDateValue, TimeUnit } from "./datetime.class";
+
+export class GeorgianCalendar implements AXCalendar {
+
+    monthNames = [
+        "January", "February", "March",
+        "April", "May", "June", "July",
+        "August", "September", "October",
+        "November", "December"
+    ];
+
+    monthShortNames = [
+        "Jan", "Feb", "Mar",
+        "Apr", "May", "Jun", "Jul",
+        "Aug", "Sep", "Oct",
+        "Nov", "Dec"
+    ];
+
+    dayNames = [
+        "Sunday", "Monday", "Tuesday", "Wednesday",
+        "Thursday", "Friday", "Saturday"
+    ];
+
+    dayShortNames = [
+        "Sun", "Mon", "Tue", "Wed",
+        "Thu", "Fri", "Sat"
+    ];
+
+
+    create(value: AXDateValue): AXDateTime {
+        return new AXDateTime(new Date(value.year, value.month - 1, value.date, value.hours || 0, value.minutes || 0, value.seconds || 0, value.ms || 0), this.name());
+    }
+
+    name(): string {
+        return 'gregorian'
+    }
+
+    dayOfMonth(date: Date): number {
+        return date.getDate();
+    }
+
+    dayOfYear(date: Date): number {
+        let result = 0;
+        let m = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+        if (this.isLeap(date)) {
+            m[1] = 29;
+        }
+        for (let i = 0; i < date.getMonth(); i++) {
+            result = result + m[i];
+        }
+        result += date.getDate();
+        return result;
+    }
+
+    dayOfWeek(date: Date): number {
+        return date.getDay() + 1;
+    }
+
+    weekOfYear(date: Date): number {
+        const firstDay = new AXDateTime(date).startOf('year');
+        return Math.ceil((((date.getTime() - firstDay.date.getTime()) / 86400000) + firstDay.date.getDay() + 1) / 7);
+    }
+
+    year(date: Date): number {
+        return date.getFullYear();
+    }
+
+    monthOfYear(date: Date): number {
+        return date.getMonth() + 1;
+    }
+
+    add(date: Date, unit: TimeUnit, amount: number): AXDateTime {
+        let value = date.valueOf();
+        switch (unit) {
+            case 'second':
+                value += 1000 * amount;
+                break
+            case 'minute':
+                value += 60000 * amount;
+                break
+            case 'hour':
+                value += 3600000 * amount;
+                break
+            case 'month':
+                const v = new Date(value);
+                var mo = date.getMonth();
+                var yr = date.getFullYear();
+                mo = (mo + amount) % 12;
+                if (0 > mo) {
+                    yr += (date.getMonth() + amount - mo - 12) / 12;
+                    mo += 12;
+                }
+                else
+                    yr += ((date.getMonth() + amount - mo) / 12);
+                v.setMonth(mo);
+                v.setFullYear(yr);
+                value = v.valueOf();
+                break
+            case 'week':
+                value += 7 * 86400000 * amount;
+                break
+            case 'year':
+                const yv = new Date(value);
+                yv.setFullYear(yv.getFullYear() + amount);
+                value = yv.valueOf();
+                break
+            case 'day':
+            default:
+                value += 86400000 * amount;
+        }
+        return new AXDateTime(new Date(value), this.name());
+    }
+
+    set(date: Date, unit: TimeUnit, value: number): AXDateTime {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), value, clone.getMilliseconds());
+                break;
+            case 'minute':
+                clone.setHours(clone.getHours(), value, clone.getSeconds(), clone.getMilliseconds());
+                break;
+            case 'hour':
+                clone.setHours(value, clone.getMinutes(), clone.getSeconds(), clone.getMilliseconds());
+                break;
+            default:
+            case 'day':
+                clone.setDate(value);
+                break;
+            case "week":
+                break;
+            case "month":
+                clone.setMonth(Math.max(0, value - 1));
+                break;
+            case "year":
+                clone.setFullYear(value);
+                break;
+        }
+        return new AXDateTime(clone, this.name());
+    }
+
+    startOf(date: Date, unit: TimeUnit): AXDateTime {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 0);
+                return new AXDateTime(clone, this.name());
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 0, 0);
+                return new AXDateTime(clone, this.name());
+            case 'hour':
+                clone.setHours(clone.getHours(), 0, 0, 0);
+                return new AXDateTime(clone, this.name());
+            default:
+            case 'day':
+                clone.setHours(0, 0, 0, 0);
+                return new AXDateTime(clone, this.name());
+            case "week":
+                const index = 0;
+                const start = index >= 0 ? index : 0;
+                const day = clone.getDay();
+                const diff = clone.getDate() - day + (start > day ? start - 7 : start);
+                clone.setDate(diff);
+                return new AXDateTime(clone, this.name()).startOf('day');
+            case "month":
+                clone.setDate(1)
+                return new AXDateTime(clone, this.name()).startOf('day');
+            case "year":
+                clone.setMonth(0);
+                clone.setDate(1);
+                return new AXDateTime(clone, this.name()).startOf('day');
+        }
+    }
+
+    endOf(date: Date, unit: TimeUnit): AXDateTime {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 999);
+                return new AXDateTime(clone, this.name());
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 59, 999);
+                return new AXDateTime(clone, this.name());
+            case 'hour':
+                clone.setHours(clone.getHours(), 59, 59, 999);
+                return new AXDateTime(clone, this.name());
+            default:
+            case 'day':
+                clone.setHours(23, 59, 59, 999);
+                return new AXDateTime(clone, this.name());
+            case 'week':
+                return this.startOf(date, 'week').add('day', 6).endOf('day');
+            case 'month':
+                return new AXDateTime(new Date(date.getFullYear(), date.getMonth() + 1, 0), this.name()).endOf('day');
+            case "year":
+                clone.setMonth(11);
+                return new AXDateTime(clone, this.name()).endOf('month');
+        }
+    }
+
+    isLeap(date: Date) {
+        let leapYear = new Date(date.getFullYear(), 1, 29);
+        return leapYear.getDate() == 29;
+    }
+}