ferngully-aurelia-tools/dist/es2015/services/date-service.js

Ferngully Tools for Aurelia

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { autoinject } from "aurelia-framework";
import * as moment from "moment";
import { ConfigurationService } from "./configuration-service";
let DateService = class DateService {
    constructor(configService) {
        this.configService = configService;
        this.localTimezoneOffset = moment().utcOffset();
    }
    createMoment(date, utc = false) {
        let m = date ? moment(date) : moment();
        if (utc) {
            m = this.momentToUTC(m);
        }
        return m;
    }
    createMomentFromString(str, format, utc = false) {
        let m = moment(str, format, true);
        if (utc) {
            m = this.momentToUTC(m);
        }
        return m;
    }
    createMomentFromTicks(ticks, utc = false) {
        let m = moment(ticks);
        if (utc) {
            m = this.momentToUTC(m);
        }
        return m;
    }
    configure() {
        this.formats = new Map();
        let formatArray = this.configService.get("date-service.formats");
        for (let format of formatArray) {
            this.formats.set(format.key, format.format);
        }
    }
    get tomorrow() {
        var tomorrow = this.createMoment().add(1, 'days');
        var dtTomorrow = new Date(tomorrow.year(), tomorrow.month(), tomorrow.date());
        return dtTomorrow;
    }
    get today() {
        var today = this.createMoment();
        var dtToday = new Date(today.year(), today.month(), today.date());
        return dtToday;
    }
    get utcNow() {
        return this.createMoment(undefined, true).toDate();
    }
    translateUtcToLocal(d) {
        return this.createMoment(d).subtract(this.localTimezoneOffset, "minutes").toDate();
    }
    translateLocalToUtc(d) {
        return this.createMoment(d).add(this.localTimezoneOffset, "minutes").toDate();
    }
    convertFormat(dateString, paramsFrom, paramsTo) {
        if (paramsFrom === paramsTo) {
            return dateString;
        }
        return this.createMomentFromString(dateString, this.getSafeParams(paramsFrom).format).format(this.getSafeParams(paramsTo).format);
    }
    ticksToString(ticks, params) {
        if (!ticks) {
            return "";
        }
        let d = this.createMomentFromTicks(ticks).toDate();
        return this.toString(d, params);
    }
    ticksToDate(ticks) {
        if (!ticks) {
            return null;
        }
        return this.createMomentFromTicks(ticks).toDate();
    }
    dateStringToTicks(dtString, params) {
        if (!dtString) {
            return 0;
        }
        let parms = this.getSafeParams(params);
        return this.createMomentFromString(dtString, parms.format).valueOf();
    }
    dateToTicks(dt) {
        if (!dt) {
            return 0;
        }
        return this.createMoment(dt).valueOf();
    }
    toString(dt, params) {
        if (!dt) {
            return null;
        }
        let parms = this.getSafeParams(params);
        return this.createMoment(dt, parms.utc).format(parms.format);
    }
    toISOString(dt) {
        if (!dt) {
            return null;
        }
        return this.createMoment(dt).toISOString();
    }
    fromISOString(str) {
        if (!str) {
            return null;
        }
        return this.createMomentFromString(str).toDate();
    }
    nameofDay(day) {
        return moment.weekdays(day);
    }
    momentToUTC(m) {
        return m.utc();
    }
    fromString(str, params) {
        if (!str) {
            return null;
        }
        let parms = this.getSafeParams(params);
        return this.createMomentFromString(str, parms.format).toDate();
    }
    nextInstanceOfDay(dayTarget, includeToday = false) {
        let today = this.today;
        let dayToday = today.getDay();
        if ((dayToday === dayTarget) && includeToday) {
            return today;
        }
        let weeklen = dayTarget > dayToday ? 0 : 7;
        let nextInstance = this.createMoment(today).add(weeklen + dayTarget - dayToday, "days");
        return new Date(nextInstance.year(), nextInstance.month(), nextInstance.date());
    }
    getSafeParams(params) {
        if (!params) {
            return {};
        }
        if (typeof (params) === "string") {
            return { format: this.formats.get(params) || params };
        }
        else {
            let parms = params;
            let format = parms.format ? this.formats.get(parms.format) || parms.format : undefined;
            return {
                utc: parms.utc,
                format: format
            };
        }
    }
};
DateService = __decorate([
    autoinject,
    __metadata("design:paramtypes", [ConfigurationService])
], DateService);
export { DateService };
//# sourceMappingURL=date-service.js.map