index.js

// This is a class designed to be an alternative to the standard Date objects
// which uses zoneinfo files to determine and adjust between various timezones.

var fs = require('fs'),
    jspack = require('jspack').jspack;

module.exports.TZDate = TZDate;
module.exports.countrycodes = require("./countrycodes");

var _zoneinfo_path = "/usr/share/zoneinfo";
var _zoneinfo_listcache = {};
var _zoneinfo_cache = {};

module.exports.setZoneinfoPath = function (newpath){
    _zoneinfo_path = newpath;
};

module.exports.setDefaultLocalization = function (localization){
    TZDate.prototype._localization = localization;
};

module.exports.setDefaultTimezone = function (timezone){
    var stat = fs.statSync(_zoneinfo_path + "/" + timezone);
    if (stat.isFile())
    {
        TZDate.prototype._zoneinfo_default = timezone;
        return true;
    }
    else
    {
        return false;
    }
};

var isTimezone = module.exports.isTimezone = function (timezone){
    try {
        var stat = fs.statSync(_zoneinfo_path + "/" + timezone);
        return stat.isFile();
    } catch (err) {
        return false;
    }
};

var parseZonefile = function (timezone){

    var file = _zoneinfo_path + "/" + timezone;

    if (isTimezone(timezone))
    {
        var buffer = fs.readFileSync(file);
        return parseZonefileFn(null, buffer);
    }
    else
    {
        return false;
    }
};

var parseZonefileAsync = function (timezone, callback){
    var file = _zoneinfo_path + "/" + timezone;

    if (isTimezone(timezone))
    {
        fs.readFile(file, function(error, buffer){
            parseZonefileFn(error, buffer, callback);
        });
    }
    else
    {
        callback(new Error("Not a timezon file"));
    }
};

