datex.js 1.0.10 → 1.0.12

package/src/module/method/base.js

@@ -0,0 +1,135 @@
+import {periodKey,periodTime} from './map/period';
+
+export default function(datex,proto){
+
+    Object.assign(proto,{
+        toDate(){
+            return this._date;
+        },
+        toObject(){
+            let _ = this._date;
+            return {
+                'year':_.getFullYear(),
+                'month':_.getMonth()+1,
+                'day':_.getDate(),
+                'hour':_.getHours(),
+                'minute':_.getMinutes(),
+                'second':_.getSeconds(),
+                'millsecond':_.getMilliseconds(),
+                'timestamp':_.getTime(),
+                'week':_.getDay()
+            };
+        },
+        toArray(){
+            let $ = this.toObject();
+            return periodKey.map(name=>$[name]);
+        },
+        toString(){
+            return this._date.toString();
+        },
+        toISOString(){
+            return this._date.toISOString();
+        },
+        getTime(){
+            return this._date.getTime();
+        },
+        getUnix(){
+            return ~~(this._date.getTime()/1000);
+        },
+        clone(){
+            let that = this;
+            let clone =  datex(this.getTime());
+            Object.getOwnPropertyNames(that).forEach(function(name){
+                if(name!='_date'){
+                    clone[name] = that[name];
+                }
+            });
+            return clone;
+        },
+        isValid(){
+            return !isNaN(this.getTime());
+        },
+        set(unit,value){
+            let _ = this._date;
+            let $ = this.toObject();
+            switch (unit) {
+                case 'year':
+                    _.setFullYear(value);
+                    break;
+                case 'month':
+                    _.setMonth(value-1);
+                    break;
+                case 'day':
+                    _.setDate(value);
+                    break;
+                case 'hour':
+                    _.setHours(value);
+                    break;
+                case 'minute':
+                    _.setMinutes(value);
+                    break;
+                case 'second':
+                    _.setSeconds(value);
+                    break;
+                case 'millsecond':
+                    _.setMilliseconds(value);
+                    break;
+                case 'timestamp':
+                    _.setTime(value);
+                    break;
+                case 'week':
+                    _.setDate($.day-$.week+value);
+                    break;
+            }
+            return this;
+        },
+        change(unit,value){
+            let $ = this.toObject();
+            if(typeof periodTime[unit]!='undefined'){
+                return this.set('timestamp',$['timestamp']+value*periodTime[unit]);
+            }else{
+                return this.set(unit,$[unit]+value);
+            }
+        },
+        get(unit){
+            let $ = this.toObject();
+            return $[unit];
+        },
+        format(pattern = 'YYYY-MM-DD HH:mm:ss'){
+            let that = this.clone();
+            let _ = that._date;
+            let $ = that.toObject();
+            let match = _.toTimeString().match(/GMT([\+\-])(\d{2})(\d{2})/);
+            let map = {
+                'YYYY':''+$.year,
+                'YY':(''+$.year).padStart(2,'0'),
+                'MM':(''+$.month).padStart(2,'0'),
+                'M':''+$.month,
+                'DD':(''+$.day).padStart(2,'0'),
+                'D':''+$.day,
+                'HH':(''+$.hour).padStart(2,'0'),
+                'H':''+$.hour,
+                'hh':(''+($.hour%12)).padStart(2,'0'),
+                'h':''+($.hour%12),
+                'mm':(''+$.minute).padStart(2,'0'),
+                'm':''+$.minute,
+                'ss':(''+$.second).padStart(2,'0'),
+                's':''+$.second,
+                'S':''+(~~(($.millsecond%1000)/100)),
+                'SS':''+(~~(($.millsecond%1000)/10)),
+                'SSS':''+($.millsecond%1000),
+                'Z':match[1]+match[2]+':'+match[3],
+                'ZZ':match[1]+match[2]+match[3],
+                'A':['AM','PM'][~~($.hour/12)],
+                'a':['am','pm'][~~($.hour/12)],
+                'X':$.timestamp,
+                'x':~~($.timestamp/1000),
+                'Q':''+(~~($.month/3)),
+                'W':$.week
+            };
+            return pattern.replace(/Y+|M+|D+|H+|h+|m+|s+|S+|Z+|A|a|X|x|Q|W+/g,function(key){
+                return map[key]||'';
+            });
+        }
+    });
+};

