@acorex/core 5.8.0 → 6.0.1

package/.browserslistrc

@@ -0,0 +1,16 @@
+# This file is used by the build system to adjust CSS and JS output to support the specified browsers below.
+# For additional information regarding the format and rule options, please see:
+# https://github.com/browserslist/browserslist#queries
+
+# For the full list of supported browsers by the Angular framework, please see:
+# https://angular.io/guide/browser-support
+
+# You can see what browsers were selected by your queries by running:
+#   npx browserslist
+
+last 1 Chrome version
+last 1 Firefox version
+last 2 Edge major versions
+last 2 Safari major versions
+last 2 iOS major versions
+Firefox ESR

package/README.md

@@ -1,24 +1,24 @@
-# Core
-
-This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 12.2.0.
-
-## Code scaffolding
-
-Run `ng generate component component-name --project core` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project core`.
-> Note: Don't forget to add `--project core` or else it will be added to the default project in your `angular.json` file. 
-
-## Build
-
-Run `ng build core` to build the project. The build artifacts will be stored in the `dist/` directory.
-
-## Publishing
-
-After building your library with `ng build core`, go to the dist folder `cd dist/core` and run `npm publish`.
-
-## Running unit tests
-
-Run `ng test core` to execute the unit tests via [Karma](https://karma-runner.github.io).
-
-## Further help
-
-To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
+# Core
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 14.0.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project core` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project core`.
+> Note: Don't forget to add `--project core` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build core` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build core`, go to the dist folder `cd dist/core` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test core` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/config/ax-preset.js

@@ -1,5 +1,5 @@
 const plugin = require('tailwindcss/plugin');
-const withAnimations = require('animated-tailwindcss');
+
 function withOpacityValue(variable) {
     return ({ opacityValue }) => {
         if (opacityValue === undefined) {
@@ -9,7 +9,7 @@ function withOpacityValue(variable) {
     }
 }
 
-module.exports = withAnimations({
+module.exports = {
     prefix: 'ax-',
     darkMode: 'class',
     mode: "jit",
@@ -17,7 +17,7 @@ module.exports = withAnimations({
         "./src/**/*.{html,ts,scss}",
         "./projects/**/*.{html,ts,scss}",
         "./dist/acorex/**/*.{html,ts,scss}",
-        "./node_modules/@acorex/**/*.{html,ts,js,mjs,scss}",
+        "./node_modules/@acorex/**/*.{html,ts,scss}",
     ],
     darkMode: "class", // or 'media' or 'class'
     theme: {
@@ -133,24 +133,8 @@ module.exports = withAnimations({
                 },
 
             },
-            width: {
-                'base': 'calc((var(--ax-base-size) * var(--ax-base-ratio)))'
-            },
-            minWidth: {
-                'base': 'calc((var(--ax-base-size) * var(--ax-base-ratio)))'
-            },
             maxWidth: {
                 '8xl': '90rem',
-                'base': 'calc((var(--ax-base-size) * var(--ax-base-ratio)))'
-            },
-            height: {
-                'base': 'calc((var(--ax-base-size) * var(--ax-base-ratio)))'
-            },
-            minHeight: {
-                'base': 'calc((var(--ax-base-size) * var(--ax-base-ratio)))'
-            },
-            maxHeight: {
-                'base': 'calc((var(--ax-base-size) * var(--ax-base-ratio)))'
             },
             keyframes: {
                 fadeIn: {
@@ -185,12 +169,6 @@ module.exports = withAnimations({
                 },
                 '.text-default': {
                     backgroundColor: 'rgb(var(--ax-color-default-color) / var(--tw-text-opacity))'
-                },
-                '.rtl': {
-                    direction: 'rtl'
-                },
-                '.ltr': {
-                    direction: 'ltr'
                 }
             }
             addUtilities(acorexClasses, ['responsive', 'hover', 'focus'])
@@ -200,5 +178,9 @@ module.exports = withAnimations({
         require('tailwindcss'),
         require('autoprefixer'),
         require('tailwind-rtl-utilities')
+        // require('@tailwindcss/aspect-ratio'),
+        // require('@tailwindcss/forms'),
+        // require('@tailwindcss/line-clamp'),
+        // require('@tailwindcss/typography')
     ],
-});
+};

package/config/index.ts

@@ -0,0 +1 @@
+export * from './public-api';

package/config/ng-package.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "../../../../node_modules/ng-packagr/ng-package.schema.json",
+  "lib": {
+    "entryFile": "public-api.ts"
+  }
+}

package/config/public-api.ts

@@ -0,0 +1 @@
+export * from './src/configs';

package/config/src/configs.ts

@@ -0,0 +1,37 @@
+import { get, set, merge } from 'lodash-es';
+import { Subject, Observable } from 'rxjs';
+
+// @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') {
+      set(AXConfig.dataModel, arg1, arg2);
+      AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+      return true;
+    }
+    if (arg1 && typeof arg1 == 'object') {
+      merge(AXConfig.dataModel, arg1);
+      AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+      return true;
+    }
+    if (!arg1 && !arg2) {
+      return AXConfig.dataChangeSubject.asObservable();
+    }
+    // TODO: Arash please check 'Not all code paths return a value.'.
+    // if remove return you can see error on line 15.
+    return '';
+  }
+
+  static get(path: string, defaultValue?: any): any {
+    return get(AXConfig.dataModel, path, defaultValue);
+  }
+}

package/dateTime/index.ts

@@ -0,0 +1 @@
+export * from './public-api';

package/dateTime/ng-package.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "../../../../node_modules/ng-packagr/ng-package.schema.json",
+  "lib": {
+    "entryFile": "public-api.ts"
+  }
+}

package/dateTime/public-api.ts

@@ -0,0 +1,5 @@
+export * from './src/datetime.class';
+export * from './src/datetime.module';
+export * from './src/datetime.pipe';
+export * from './src/georgian.calendar';
+export * from './src/jalali.calendar';

package/dateTime/src/datetime.class.ts

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

@@ -0,0 +1,29 @@
+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'
+            }
+        });
+
+    }
+}