var parseZonefileFn = function (error, buffer, callback){
    if (error) {
        throw new Error(error);
    }

    var tzinfo = {};

    var buffer_idx = 0;

    // From tzfile(5):
    //
    // The time zone information files used by tzset(3)
    // begin with the magic characters "TZif" to identify
    // them as time zone information files, followed by
    // sixteen bytes reserved for future use, followed by
    // six four-byte values of type long, written in a
    // ``standard'' byte order (the high-order  byte
    // of the value is written first).
    if (buffer.slice(0,4).toString('ascii') != "TZif")
    {
        throw "file format not recognized";
    }
    else
    {
        //ignore 16 bytes
        buffer_idx = 20;
        var tmp = jspack.Unpack(">6l", buffer.slice(buffer_idx, buffer_idx + 24));
        buffer_idx += 24;
        // The number of UTC/local indicators stored in the file.
        var _ttisgmtct = tmp[0];
        // The number of standard/wall indicators stored in the file.
        var _ttisstdct = tmp[1];
        // The number of leap seconds for which data is
        // stored in the file.
        var _leapct = tmp[2];
        // The number of "transition times" for which data
        // is stored in the file.
        var _timect = tmp[3];
        // The number of "local time types" for which data
        // is stored in the file (must not be zero).
        var _typect = tmp[4];
        // The  number  of  characters  of "time zone
        // abbreviation strings" stored in the file.
        var _charct = tmp[5];

        tzinfo = {
            trans_list: null,
            trans_idx: null,
            ttinfo_list: null,
            ttinfo_std: null,
            ttinfo_dst: null,
            ttinfo_before: null
        };

        // The above header is followed by tzh_timecnt four-byte
        // values  of  type long,  sorted  in ascending order.
        // These values are written in ``standard'' byte order.
        // Each is used as a transition time (as  returned  by
        // time(2)) at which the rules for computing local time
        // change.
        if (_timect)
        {
            tzinfo.trans_list = jspack.Unpack(">"+_timect+"l", buffer.slice(buffer_idx, buffer_idx + (_timect * 4)));
            buffer_idx += (_timect * 4);
        }
        else
            tzinfo.trans_list = [];

        // Next come tzh_timecnt one-byte values of type unsigned
        // char; each one tells which of the different types of
        // ``local time'' types described in the file is associated
        // with the same-indexed transition time. These values
        // serve as indices into an array of ttinfo structures that
        // appears next in the file.
        if (_timect)
        {
            tzinfo.trans_idx = jspack.Unpack(">"+_timect+"B", buffer.slice(buffer_idx, buffer_idx + _timect));
            buffer_idx += _timect;
        }
        else
            tzinfo.trans_idx = [];


        // Each ttinfo structure is written as a four-byte value
        // for tt_gmtoff  of  type long,  in  a  standard  byte
        // order, followed  by a one-byte value for tt_isdst
        // and a one-byte  value  for  tt_abbrind.   In  each
        // structure, tt_gmtoff  gives  the  number  of
        // seconds to be added to UTC, tt_isdst tells whether
        // tm_isdst should be set by  localtime(3),  and
        // tt_abbrind serves  as an index into the array of
        // time zone abbreviation characters that follow the
        // ttinfo structure(s) in the file.

        var _ttinfo = [];
        for (var i = 0; i < _typect; i++){
            _ttinfo.push(jspack.Unpack(">lbb", buffer.slice(buffer_idx, buffer_idx + 6)));
            buffer_idx += 6;
        }


        var _abbr = buffer.slice(buffer_idx, buffer_idx + _charct).toString();
        buffer_idx += _charct;


        // Then there are tzh_leapcnt pairs of four-byte
        // values, written in  standard byte  order;  the
        // first  value  of  each pair gives the time (as
        // returned by time(2)) at which a leap second
        // occurs;  the  second  gives the  total  number of
        // leap seconds to be applied after the given time.
        // The pairs of values are sorted in ascending order
        // by time.

        var _leap = null;
        if (_leapct)
        {
            _leap = jspack.Unpack(">"+(_leapct * 2)+"l", buffer.slice(buffer_idx, buffer_idx + (_leapct * 8)));
            buffer_idx += _leapct * 8;
        }


        // Then there are tzh_ttisstdcnt standard/wall
        // indicators, each stored as a one-byte value;
        // they tell whether the transition times associated
        // with local time types were specified as standard
        // time or wall clock time, and are used when
        // a time zone file is used in handling POSIX-style
        // time zone environment variables.
        var _isstd = null;
        if (_ttisstdct)
        {
            _isstd = jspack.Unpack(">"+_ttisstdct+"b", buffer.slice(buffer_idx, buffer_idx + _ttisstdct));
            buffer_idx += _ttisstdct;
        }


        // Finally, there are tzh_ttisgmtcnt UTC/local
        // indicators, each stored as a one-byte value;
        // they tell whether the transition times associated
        // with local time types were specified as UTC or
        // local time, and are used when a time zone file
        // is used in handling POSIX-style time zone envi-
        // ronment variables.
        var _isgmt = null;
        if (_ttisgmtct)
        {
            _isgmt = jspack.Unpack(">"+_ttisgmtct+"b", buffer.slice(buffer_idx, buffer_idx + _ttisgmtct));
            buffer_idx += _ttisgmtct;
        }


        //finished reading

        tzinfo.ttinfo_list = [];
        _ttinfo.forEach(function (item, index){
            item[0] = Math.floor((item[0] + 30) / (60*60));

            tzinfo.ttinfo_list.push({
                offset: item[0],
                isdst: item[1],
                abbr: _abbr.slice(item[2], _abbr.indexOf('\x00',item[2])),
                isstd: _ttisstdct > index && _isstd[index] != 0,
                isgmt: _ttisgmtct > index && _isgmt[index] != 0
            });
        });

        // Replace ttinfo indexes for ttinfo objects.
        tzinfo.trans_idx = tzinfo.trans_idx.map(function (item){return tzinfo.ttinfo_list[item];});

        // Set standard, dst, and before ttinfos. before will be
        // used when a given time is before any transitions,
        // and will be set to the first non-dst ttinfo, or to
        // the first dst, if all of them are dst.
        if (tzinfo.ttinfo_list.length)
        {
            if (!tzinfo.trans_list.length)
                tzinfo.ttinfo_std = tzinfo.ttinfo_first = tzinfo.ttinfo_list[0];
            else
            {
                for (var j = _timect - 1; j > -1; j--)
                {
                    var tti = tzinfo.trans_idx[j];
                    if (!tzinfo.ttinfo_std && !tti.isdst)
                        tzinfo.ttinfo_std = tti;
                    else if (!tzinfo.ttinfo_dst && tti.isdst)
                        tzinfo.ttinfo_dst = tti;

                    if (tzinfo.ttinfo_dst && tzinfo.ttinfo_std)
                        break;
                }

                if (tzinfo.ttinfo_dst && !tzinfo.ttinfo_std)
                    tzinfo.ttinfo_std = tzinfo.ttinfo_dst;

                for (var k in tzinfo.ttinfo_list)
                {
                    if (!tzinfo.ttinfo_list[k].isdst)
                    {
                        tzinfo.ttinfo_before = tzinfo.ttinfo_list[k];
                        break;
                    }
                }

                if (!tzinfo.ttinfo_before)
                    tzinfo.ttinfo_before = tzinfo.ttinfo_list[0];
            }
        }

        /*# Now fix transition times to become relative to wall time.
        #
        # I'm not sure about this. In my tests, the tz source file
        # is setup to wall time, and in the binary file isstd and
        # isgmt are off, so it should be in wall time. OTOH, it's
        # always in gmt time. Let me know if you have comments
        # about this.
        laststdoffset = 0
        self._trans_list = list(self._trans_list)
        for i in range(len(self._trans_list)):
            tti = self._trans_idx[i]
            if not tti.isdst:
                # This is std time.
                self._trans_list[i] += tti.offset
                laststdoffset = tti.offset
            else:
                # This is dst time. Convert to std.
                self._trans_list[i] += laststdoffset
        self._trans_list = tuple(self._trans_list)*/
        if(typeof callback === "function") {
            callback(null, tzinfo);
        }
        return tzinfo;
    }
};

