@acorex/core 6.0.1 → 6.0.2

package/dateTime/src/datetime.class.ts

@@ -1,452 +0,0 @@
-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 {
-    // let date: AXDateTime = new AXDateTime(new Date(), value.calendar);
-    // date.set('year', value.year);
-    // date.set('month', value.month);
-    // date.set('day', value.date);
-    // date.set('hour', value.hours);
-    // date.set('minute', value.minutes);
-    // date.set('second', value.seconds);
-    // date.set('ms', value.ms);
-
-    return AXDateTime.resolveCalendar(value.calendar).create(value);
-  }
-
-
-  static resolveCalendar(calendar: string | AXCalendar): AXCalendar {
-    return typeof calendar == 'string'
-      ? AXConfig.get(`dateTime.calendars.${calendar}`)
-      : 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[] {
-    // TODO: setptemper savingtime issue
-    const result: AXDateTime[] = [];
-    let item = this._startTime.clone();
-    while (item.compare(this._endTime, unit) < 1) {
-      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

@@ -1,29 +0,0 @@
-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: new JalaliCalendar(),
-                    gregorian: new GeorgianCalendar()
-                },
-                calendar:'gregorian',
-                shortDateFormat:'DDDD, d MMM yyyy'
-            }
-        });
-
-    }
-}

package/dateTime/src/datetime.pipe.ts

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

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