package/src/module/method/compare.js

@@ -0,0 +1,22 @@
+export default function(datex,proto){
+    
+    Object.assign(proto,{
+        isAfter(that,unit = 'timestamp'){
+            that = datex(that);
+            return this.get(unit)>that.get(unit);
+        },
+        isBefore(that,unit = 'timestamp'){
+            that = datex(that);
+            return this.get(unit)<that.get(unit);
+        },
+        isBetween(startDate,endDate,unit = 'timestamp'){
+            startDate = datex(startDate);
+            endDate = datex(endDate);
+            return this.get(unit)>startDate.get(unit)&&this.get(unit)<endDate.get(unit);
+        },
+        isSame(that,unit = 'timestamp'){
+            that = datex(that);
+            return this.get(unit)==that.get(unit);
+        }
+    });
+};

package/src/module/method/compute.js

@@ -0,0 +1,64 @@
+import {periodKey,periodValue,periodTime} from './map/period';
+
+export default function(datex,proto){
+
+    Object.assign(proto,{
+        diffWith(that,unit){
+            that = datex(that);
+            if(!that.isValid()){
+                return false;
+            }
+            let timestamp = this.getTime()-that.getTime();
+            let value = 0;
+            if(unit){
+                if(periodTime[unit]){
+                    value = ~~(timestamp/periodTime[unit]);
+                }else if(unit=='month'){
+                    let this_month = 12*(this.get('year')-1)+this.get('month');
+                    let that_month = 12*(that.get('year')-1)+that.get('month');
+                    value = this_month -that_month;
+                    if(value<0&&this.get('day')>that.get('day')){
+                        value+=1;
+                    }else if(value>0&&this.get('day')<that.get('day')){
+                        value-=1;
+                    }
+                }else if(unit=='year'){
+                    value = this.get('year') - that.get('year');
+                    if(value<0&&(this.get('month')>that.get('month')||this.get('month')==that.get('month')&&this.get('day')>that.get('day'))){
+                        value+=1;
+                    }else if(value>0&&(this.get('month')<that.get('month')||this.get('month')==that.get('month')&&this.get('day')<that.get('day'))){
+                        value-=1;
+                    }
+                }
+                return value;
+            }else{
+                let clone = this.clone();
+                let hash = {};
+                periodKey.forEach(function(unit){
+                    hash[unit] = clone.diffWith(that,unit);
+                    clone.set(unit,that.get(unit));
+                });
+                return hash;
+            }
+        },
+        endOf(unit){
+            return this.startOf(unit).change(unit,unit=='week'?7:1).change('millsecond',-1);
+        },
+        startOf(unit){
+            let $ = this.toObject();
+            let that = null;
+            let index = periodKey.indexOf(unit)+1;
+            let dateSet = this.toArray();
+            let initSet = periodValue.slice(index);
+            dateSet.splice(index,initSet.length,...initSet);
+            if(unit=='timestamp'){
+                that = this.clone();
+            }else if(unit=='week'){
+                that = datex($.year,$.month,$.day-$.week,0,0,0,0);
+            }else{
+                that = datex(...dateSet);
+            }
+            return that;
+        }
+    });
+};

package/src/module/method/language.js