module.exports.listTimezones = function (country_code){
    country_code = country_code ? country_code.trim().toUpperCase() : "";

    if (_zoneinfo_listcache[country_code || "_"]){
        return _zoneinfo_listcache[country_code || "_"];
    }

    var path = _zoneinfo_path;
    var stat = fs.statSync(path);
    if (stat.isDirectory())
    {
        if (country_code)
        {
            var buffer = fs.readFileSync(path + "/" + "zone.tab", 'ascii');
            buffer = buffer.split("\n");

            buffer.forEach(function (line){
                if (!line.trim()) return;
                if (line.substring(0,1) == "#") return;

                line = line.split("\t");
                var ccode = line[0].trim().toUpperCase();

                if (!_zoneinfo_listcache[ccode]) _zoneinfo_listcache[ccode] = [];

                if (_zoneinfo_listcache[ccode].indexOf(line[2]) == -1)
                    _zoneinfo_listcache[ccode].push(line[2]);
            });

            return _zoneinfo_listcache[country_code];
        }
        else
        {
            var retlist = [];
            var list = fs.readdirSync(path);

            var root_ignore = ["posix","right","SystemV","US"];

            function descend(parent, list){
                parent = parent ? parent + "/" : "";
                for (var i in list){
                    var stat = fs.statSync(path + "/" + parent + list[i]);
                    if (stat.isDirectory() && (parent || root_ignore.indexOf(list[i]) == -1)){
                        descend(parent + list[i], fs.readdirSync(path + "/" + parent + list[i]).sort());
                    }
                    else if (parent && stat.isFile())
                    {
                        retlist.push(parent + list[i]);
                    }
                }
            }

            descend("", fs.readdirSync(path).sort());

            _zoneinfo_listcache["_"] = retlist;

            return retlist;
        }

    }
    else
    {
        return false;
    }
};

