@acorex/core 5.0.5 → 5.0.9

package/fesm2015/acorex-core.js

@@ -0,0 +1,1169 @@
+import * as i0 from '@angular/core';
+import { Pipe, NgModule, Injectable } from '@angular/core';
+import * as i1 from '@angular/platform-browser';
+import { Subject } from 'rxjs';
+import merge from 'lodash-es/merge';
+
+// @dynamic
+class AXObjectUtil {
+    static deepJSONClone(obj) {
+        return obj ? JSON.parse(JSON.stringify(obj)) : null;
+    }
+    static deepCopy(obj) {
+        let copy;
+        // Handle the 3 simple types, and null or undefined
+        if (null == obj || 'object' !== typeof obj) {
+            return obj;
+        }
+        // Handle Date
+        if (obj instanceof Date) {
+            copy = new Date();
+            copy.setTime(obj.getTime());
+            return copy;
+        }
+        // Handle Array
+        if (obj instanceof Array) {
+            copy = [];
+            for (let i = 0, len = obj.length; i < len; i++) {
+                copy[i] = AXObjectUtil.deepCopy(obj[i]);
+            }
+            return copy;
+        }
+        // Handle Object
+        if (obj instanceof Object) {
+            copy = {};
+            for (const attr in obj) {
+                if (obj.hasOwnProperty(attr)) {
+                    copy[attr] = AXObjectUtil.deepCopy(obj[attr]);
+                }
+            }
+            return copy;
+        }
+        throw new Error('Unable to copy obj! Its type isn\'t supported.');
+    }
+    static fetchProp(obj, prop) {
+        if (typeof obj === 'undefined') {
+            return false;
+        }
+        const index = prop.indexOf('.');
+        if (index > -1) {
+            return AXObjectUtil.fetchProp(obj[prop.substring(0, index)], prop.substr(index + 1));
+        }
+        return obj[prop];
+    }
+    static getPropByPath(obj, path, defaultVal) {
+        path = path
+            .replace(/\[/g, '.')
+            .replace(/]/g, '')
+            .split('.');
+        path.forEach((level) => {
+            if (obj) {
+                obj = obj[level];
+            }
+        });
+        if (obj === undefined) {
+            return defaultVal;
+        }
+        return obj;
+    }
+    static setPropByPath(obj, path, value) {
+        if (Object(obj) !== obj) {
+            return obj;
+        } // When obj is not an object
+        // If not yet an array, get the keys from the string-path
+        if (!Array.isArray(path)) {
+            path = path.toString().match(/[^.[\]]+/g) || [];
+        }
+        path.slice(0, -1).reduce((a, c, i) => // Iterate all of them except the last one
+         Object(a[c]) === a[c] // Does the key exist and is its value an object?
+            // Yes: then follow that path
+            ? a[c]
+            // No: create the key. Is the next key a potential array-index?
+            : a[c] = Math.abs(path[i + 1]) >> 0 === +path[i + 1]
+                ? [] // Yes: assign a new array object
+                : {}, // No: assign a new plain object
+        obj)[path[path.length - 1]] = value; // Finally assign the value to the last key
+        return obj; // Return the top-level object to allow chaining
+    }
+}
+
+// @dynamic
+class AXDrawingUtil {
+    static collision(a, b) {
+        const ac = a.getBoundingClientRect();
+        const bc = b.getBoundingClientRect();
+        if (ac.left < bc.left + bc.width && ac.left + ac.width > bc.left &&
+            ac.top < bc.top + bc.height && ac.top + ac.height > bc.top) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    static isInElementBound(pos, element) {
+        const elBound = element.getBoundingClientRect();
+        return AXDrawingUtil.isInRecPoint(pos, {
+            left: elBound.x,
+            width: elBound.width,
+            top: elBound.y,
+            height: elBound.height
+        });
+    }
+    static isInRecPoint(pos, rec) {
+        return pos.x >= rec.left && pos.x <= (rec.left + rec.width) && pos.y >= rec.top && (pos.y <= (rec.top + rec.height));
+    }
+}
+
+class AXSafePipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(value, type) {
+        if (value == null || value == undefined || value == '')
+            return null;
+        switch (type) {
+            case 'html': return this.sanitizer.bypassSecurityTrustHtml(value);
+            case 'style': return this.sanitizer.bypassSecurityTrustStyle(value);
+            case 'script': return this.sanitizer.bypassSecurityTrustScript(value);
+            case 'url': return this.sanitizer.bypassSecurityTrustUrl(value);
+            case 'resourceUrl': return this.sanitizer.bypassSecurityTrustResourceUrl(value);
+            default: throw new Error(`Invalid safe type specified: ${type}`);
+        }
+    }
+}
+AXSafePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXSafePipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+AXSafePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXSafePipe, name: "safe" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXSafePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safe',
+                    pure: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+
+class AXCoreModule {
+}
+AXCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXCoreModule, declarations: [AXSafePipe], exports: [AXSafePipe] });
+AXCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXCoreModule, providers: [], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [AXSafePipe],
+                    declarations: [AXSafePipe],
+                    providers: [],
+                }]
+        }] });
+
+// @dynamic
+class AXConfig {
+    static get onChange() {
+        return AXConfig.dataChangeSubject.asObservable();
+    }
+    static set(arg1, arg2) {
+        if (arg1 && typeof arg1 == 'string') {
+            AXObjectUtil.setPropByPath(AXConfig.dataModel, arg1, arg2);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (arg1 && typeof arg1 == 'object') {
+            //TODO : fix override
+            Object.assign(AXConfig.dataModel, arg1);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (!arg1 && !arg2) {
+            return AXConfig.dataChangeSubject.asObservable();
+        }
+    }
+    static get(path, defaultValue) {
+        return AXObjectUtil.getPropByPath(AXConfig.dataModel, path) || defaultValue;
+    }
+}
+AXConfig.dataModel = {};
+AXConfig.dataChangeSubject = new Subject();
+
+// @dynamic
+class AXDateTime {
+    constructor(value = new Date(), calendar = AXConfig.get('dateTime.type') || 'gregorian') {
+        this._calendar =
+            // typeof calendar == 'string'
+            //   ? eval(`new ${AX_CALENDARS.find((c) => c.name == calendar).type}()`)
+            //   : calendar;
+            typeof calendar == 'string'
+                ? AXConfig.get(`dateTime.calendars.${calendar}`)
+                : calendar;
+        if (value instanceof Date) {
+            this._date = value;
+        }
+        else {
+            this._date = new Date(value);
+        }
+    }
+    static convert(value, calendar = AXConfig.get('dateTime.type') || 'gregorian') {
+        let date;
+        if (typeof value === 'string' || value instanceof String) {
+            date = new AXDateTime(value, calendar);
+        }
+        else if (value instanceof Date) {
+            date = new AXDateTime(value, calendar);
+        }
+        else if (value instanceof AXDateTime) {
+            date = new AXDateTime(value.date, calendar);
+        }
+        return date;
+    }
+    get date() {
+        return this._date;
+    }
+    get calendar() {
+        return this._calendar;
+    }
+    clone() {
+        return new AXDateTime(this.date, this.calendar.name());
+    }
+    get dayOfMonth() {
+        return this._calendar.dayOfMonth(this.date);
+    }
+    get dayOfYear() {
+        return this._calendar.dayOfYear(this.date);
+    }
+    get dayOfWeek() {
+        return this._calendar.dayOfWeek(this.date);
+    }
+    get hour() {
+        return this._date.getHours();
+    }
+    get minute() {
+        return this._date.getMinutes();
+    }
+    get second() {
+        return this._date.getSeconds();
+    }
+    get year() {
+        return this._calendar.year(this.date);
+    }
+    get monthOfYear() {
+        return this._calendar.monthOfYear(this.date);
+    }
+    get weekOfYear() {
+        return this._calendar.weekOfYear(this.date);
+    }
+    get month() {
+        return new AXCalendarMonth(this);
+    }
+    add(unit, amount) {
+        return this._calendar.add(this.date, unit, amount);
+    }
+    set(unit = 'day', value) {
+        return this._calendar.set(this.date, unit, value);
+    }
+    duration(end, unit = 'day') {
+        const range = new AXDateTimeRange(this, AXDateTime.convert(end, this.calendar.name()));
+        return range.duration();
+    }
+    startOf(unit = 'day') {
+        return this._calendar.startOf(this.date, unit);
+    }
+    endOf(unit = 'day') {
+        return this._calendar.endOf(this.date, unit);
+    }
+    format(format = AXConfig.get('dateTime.shortDateFormat') ||
+        'DDD, dd MMM yyyy') {
+        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.dayOfMonth(this.date), 2));
+        format = format.replace('d', this.calendar.dayOfMonth(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.dayOfWeek(this.date) - 1]);
+        format = format.replace('DDD', this.calendar.dayShortNames[this.calendar.dayOfWeek(this.date) - 1]);
+        format = format.replace(/D(?!e)/, this.calendar.dayNames[this.calendar.dayOfWeek(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;
+    }
+    pad(n, width, z = '0') {
+        n = n + '';
+        return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
+    }
+    toString() {
+        return this.format();
+    }
+    equal(value, unit = 'day') {
+        return this.compare(value, unit) == 0;
+    }
+    compare(value, unit = 'day') {
+        const val = AXDateTime.convert(value);
+        const func = (v1, v2) => {
+            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) {
+        return AXDateTime.convert(this, calendar);
+    }
+}
+class AXCalendarMonth {
+    constructor(date) {
+        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));
+    }
+    get range() {
+        return this._range;
+    }
+    set range(v) {
+        this._range = v;
+    }
+}
+class AXDateTimeRange {
+    constructor(startTime, endTime) {
+        this._startTime = startTime;
+        this._endTime = endTime;
+    }
+    get startTime() {
+        return this._startTime;
+    }
+    get endTime() {
+        return this._endTime;
+    }
+    duration() {
+        const result = {
+            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 = 'day', amount = 1) {
+        // TODO: setptemper savingtime issue
+        const result = [];
+        let item = this._startTime.clone();
+        while (item.compare(this._endTime, unit) < 1) {
+            result.push(item);
+            item = item.add(unit, amount);
+        }
+        return result;
+    }
+    includes(value, unit = 'day') {
+        // TODO: ??
+        return true;
+    }
+}
+
+class AXDateTimePipe {
+    constructor() { }
+    transform(value, format, calendar) {
+        if (value == null) {
+            return '';
+        }
+        const date = value instanceof AXDateTime ? value.clone() : AXDateTime.convert(value, calendar);
+        if (!format) {
+            return date.toString();
+        }
+        else {
+            return date.format(format);
+        }
+    }
+}
+AXDateTimePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+AXDateTimePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimePipe, name: "axDate" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'axDate' }]
+        }], ctorParameters: function () { return []; } });
+
+class GeorgianCalendar {
+    constructor() {
+        this.monthNames = [
+            "January", "February", "March",
+            "April", "May", "June", "July",
+            "August", "September", "October",
+            "November", "December"
+        ];
+        this.monthShortNames = [
+            "Jan", "Feb", "Mar",
+            "Apr", "May", "Jun", "Jul",
+            "Aug", "Sep", "Oct",
+            "Nov", "Dec"
+        ];
+        this.dayNames = [
+            "Sunday", "Monday", "Tuesday", "Wednesday",
+            "Thursday", "Friday", "Saturday"
+        ];
+        this.dayShortNames = [
+            "Sun", "Mon", "Tue", "Wed",
+            "Thu", "Fri", "Sat"
+        ];
+    }
+    name() {
+        return 'gregorian';
+    }
+    dayOfMonth(date) {
+        return date.getDate();
+    }
+    dayOfYear(date) {
+        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) {
+        return date.getDay() + 1;
+    }
+    weekOfYear(date) {
+        const firstDay = new AXDateTime(date).startOf('year');
+        return Math.ceil((((date.getTime() - firstDay.date.getTime()) / 86400000) + firstDay.date.getDay() + 1) / 7);
+    }
+    year(date) {
+        return date.getFullYear();
+    }
+    monthOfYear(date) {
+        return date.getMonth() + 1;
+    }
+    add(date, unit, amount) {
+        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, unit, value) {
+        throw new Error("Method not implemented.");
+    }
+    startOf(date, unit) {
+        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, unit) {
+        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) {
+        let leapYear = new Date(date.getFullYear(), 1, 29);
+        return leapYear.getDate() == 29;
+    }
+}
+
+class JalaliCalendar {
+    constructor() {
+        this.monthNames = ("فروردین_اردیبهشت_خرداد_تیر_مرداد_شهریور_مهر_آبان_آذر_دی_بهمن_اسفند").split("_");
+        this.monthShortNames = ("فروردین_اردیبهشت_خرداد_تیر_مرداد_شهریور_مهر_آبان_آذر_دی_بهمن_اسفند").split("_");
+        this.dayNames = ("شنبه_یکشنبه_دوشنبه_سه شنبه_چهارشنبه_پنج شنبه_جمعه").split("_");
+        this.dayShortNames = "ش_ی_د_س_چ_پ_ج".split("_");
+    }
+    name() {
+        return 'jalali';
+    }
+    dayOfMonth(date) {
+        return this.toJalali(date).day;
+    }
+    dayOfYear(date) {
+        const j = this.toJalali(date);
+        return (j.month <= 6 ? ((j.month - 1) * 31) : ((6 * 31) + (j.month - 7) * 30)) + j.day;
+    }
+    dayOfWeek(date) {
+        return date.getDay() == 6 ? 1 : date.getDay() + 2;
+    }
+    weekOfYear(date) {
+        //TODO : apply jalali
+        const firstDay = new AXDateTime(date).startOf('year');
+        return Math.ceil((((date.getTime() - firstDay.date.getTime()) / 86400000) + firstDay.date.getDay() + 1) / 7);
+    }
+    year(date) {
+        return this.toJalali(date).year;
+    }
+    monthOfYear(date) {
+        return this.toJalali(date).month;
+    }
+    add(date, unit, amount) {
+        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);
+                    let jd = this.dayOfMonth(date);
+                    let jm = this.monthOfYear(date);
+                    let jy = this.year(date);
+                    jm = (jm + amount) % 12;
+                    if (0 > jm) {
+                        jy += (this.monthOfYear(date) + amount - jm - 12) / 12;
+                        jm += 12;
+                    }
+                    else {
+                        jy += ((this.monthOfYear(date) + amount - jm) / 12);
+                    }
+                    const vv = this.toGregorian(jy, jm, jd);
+                    v.setFullYear(vv.getFullYear());
+                    v.setMonth(vv.getMonth());
+                    v.setDate(vv.getDate());
+                    value = v.valueOf();
+                    break;
+                }
+            case 'week':
+                value += 7 * 86400000 * amount;
+                break;
+            case 'year':
+                {
+                    const v = new Date(value);
+                    let jd = this.dayOfMonth(date);
+                    let jm = this.monthOfYear(date);
+                    let jy = this.year(date);
+                    const vv = this.toGregorian(jy + amount, jm, jd);
+                    v.setFullYear(vv.getFullYear());
+                    v.setMonth(vv.getMonth());
+                    v.setDate(vv.getDate());
+                    value = v.valueOf();
+                }
+                break;
+            case 'day':
+            default:
+                value += 86400000 * amount;
+        }
+        return new AXDateTime(new Date(value), this.name());
+    }
+    set(date, unit, value) {
+        throw new Error("Method not implemented.");
+    }
+    startOf(date, unit) {
+        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":
+                return new AXDateTime(clone, this.name()).add('day', -this.dayOfWeek(clone) + 1).startOf('day');
+            case "month":
+                {
+                    const jy = this.year(date);
+                    const jm = this.monthOfYear(date);
+                    const gDate = this.toGregorian(jy, jm, 1);
+                    return new AXDateTime(gDate, this.name()).startOf('day');
+                }
+            case "year":
+                {
+                    const jy = this.year(date);
+                    const gDate = this.toGregorian(jy, 1, 1);
+                    return new AXDateTime(gDate, this.name()).startOf('day');
+                }
+        }
+    }
+    endOf(date, unit) {
+        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':
+                {
+                    const jy = this.year(date);
+                    const jm = this.monthOfYear(date);
+                    const jd = this.monthLength(jy, jm);
+                    const gDate = this.toGregorian(jy, jm, jd);
+                    return new AXDateTime(gDate, this.name()).endOf('day');
+                }
+            case "year":
+                let jy = this.year(date);
+                const gDate = this.toGregorian(jy, 12, this.monthLength(jy, 12));
+                return new AXDateTime(gDate, this.name()).endOf('day');
+        }
+    }
+    toJalali(date) {
+        const gy = date.getFullYear();
+        const gm = date.getMonth() + 1;
+        const gd = date.getDate();
+        const r = this.d2j(this.g2d(gy, gm, gd));
+        return {
+            year: r.jy,
+            month: r.jm,
+            day: r.jd,
+        };
+    }
+    /*
+      Converts a Jalaali date to Gregorian.
+    */
+    toGregorian(jy, jm, jd) {
+        const g = this.d2g(this.j2d(jy, jm, jd));
+        return new Date(g.gy, g.gm - 1, g.gd);
+    }
+    /*
+      Checks whether a Jalaali date is valid or not.
+    */
+    isValid(jy, jm, jd) {
+        return jy >= -61 && jy <= 3177 &&
+            jm >= 1 && jm <= 12 &&
+            jd >= 1 && jd <= this.monthLength(jy, jm);
+    }
+    /*
+      Is this a leap year or not?
+    */
+    isLeapYear(jy) {
+        return this.jalCal(jy).leap === 0;
+    }
+    /*
+      Number of days in a given month in a Jalaali year.
+    */
+    monthLength(jy, jm) {
+        if (jm <= 6)
+            return 31;
+        if (jm <= 11)
+            return 30;
+        if (this.isLeapYear(jy))
+            return 30;
+        return 29;
+    }
+    jalCal(jy) {
+        // Jalaali years starting the 33-year rule.
+        let breaks = [-61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181, 1210,
+            1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178
+        ], bl = breaks.length, gy = jy + 621, leapJ = -14, jp = breaks[0], jm, jump, leap, leapG, march, n, i;
+        if (jy < jp || jy >= breaks[bl - 1])
+            throw new Error('Invalid Jalaali year ' + jy);
+        // Find the limiting years for the Jalaali year jy.
+        for (i = 1; i < bl; i += 1) {
+            jm = breaks[i];
+            jump = jm - jp;
+            if (jy < jm)
+                break;
+            leapJ = leapJ + this.div(jump, 33) * 8 + this.div(this.mod(jump, 33), 4);
+            jp = jm;
+        }
+        n = jy - jp;
+        // Find the number of leap years from AD 621 to the beginning
+        // of the current Jalaali year in the Persian calendar.
+        leapJ = leapJ + this.div(n, 33) * 8 + this.div(this.mod(n, 33) + 3, 4);
+        if (this.mod(jump, 33) === 4 && jump - n === 4)
+            leapJ += 1;
+        // And the same in the Gregorian calendar (until the year gy).
+        leapG = this.div(gy, 4) - this.div((this.div(gy, 100) + 1) * 3, 4) - 150;
+        // Determine the Gregorian date of Farvardin the 1st.
+        march = 20 + leapJ - leapG;
+        // Find how many years have passed since the last leap year.
+        if (jump - n < 6)
+            n = n - jump + this.div(jump + 4, 33) * 33;
+        leap = this.mod(this.mod(n + 1, 33) - 1, 4);
+        if (leap === -1) {
+            leap = 4;
+        }
+        return {
+            leap: leap,
+            gy: gy,
+            march: march
+        };
+    }
+    /*
+      Converts a date of the Jalaali calendar to the Julian Day number.
+      @param jy Jalaali year (1 to 3100)
+      @param jm Jalaali month (1 to 12)
+      @param jd Jalaali day (1 to 29/31)
+      @return Julian Day number
+    */
+    j2d(jy, jm, jd) {
+        let r = this.jalCal(jy);
+        return this.g2d(r.gy, 3, r.march) + (jm - 1) * 31 - this.div(jm, 7) * (jm - 7) + jd - 1;
+    }
+    /*
+      Converts the Julian Day number to a date in the Jalaali calendar.
+      @param jdn Julian Day number
+      @return
+        jy: Jalaali year (1 to 3100)
+        jm: Jalaali month (1 to 12)
+        jd: Jalaali day (1 to 29/31)
+    */
+    d2j(jdn) {
+        let gy = this.d2g(jdn).gy // Calculate Gregorian year (gy).
+        , jy = gy - 621, r = this.jalCal(jy), jdn1f = this.g2d(gy, 3, r.march), jd, jm, k;
+        // Find number of days that passed since 1 Farvardin.
+        k = jdn - jdn1f;
+        if (k >= 0) {
+            if (k <= 185) {
+                // The first 6 months.
+                jm = 1 + this.div(k, 31);
+                jd = this.mod(k, 31) + 1;
+                return {
+                    jy: jy,
+                    jm: jm,
+                    jd: jd
+                };
+            }
+            else {
+                // The remaining months.
+                k -= 186;
+            }
+        }
+        else {
+            // Previous Jalaali year.
+            jy -= 1;
+            k += 179;
+            if (r.leap === 1)
+                k += 1;
+        }
+        jm = 7 + this.div(k, 30);
+        jd = this.mod(k, 30) + 1;
+        return {
+            jy: jy,
+            jm: jm,
+            jd: jd
+        };
+    }
+    g2d(gy, gm, gd) {
+        let d = this.div((gy + this.div(gm - 8, 6) + 100100) * 1461, 4)
+            + this.div(153 * this.mod(gm + 9, 12) + 2, 5)
+            + gd - 34840408;
+        d = d - this.div(this.div(gy + 100100 + this.div(gm - 8, 6), 100) * 3, 4) + 752;
+        return d;
+    }
+    d2g(jdn) {
+        let j, i, gd, gm, gy;
+        j = 4 * jdn + 139361631;
+        j = j + this.div(this.div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908;
+        i = this.div(this.mod(j, 1461), 4) * 5 + 308;
+        gd = this.div(this.mod(i, 153), 5) + 1;
+        gm = this.mod(this.div(i, 153), 12) + 1;
+        gy = this.div(j, 1461) - 100100 + this.div(8 - gm, 6);
+        return {
+            gy: gy,
+            gm: gm,
+            gd: gd
+        };
+    }
+    /*
+      Utility helper functions.
+    */
+    div(a, b) {
+        return ~~(a / b);
+    }
+    mod(a, b) {
+        return a - ~~(a / b) * b;
+    }
+}
+
+class AXDateTimeModule {
+    constructor() {
+        AXConfig.set({
+            dateTime: {
+                calendars: {
+                    jalali: new JalaliCalendar(),
+                    gregorian: new GeorgianCalendar()
+                }
+            }
+        });
+    }
+}
+AXDateTimeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXDateTimeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimeModule, declarations: [AXDateTimePipe], exports: [AXDateTimePipe] });
+AXDateTimeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimeModule, providers: [], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [AXDateTimePipe],
+                    declarations: [AXDateTimePipe],
+                    providers: [],
+                }]
+        }], ctorParameters: function () { return []; } });
+
+// @dynamic
+class AXTranslator {
+    static get onChange() {
+        return AXTranslator.dataChangeSubject.asObservable();
+    }
+    static load(lang, value) {
+        if (typeof value === 'object') {
+            if (!AXTranslator[`__data__${lang}`]) {
+                AXTranslator[`__data__${lang}`] = {};
+            }
+            AXTranslator[`__data__${lang}`] = merge(AXTranslator[`__data__${lang}`], value);
+        }
+    }
+    static use(lang) {
+        AXTranslator.lang = lang;
+    }
+    static get(key, lang) {
+        return AXObjectUtil.getPropByPath(AXTranslator[`__data__${lang || AXTranslator.lang}`], key) || key;
+    }
+}
+AXTranslator.lang = 'en';
+AXTranslator.dataChangeSubject = new Subject();
+
+class AXTranslatorPipe {
+    transform(value, lang) {
+        return AXTranslator.get(value, lang);
+    }
+}
+AXTranslatorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslatorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+AXTranslatorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslatorPipe, name: "trans" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslatorPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'trans', pure: true }]
+        }] });
+
+class AXTranslationModule {
+}
+AXTranslationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXTranslationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslationModule, declarations: [AXTranslatorPipe], exports: [AXTranslatorPipe] });
+AXTranslationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslationModule, providers: [], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [AXTranslatorPipe],
+                    declarations: [AXTranslatorPipe],
+                    providers: [],
+                }]
+        }] });
+
+const isChrome = (win) => testUserAgent(win, /Chrome/i);
+const isFirefox = (win) => testUserAgent(win, /Firefox/i);
+const isEdge = (win) => testUserAgent(win, /Edge/i);
+const isSafari = (win) => testUserAgent(win, /Safari/i);
+const isOpera = (win) => testUserAgent(win, /Opera/i) || testUserAgent(win, /OPR/i);
+const isMSIE = (win) => testUserAgent(win, /MSIE/i) || testUserAgent(win, /Trident/i);
+const isMobileWeb = (win) => isMobile(win) && !isHybrid(win);
+const isIpad = (win) => {
+    // iOS 12 and below
+    if (testUserAgent(win, /iPad/i)) {
+        return true;
+    }
+    // iOS 13+
+    if (testUserAgent(win, /Macintosh/i) && isMobile(win)) {
+        return true;
+    }
+    return false;
+};
+const isIphone = (win) => testUserAgent(win, /iPhone/i);
+const isIOS = (win) => testUserAgent(win, /iPhone|iPod/i) || isIpad(win);
+const isAndroid = (win) => testUserAgent(win, /android|sink/i);
+const isAndroidTablet = (win) => {
+    return isAndroid(win) && !testUserAgent(win, /mobile/i);
+};
+const isPhablet = (win) => {
+    const width = win.innerWidth;
+    const height = win.innerHeight;
+    const smallest = Math.min(width, height);
+    const largest = Math.max(width, height);
+    return (smallest > 390 && smallest < 520) &&
+        (largest > 620 && largest < 800);
+};
+const isTablet = (win) => {
+    const width = win.innerWidth;
+    const height = win.innerHeight;
+    const smallest = Math.min(width, height);
+    const largest = Math.max(width, height);
+    return (isIpad(win) ||
+        isAndroidTablet(win) ||
+        ((smallest > 460 && smallest < 820) &&
+            (largest > 780 && largest < 1400)));
+};
+const isMobile = (win) => matchMedia(win, '(any-pointer:coarse)');
+const isDesktop = (win) => !isMobile(win);
+const isHybrid = (win) => isCordova(win) || isCapacitorNative(win);
+const isCordova = (win) => !!(win['cordova'] || win['phonegap'] || win['PhoneGap']);
+const isCapacitorNative = (win) => {
+    const capacitor = win['Capacitor'];
+    return !!(capacitor && capacitor.isNative);
+};
+const isElectron = (win) => testUserAgent(win, /electron/i);
+const isPWA = (win) => !!(win.matchMedia('(display-mode: standalone)').matches || win.navigator.standalone);
+const testUserAgent = (win, expr) => expr.test(win.navigator.userAgent);
+const matchMedia = (win, query) => win.matchMedia(query).matches;
+const PLATFORMS_MAP = {
+    'Android': isAndroid,
+    'iOS': isIOS,
+    'Desktop': isDesktop,
+    'Mobile': isMobile,
+    'Chrome': isChrome,
+    'Firefox': isFirefox,
+    'Safari': isSafari,
+    'Edge': isEdge,
+    'Opera': isOpera,
+    'Hybrid': isHybrid,
+    'PWA': isPWA,
+    'Electron': isElectron,
+};
+class AXPlatformEvent {
+}
+class AXPlatform {
+    constructor() {
+        this.resize = new Subject();
+        this.click = new Subject();
+        this.scroll = new Subject();
+        window.addEventListener('resize', (e) => {
+            this.resize.next({
+                nativeEvent: e,
+                source: this
+            });
+        });
+        document.addEventListener('click', (e) => {
+            this.click.next({
+                nativeEvent: e,
+                source: this
+            });
+        }, true);
+        document.addEventListener('scroll', (e) => {
+            this.scroll.next({
+                nativeEvent: e,
+                source: this
+            });
+        }, true);
+    }
+    isRtl() {
+        return document.dir == 'rtl' || document.body.dir == 'rtl' || document.body.style.direction == 'rtl';
+    }
+    isLandscape() {
+        return window.innerHeight < window.innerWidth;
+    }
+    isPortrate() {
+        return !this.isLandscape();
+    }
+    is(name) {
+        return PLATFORMS_MAP[name](window) || false;
+    }
+    switchDarkMode() {
+        const _html = document.getElementsByTagName("html")[0];
+        const _class = 'ax-dark-mode';
+        const _isDark = _html.classList.contains(_class);
+        if (_isDark) {
+            _html.classList.remove(_class);
+            localStorage.setItem("MODE", "light");
+        }
+        else {
+            _html.classList.add(_class);
+            localStorage.setItem("MODE", "dark");
+        }
+    }
+}
+AXPlatform.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXPlatform, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXPlatform.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXPlatform, providedIn: 'platform' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXPlatform, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'platform',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+/**
+ * Public API refrences of core libraries
+ * @module @acorex/core
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXCalendarMonth, AXConfig, AXCoreModule, AXDateTime, AXDateTimeModule, AXDateTimePipe, AXDateTimeRange, AXDrawingUtil, AXObjectUtil, AXPlatform, AXPlatformEvent, AXSafePipe, AXTranslationModule, AXTranslator, AXTranslatorPipe, GeorgianCalendar, testUserAgent };
+//# sourceMappingURL=acorex-core.js.map