-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathchronos.js.html
413 lines (394 loc) · 30.5 KB
/
chronos.js.html
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>JSDoc: Source: chronos.js</title>
<script src="scripts/prettify/prettify.js"> </script>
<script src="scripts/prettify/lang-css.js"> </script>
<!--[if lt IE 9]>
<script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->
<link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">
<link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">
</head>
<body>
<div id="main">
<h1 class="page-title">Source: chronos.js</h1>
<section>
<article>
<pre class="prettyprint source linenums"><code>/** Basic functions for calendrical computations.
All parameters should be integer numbers. In order to increase efficiency, almost no check is done.
Any NaN parameter will yield NaN values.
Non-integer parameter will yield erroneous non-integer values.
Default parameters assume that computations are done using 1 for the first month of any calendar.
* @module chronos
* @version M2024-07-02
* @author Louis A. de Fouquières https://github.com/Louis-Aime
* @license MIT 2016-2024
*/
// Character set is UTF-8
/* Versions: see GitHub
*/
/* Copyright Louis A. de Fouquières https://github.com/Louis-Aime 2016-2024
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
1. The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
2. Changes with respect to any former version shall be documented.
The software is provided "as is", without warranty of any kind,
express of implied, including but not limited to the warranties of
merchantability, fitness for a particular purpose and noninfringement.
In no event shall the authors of copyright holders be liable for any
claim, damages or other liability, whether in an action of contract,
tort or otherwise, arising from, out of or in connection with the software
or the use or other dealings in the software.
*/
"use strict";
/** Structure of the calendar rule parameter that describes a calendar's computation rules
* and that is passed to the Cycle Bases Calendar Computation Engine (Cbcce), a class constructor.
* The calendar structure is made up of nested cycles. Each cycle finishes with an intercalary or missing element.
* Computations are made on an intermediary calendar which is derived from a real-life calendar.
* E.g. for the Julian-Gregorian calendar, the derived calendar's year finishes in February, the intercalary day (29 February) is at the very end,
* and the olympiade (4-years cycle), finishes with the leap year.
* Non checked constraints:
* 1. The cycles and the canvas elements shall be defined from the largest to the smallest
* e.g. four-centuries cycle, then century, then four-year cycle, then year, etc.
* 2. The same names shall be used for the "coeff" and the "canvas" properties, otherwise functions shall give erroneous results.
* @typedef {Object} calendarRule
* @property {Number} timeepoch - origin date or timestamp in elementary units (days, milliseconds...) to be used for the decomposition, with respect to instant 0 of used timestamp.
* @property {Array} coeff - Array of coefficients used to decompose a timestamp into time cycles like eras, quadrisaeculae, centuries, ... down to the elementary unit.
* @property {Number} coeff[].cyclelength - length of the cycle, in elementary units.
* @property {Number} coeff[].ceiling - Infinity, or the maximum number of cycles of this size minus one in the upper cycle;
* the last cycle may hold an intercalation remainder up to the next level,
* example: this level is year of 365 days, upper level is 1461 days i.e. the last year holds more than 365 days.
* @property {Number} coeff[].subCycleShift - number (-1, 0 or +1) to add to the ceiling of the cycle of the next level when the ceiling is reached at this level;
* to be used for common/embolismic years in a Meton cycle, or for 128-years cycles of 4 or 5 years elementary cycles.
* @property {Number} coeff[].multiplier - multiplies the number of cycles of this level to convert into target units.
* @property {String} coeff[].target - the unit (e.g. "year") of the decomposition element at this level.
* @property {String} coeff[].notify - optional, the boolean field (e.g. "leapyear") where to indicate that the element's length is "singular" (i.e. not "common").
* @property {Array} canvas - Canvas of the decomposition , e.g. "year", "month", "day", with suitable properties at each level.
* @property {String} canvas[].name - the name of the property at this level, which must match one target property of the coeff component,
* @property {Number} canvas[].init - value of this component at epoch, which is the lowest value (except for the first component),
* e.g. 0 or 1 for month, 1 for date, 0 for hours, minutes, seconds.
*/
/** The Cycle Based Calendar Computation Engine (Cbcce) class.
* @see module:chronos for the definition of the calendarRule structure.
* @class
* @param {calendarRule} calendarRule - The object that describes the rules of the calendar to be implemented.
*/
export class Cbcce {
constructor (calendarRule) {
this.calendarRule = calendarRule;
}
/** The Modulo function for calendrical computations.
* @static
* @param {number} a - dividend, may be positive, null or negative.
* @param {number} d - divisor, shall be non-zero.
* @return {number} modulo of a divided by d, with 0 <= modulo < d or d < modulo <= 0; e.g. -2 mod 3 is +1, not -2.
*/
static mod (a, d) {
return ( a*Math.sign(d) >= 0 ? a % d : (a % d + +d) % d)
}
/** Division with modulo for calendrical computations
* @static
* @param {number} a - dividend; integer recommended.
* @param {number} d - divisor; integer recommended.
* @return {number[]} [quotient, modulo] with 0 <= modulo < d or d < modulo <= 0.
*/
static divmod (a, d) {
if (d >=0) {
let quotient = Math.floor (a/d);
return [ quotient, a - d * quotient ]
}
else if (d < 0) { return Cbcce.divmod (-a, -d).map (x => -x) }
else { return [NaN, NaN] }
}
/** Cycle start shifting, keeping phase measure. Example : (20, 1) shifted by 2 in a 12-cycle with base 1 yields (19, 13), but (20, 6) yields (20, 6)
This operation is used for calendrical computations on Julian-Gregorian calendars (shift year start to March), but also for computations on weeks.
* @static
* @param {number} cycle - the rank of cycle, which is increased by 1 each time 'phase' reaches (mod (cycleBase, period)).
* @param {number} phase - indicates the phase within the cycle, e.g. for the month or the day of week. (phase == cycleBase) means the start of a new cycle.
* @param {number} period - the cycle's period, typically 12 or 7 for calendrical computations, but may also be the moon's month mean duration in milliseconds.
* @param {number} shift - the number of units for shifting. After shifting, cycleBase is cycleBase + shift.
* @param {number} cycleBase - which phase is that of a new cycle, in the parameter [cycle, phase] representation. 0 by default (like month representation with Date objects).
* @return {number[]} [returnCycle, returnPhase] with: (returnCycle * period + returnPhase == cycle * period + phase) && (shift + cycleBase) <= returnPhase < (shift + cycleBase)+period.
*/
static shiftCycle (cycle, phase, period, shift, cycleBase=0) {
// if (Array.from(arguments).some(isNaN)) throw new TypeError ("Non numeric value among arguments: " + Array.from(arguments).toString());
if (phase < cycleBase || phase >= cycleBase + period) throw new RangeError
("Phase out of range: " + cycleBase + " <= " + phase + " < " + (cycleBase + period)); //Cbcce.cycleShifting;
return Cbcce.divmod (cycle * period + phase - cycleBase - shift, period).map
((value, index) => (index == 1 ? value + cycleBase + shift : value) )
}
/** Whether a year is a leap year in the Julian calendar, with the year origin Anno Domini as defined by Dionysius Exiguus in the 6th century.
* @static
* @param {number} a signed integer number representing the year. 0 means 1 B.C. and so on. Leap years, either positive or negative, are divisible by 4.
* @return {boolean} true if year is a leap year i.e. there is a 29 February in this year.
*/
static isJulianLeapYear (year) {
return Cbcce.mod (year, 4) == 0
}
/** Whether a year is a leap year in the Gregorian calendar, with the year origin Anno Domini as defined by Dionysius Exiguus in the 6th century.
* @static
* @param {number} a signed integer number representing the year. 0 means 1 B.C. Leap years, are either not divisible by 100 but by 4, or divisible by 400.
* @return {boolean} true if year is a leap year i.e. there is a 29 February in this year.
*/
static isGregorianLeapYear (year) {
return Cbcce.mod (year, 4) == 0 && (Cbcce.mod(year, 100) != 0 || Cbcce.mod(year, 400) ==0)
}
/** Build a compound object from a timestamp holding the elements as required by a given cycle hierarchy model.
* @param {number} askedNumber - a timestamp representing the date to convert.
* @returns {Object} the calendar elements in the structure that calendarRule prescribes.
*/
getObject (askedNumber) {
let quantity = askedNumber - this.calendarRule.timeepoch; // set at initial value the quantity to decompose into cycles.
var result = new Object(); // Construct initial compound result
for (let i = 0; i < this.calendarRule.canvas.length; i++) // Define property of result object (a date or date-time)
Object.defineProperty (result, this.calendarRule.canvas[i].name, {enumerable : true, writable : true, value : this.calendarRule.canvas[i].init});
let addCycle = 0; // flag that upper cycle has one element more or less (i.e. a 5 years franciade or 13 months luni-solar year)
for (let i = 0; i < this.calendarRule.coeff.length; ++i) { // Perform decomposition by dividing by the successive cycle length
if (isNaN(quantity))
result[this.calendarRule.coeff[i].target] = NaN // Case where timestamp is not a number, e.g. out of bounds.
else { // Here we make the suitable Euclidian division, with ceiling.
let ceiling = this.calendarRule.coeff[i].ceiling + addCycle,
[q, m] = Cbcce.divmod (quantity, this.calendarRule.coeff[i].cyclelength);
if (q > ceiling) {
if ( q > ceiling + 1 ) throw new RangeError
("Unsuitable quotient in ceiled division: " + quantity + " by " + this.calendarRule.coeff[i].cyclelength + " ceiled with " + ceiling);
--q;
}
quantity -= q * this.calendarRule.coeff[i].cyclelength;
addCycle = (q == ceiling) ? this.calendarRule.coeff[i].subCycleShift : 0; // if at last section of this cycle, add or subtract 1 to the ceiling of next cycle
if (this.calendarRule.coeff[i].notify != undefined) result[this.calendarRule.coeff[i].notify] = (q == ceiling); // notify special cycle, like leap year etc.
result[this.calendarRule.coeff[i].target] += q*this.calendarRule.coeff[i].multiplier; // add result to suitable part of result array
}
}
return result;
}
/** Compute the timestamp from the element of a date in a given calendar.
* @param {Object} askedObject - the numeric elements of the date, collected in an object containing the elements that calendarRule prescribes.
* @returns {number} the timestamp.
*/
getNumber (askedObject) { // from an object askedObject structured as calendarRule.canvas, compute the chronological number
var cells = {...askedObject}, quantity = this.calendarRule.timeepoch; // initialise Unix quantity to computation epoch
for (let i = 0; i < this.calendarRule.canvas.length; i++) { // cells value shifted as to have all 0 if at epoch
cells[this.calendarRule.canvas[i].name] -= this.calendarRule.canvas[i].init;
if (isNaN (cells[this.calendarRule.canvas[i].name])) throw new TypeError ('Missing or invalid expected field ' + this.calendarRule.canvas[i].name);
}
let currentTarget = this.calendarRule.coeff[0].target; // Set to uppermost unit used for date (year, most often)
let currentCounter = cells[this.calendarRule.coeff[0].target]; // This counter shall hold the successive remainders
let addCycle = 0; // This flag says whether there is an additional period at end of cycle, e.g. a 5th year in the Franciade or a 13th month
for (let i = 0; i < this.calendarRule.coeff.length; i++) {
if (currentTarget != this.calendarRule.coeff[i].target) { // If we go to the next level (e.g. year to month), reset variables
currentTarget = this.calendarRule.coeff[i].target;
currentCounter = cells[currentTarget];
}
let ceiling = this.calendarRule.coeff[i].ceiling + addCycle; // Ceiling of this level may be increased
// i.e. Franciade is 5 years if at end of upper cycle
let [f,m] = Cbcce.divmod (currentCounter,this.calendarRule.coeff[i].multiplier);
if (f > ceiling) {
if ( f > ceiling + 1 || m != 0 ) {
throw new RangeError
("Unsuitable quotient in ceiled division: " + currentCounter + " by " + this.calendarRule.coeff[i].multiplier + " ceiled with " + ceiling);
};
--f;
}
currentCounter -= f * this.calendarRule.coeff[i].multiplier;
addCycle = (f == ceiling) ? this.calendarRule.coeff[i].subCycleShift : 0; // If at end of this cycle, the ceiling of the lower cycle may be increased or decreased.
quantity += f * this.calendarRule.coeff[i].cyclelength; // contribution to quantity at this level.
}
return quantity ;
}
} // end of Cbcce class
/** Structure of the weekRule parameter passed to WeekClock that describes the structure of the week.
* Non checked constraints:
* 1. characWeekNumber shall be at beginning of year, before any intercalary month or day.
* 2. weekLength shall be > 0.
* @typedef {Object} weekRule - set of parameters for the computation of week elements.
* @property {Number} originWeekday - weekday number of day 0; value is renormalised to 0..weekLength-1.
* @property {Function} daysInYear - function (year), number of days in year; year is specified as "fullyear" (unambiguous);
* with solar calendars, result is 365 or 366.
* @property {Function} characDayIndex - function (year): the day index of one day of week number characWeekNumber of year;
* if weekReset is true, this day shall be the first day of the week characWeekNumber ; if not, all weeks are of same length.
* @property {Number} [startOfWeek=1] - weekday number of the first day of the week for this calendar, e.g. 0 for Sunday, 1 for Monday etc. Default is 1;
* value is renormalised to 0..weekLength-1.
* @property {Number} [characWeekNumber=1] - number of the week of the characDayIndex; default is 1.
* @property {Number} [dayBase=1] - the lowest number a weekday may have, normally only 0 or 1 are possible; not necessarily startOfWeek; default is 1.
* @property {Number} [weekBase=1] - the lowest number for a week, normally only 0 or 1 are possible; not necessarily characWeekNumber; default is 1.
* @property {Number} [weekLength=7] - number of days, or minimum number of days in one week; default is 7.
* @property {Number} [weekReset=false] - whether weekday is forced to a constant value at beginning of year; default is false.
* @property {Number[]} [uncappedWeeks=null] - an array of the week numbers that have one or more day above weekLength; possible cases:
* undefined (and set to null): all weeks have always the same duration, weekLength;
* .length = 1: last complete week of year is followed by several epagomenal days. These days are attached to the last week and hold numbers above weekLength;
* .length > 1: each indentified week is followed by one (unique) epagomenal day. Any such week has weekLength + 1 days;
* e.g. for French revolutionary calendar: [36], and the epagomenal days are indexed above Décadi, last day of the ordinary decade;
* e.g. for ONU projected calendar: [26, 52], the Mondial day in the middle of year and the Bissextile day at the very end.
* These days are only considered if weekReset is true, and in this case, uncappedWeeks should at least have one value.
*/
/** Get and set week figures using a specified reckoning sytems for weeks.
* @see module:chronos for the definition of the weekRule structure.
* @class
* @param {weekRule} weekRule - the description of the week.
*/
export class WeekClock {
constructor (weekRule) {
this.originWeekday = weekRule.originWeekday;
this.daysInYear = weekRule.daysInYear;
this.characDayIndex = weekRule.characDayIndex;
this.weekLength = weekRule.weekLength != undefined ? weekRule.weekLength : 7 ;
this.startOfWeek = weekRule.startOfWeek != undefined ? Cbcce.mod (weekRule.startOfWeek, this.weekLength) : 1 ;
this.characWeekNumber = weekRule.characWeekNumber != undefined ? weekRule.characWeekNumber : 1 ;
this.dayBase = weekRule.dayBase != undefined ? Cbcce.mod (weekRule.dayBase, this.weekLength) : 1 ;
this.weekBase = weekRule.weekBase != undefined ? weekRule.weekBase : 1;
this.weekReset = weekRule.weekReset != undefined ? weekRule.weekReset : false;
this.uncappedWeeks = weekRule.uncappedWeeks != undefined ? weekRule.uncappedWeeks : null;
}
/** Compute week figures in the defined week structure.
* @param {number} dayIndex - date stamp, in day unit, of the day whose figures are computed.
* @param {number} year - the algebraic year the dayIndex date belongs to.
* @return {Array}
* [0] : week number;
* [1] : week day number, depending on dayBase. Modulo this.weekLength value is always : 0 (or this.weekLength) for Sunday of first day, 1 for Monday etc.
* [2] : year offset: -1 if week belongs to last week year, 0 if in same year, 1 if in next year.
* [3] : weeks in year: number of weeks for the week year the date belongs to. This is not always the number of the last week (check this.weekBase)!
*/
getWeekFigures (dayIndex, year) { // (dayIndex, characDayIndex, year)
let cDayIndex = this.characDayIndex (year),
weekNumberShift = this.weekBase - 1, // used to compute last week's number
[weeksInYear, weekShiftNextYear] = Cbcce.divmod (this.daysInYear(year), this.weekLength), // Integer division of calendar year in weeks.
// this figure characterises the week year, in particular versus number of weeks.
weekYearPhase = (this.weekReset ? 0 : Cbcce.mod (cDayIndex + this.originWeekday - this.startOfWeek, this.weekLength));
// Compute basic coordinates: week cycle number (base 0) from referenceDay, day number 0..this.weekLength-1 in week beginning at 0 then shift to this.startOfWeek.
var result = Cbcce.divmod ( dayIndex - cDayIndex + this.startOfWeek + weekYearPhase, this.weekLength ); // Here, first week is 0 and first day of week is 0.
if (this.uncappedWeeks != null && this.uncappedWeeks.length > 1) // one or several weeks with one epagomenal days within year. One epagomenal day per singular week.
this.uncappedWeeks.forEach (item => {if (result[0] > item) {
result[1]--; result = Cbcce.divmod (result[0] * this.weekLength + result[1], this.weekLength) }}) // shift week counts by one day for each singular week.
result[0] += this.characWeekNumber; // set week number with respect to number of week of the reference day
result = Cbcce.shiftCycle ( result[0], result [1], this.weekLength, this.startOfWeek ); // shift week cycle, first day is this.startOfWeek and last day is this.startOfWeek + this.weekLength-1
if (this.dayBase != this.startOfWeek) result[1] = Cbcce.mod (result[1]-this.dayBase, this.weekLength) + this.dayBase; // day number forced to range this.dayBase .. this.dayBase + this.weekLength-1;
if (this.uncappedWeeks != null && this.uncappedWeeks.length == 1)
if (result[0] > this.uncappedWeeks[0]) {result[0]-- ; result[1] += this.weekLength } // epagomenal days at end of year have indexes above ordinary weekLength
// Solve overflow
let WeeksInDateYear = weeksInYear + ( !this.weekReset && weekYearPhase >= Cbcce.mod (-weekShiftNextYear, this.weekLength) ? 1 : 0); // Number of weeks for present week year
if (result[0] < this.weekBase) { // the week belongs to the preceding weekyear
[weeksInYear, weekShiftNextYear] = Cbcce.divmod (this.daysInYear(year-1), this.weekLength); // recompute week year parameters for preceding year
result.push(-1, // reference year for the week number is the year before the date's year
Cbcce.mod (weekYearPhase - weekShiftNextYear, this.weekLength) >= Cbcce.mod (-weekShiftNextYear, this.weekLength) // weekYearPhase of preceding year computed after this year's
? weeksInYear + 1 : weeksInYear ); // Number of weeks in the preceding year
result[0] = result[3] + weekNumberShift; // Set to last week of preceding year
} else if (result[0] > WeeksInDateYear + weekNumberShift) { // The week belongs to the following year
let [ weeksInYearPlus, weekShiftNextYearPlus ] = Cbcce.divmod (this.daysInYear(year+1), this.weekLength); // Integer division of next calendar year in weeks
result.push (1, // reference year for the week number is the year after the date's year
Cbcce.mod (weekYearPhase + weekShiftNextYear, this.weekLength) >= Cbcce.mod (-weekShiftNextYearPlus, this.weekLength) // weekYearPhase cycle of next year computed from this year's
? weeksInYearPlus + 1 : weeksInYearPlus); // Number of weeks in the next wwek year
result[0] = this.weekBase; // set to first week
} else result.push (0, WeeksInDateYear); // most cases.
return result;
}
/** Compute day index from week figures in the defined week structure.
* @param {number} weekYear - the year (full year, a relative integer) of the week figures. There may be 1 year difference with the year of the calendar's date.
* @param {number} [weekNumber] - the week number; if not specified, this.weekBase i.e. the first week of any year.
* @param {number} [dayOfWeek] - the weekday number; if not specified, this.startOfWeek i.e. the first day of the week for this culture.
* @param {boolean} [check] - check consistency of result; no check by default.
* @return {number} day index of the day that corresponds to the week figures.
*/
getNumberFromWeek (weekYear, weekNumber = this.weekBase, dayOfWeek = this.startOfWeek, check = false) {
if (weekNumber < this.weekBase) throw new RangeError ('Week number too low: ' + weekNumber);
if (dayOfWeek < this.dayBase) throw new RangeError ('Day of week too low: ' + dayOfWeek);
let cDayIndex = this.characDayIndex (weekYear); // Find a day within week number characWeekNumber of this year.
cDayIndex -= (this.weekReset ? 0 : Cbcce.mod ( cDayIndex + this.originWeekday - this.startOfWeek, this.weekLength )) ; // Find first day of said week.
let weekcomponents = Cbcce.divmod (dayOfWeek - this.startOfWeek, this.weekLength); // Take note of epagomenal days
let result = cDayIndex + (weekNumber - this.weekBase) * this.weekLength + weekcomponents[1] ; // Add weeks and week "phase".
if (this.uncappedWeeks != null) {
this.uncappedWeeks.forEach ((value) => ( result += (weekNumber > value ? 1 :0) )) ; // Add shift due to days added in middle of year.
if (this.uncappedWeeks.length == 1 && weekNumber == this.uncappedWeeks[0]) result += weekcomponents[0] * this.weekLength; // Add additional days
}
// Control by doing the reverse computation
let test = this.getWeekFigures (cDayIndex, weekYear);
if (check) {
if (test [3] < weekNumber) throw new RangeError ('Week number too high: ' + weekNumber);
if (test [0] != weekNumber || test [1] != dayOfWeek) throw new RangeError
('Recomputed week figures do not match asked ones: '+ weekYear + ', ' + weekNumber + ', ' + dayOfWeek);
}
return result;
}
}
/** Convert number of days since epoch to or from a date expressed after ISO 8601.
* @class
* @param {number} [originYear=1970] - the epoch year in ISO, a signed integer, default: 1970 for the Unix epoch.
* @param {number} [originMonth=1] - the epoch month in ISO, a number in range 1..12, default: 1.
* @param {number} [originDay=1] - the epoch day of the month in ISO, a number in range 1..31, default: 1. If this day does not exist in this month, date is balanced to next month.
*/
export class IsoCounter {
constructor (originYear=1970, originMonth=1, originDay=1) {
const
isoCoeff = [
{cyclelength : 146097, ceiling : Infinity, subCycleShift : 0, multiplier : 400, target : "isoYear"}, // 400 Gregorian years
{cyclelength : 36524, ceiling : 3, subCycleShift : 0, multiplier : 100, target : "isoYear"}, // 1 Gregorian short century
{cyclelength : 1461, ceiling : Infinity, subCycleShift : 0, multiplier : 4, target : "isoYear"}, // 4 Julian years
{cyclelength : 365, ceiling : 3, subCycleShift : 0, multiplier : 1, target : "isoYear"}, // One 365-days year
{cyclelength : 153, ceiling : Infinity, subCycleShift : 0, multiplier : 5, target : "isoMonth"}, // Five-months cycle
{cyclelength : 61, ceiling : Infinity, subCycleShift : 0, multiplier : 2, target : "isoMonth"}, // 61-days bimester
{cyclelength : 31, ceiling : Infinity, subCycleShift : 0, multiplier : 1, target : "isoMonth"}, // 31-days month
{cyclelength : 1, ceiling : Infinity, subCycleShift : 0, multiplier : 1, target : "isoDay"}
],
isoCanvas = [
{name : "isoYear", init : 0},
{name : "isoMonth", init : 3}, // this.monthBase + 2
{name : "isoDay", init : 1}
];
// Compute counter of specified date as if it were since 0000-03-01
this.clockwork = new Cbcce ({
timeepoch : 0, // 0 on 0000-03-01.
coeff : isoCoeff, canvas : isoCanvas
})
let shift = this.toCounter ( {isoYear: originYear, isoMonth: originMonth, isoDay: originDay} );
// Then establish new clockwork taking the opposite value for epoch counter
this.clockwork = new Cbcce ({
timeepoch : -shift, // re-instatiated to the value that corresponds to the asked date
coeff : isoCoeff, canvas : isoCanvas
})
}
/** Compute day counter, an integer number for the date specified under ISO 8601.
* @function
* @param {Object} isoFields - fields isoYear, isoMonth and isoDay must be specified as integer. isoMonth must lay in range 1..12
if day is out of range of valid days for the month, date is balanced to the number of days out of the range.
* @return {number} the counter, an integer number representing the date with the day counter.
*/
toCounter = function ( isoFields ) {
let myFields = {...isoFields};
// for missing fields: getNumber shall throw
[myFields.isoYear, myFields.isoMonth] = Cbcce.shiftCycle (isoFields.isoYear, isoFields.isoMonth, 12, 2, 1); // replace last parameter if monthBase 0 is required
return this.clockwork.getNumber (myFields)
}
/** Compute ISO8601 date figures from a number of days since epoch.
* @function
* @param {number} counter - the day counter, a counter representing a date; if not integer, the floor value is taken.
* @return {Object} fields isoYear, isoMonth and isoDay specify the date in ISO8601 calendar.
*/
toIsoFields = function ( counter ) {
let myFields = this.clockwork.getObject (Math.floor (counter));
[myFields.isoYear, myFields.isoMonth] = Cbcce.shiftCycle (myFields.isoYear, myFields.isoMonth, 12, -2, 3); // replace last parameter if monthBase 0 is required
return myFields
}
}
</code></pre>
</article>
</section>
</div>
<nav>
<h2><a href="index.html">Home</a></h2><h3>Modules</h3><ul><li><a href="module-calendars.html">calendars</a></li><li><a href="module-chronos.html">chronos</a></li><li><a href="module-customcalendarmodel.html">customcalendarmodel</a></li><li><a href="module-extdate.html">extdate</a></li><li><a href="module-extdatetimeformat.html">extdatetimeformat</a></li><li><a href="module-fetchdom.html">fetchdom</a></li><li><a href="module-pldr.html">pldr</a></li><li><a href="module-time-units.html">time-units</a></li></ul><h3>Namespaces</h3><ul><li><a href="window.html">window</a></li></ul><h3>Classes</h3><ul><li><a href="module-calendars.FrenchRevCalendar.html">FrenchRevCalendar</a></li><li><a href="module-calendars.GregorianCalendar.html">GregorianCalendar</a></li><li><a href="module-calendars.JulianCalendar.html">JulianCalendar</a></li><li><a href="module-calendars.MilesianCalendar.html">MilesianCalendar</a></li><li><a href="module-calendars.Persian33Calendar.html">Persian33Calendar</a></li><li><a href="module-calendars.ProlepticGregorianCalendar.html">ProlepticGregorianCalendar</a></li><li><a href="module-chronos.Cbcce.html">Cbcce</a></li><li><a href="module-chronos.IsoCounter.html">IsoCounter</a></li><li><a href="module-chronos.WeekClock.html">WeekClock</a></li><li><a href="module-extdate.html">extdate</a></li><li><a href="module-extdatetimeformat.html">extdatetimeformat</a></li></ul><h3>Global</h3><ul><li><a href="global.html#TZ">TZ</a></li><li><a href="global.html#TZOffset">TZOffset</a></li><li><a href="global.html#addTime">addTime</a></li><li><a href="global.html#addedTime">addedTime</a></li><li><a href="global.html#askedOptions">askedOptions</a></li><li><a href="global.html#calcCustom">calcCustom</a></li><li><a href="global.html#calcTime">calcTime</a></li><li><a href="global.html#calcWeek">calcWeek</a></li><li><a href="global.html#calendars">calendars</a></li><li><a href="global.html#calendrical">calendrical</a></li><li><a href="global.html#changeAddTime">changeAddTime</a></li><li><a href="global.html#changeDayOffset">changeDayOffset</a></li><li><a href="global.html#compLocalePresentationCalendar">compLocalePresentationCalendar</a></li><li><a href="global.html#cusAskedOptions">cusAskedOptions</a></li><li><a href="global.html#customCalIndex">customCalIndex</a></li><li><a href="global.html#dayOffset">dayOffset</a></li><li><a href="global.html#extAskedOptions">extAskedOptions</a></li><li><a href="global.html#extUsedOptions">extUsedOptions</a></li><li><a href="global.html#getMode">getMode</a></li><li><a href="global.html#loadCalendrical">loadCalendrical</a></li><li><a href="global.html#setCalend">setCalend</a></li><li><a href="global.html#setDateToNow">setDateToNow</a></li><li><a href="global.html#setDayOffset">setDayOffset</a></li><li><a href="global.html#setDisplay">setDisplay</a></li><li><a href="global.html#setUTCHoursFixed">setUTCHoursFixed</a></li><li><a href="global.html#switchingDate">switchingDate</a></li><li><a href="global.html#targetDate">targetDate</a></li><li><a href="global.html#usedOptions">usedOptions</a></li></ul>
</nav>
<br class="clear">
<footer>
Documentation generated by <a href="https://github.com/jsdoc/jsdoc">JSDoc 4.0.3</a> on Sun Jun 23 2024 19:20:55 GMT+0200 (heure d’été d’Europe centrale)
</footer>
<script> prettyPrint(); </script>
<script src="scripts/linenumber.js"> </script>
</body>
</html>