@acorex/core 5.0.0 → 5.0.5

package/karma.conf.js

@@ -0,0 +1,44 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      jasmine: {
+        // you can add configuration options for Jasmine here
+        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
+        // for example, you can disable the random execution with `random: false`
+        // or set a specific seed with `seed: 4321`
+      },
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    jasmineHtmlReporter: {
+      suppressAll: true // removes the duplicated traces
+    },
+    coverageReporter: {
+      dir: require('path').join(__dirname, '../../../coverage/acorex/core'),
+      subdir: '.',
+      reporters: [
+        { type: 'html' },
+        { type: 'text-summary' }
+      ]
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false,
+    restartOnFileChange: true
+  });
+};

package/ng-package.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../../dist/acorex/core",
+  "lib": {
+    "entryFile": "src/public-api.ts",
+    "umdModuleIds": {
+      "lodash-es/merge": "lodash-es/merge"
+    }
+  },
+  "allowedNonPeerDependencies": ["lodash-es"]
+}

package/package.json

@@ -1,19 +1,15 @@
-{
-  "name": "@acorex/core",
-  "version": "5.0.0",
-  "peerDependencies": {
-    "@angular/common": "^12.2.0",
-    "@angular/core": "^12.2.0"
-  },
-  "dependencies": {
-    "lodash-es": "^4.17.20",
-    "tslib": "^2.3.0"
-  },
-  "main": "bundles/acorex-core.umd.js",
-  "module": "fesm2015/acorex-core.js",
-  "es2015": "fesm2015/acorex-core.js",
-  "esm2015": "esm2015/acorex-core.js",
-  "fesm2015": "fesm2015/acorex-core.js",
-  "typings": "acorex-core.d.ts",
-  "sideEffects": false
+{
+    "name": "@acorex/core",
+    "version": "5.0.5",
+    "peerDependencies": {
+        "@angular/common": "^12.2.6",
+        "@angular/core": "^12.2.6"
+    },
+    "dependencies": {
+        "lodash-es": "^4.17.20",
+        "tslib": "^2.3.0"
+    },
+    "devDependencies": {
+        "@angular-devkit/build-angular": "^12.2.6"
+    }
 }

package/src/lib/config/configs.ts

@@ -0,0 +1,36 @@
+import { Subject, Observable } from 'rxjs';
+import { AXObjectUtil } from '../utils/object-util';
+
+// @dynamic
+export class AXConfig {
+    private static dataModel: any = {};
+    private static dataChangeSubject = new Subject<any>();
+
+
+    static get onChange(): Observable<any> {
+        return AXConfig.dataChangeSubject.asObservable();
+    }
+
+    static set(config: any): any;
+    static set(path: string, value?: any): void;
+    static set(arg1?: any, arg2?: any) {
+
+        if (arg1 && typeof arg1 == 'string') {
+            AXObjectUtil.setPropByPath(AXConfig.dataModel, arg1, arg2);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (arg1 && typeof arg1 == 'object') {
+            Object.assign(AXConfig.dataModel, arg1);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (!arg1 && !arg2) {
+            return AXConfig.dataChangeSubject.asObservable();
+        }
+    }
+
+    static get(path: string, defaultValue?: any): any {
+        return AXObjectUtil.getPropByPath(AXConfig.dataModel, path) || defaultValue;
+    }
+}

package/src/lib/core.module.ts

@@ -0,0 +1,10 @@
+import { NgModule } from "@angular/core";
+import { AXSafePipe } from "./utils";
+
+@NgModule({
+    imports: [],
+    exports: [AXSafePipe],
+    declarations: [AXSafePipe],
+    providers: [],
+})
+export class AXCoreModule { }

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

@@ -0,0 +1,395 @@
+import { AXConfig } from '../config/configs';
+
+
+export const AX_CALENDARS: any[] = [
+  {
+    name: 'gregorian',
+    type: 'GeorgianCalendar'
+  },
+  {
+    name: 'jalali',
+    type: 'JalaliCalendar'
+  }
+];
+export type TimeUnit =
+  | 'second'
+  | 'minute'
+  | 'hour'
+  | 'day'
+  | 'month'
+  | 'year'
+  | 'week';
+
+export interface AXCalendar {
+  monthNames: string[];
+
+  monthShortNames: string[];
+
+  dayNames: string[];
+
+  dayShortNames: string[];
+
+  name(): string;
+
+  dayInMonth(date: Date): number;
+
+  dayOfYear(date: Date): number;
+
+  dayInWeek(date: Date): number;
+
+  year(date: Date): number;
+
+  monthOfYear(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;
+
+  /**
+ * This comment _supports_ [Markdown](https://marked.js.org/)
+ */
+  endOf(date: Date, unit: TimeUnit): AXDateTime;
+}
+
+/**
+ * Standard links:
+ * {@link Foo} or {@linkplain Foo} or [[Foo]]
+ *
+ * Code links: (Puts Foo inside <code> tags)
+ * {@linkcode Foo} or [[`Foo`]]
+ */
+// @dynamic
+export class AXDateTime {
+  static convert(
+    value: any,
+    calendar: string = AXConfig.get('dateTime.type') || 'gregorian'
+  ): 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;
+  }
+
+
+  private _date: Date;
+    /**
+ * This comment _supports_ [Markdown](https://marked.js.org/)
+ */
+  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.type') || 'gregorian'
+  ) {
+    this._calendar =
+      typeof calendar == 'string'
+        ? eval(`new ${AX_CALENDARS.find((c) => c.name == calendar).type}()`)
+        : calendar;
+    if (value instanceof Date) {
+      this._date = value as Date;
+    } else {
+      this._date = new Date(value);
+    }
+  }
+
+  clone(): AXDateTime {
+    return new AXDateTime(this.date, this.calendar.name());
+  }
+
+  get dayInMonth(): number {
+    return this._calendar.dayInMonth(this.date);
+  }
+
+  get dayOfYear(): number {
+    return this._calendar.dayOfYear(this.date);
+  }
+
+  get dayInWeek(): number {
+    return this._calendar.dayInWeek(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 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: AXDateTime | Date | string,
+    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);
+  }
+
+  format(
+    format: string = AXConfig.get('dateTime.shortDateFormat') ||
+      'DDD, dd MMM yyyy'
+  ): string {
+    format = format.replace('ss', this.pad(this.date.getSeconds(), 2));
+    format = format.replace('s', this.date.getSeconds().toString());
+    format = format.replace(
+      'dd',
+      this.pad(this.calendar.dayInMonth(this.date), 2)
+    );
+    format = format.replace(
+      'd',
+      this.calendar.dayInMonth(this.date).toString()
+    );
+    format = format.replace('mm', this.pad(this.date.getMinutes(), 2));
+    format = format.replace('m', this.date.getMinutes().toString());
+    format = format.replace(
+      'MMMM',
+      this.calendar.monthNames[this.calendar.monthOfYear(this.date) - 1]
+    );
+    format = format.replace(
+      'MMM',
+      this.calendar.monthShortNames[this.calendar.monthOfYear(this.date) - 1]
+    );
+    format = format.replace(
+      'MM',
+      this.pad(this.calendar.monthOfYear(this.date), 2)
+    );
+    format = format.replace(
+      /M(?![ao])/,
+      this.calendar.monthOfYear(this.date).toString()
+    );
+    format = format.replace(
+      'DDDD',
+      this.calendar.dayNames[this.calendar.dayInWeek(this.date) - 1]
+    );
+    format = format.replace(
+      'DDD',
+      this.calendar.dayShortNames[this.calendar.dayInWeek(this.date) - 1]
+    );
+    format = format.replace(
+      /D(?!e)/,
+      this.calendar.dayNames[this.calendar.dayInWeek(this.date) - 1].substring(
+        0,
+        3
+      )
+    );
+    format = format.replace('yyyy', this.calendar.year(this.date).toString());
+    format = format.replace('YYYY', this.calendar.year(this.date).toString());
+    format = format.replace(
+      'yy',
+      this.calendar.year(this.date).toString().substring(2)
+    );
+    format = format.replace(
+      'YY',
+      this.calendar.year(this.date).toString().substring(2)
+    );
+    format = format.replace('HH', this.pad(this.date.getHours(), 2));
+    format = format.replace('H', this.date.getHours().toString());
+    return format;
+  }
+
+  private pad(n, width, z = '0') {
+    n = n + '';
+    return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
+  }
+
+  toString(): string {
+    return this.format();
+  }
+
+  equal(value: any, unit: TimeUnit = 'day') {
+    return this.compaire(value, unit) == 0;
+  }
+
+  compaire(value: any, unit: TimeUnit = 'day') {
+    // TODO:
+    const val = AXDateTime.convert(value);
+    if (this.date == val.date) {
+      return 0;
+    } else if (this.date > val.date) {
+      return 1;
+    } else {
+      return -1;
+    }
+  }
+
+  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 {
+  constructor(public startTime: AXDateTime, public endTime: AXDateTime) { }
+
+  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'): AXDateTime[] {
+    // TODO: ??
+    return [];
+  }
+
+  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/src/lib/dateTime/datetime.module.ts

@@ -0,0 +1,11 @@
+import { NgModule } from '@angular/core';
+import { AXDateTimePipe } from './datetime.pipe';
+
+
+@NgModule({
+    imports: [],
+    exports: [AXDateTimePipe],
+    declarations: [AXDateTimePipe],
+    providers: [],
+})
+export class AXDateTimeModule { }

package/src/lib/dateTime/datetime.pipe.ts

@@ -0,0 +1,20 @@
+import { PipeTransform, Pipe } from '@angular/core';
+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.toString();
+        }
+        else {
+            return date.format(format);
+        }
+    }
+}