function TZDate(arg, timezone, initAsync, callback){
    this._zoneinfo = null;
    this._zoneinfo_name = null;

    var _adjust = false;

    //constructor
    if (arg && arg != "now"){
        if (typeof arg.trim != "undefined"){
            arg = arg.trim();
        }

        if (typeof arg != "number" && arg[arg.length - 1] != "Z"){
            _adjust = true;
            this._date = new Date(arg + " Z");
        }
        else {
            this._date = new Date(arg);
        }
    }
    else {
        this._date = new Date();
    }

    if(initAsync) {
        this.setTimezoneAsync((timezone && isTimezone(timezone)) ? timezone : this._zoneinfo_default, (function(error, date){
            if (_adjust){
                this._date.setTime(this._date.getTime() - this._utcoffset() * 3600 * 1000);
            }
            callback(error, date);
        }).bind(this));
    }
    else {
        this.setTimezone((timezone && isTimezone(timezone)) ? timezone : this._zoneinfo_default);
        if (_adjust){
            this._date.setTime(this._date.getTime() - this._utcoffset() * 3600 * 1000);
        }
    }
}

TZDate.prototype._zoneinfo_default = "Etc/UTC";

TZDate.prototype._formats = function (letter){
    var self = this;
    var letters = {
        // Y Full year
        "Y": function (){return self._date.getUTCFullYear();},
        // m zero-padded month number 1-12
        "m": function (){return self._zeropad(self._date.getUTCMonth() + 1);},
        // n month number 1-12
        "n": function (){return self._date.getUTCMonth() + 1;},
        // d zero-padded date number
        "d": function (){return self._zeropad(self._date.getUTCDate());},
        // j date number
        "j": function (){return self._date.getUTCDate();},
        // F full month name
        "F": function (){return self._localization.months[self._date.getUTCMonth()];},
        // M short month name
        "M": function (){return self._localization.months_short[self._date.getUTCMonth()];},
        // l full weekday name
        "l": function (){return self._localization.weekdays[self._date.getUTCDay()];},
        // D short weekday name
        "D": function (){return self._localization.weekdays_short[self._date.getUTCDay()];},
        // H zero-padded 24-hour
        "H": function (){return self._zeropad(self._date.getUTCHours());},
        // h zero-padded 12-hour
        "h": function (){return self._zeropad((self._date.getUTCHours() % 12) || 12);},
        // G 24-hour
        "G": function (){return self._date.getUTCHours();},
        // g 12-hour
        "g": function (){return (self._date.getUTCHours() % 12) || 12;},
        // i zero-padded minutes
        "i": function (){return self._zeropad(self._date.getUTCMinutes());},
        // s zero-padded seconds
        "s": function (){return self._zeropad(self._date.getUTCSeconds());},
        // A upper-case AM/PM
        "A": function (){return self._date.getUTCHours() >= 12 ? "PM" : "AM";},
        // a lower-case am/pm
        "a": function (){return self._date.getUTCHours() >= 12 ? "pm" : "am";},
        // T short timezone
        "T": function (){return self.getTimezone(false);},
        // t full timezone name
        "t": function (){return self.getTimezone(true);},
        // O UTC offset
        "O": function (){
            var offset = parseInt(self._utcoffset(), 10);
            var minus = false;
            if (offset < 0)
            {
                minus = true;
                offset = -offset;
            }

            offset = self._zeropad(offset)+"00";
            if (minus) offset = "-"+offset;
            else offset = "+"+offset;

            return offset;
        }
    };

    return letters[letter];
};

TZDate.prototype._localization = {
    weekdays: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
    weekdays_short: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
    months: ['January','February','March','April','May','June','July','August','September','October','November','December'],
    months_short: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']
};