@@ -0,0 +1,72 @@
+import en_us from './locale/en-us';
+import zh_cn from './locale/zh-cn';
+
+export default function(datex,proto){
+    let _langMap = {};
+    _langMap['en-us'] = en_us;
+    _langMap['zh-cn'] = zh_cn;
+    let _lang = 'en-us';
+    if(typeof self!='undefined'&&self.navigator){
+        _lang = self.navigator.language.toLowerCase();
+        if (!_langMap[_lang]) {
+            _lang = 'en-us';
+        }
+    }
+
+    Object.assign(datex,{
+        setLanguage(lang,data={}){
+            lang = lang.toLowerCase();
+            _langMap[lang] = Object.assign(_langMap[lang]||{},data);
+            return this;
+        },
+        switchLanguage(lang){
+            _lang = lang.toLowerCase();
+            return this;
+        },
+        getLanguage(){
+            return _langMap[_lang];
+        }
+    });
+
+    Object.assign(proto,{
+        _langMap:{},
+        _lang:null,
+        setLanguage(lang,data={}){
+            lang = lang.toLowerCase();
+            this._langMap[lang] = Object.assign(this._langMap[lang]||{},data);
+            return this;
+        },
+        switchLanguage(lang){
+            this._lang = lang.toLowerCase();
+            return this;
+        },
+        getLanguage(){
+            return this._langMap[this._lang];
+        }
+    });
+
+    proto.onInit(function(){
+        this._langMap = Object.assign(this._langMap,_langMap);
+        this._lang = _lang;
+    });
+
+    // 重写
+    let format = proto.format;
+    Object.assign(proto,{
+        format(pattern = 'YYYY-MM-DD HH:mm:ss'){
+            let that = this.clone();
+            let $ = that.toObject();
+            let language = datex.getLanguage()||this.getLanguage();
+            let map = {};
+            map['MMM'] = language['MMM'][$.month-1];
+            map['MMMM'] = language['MMMM'][$.month-1];
+            map['Do'] = language['Do'][$.day-1];
+            map['WW'] = language['WW'][$.week];
+            map['WWW'] = language['WWW'][$.week];
+            for (let key in map) {
+                pattern = pattern.replace(key,map[key]||'');
+            }
+            return format.bind(this)(pattern);
+        }
+    });
+};

package/src/module/method/locale/en-us.js

