@js-joda/timezone 3.0.0 → 3.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@js-joda/timezone",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "description": "iana tzdb timezone bindings for js-joda",
   "typings": "typings/js-joda-timezone.d.ts",
   "main": "dist/js-joda-timezone.js",
@@ -45,12 +45,12 @@
     "@js-joda/core": ">=5.7.0"
   },
   "devDependencies": {
-    "@js-joda/core": "^6.2.0"
+    "@js-joda/core": "^6.3.1"
   },
   "license": "BSD-3-Clause",
   "bugs": {
     "url": "https://github.com/js-joda/js-joda/issues"
   },
   "homepage": "https://js-joda.github.io/js-joda",
-  "gitHead": "3b54bb6036347604e8d1ab2eebf5ec1b20033c06"
+  "gitHead": "109fb8287af88f6cbc00cf7982201e1b999aa04e"
 }

package/src/{MomentZoneRules.js → TzdbZoneRules.js}

@@ -5,10 +5,10 @@
  */
 
 import {
-    LocalDateTime, Instant, ZoneOffset, ZoneOffsetTransition, ZoneRules
+    Duration, LocalDateTime, Instant, ZoneOffset, ZoneOffsetTransition, ZoneRules
 } from '@js-joda/core';
 
-export class MomentZoneRules extends ZoneRules{
+export class TzdbZoneRules extends ZoneRules{
     constructor(tzdbInfo){
         super();
         this._tzdbInfo = tzdbInfo;
@@ -37,7 +37,7 @@ export class MomentZoneRules extends ZoneRules{
      * @return {ZoneOffset} the offset, not null
      */
     offsetOfInstant(instant){
-        const epochMilli = instant.toEpochMilli();
+        const epochMilli = epochMilliOf(instant);
         return this.offsetOfEpochMilli(epochMilli);
     }
 
@@ -220,14 +220,25 @@ export class MomentZoneRules extends ZoneRules{
      * has changed over time.
      * The standard offset is the offset before any daylight saving time is applied.
      * This is typically the offset applicable during winter.
+     * <p>
+     * Needs tz data with standard offsets (field 7 of the packed format); throws for older data.
      *
      * @param {Instant} instant - the instant to find the offset information for, not null, but null
      *  may be ignored if the rules have a single offset for all instants
      * @return {ZoneOffset} the standard offset, not null
+     * @throws {Error} if the tz data of the zone has no standard offsets
      */
-    // eslint-disable-next-line no-unused-vars
     standardOffset(instant){
-        notSupported('ZoneRules.standardOffset');
+        return ZoneOffset.ofTotalSeconds(this._standardOffsetInSeconds(epochMilliOf(instant)));
+    }
+
+    _standardOffsetInSeconds(epochMilli){
+        const stdOffsets = this._tzdbInfo.stdOffsets;
+        if (stdOffsets == null) {
+            throw new Error(`The tz data of zone ${this._tzdbInfo.name} has no standard offsets, ` +
+                'load tz data with standard offsets (packed field 7) for standardOffset, daylightSavings and isDaylightSavings');
+        }
+        return -offsetInSeconds(stdOffsets[binarySearch(this._tzdbInfo.untils, epochMilli)]);
     }
 
     /**
@@ -242,10 +253,12 @@ export class MomentZoneRules extends ZoneRules{
      * @param {Instant} instant - the instant to find the daylight savings for, not null, but null
      *  may be ignored if the rules have a single offset for all instants
      * @return {Duration} the difference between the standard and actual offset, not null
+     * @throws {Error} if the tz data of the zone has no standard offsets
      */
-    // eslint-disable-next-line no-unused-vars
     daylightSavings(instant){
-        notSupported('ZoneRules.daylightSavings');
+        const epochMilli = epochMilliOf(instant);
+        const index = binarySearch(this._tzdbInfo.untils, epochMilli);
+        return Duration.ofSeconds(this._offsetByIndexInSeconds(index) - this._standardOffsetInSeconds(epochMilli));
     }
 
     /**
@@ -255,11 +268,11 @@ export class MomentZoneRules extends ZoneRules{
      *
      * @param {Instant} instant - the instant to find the offset information for, not null, but null
      *  may be ignored if the rules have a single offset for all instants
-     * @return {boolean} the standard offset, not null
+     * @return {boolean} true if the standard offset differs from the actual offset
+     * @throws {Error} if the tz data of the zone has no standard offsets
      */
-    // eslint-disable-next-line no-unused-vars
     isDaylightSavings(instant) {
-        notSupported('ZoneRules.isDaylightSavings');
+        return !this.daylightSavings(instant).isZero();
     }
 
     /**
@@ -289,9 +302,13 @@ export class MomentZoneRules extends ZoneRules{
      *  may be ignored if the rules have a single offset for all instants
      * @return {ZoneOffsetTransition} the next transition after the specified instant, null if this is after the last transition
      */
-    // eslint-disable-next-line no-unused-vars
     nextTransition(instant){
-        notSupported('ZoneRules.nextTransition');
+        const indices = this._transitionIndices();
+        const untils = this._tzdbInfo.untils;
+        // transitions are at whole milliseconds, so "after the instant" equals "after its truncated milli"
+        const epochMilli = epochMilliOf(instant);
+        const k = firstIndexWhere(indices, (i) => untils[i] > epochMilli);
+        return k < indices.length ? this._createTransition(indices[k]) : null;
     }
 
     /**
@@ -305,47 +322,75 @@ export class MomentZoneRules extends ZoneRules{
      *  may be ignored if the rules have a single offset for all instants
      * @return {ZoneOffsetTransition} the previous transition after the specified instant, null if this is before the first transition
      */
-    // eslint-disable-next-line no-unused-vars
     previousTransition(instant){
-        notSupported('ZoneRules.previousTransition');
+        const indices = this._transitionIndices();
+        const untils = this._tzdbInfo.untils;
+        // round up to the next milli if the instant has a fraction of a milli,
+        // so that a transition at the truncated milli counts as before the instant
+        const epochMilli = epochMilliOf(instant) + (instant.nano() % 1000000 > 0 ? 1 : 0);
+        const k = firstIndexWhere(indices, (i) => untils[i] >= epochMilli);
+        return k > 0 ? this._createTransition(indices[k - 1]) : null;
     }
 
     /**
-     * Gets the complete list of fully defined transitions.
-     * <p>
-     * The complete set of transitions for this rules instance is defined by this method
-     * and {@link #getTransitionRules()}. This method returns those transitions that have
-     * been fully defined. These are typically historical, but may be in the future.
+     * The indices i of the periods whose end, untils[i], is an offset transition, in ascending
+     * order. Period boundaries where the offset doesn't change (only the abbreviation or the
+     * isdst flag) and the last open-ended period are not transitions. Computed on first use and
+     * cached on the zone's tz data, which all rules instances of the zone share.
+     *
+     * @return {number[]}
+     * @private
+     */
+    _transitionIndices(){
+        const tzdbInfo = this._tzdbInfo;
+        if (tzdbInfo._transitionIndices == null) {
+            const indices = [];
+            for (let i = 0; i < tzdbInfo.offsets.length - 1; i++) {
+                if (this._offsetByIndexInSeconds(i) !== this._offsetByIndexInSeconds(i + 1)) {
+                    indices.push(i);
+                }
+            }
+            tzdbInfo._transitionIndices = indices;
+        }
+        return tzdbInfo._transitionIndices;
+    }
+
+    /**
+     * @param {number} index - the index of the period that ends with the transition
+     * @return {ZoneOffsetTransition}
+     * @private
+     */
+    _createTransition(index){
+        const offsetBefore = ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(index));
+        const offsetAfter = ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(index + 1));
+        const instant = Instant.ofEpochMilli(this._tzdbInfo.untils[index]);
+        return ZoneOffsetTransition.of(LocalDateTime.ofInstant(instant, offsetBefore), offsetBefore, offsetAfter);
+    }
+
+    /**
+     * Not supported, always throws.
      * <p>
-     * The list will be empty for fixed offset rules and for any time-zone where there has
-     * only ever been a single offset. The list will also be empty if the transition rules are unknown.
+     * In java.time, the complete set of transitions is this list of the historic transitions
+     * together with {@link #transitionRules()} for the later years. The tzdb data of this
+     * package contains only explicit transitions through the year 2499 and doesn't say where
+     * the historic part ends, so it can't return what java.time returns.
+     * Use {@link #nextTransition} or {@link #previousTransition} to iterate over the transitions.
      *
-     * @return {ZoneOffsetTransition[]} an immutable list of fully defined transitions, not null
+     * @throws {Error} always
      */
     transitions(){
         notSupported('ZoneRules.transitions');
     }
 
     /**
-     * Gets the list of transition rules for years beyond those defined in the transition list.
-     * <p>
-     * The complete set of transitions for this rules instance is defined by this method
-     * and {@link #getTransitions()}. This method returns instances of {@link ZoneOffsetTransitionRule}
-     * that define an algorithm for when transitions will occur.
-     * <p>
-     * For any given {@code ZoneRules}, this list contains the transition rules for years
-     * beyond those years that have been fully defined. These rules typically refer to future
-     * daylight saving time rule changes.
-     * <p>
-     * If the zone defines daylight savings into the future, then the list will normally
-     * be of size two and hold information about entering and exiting daylight savings.
-     * If the zone does not have daylight savings, or information about future changes
-     * is uncertain, then the list will be empty.
+     * Not supported, always throws.
      * <p>
-     * The list will be empty for fixed offset rules and for any time-zone where there is no
-     * daylight saving time. The list will also be empty if the transition rules are unknown.
+     * In java.time, this returns the recurring rules (such as "last Sunday in March") for the
+     * years after the list of {@link #transitions()}. The tzdb data of this package is expanded
+     * into explicit transitions through the year 2499 and has no such rules.
+     * Use {@link #nextTransition} or {@link #previousTransition} to iterate over the transitions.
      *
-     * @return {ZoneOffsetTransitionRule[]} an immutable list of transition rules, not null
+     * @throws {Error} always
      */
     transitionRules(){
         notSupported('ZoneRules.transitionRules');
@@ -360,7 +405,7 @@ export class MomentZoneRules extends ZoneRules{
         if (this === other) {
             return true;
         }
-        if (other instanceof MomentZoneRules) {
+        if (other instanceof TzdbZoneRules) {
             return this._tzdbInfo === other._tzdbInfo;
         }
         return false;
@@ -434,16 +479,26 @@ function ldtBinarySearch(array, value) {
     return hi;
 }
 
+// the offset is stored in minutes, with seconds as a base 60 fraction; multiplying it back can
+// give a value just below the whole second (e.g. 65.35 * 60 = 3920.9999...), so round it
 function offsetInSeconds(tzdbOffset){
-    return roundDown(+tzdbOffset*60);
+    return Math.round(+tzdbOffset*60);
 }
 
-function roundDown(r){
-    if (r < 0) {
-        return Math.ceil(r);
-    } else {
-        return Math.floor(r);
+// beyond this epoch second, Instant.toEpochMilli() overflows; far outside the tz data
+const MAX_EPOCH_SECOND_FOR_MILLIS = Math.floor(Number.MAX_SAFE_INTEGER / 1000) - 1;
+
+// the epoch milli of the instant, or +/-Infinity for an instant too far out for an epoch milli
+// (e.g. Instant.MAX); infinities compare with the untils of the tz data like any far instant
+function epochMilliOf(instant) {
+    const epochSecond = instant.epochSecond();
+    if (epochSecond > MAX_EPOCH_SECOND_FOR_MILLIS) {
+        return Infinity;
+    }
+    if (epochSecond < -MAX_EPOCH_SECOND_FOR_MILLIS) {
+        return -Infinity;
     }
+    return instant.toEpochMilli();
 }
 
 // modified bin-search, to always find existing indices for non-empty arrays
@@ -460,6 +515,21 @@ function binarySearch(array, value) {
     return hi;
 }
 
+// the first index k of a sorted array for which predicate(array[k]) is true, assuming the
+// predicate is false for a prefix and true for the rest; array.length if it is never true
+function firstIndexWhere(array, predicate) {
+    let lo = 0, hi = array.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (predicate(array[mid])) {
+            hi = mid;
+        } else {
+            lo = mid + 1;
+        }
+    }
+    return lo;
+}
+
 function notSupported(msg){
     throw new Error(`not supported: ${msg}`);
 }

package/src/{MomentZoneRulesProvider.js → TzdbZoneRulesProvider.js}

@@ -9,7 +9,7 @@ import {
     ZoneRulesProvider,
 } from '@js-joda/core';
 
-import { MomentZoneRules } from './MomentZoneRules';
+import { TzdbZoneRules } from './TzdbZoneRules';
 
 import { unpack } from './unpack';
 
@@ -20,7 +20,7 @@ const AVAILABLE_ZONE_IDS = [];
 const zones = {};
 const links = {};
 
-export class MomentZoneRulesProvider extends ZoneRulesProvider {
+export class TzdbZoneRulesProvider extends ZoneRulesProvider {
     /**
      * Gets the rules for the zone ID.
      * <p>
@@ -36,7 +36,7 @@ export class MomentZoneRulesProvider extends ZoneRulesProvider {
         if(tzdbZoneInfo == null){
             throw new DateTimeException(`Unknown time-zone ID: ${zoneId}`);
         }
-        return new MomentZoneRules(tzdbZoneInfo);
+        return new TzdbZoneRules(tzdbZoneInfo);
     }
 
 

package/src/js-joda-timezone.js

@@ -5,9 +5,9 @@
 
 import latest from './tzdbData';
 
-import { MomentZoneRulesProvider } from './MomentZoneRulesProvider';
+import { TzdbZoneRulesProvider } from './TzdbZoneRulesProvider';
 import autoPlug from './auto-plug';
 
-MomentZoneRulesProvider.loadTzdbData(latest);
+TzdbZoneRulesProvider.loadTzdbData(latest);
 
 autoPlug();

package/src/plug.js

@@ -3,17 +3,17 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import { MomentZoneRulesProvider } from './MomentZoneRulesProvider';
+import { TzdbZoneRulesProvider } from './TzdbZoneRulesProvider';
 import extendSystemDefaultZoneId from './system-default-zone';
 
 /**
  * @private
  */
 export default function (jsJoda) {
-    jsJoda.ZoneRulesProvider.getRules = MomentZoneRulesProvider.getRules;
-    jsJoda.ZoneRulesProvider.getAvailableZoneIds = MomentZoneRulesProvider.getAvailableZoneIds;
-    jsJoda.ZoneRulesProvider.getTzdbData = MomentZoneRulesProvider.getTzdbData;
-    jsJoda.ZoneRulesProvider.loadTzdbData = MomentZoneRulesProvider.loadTzdbData;
+    jsJoda.ZoneRulesProvider.getRules = TzdbZoneRulesProvider.getRules;
+    jsJoda.ZoneRulesProvider.getAvailableZoneIds = TzdbZoneRulesProvider.getAvailableZoneIds;
+    jsJoda.ZoneRulesProvider.getTzdbData = TzdbZoneRulesProvider.getTzdbData;
+    jsJoda.ZoneRulesProvider.loadTzdbData = TzdbZoneRulesProvider.loadTzdbData;
 
     extendSystemDefaultZoneId(jsJoda.ZoneId);
     return jsJoda;

package/src/unpack.js

@@ -84,14 +84,19 @@ function mapIndices (source, indices) {
 /**
  * @private
  *
+ * Changes: field 7, the standard offset per period type (encoded like the offsets), is unpacked
+ * into `stdOffsets` when present.
+ *
  * @param string
- * @returns {{offsets: *[], abbrs: *[], name, untils: *, population: number}}
+ * @returns {{offsets: *[], abbrs: *[], name, untils: *, population: number, stdOffsets: (number[]|undefined)}}
  */
 export function unpack (string) {
     var data = string.split('|'),
         offsets = data[2].split(' '),
         indices = data[3].split(''),
-        untils  = data[4].split(' ');
+        untils  = data[4].split(' '),
+        stdOffsets = data[7] ? data[7].split(' ') : null,
+        result;
 
     arrayToInt(offsets);
     arrayToInt(indices);
@@ -99,12 +104,19 @@ export function unpack (string) {
 
     intToUntil(untils, indices.length);
 
-    return {
+    result = {
         name       : data[0],
         abbrs      : mapIndices(data[1].split(' '), indices),
         offsets    : mapIndices(offsets, indices),
         untils     : untils,
         population : data[5] | 0
     };
+
+    if (stdOffsets) {
+        arrayToInt(stdOffsets);
+        result.stdOffsets = mapIndices(stdOffsets, indices);
+    }
+
+    return result;
 }