TZDate.prototype._resetOffset = function (newtz){
    var old_offset = 0;
    if (this._zoneinfo) old_offset = this._utcoffset();
    this._zoneinfo = newtz;
    this._date.setTime(this._date.getTime() + ((this._utcoffset() - old_offset) * 3600 * 1000));
};

TZDate.prototype._zeropad = function (value, len){
    len = len || 2;
    value += "";

    for (var i = value.length; i < len; i++){
        value = "0"+value;
    }

    return value;
};

TZDate.prototype._ttinfo = function (laststd){
    var timestamp = Math.floor(this._date.getTime() / 1000),
        idx = 0,
        found = false;

    for (var i in this._zoneinfo.trans_list){
        if (timestamp < this._zoneinfo.trans_list[i])
        {
            found = true;
            break;
        }
        idx++;
    }

    if (!found) return this._zoneinfo.ttinfo_std;
    if (idx == 0) return this._zoneinfo.ttinfo_before;

    if (laststd)
    {
        while (idx > 0){
            if (!this._zoneinfo.trans_idx[idx - 1].isdst) return this._zoneinfo.trans_idx[idx - 1];
            idx--;
        }

        return this._zoneinfo.ttinfo_std;
    }
    else return this._zoneinfo.trans_idx[idx - 1];

};

TZDate.prototype._utcoffset = function (){
    if (!this._zoneinfo.ttinfo_std) return 0;
    return this._ttinfo().offset;
};

TZDate.prototype._dst = function (){
    if (!this._zoneinfo.ttinfo_dst) return 0;
    var tti = this._ttinfo();
    if (!tti.isdst) return 0;

    return tti.offset - this._ttinfo(1).offset;
};

TZDate.prototype._tzname = function (){
    if (!this._zoneinfo.ttinfo_std) return "";
    return this._ttinfo().abbr;
};

TZDate.prototype.setTimezone = function (timezone){
    if (_zoneinfo_cache[timezone])
    {
        this._resetOffset(_zoneinfo_cache[timezone]);
    }
    else
    {
        var zi = parseZonefile(timezone);
        _zoneinfo_cache[timezone] = zi;
        this._resetOffset(zi);
    }

    this._zoneinfo_name = timezone;
};

TZDate.prototype.setTimezoneAsync = function (timezone, callback){
    var self = this;

    if (_zoneinfo_cache[timezone])
    {
        this._resetOffset(_zoneinfo_cache[timezone]);
        callback(null, self);
    }
    else
    {
        parseZonefileAsync(timezone, function(error, zi){
            if(error) {
                callback(error);
                return;
            }
            _zoneinfo_cache[timezone] = zi;
            self._resetOffset(zi);
            callback(null, self);
        });
    }

    this._zoneinfo_name = timezone;
};

TZDate.prototype.getTimezone = function (full_name){
    if (full_name) return this._zoneinfo_name;

    return this._tzname();
};


TZDate.prototype.format = function (fmt_string){
    if (!fmt_string) return this.toString();

    var slashct = 0;
    var arr = fmt_string.split("");
    fmt_string = "";

    var self = this;

    arr.forEach(function (chr, ind){
        if (chr == "\\"){
            slashct++;
            return;
        }

        if (self._formats(chr))
        {
            var realslashes = Math.floor(slashct / 2);
            for (var i = 0; i < realslashes; i++){fmt_string += "\\";}
            if (slashct % 2)
            {
                fmt_string += chr;
            }
            else
            {
                //parse
                fmt_string += self._formats(chr)();
            }

            slashct = 0;
        }
        else
        {
            for (var j = 0; j < slashct; j++){fmt_string += "\\";}
            slashct = 0;
            fmt_string += chr;
        }
    });

    return fmt_string;
};

TZDate.prototype.setLocalization = function (localization){
    this._localization = localization;
};

TZDate.prototype.toString = function (){
    if (this._formats("O")() == "+0000")
        return this.format("Y-m-d H:i:s")+" GMT";
    else
        return this.format("Y-m-d H:i:s \\G\\M\\TO");
};