@@ -0,0 +1,7 @@
+export default {
+    'MMM':['Jan.','Feb.','Mar.','Apr.','May.','Jun.','Jul.','Aug.','Sept.','Oct.','Nov.','Dec.'],
+    'MMMM':['January','February','March','April','May','June','July','August','September','October','November','December'],
+    'Do':['1st','2nd','3rd','4th','5th','6th','7th','8th','9th','10th','11th','12th','13th','14th','15th','16th','17th','18th','19th','20th','21st','22nd','23rd','24th','25th','26th','27th','28th','29th','30th','31st'],
+    'WW':['Sun.','Mon.','Tues.','Wed.','Thur.','Fri.','Sat.'],
+    'WWW':['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
+};

package/src/module/method/locale/zh-cn.js

@@ -0,0 +1,7 @@
+export default {
+    'MMM':['1月','2月','3月','4月','5月','6月','7月','8月','9月','10月','11月','12月'],
+    'MMMM':['一月','二月','三月','四月','五月','六月','七月','八月','九月','十月','十一月','十二月'],
+    'Do':['1日','2日','3日','4日','5日','6日','7日','8日','9日','10日','11日','12日','13日','14日','15日','16日','17日','18日','19日','20日','21日','22日','23日','24日','25日','26日','27日','28日','29日','30日','31日'],
+    'WW':['周日','周一','周二','周三','周四','周五','周六'],
+    'WWW':['星期日','星期一','星期二','星期三','星期四','星期五','星期六'],
+};

package/src/module/method/map/period.js

@@ -0,0 +1,9 @@
+export const periodKey = ['year','month','day','hour','minute','second','millsecond'];
+export const periodValue = [1970,1,1,0,0,0,0];
+export const periodTime = {
+    'day':8.64e7,
+    'hour':3.6e6,
+    'minute':6e4,
+    'second':1000,
+    'millsecond':1
+};

package/src/module/method/timezone.js

@@ -0,0 +1,60 @@
+export default function(datex,proto){
+    let _timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    let _offset = 0;
+
+    const convertTimeZone = (date, timeZone) => {return new Date(date.toLocaleString('en-US', { timeZone }))};
+
+    Object.assign(datex,{
+        supportedTimezones:(typeof Intl!='undefined'&&Intl.supportedValuesOf?Intl.supportedValuesOf('timeZone'):[]),
+        switchTimezone(timeZone){
+            _timezone = timeZone;
+            _offset =  convertTimeZone(new Date('1970/1/1'),_timezone).getTime() - (new Date('1970/1/1')).getTime();
+            return this;
+        },
+        getTimezoneOffset(){
+            return (new Date).getTimezoneOffset() - _offset/60000;
+        },
+        getTimezone(){
+            return _timezone;
+        }
+    });
+
+    Object.assign(proto,{
+        _timezone:null,
+        _offset:0,
+        switchTimezone(timezone){
+            this._timezone = timezone;
+            this._offset = convertTimeZone(new Date('1970/1/1'),this._timezone).getTime() - (new Date('1970/1/1')).getTime();
+            return this;
+        },
+        getTimezoneOffset(){
+            return this._date.getTimezoneOffset() - this._offset/60000;
+        },
+        getTimezone(){
+            return this._timezone;
+        }
+    });
+
+    proto.onInit(function(...argu){
+        this._timezone = _timezone;
+        this._offset = _offset;
+        if(argu.length){
+            if(argu[0] instanceof Date){
+            }else if(argu[0] instanceof datex){
+            }else if(argu.length==1&&typeof argu[0]=='number'){
+            }else if(_offset){
+                this._date.setTime(this._date.getTime()-_offset);
+            }
+        }
+    });
+
+    // 重写
+    let format = proto.format;
+    Object.assign(proto,{
+        format(pattern = 'YYYY-MM-DD HH:mm:ss'){
+            let that = this.clone();
+            that._date.setTime(that._date.getTime()+that._offset);
+            return format.bind(that)(pattern);
+        }
+    });
+};

package/src/module/prototype.js

@@ -0,0 +1,63 @@
+import {periodKey,periodValue} from './method/map/period';
+
+function isObject(value){
+    return value != null && (typeof value == 'object' || typeof value == 'function');
+}
+
+let taskQueue = [];
+
+export default {
+    _date:null,
+    init:function(...argu){
+        if(argu.length){
+
+            if(Object.getPrototypeOf(argu[0])==Object.getPrototypeOf(this)){
+                return argu[0];
+            }else if(argu[0] instanceof Date){
+                this._date = argu[0];
+            }else{
+                if(Array.isArray(argu[0])){
+                    argu = periodValue.map((value,index)=>(argu[0][index]||value));
+                }else if(isObject(argu[0])){
+                    argu = periodValue.map((value,index)=>(argu[0][periodKey[index]]||value));
+                }
+                if(argu.length==1&&typeof argu[0]=='string'){
+                    let matchs1 = argu[0].match(/(\d{1,4})[\-\/](\d{1,2})[\-\/](\d{1,2})([\sT](\d{1,2})?:(\d{1,2})?(:(\d{1,2}))?(\.(\d{1,3}))?)?/);
+                    let matchs2 = argu[0].match(/(\d{1,2})[\-\/](\d{1,2})[\-\/](\d{3,4})([\sT](\d{1,2})?:(\d{1,2})?(:(\d{1,2}))?(\.(\d{1,3}))?)?/);
+                    let matchs3 = argu[0].match(/^([12]\d{3})(\d{2})(\d{2})(\d{2})?(\d{2})?(\d{2})?(\d{1,3})?/);
+                    if(matchs1&&!matchs2){
+                        argu = [1,2,3,5,6,8,10].map(function(i,index){
+                            return +(matchs1[i]||periodValue[index]);
+                        });
+                    }else if(matchs2){
+                        argu = [3,1,2,5,6,8,10].map(function(i,index){
+                            return +(matchs2[i]||periodValue[index]);
+                        });
+                    }else if(matchs3){
+                        argu = [1,2,3,4,5,6,7].map(function(i,index){
+                            return +(matchs3[i]||periodValue[index]);
+                        });
+                    }
+                }
+                if(argu.length>=3){
+                    argu[1]--;
+                }
+                this._date = new Date(...argu);
+                if(argu.length>=2&&!isNaN(argu[0])&&argu[0]<100){
+                    this._date.setFullYear(argu[0]);
+                }
+            }
+        }else{
+            this._date = new Date();
+        }
+
+        let _ = this;
+        taskQueue.forEach(function(task){
+            task.bind(_)(...argu);
+        });
+        return this;
+    },
+    onInit:function(callback){
+        taskQueue.push(callback);
+    }
+};