mirror of
https://github.com/MHSanaei/3x-ui.git
synced 2025-03-02 01:30:51 +03:00
c76199514a
* added datepicker option in setting page jalalian datepicker component was added translate files for datepicker updated * dark mode bug fixed
1252 lines
42 KiB
JavaScript
1252 lines
42 KiB
JavaScript
|
||
;(function(){
|
||
|
||
/**
|
||
* Require the module at `name`.
|
||
*
|
||
* @param {String} name
|
||
* @return {Object} exports
|
||
* @api public
|
||
*/
|
||
|
||
function require(name) {
|
||
var module = require.modules[name];
|
||
if (!module) throw new Error('failed to require "' + name + '"');
|
||
|
||
if (!('exports' in module) && typeof module.definition === 'function') {
|
||
module.client = module.component = true;
|
||
module.definition.call(this, module.exports = {}, module);
|
||
delete module.definition;
|
||
}
|
||
|
||
return module.exports;
|
||
}
|
||
|
||
/**
|
||
* Registered modules.
|
||
*/
|
||
|
||
require.modules = {
|
||
moment: { exports: moment }
|
||
};
|
||
|
||
/**
|
||
* Register module at `name` with callback `definition`.
|
||
*
|
||
* @param {String} name
|
||
* @param {Function} definition
|
||
* @api private
|
||
*/
|
||
|
||
require.register = function (name, definition) {
|
||
require.modules[name] = {
|
||
definition: definition
|
||
};
|
||
};
|
||
|
||
/**
|
||
* Define a module's exports immediately with `exports`.
|
||
*
|
||
* @param {String} name
|
||
* @param {Generic} exports
|
||
* @api private
|
||
*/
|
||
|
||
require.define = function (name, exports) {
|
||
require.modules[name] = {
|
||
exports: exports
|
||
};
|
||
};
|
||
|
||
require.register("jalaali-js", function (exports, module) {
|
||
/*
|
||
Expose functions.
|
||
*/
|
||
module.exports =
|
||
{ toJalaali: toJalaali
|
||
, toGregorian: toGregorian
|
||
, isValidJalaaliDate: isValidJalaaliDate
|
||
, isLeapJalaaliYear: isLeapJalaaliYear
|
||
, jalaaliMonthLength: jalaaliMonthLength
|
||
, jalCal: jalCal
|
||
, j2d: j2d
|
||
, d2j: d2j
|
||
, g2d: g2d
|
||
, d2g: d2g
|
||
}
|
||
|
||
/*
|
||
Converts a Gregorian date to Jalaali.
|
||
*/
|
||
function toJalaali(gy, gm, gd) {
|
||
if (Object.prototype.toString.call(gy) === '[object Date]') {
|
||
gd = gy.getDate()
|
||
gm = gy.getMonth() + 1
|
||
gy = gy.getFullYear()
|
||
}
|
||
return d2j(g2d(gy, gm, gd))
|
||
}
|
||
|
||
/*
|
||
Converts a Jalaali date to Gregorian.
|
||
*/
|
||
function toGregorian(jy, jm, jd) {
|
||
return d2g(j2d(jy, jm, jd))
|
||
}
|
||
|
||
/*
|
||
Checks whether a Jalaali date is valid or not.
|
||
*/
|
||
function isValidJalaaliDate(jy, jm, jd) {
|
||
return jy >= -61 && jy <= 3177 &&
|
||
jm >= 1 && jm <= 12 &&
|
||
jd >= 1 && jd <= jalaaliMonthLength(jy, jm)
|
||
}
|
||
|
||
/*
|
||
Is this a leap year or not?
|
||
*/
|
||
function isLeapJalaaliYear(jy) {
|
||
return jalCal(jy).leap === 0
|
||
}
|
||
|
||
/*
|
||
Number of days in a given month in a Jalaali year.
|
||
*/
|
||
function jalaaliMonthLength(jy, jm) {
|
||
if (jm <= 6) return 31
|
||
if (jm <= 11) return 30
|
||
if (isLeapJalaaliYear(jy)) return 30
|
||
return 29
|
||
}
|
||
|
||
/*
|
||
This function determines if the Jalaali (Persian) year is
|
||
leap (366-day long) or is the common year (365 days), and
|
||
finds the day in March (Gregorian calendar) of the first
|
||
day of the Jalaali year (jy).
|
||
|
||
@param jy Jalaali calendar year (-61 to 3177)
|
||
@return
|
||
leap: number of years since the last leap year (0 to 4)
|
||
gy: Gregorian year of the beginning of Jalaali year
|
||
march: the March day of Farvardin the 1st (1st day of jy)
|
||
@see: http://www.astro.uni.torun.pl/~kb/Papers/EMP/PersianC-EMP.htm
|
||
@see: http://www.fourmilab.ch/documents/calendar/
|
||
*/
|
||
function jalCal(jy) {
|
||
// Jalaali years starting the 33-year rule.
|
||
var breaks = [ -61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181, 1210
|
||
, 1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178
|
||
]
|
||
, bl = breaks.length
|
||
, gy = jy + 621
|
||
, leapJ = -14
|
||
, jp = breaks[0]
|
||
, jm
|
||
, jump
|
||
, leap
|
||
, leapG
|
||
, march
|
||
, n
|
||
, i
|
||
|
||
if (jy < jp || jy >= breaks[bl - 1])
|
||
throw new Error('Invalid Jalaali year ' + jy)
|
||
|
||
// Find the limiting years for the Jalaali year jy.
|
||
for (i = 1; i < bl; i += 1) {
|
||
jm = breaks[i]
|
||
jump = jm - jp
|
||
if (jy < jm)
|
||
break
|
||
leapJ = leapJ + div(jump, 33) * 8 + div(mod(jump, 33), 4)
|
||
jp = jm
|
||
}
|
||
n = jy - jp
|
||
|
||
// Find the number of leap years from AD 621 to the beginning
|
||
// of the current Jalaali year in the Persian calendar.
|
||
leapJ = leapJ + div(n, 33) * 8 + div(mod(n, 33) + 3, 4)
|
||
if (mod(jump, 33) === 4 && jump - n === 4)
|
||
leapJ += 1
|
||
|
||
// And the same in the Gregorian calendar (until the year gy).
|
||
leapG = div(gy, 4) - div((div(gy, 100) + 1) * 3, 4) - 150
|
||
|
||
// Determine the Gregorian date of Farvardin the 1st.
|
||
march = 20 + leapJ - leapG
|
||
|
||
// Find how many years have passed since the last leap year.
|
||
if (jump - n < 6)
|
||
n = n - jump + div(jump + 4, 33) * 33
|
||
leap = mod(mod(n + 1, 33) - 1, 4)
|
||
if (leap === -1) {
|
||
leap = 4
|
||
}
|
||
|
||
return { leap: leap
|
||
, gy: gy
|
||
, march: march
|
||
}
|
||
}
|
||
|
||
/*
|
||
Converts a date of the Jalaali calendar to the Julian Day number.
|
||
|
||
@param jy Jalaali year (1 to 3100)
|
||
@param jm Jalaali month (1 to 12)
|
||
@param jd Jalaali day (1 to 29/31)
|
||
@return Julian Day number
|
||
*/
|
||
function j2d(jy, jm, jd) {
|
||
var r = jalCal(jy)
|
||
return g2d(r.gy, 3, r.march) + (jm - 1) * 31 - div(jm, 7) * (jm - 7) + jd - 1
|
||
}
|
||
|
||
/*
|
||
Converts the Julian Day number to a date in the Jalaali calendar.
|
||
|
||
@param jdn Julian Day number
|
||
@return
|
||
jy: Jalaali year (1 to 3100)
|
||
jm: Jalaali month (1 to 12)
|
||
jd: Jalaali day (1 to 29/31)
|
||
*/
|
||
function d2j(jdn) {
|
||
var gy = d2g(jdn).gy // Calculate Gregorian year (gy).
|
||
, jy = gy - 621
|
||
, r = jalCal(jy)
|
||
, jdn1f = g2d(gy, 3, r.march)
|
||
, jd
|
||
, jm
|
||
, k
|
||
|
||
// Find number of days that passed since 1 Farvardin.
|
||
k = jdn - jdn1f
|
||
if (k >= 0) {
|
||
if (k <= 185) {
|
||
// The first 6 months.
|
||
jm = 1 + div(k, 31)
|
||
jd = mod(k, 31) + 1
|
||
return { jy: jy
|
||
, jm: jm
|
||
, jd: jd
|
||
}
|
||
} else {
|
||
// The remaining months.
|
||
k -= 186
|
||
}
|
||
} else {
|
||
// Previous Jalaali year.
|
||
jy -= 1
|
||
k += 179
|
||
if (r.leap === 1)
|
||
k += 1
|
||
}
|
||
jm = 7 + div(k, 30)
|
||
jd = mod(k, 30) + 1
|
||
return { jy: jy
|
||
, jm: jm
|
||
, jd: jd
|
||
}
|
||
}
|
||
|
||
/*
|
||
Calculates the Julian Day number from Gregorian or Julian
|
||
calendar dates. This integer number corresponds to the noon of
|
||
the date (i.e. 12 hours of Universal Time).
|
||
The procedure was tested to be good since 1 March, -100100 (of both
|
||
calendars) up to a few million years into the future.
|
||
|
||
@param gy Calendar year (years BC numbered 0, -1, -2, ...)
|
||
@param gm Calendar month (1 to 12)
|
||
@param gd Calendar day of the month (1 to 28/29/30/31)
|
||
@return Julian Day number
|
||
*/
|
||
function g2d(gy, gm, gd) {
|
||
var d = div((gy + div(gm - 8, 6) + 100100) * 1461, 4)
|
||
+ div(153 * mod(gm + 9, 12) + 2, 5)
|
||
+ gd - 34840408
|
||
d = d - div(div(gy + 100100 + div(gm - 8, 6), 100) * 3, 4) + 752
|
||
return d
|
||
}
|
||
|
||
/*
|
||
Calculates Gregorian and Julian calendar dates from the Julian Day number
|
||
(jdn) for the period since jdn=-34839655 (i.e. the year -100100 of both
|
||
calendars) to some millions years ahead of the present.
|
||
|
||
@param jdn Julian Day number
|
||
@return
|
||
gy: Calendar year (years BC numbered 0, -1, -2, ...)
|
||
gm: Calendar month (1 to 12)
|
||
gd: Calendar day of the month M (1 to 28/29/30/31)
|
||
*/
|
||
function d2g(jdn) {
|
||
var j
|
||
, i
|
||
, gd
|
||
, gm
|
||
, gy
|
||
j = 4 * jdn + 139361631
|
||
j = j + div(div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908
|
||
i = div(mod(j, 1461), 4) * 5 + 308
|
||
gd = div(mod(i, 153), 5) + 1
|
||
gm = mod(div(i, 153), 12) + 1
|
||
gy = div(j, 1461) - 100100 + div(8 - gm, 6)
|
||
return { gy: gy
|
||
, gm: gm
|
||
, gd: gd
|
||
}
|
||
}
|
||
|
||
/*
|
||
Utility helper functions.
|
||
*/
|
||
|
||
function div(a, b) {
|
||
return ~~(a / b)
|
||
}
|
||
|
||
function mod(a, b) {
|
||
return a - ~~(a / b) * b
|
||
}
|
||
})
|
||
require.register("moment-jalaali", function (exports, module) {
|
||
|
||
module.exports = jMoment
|
||
|
||
var moment = require('moment')
|
||
, jalaali = require('jalaali-js')
|
||
|
||
/************************************
|
||
Constants
|
||
************************************/
|
||
|
||
var formattingTokens = /(\[[^\[]*\])|(\\)?j(Mo|MM?M?M?|Do|DDDo|DD?D?D?|w[o|w]?|YYYYY|YYYY|YY|gg(ggg?)?|)|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|SS?S?|X|zz?|ZZ?|.)/g
|
||
, localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS?|LL?L?L?|l{1,4})/g
|
||
|
||
, parseTokenOneOrTwoDigits = /\d\d?/
|
||
, parseTokenOneToThreeDigits = /\d{1,3}/
|
||
, parseTokenThreeDigits = /\d{3}/
|
||
, parseTokenFourDigits = /\d{1,4}/
|
||
, parseTokenSixDigits = /[+\-]?\d{1,6}/
|
||
, parseTokenWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i
|
||
, parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/i
|
||
, parseTokenT = /T/i
|
||
, parseTokenTimestampMs = /[\+\-]?\d+(\.\d{1,3})?/
|
||
, symbolMap = {
|
||
'1': '۱',
|
||
'2': '۲',
|
||
'3': '۳',
|
||
'4': '۴',
|
||
'5': '۵',
|
||
'6': '۶',
|
||
'7': '۷',
|
||
'8': '۸',
|
||
'9': '۹',
|
||
'0': '۰'
|
||
}
|
||
, numberMap = {
|
||
'۱': '1',
|
||
'۲': '2',
|
||
'۳': '3',
|
||
'۴': '4',
|
||
'۵': '5',
|
||
'۶': '6',
|
||
'۷': '7',
|
||
'۸': '8',
|
||
'۹': '9',
|
||
'۰': '0'
|
||
}
|
||
|
||
|
||
, unitAliases =
|
||
{ jm: 'jmonth'
|
||
, jmonths: 'jmonth'
|
||
, jy: 'jyear'
|
||
, jyears: 'jyear'
|
||
}
|
||
|
||
, formatFunctions = {}
|
||
|
||
, ordinalizeTokens = 'DDD w M D'.split(' ')
|
||
, paddedTokens = 'M D w'.split(' ')
|
||
|
||
, formatTokenFunctions =
|
||
{ jM: function () {
|
||
return this.jMonth() + 1
|
||
}
|
||
, jMMM: function (format) {
|
||
return this.localeData().jMonthsShort(this, format)
|
||
}
|
||
, jMMMM: function (format) {
|
||
return this.localeData().jMonths(this, format)
|
||
}
|
||
, jD: function () {
|
||
return this.jDate()
|
||
}
|
||
, jDDD: function () {
|
||
return this.jDayOfYear()
|
||
}
|
||
, jw: function () {
|
||
return this.jWeek()
|
||
}
|
||
, jYY: function () {
|
||
return leftZeroFill(this.jYear() % 100, 2)
|
||
}
|
||
, jYYYY: function () {
|
||
return leftZeroFill(this.jYear(), 4)
|
||
}
|
||
, jYYYYY: function () {
|
||
return leftZeroFill(this.jYear(), 5)
|
||
}
|
||
, jgg: function () {
|
||
return leftZeroFill(this.jWeekYear() % 100, 2)
|
||
}
|
||
, jgggg: function () {
|
||
return this.jWeekYear()
|
||
}
|
||
, jggggg: function () {
|
||
return leftZeroFill(this.jWeekYear(), 5)
|
||
}
|
||
}
|
||
|
||
function padToken(func, count) {
|
||
return function (a) {
|
||
return leftZeroFill(func.call(this, a), count)
|
||
}
|
||
}
|
||
function ordinalizeToken(func, period) {
|
||
return function (a) {
|
||
return this.localeData().ordinal(func.call(this, a), period)
|
||
}
|
||
}
|
||
|
||
(function () {
|
||
var i
|
||
while (ordinalizeTokens.length) {
|
||
i = ordinalizeTokens.pop()
|
||
formatTokenFunctions['j' + i + 'o'] = ordinalizeToken(formatTokenFunctions['j' + i], i)
|
||
}
|
||
while (paddedTokens.length) {
|
||
i = paddedTokens.pop()
|
||
formatTokenFunctions['j' + i + i] = padToken(formatTokenFunctions['j' + i], 2)
|
||
}
|
||
formatTokenFunctions.jDDDD = padToken(formatTokenFunctions.jDDD, 3)
|
||
}())
|
||
|
||
/************************************
|
||
Helpers
|
||
************************************/
|
||
|
||
function extend(a, b) {
|
||
var key
|
||
for (key in b)
|
||
if (b.hasOwnProperty(key))
|
||
a[key] = b[key]
|
||
return a
|
||
}
|
||
|
||
function leftZeroFill(number, targetLength) {
|
||
var output = number + ''
|
||
while (output.length < targetLength)
|
||
output = '0' + output
|
||
return output
|
||
}
|
||
|
||
function isArray(input) {
|
||
return Object.prototype.toString.call(input) === '[object Array]'
|
||
}
|
||
|
||
// function compareArrays(array1, array2) {
|
||
// var len = Math.min(array1.length, array2.length)
|
||
// , lengthDiff = Math.abs(array1.length - array2.length)
|
||
// , diffs = 0
|
||
// , i
|
||
// for (i = 0; i < len; i += 1)
|
||
// if (~~array1[i] !== ~~array2[i])
|
||
// diffs += 1
|
||
// return diffs + lengthDiff
|
||
// }
|
||
|
||
function normalizeUnits(units) {
|
||
if (units) {
|
||
var lowered = units.toLowerCase()
|
||
units = unitAliases[lowered] || lowered
|
||
}
|
||
return units
|
||
}
|
||
|
||
function setDate(m, year, month, date) {
|
||
var d = m._d
|
||
if (isNaN(year)) {
|
||
m._isValid = false
|
||
}
|
||
if (m._isUTC) {
|
||
/*eslint-disable new-cap*/
|
||
m._d = new Date(Date.UTC(year, month, date,
|
||
d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds()))
|
||
/*eslint-enable new-cap*/
|
||
} else {
|
||
m._d = new Date(year, month, date,
|
||
d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds())
|
||
}
|
||
}
|
||
|
||
function objectCreate(parent) {
|
||
function F() {}
|
||
F.prototype = parent
|
||
return new F()
|
||
}
|
||
|
||
function getPrototypeOf(object) {
|
||
if (Object.getPrototypeOf)
|
||
return Object.getPrototypeOf(object)
|
||
else if (''.__proto__)
|
||
return object.__proto__
|
||
else
|
||
return object.constructor.prototype
|
||
}
|
||
|
||
/************************************
|
||
Languages
|
||
************************************/
|
||
extend(getPrototypeOf(moment.localeData()),
|
||
{ _jMonths: [ 'Farvardin'
|
||
, 'Ordibehesht'
|
||
, 'Khordaad'
|
||
, 'Tir'
|
||
, 'Amordaad'
|
||
, 'Shahrivar'
|
||
, 'Mehr'
|
||
, 'Aabaan'
|
||
, 'Aazar'
|
||
, 'Dey'
|
||
, 'Bahman'
|
||
, 'Esfand'
|
||
]
|
||
, jMonths: function (m) {
|
||
return this._jMonths[m.jMonth()]
|
||
}
|
||
|
||
, _jMonthsShort: [ 'Far'
|
||
, 'Ord'
|
||
, 'Kho'
|
||
, 'Tir'
|
||
, 'Amo'
|
||
, 'Sha'
|
||
, 'Meh'
|
||
, 'Aab'
|
||
, 'Aaz'
|
||
, 'Dey'
|
||
, 'Bah'
|
||
, 'Esf'
|
||
]
|
||
, jMonthsShort: function (m) {
|
||
return this._jMonthsShort[m.jMonth()]
|
||
}
|
||
|
||
, jMonthsParse: function (monthName) {
|
||
var i
|
||
, mom
|
||
, regex
|
||
if (!this._jMonthsParse)
|
||
this._jMonthsParse = []
|
||
for (i = 0; i < 12; i += 1) {
|
||
// Make the regex if we don't have it already.
|
||
if (!this._jMonthsParse[i]) {
|
||
mom = jMoment([2000, (2 + i) % 12, 25])
|
||
regex = '^' + this.jMonths(mom, '') + '|^' + this.jMonthsShort(mom, '')
|
||
this._jMonthsParse[i] = new RegExp(regex.replace('.', ''), 'i')
|
||
}
|
||
// Test the regex.
|
||
if (this._jMonthsParse[i].test(monthName))
|
||
return i
|
||
}
|
||
}
|
||
}
|
||
)
|
||
|
||
/************************************
|
||
Formatting
|
||
************************************/
|
||
|
||
function makeFormatFunction(format) {
|
||
var array = format.match(formattingTokens)
|
||
, length = array.length
|
||
, i
|
||
|
||
for (i = 0; i < length; i += 1)
|
||
if (formatTokenFunctions[array[i]])
|
||
array[i] = formatTokenFunctions[array[i]]
|
||
|
||
return function (mom) {
|
||
var output = ''
|
||
for (i = 0; i < length; i += 1)
|
||
output += array[i] instanceof Function ? '[' + array[i].call(mom, format) + ']' : array[i]
|
||
return output
|
||
}
|
||
}
|
||
|
||
/************************************
|
||
Parsing
|
||
************************************/
|
||
|
||
function getParseRegexForToken(token, config) {
|
||
switch (token) {
|
||
case 'jDDDD':
|
||
return parseTokenThreeDigits
|
||
case 'jYYYY':
|
||
return parseTokenFourDigits
|
||
case 'jYYYYY':
|
||
return parseTokenSixDigits
|
||
case 'jDDD':
|
||
return parseTokenOneToThreeDigits
|
||
case 'jMMM':
|
||
case 'jMMMM':
|
||
return parseTokenWord
|
||
case 'jMM':
|
||
case 'jDD':
|
||
case 'jYY':
|
||
case 'jM':
|
||
case 'jD':
|
||
return parseTokenOneOrTwoDigits
|
||
case 'DDDD':
|
||
return parseTokenThreeDigits
|
||
case 'YYYY':
|
||
return parseTokenFourDigits
|
||
case 'YYYYY':
|
||
return parseTokenSixDigits
|
||
case 'S':
|
||
case 'SS':
|
||
case 'SSS':
|
||
case 'DDD':
|
||
return parseTokenOneToThreeDigits
|
||
case 'MMM':
|
||
case 'MMMM':
|
||
case 'dd':
|
||
case 'ddd':
|
||
case 'dddd':
|
||
return parseTokenWord
|
||
case 'a':
|
||
case 'A':
|
||
return moment.localeData(config._l)._meridiemParse
|
||
case 'X':
|
||
return parseTokenTimestampMs
|
||
case 'Z':
|
||
case 'ZZ':
|
||
return parseTokenTimezone
|
||
case 'T':
|
||
return parseTokenT
|
||
case 'MM':
|
||
case 'DD':
|
||
case 'YY':
|
||
case 'HH':
|
||
case 'hh':
|
||
case 'mm':
|
||
case 'ss':
|
||
case 'M':
|
||
case 'D':
|
||
case 'd':
|
||
case 'H':
|
||
case 'h':
|
||
case 'm':
|
||
case 's':
|
||
return parseTokenOneOrTwoDigits
|
||
default:
|
||
return new RegExp(token.replace('\\', ''))
|
||
}
|
||
}
|
||
|
||
function addTimeToArrayFromToken(token, input, config) {
|
||
var a
|
||
, datePartArray = config._a
|
||
|
||
switch (token) {
|
||
case 'jM':
|
||
case 'jMM':
|
||
datePartArray[1] = input == null ? 0 : ~~input - 1
|
||
break
|
||
case 'jMMM':
|
||
case 'jMMMM':
|
||
a = moment.localeData(config._l).jMonthsParse(input)
|
||
if (a != null)
|
||
datePartArray[1] = a
|
||
else
|
||
config._isValid = false
|
||
break
|
||
case 'jD':
|
||
case 'jDD':
|
||
case 'jDDD':
|
||
case 'jDDDD':
|
||
if (input != null)
|
||
datePartArray[2] = ~~input
|
||
break
|
||
case 'jYY':
|
||
datePartArray[0] = ~~input + (~~input > 47 ? 1300 : 1400)
|
||
break
|
||
case 'jYYYY':
|
||
case 'jYYYYY':
|
||
datePartArray[0] = ~~input
|
||
}
|
||
if (input == null)
|
||
config._isValid = false
|
||
}
|
||
|
||
function dateFromArray(config) {
|
||
var g
|
||
, j
|
||
, jy = config._a[0]
|
||
, jm = config._a[1]
|
||
, jd = config._a[2]
|
||
|
||
if ((jy == null) && (jm == null) && (jd == null))
|
||
return [0, 0, 1]
|
||
jy = jy != null ? jy : 0
|
||
jm = jm != null ? jm : 0
|
||
jd = jd != null ? jd : 1
|
||
if (jd < 1 || jd > jMoment.jDaysInMonth(jy, jm) || jm < 0 || jm > 11)
|
||
config._isValid = false
|
||
g = toGregorian(jy, jm, jd)
|
||
j = toJalaali(g.gy, g.gm, g.gd)
|
||
if (isNaN(g.gy))
|
||
config._isValid = false
|
||
config._jDiff = 0
|
||
if (~~j.jy !== jy)
|
||
config._jDiff += 1
|
||
if (~~j.jm !== jm)
|
||
config._jDiff += 1
|
||
if (~~j.jd !== jd)
|
||
config._jDiff += 1
|
||
return [g.gy, g.gm, g.gd]
|
||
}
|
||
|
||
function makeDateFromStringAndFormat(config) {
|
||
var tokens = config._f.match(formattingTokens)
|
||
, string = config._i + ''
|
||
, len = tokens.length
|
||
, i
|
||
, token
|
||
, parsedInput
|
||
|
||
config._a = []
|
||
|
||
for (i = 0; i < len; i += 1) {
|
||
token = tokens[i]
|
||
parsedInput = (getParseRegexForToken(token, config).exec(string) || [])[0]
|
||
if (parsedInput)
|
||
string = string.slice(string.indexOf(parsedInput) + parsedInput.length)
|
||
if (formatTokenFunctions[token])
|
||
addTimeToArrayFromToken(token, parsedInput, config)
|
||
}
|
||
if (string)
|
||
config._il = string
|
||
return dateFromArray(config)
|
||
}
|
||
|
||
function makeDateFromStringAndArray(config, utc) {
|
||
var len = config._f.length
|
||
, i
|
||
, format
|
||
, tempMoment
|
||
, bestMoment
|
||
, currentScore
|
||
, scoreToBeat
|
||
|
||
if (len === 0) {
|
||
return makeMoment(new Date(NaN))
|
||
}
|
||
|
||
for (i = 0; i < len; i += 1) {
|
||
format = config._f[i]
|
||
currentScore = 0
|
||
tempMoment = makeMoment(config._i, format, config._l, config._strict, utc)
|
||
|
||
if (!tempMoment.isValid()) continue
|
||
|
||
// currentScore = compareArrays(tempMoment._a, tempMoment.toArray())
|
||
currentScore += tempMoment._jDiff
|
||
if (tempMoment._il)
|
||
currentScore += tempMoment._il.length
|
||
if (scoreToBeat == null || currentScore < scoreToBeat) {
|
||
scoreToBeat = currentScore
|
||
bestMoment = tempMoment
|
||
}
|
||
}
|
||
|
||
return bestMoment
|
||
}
|
||
|
||
function removeParsedTokens(config) {
|
||
var string = config._i + ''
|
||
, input = ''
|
||
, format = ''
|
||
, array = config._f.match(formattingTokens)
|
||
, len = array.length
|
||
, i
|
||
, match
|
||
, parsed
|
||
|
||
for (i = 0; i < len; i += 1) {
|
||
match = array[i]
|
||
parsed = (getParseRegexForToken(match, config).exec(string) || [])[0]
|
||
if (parsed)
|
||
string = string.slice(string.indexOf(parsed) + parsed.length)
|
||
if (!(formatTokenFunctions[match] instanceof Function)) {
|
||
format += match
|
||
if (parsed)
|
||
input += parsed
|
||
}
|
||
}
|
||
config._i = input
|
||
config._f = format
|
||
}
|
||
|
||
/************************************
|
||
Week of Year
|
||
************************************/
|
||
|
||
function jWeekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
|
||
var end = firstDayOfWeekOfYear - firstDayOfWeek
|
||
, daysToDayOfWeek = firstDayOfWeekOfYear - mom.day()
|
||
, adjustedMoment
|
||
|
||
if (daysToDayOfWeek > end) {
|
||
daysToDayOfWeek -= 7
|
||
}
|
||
if (daysToDayOfWeek < end - 7) {
|
||
daysToDayOfWeek += 7
|
||
}
|
||
adjustedMoment = jMoment(mom).add(daysToDayOfWeek, 'd')
|
||
return { week: Math.ceil(adjustedMoment.jDayOfYear() / 7)
|
||
, year: adjustedMoment.jYear()
|
||
}
|
||
}
|
||
|
||
/************************************
|
||
Top Level Functions
|
||
************************************/
|
||
var maxTimestamp = 57724432199999
|
||
|
||
function makeMoment(input, format, lang, strict, utc) {
|
||
if (typeof lang === 'boolean') {
|
||
strict = lang
|
||
lang = undefined
|
||
}
|
||
|
||
if (format && typeof format === 'string')
|
||
format = fixFormat(format, moment)
|
||
|
||
var config =
|
||
{ _i: input
|
||
, _f: format
|
||
, _l: lang
|
||
, _strict: strict
|
||
, _isUTC: utc
|
||
}
|
||
, date
|
||
, m
|
||
, jm
|
||
, origInput = input
|
||
, origFormat = format
|
||
if (format) {
|
||
if (isArray(format)) {
|
||
return makeDateFromStringAndArray(config, utc)
|
||
} else {
|
||
date = makeDateFromStringAndFormat(config)
|
||
removeParsedTokens(config)
|
||
format = 'YYYY-MM-DD-' + config._f
|
||
input = leftZeroFill(date[0], 4) + '-'
|
||
+ leftZeroFill(date[1] + 1, 2) + '-'
|
||
+ leftZeroFill(date[2], 2) + '-'
|
||
+ config._i
|
||
}
|
||
}
|
||
if (utc)
|
||
m = moment.utc(input, format, lang, strict)
|
||
else
|
||
m = moment(input, format, lang, strict)
|
||
if (config._isValid === false)
|
||
m._isValid = false
|
||
m._jDiff = config._jDiff || 0
|
||
jm = objectCreate(jMoment.fn)
|
||
extend(jm, m)
|
||
if (strict && format && jm.isValid()) {
|
||
jm._isValid = jm.format(origFormat) === origInput
|
||
}
|
||
if (m._d.getTime() > maxTimestamp) {
|
||
jm._isValid = false
|
||
}
|
||
return jm
|
||
}
|
||
|
||
function jMoment(input, format, lang, strict) {
|
||
return makeMoment(input, format, lang, strict, false)
|
||
}
|
||
|
||
extend(jMoment, moment)
|
||
jMoment.fn = objectCreate(moment.fn)
|
||
|
||
jMoment.utc = function (input, format, lang, strict) {
|
||
return makeMoment(input, format, lang, strict, true)
|
||
}
|
||
|
||
jMoment.unix = function (input) {
|
||
return makeMoment(input * 1000)
|
||
}
|
||
|
||
/************************************
|
||
jMoment Prototype
|
||
************************************/
|
||
|
||
function fixFormat(format, _moment) {
|
||
var i = 5
|
||
var replace = function (input) {
|
||
return _moment.localeData().longDateFormat(input) || input
|
||
}
|
||
while (i > 0 && localFormattingTokens.test(format)) {
|
||
i -= 1
|
||
format = format.replace(localFormattingTokens, replace)
|
||
}
|
||
return format
|
||
}
|
||
|
||
jMoment.fn.format = function (format) {
|
||
|
||
if (format) {
|
||
format = fixFormat(format, this)
|
||
|
||
if (!formatFunctions[format]) {
|
||
formatFunctions[format] = makeFormatFunction(format)
|
||
}
|
||
format = formatFunctions[format](this)
|
||
}
|
||
return moment.fn.format.call(this, format)
|
||
}
|
||
|
||
jMoment.fn.jYear = function (input) {
|
||
var lastDay
|
||
, j
|
||
, g
|
||
if (typeof input === 'number') {
|
||
j = toJalaali(this.year(), this.month(), this.date())
|
||
lastDay = Math.min(j.jd, jMoment.jDaysInMonth(input, j.jm))
|
||
g = toGregorian(input, j.jm, lastDay)
|
||
setDate(this, g.gy, g.gm, g.gd)
|
||
moment.updateOffset(this)
|
||
return this
|
||
} else {
|
||
return toJalaali(this.year(), this.month(), this.date()).jy
|
||
}
|
||
}
|
||
|
||
jMoment.fn.jMonth = function (input) {
|
||
var lastDay
|
||
, j
|
||
, g
|
||
if (input != null) {
|
||
if (typeof input === 'string') {
|
||
input = this.localeData().jMonthsParse(input)
|
||
if (typeof input !== 'number')
|
||
return this
|
||
}
|
||
j = toJalaali(this.year(), this.month(), this.date())
|
||
lastDay = Math.min(j.jd, jMoment.jDaysInMonth(j.jy, input))
|
||
this.jYear(j.jy + div(input, 12))
|
||
input = mod(input, 12)
|
||
if (input < 0) {
|
||
input += 12
|
||
this.jYear(this.jYear() - 1)
|
||
}
|
||
g = toGregorian(this.jYear(), input, lastDay)
|
||
setDate(this, g.gy, g.gm, g.gd)
|
||
moment.updateOffset(this)
|
||
return this
|
||
} else {
|
||
return toJalaali(this.year(), this.month(), this.date()).jm
|
||
}
|
||
}
|
||
|
||
jMoment.fn.jDate = function (input) {
|
||
var j
|
||
, g
|
||
if (typeof input === 'number') {
|
||
j = toJalaali(this.year(), this.month(), this.date())
|
||
g = toGregorian(j.jy, j.jm, input)
|
||
setDate(this, g.gy, g.gm, g.gd)
|
||
moment.updateOffset(this)
|
||
return this
|
||
} else {
|
||
return toJalaali(this.year(), this.month(), this.date()).jd
|
||
}
|
||
}
|
||
|
||
jMoment.fn.jDayOfYear = function (input) {
|
||
var dayOfYear = Math.round((jMoment(this).startOf('day') - jMoment(this).startOf('jYear')) / 864e5) + 1
|
||
return input == null ? dayOfYear : this.add(input - dayOfYear, 'd')
|
||
}
|
||
|
||
jMoment.fn.jWeek = function (input) {
|
||
var week = jWeekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).week
|
||
return input == null ? week : this.add((input - week) * 7, 'd')
|
||
}
|
||
|
||
jMoment.fn.jWeekYear = function (input) {
|
||
var year = jWeekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year
|
||
return input == null ? year : this.add(input - year, 'y')
|
||
}
|
||
|
||
jMoment.fn.add = function (val, units) {
|
||
var temp
|
||
if (units !== null && !isNaN(+units)) {
|
||
temp = val
|
||
val = units
|
||
units = temp
|
||
}
|
||
units = normalizeUnits(units)
|
||
if (units === 'jyear') {
|
||
this.jYear(this.jYear() + val)
|
||
} else if (units === 'jmonth') {
|
||
this.jMonth(this.jMonth() + val)
|
||
} else {
|
||
moment.fn.add.call(this, val, units)
|
||
if (isNaN(this.jYear())) {
|
||
this._isValid = false
|
||
}
|
||
}
|
||
return this
|
||
}
|
||
|
||
jMoment.fn.subtract = function (val, units) {
|
||
var temp
|
||
if (units !== null && !isNaN(+units)) {
|
||
temp = val
|
||
val = units
|
||
units = temp
|
||
}
|
||
units = normalizeUnits(units)
|
||
if (units === 'jyear') {
|
||
this.jYear(this.jYear() - val)
|
||
} else if (units === 'jmonth') {
|
||
this.jMonth(this.jMonth() - val)
|
||
} else {
|
||
moment.fn.subtract.call(this, val, units)
|
||
}
|
||
return this
|
||
}
|
||
|
||
jMoment.fn.startOf = function (units) {
|
||
units = normalizeUnits(units)
|
||
if (units === 'jyear' || units === 'jmonth') {
|
||
if (units === 'jyear') {
|
||
this.jMonth(0)
|
||
}
|
||
this.jDate(1)
|
||
this.hours(0)
|
||
this.minutes(0)
|
||
this.seconds(0)
|
||
this.milliseconds(0)
|
||
return this
|
||
} else {
|
||
return moment.fn.startOf.call(this, units)
|
||
}
|
||
}
|
||
|
||
jMoment.fn.endOf = function (units) {
|
||
units = normalizeUnits(units)
|
||
if (units === undefined || units === 'milisecond') {
|
||
return this
|
||
}
|
||
return this.startOf(units).add(1, (units === 'isoweek' ? 'week' : units)).subtract(1, 'ms')
|
||
}
|
||
|
||
jMoment.fn.isSame = function (other, units) {
|
||
units = normalizeUnits(units)
|
||
if (units === 'jyear' || units === 'jmonth') {
|
||
return moment.fn.isSame.call(this.startOf(units), other.startOf(units))
|
||
}
|
||
return moment.fn.isSame.call(this, other, units)
|
||
}
|
||
|
||
jMoment.fn.clone = function () {
|
||
return jMoment(this)
|
||
}
|
||
|
||
jMoment.fn.jYears = jMoment.fn.jYear
|
||
jMoment.fn.jMonths = jMoment.fn.jMonth
|
||
jMoment.fn.jDates = jMoment.fn.jDate
|
||
jMoment.fn.jWeeks = jMoment.fn.jWeek
|
||
|
||
/************************************
|
||
jMoment Statics
|
||
************************************/
|
||
|
||
jMoment.jDaysInMonth = function (year, month) {
|
||
year += div(month, 12)
|
||
month = mod(month, 12)
|
||
if (month < 0) {
|
||
month += 12
|
||
year -= 1
|
||
}
|
||
if (month < 6) {
|
||
return 31
|
||
} else if (month < 11) {
|
||
return 30
|
||
} else if (jMoment.jIsLeapYear(year)) {
|
||
return 30
|
||
} else {
|
||
return 29
|
||
}
|
||
}
|
||
|
||
jMoment.jIsLeapYear = jalaali.isLeapJalaaliYear
|
||
|
||
jMoment.loadPersian = function (args) {
|
||
var usePersianDigits = args !== undefined && args.hasOwnProperty('usePersianDigits') ? args.usePersianDigits : false
|
||
var dialect = args !== undefined && args.hasOwnProperty('dialect') ? args.dialect : 'persian'
|
||
moment.locale('fa')
|
||
moment.updateLocale('fa'
|
||
, { months: ('ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر').split('_')
|
||
, monthsShort: ('ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر').split('_')
|
||
, weekdays:
|
||
{
|
||
'persian': ('یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_آدینه_شنبه').split('_'),
|
||
'persian-modern': ('یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه').split('_')
|
||
}[dialect]
|
||
, weekdaysShort:
|
||
{
|
||
'persian': ('یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_آدینه_شنبه').split('_'),
|
||
'persian-modern': ('یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه').split('_')
|
||
}[dialect]
|
||
, weekdaysMin:
|
||
{
|
||
'persian': 'ی_د_س_چ_پ_آ_ش'.split('_'),
|
||
'persian-modern': 'ی_د_س_چ_پ_ج_ش'.split('_')
|
||
}[dialect]
|
||
, longDateFormat:
|
||
{ LT: 'HH:mm'
|
||
, L: 'jYYYY/jMM/jDD'
|
||
, LL: 'jD jMMMM jYYYY'
|
||
, LLL: 'jD jMMMM jYYYY LT'
|
||
, LLLL: 'dddd، jD jMMMM jYYYY LT'
|
||
}
|
||
, calendar:
|
||
{ sameDay: '[امروز ساعت] LT'
|
||
, nextDay: '[فردا ساعت] LT'
|
||
, nextWeek: 'dddd [ساعت] LT'
|
||
, lastDay: '[دیروز ساعت] LT'
|
||
, lastWeek: 'dddd [ی پیش ساعت] LT'
|
||
, sameElse: 'L'
|
||
}
|
||
, relativeTime:
|
||
{ future: 'در %s'
|
||
, past: '%s پیش'
|
||
, s: 'چند ثانیه'
|
||
, m: '1 دقیقه'
|
||
, mm: '%d دقیقه'
|
||
, h: '1 ساعت'
|
||
, hh: '%d ساعت'
|
||
, d: '1 روز'
|
||
, dd: '%d روز'
|
||
, M: '1 ماه'
|
||
, MM: '%d ماه'
|
||
, y: '1 سال'
|
||
, yy: '%d سال'
|
||
}
|
||
, preparse: function (string) {
|
||
if (usePersianDigits) {
|
||
return string.replace(/[۰-۹]/g, function (match) {
|
||
return numberMap[match]
|
||
}).replace(/،/g, ',')
|
||
}
|
||
return string
|
||
}
|
||
, postformat: function (string) {
|
||
if (usePersianDigits) {
|
||
return string.replace(/\d/g, function (match) {
|
||
return symbolMap[match]
|
||
}).replace(/,/g, '،')
|
||
}
|
||
return string
|
||
}
|
||
, ordinal: '%dم'
|
||
, week:
|
||
{ dow: 6 // Saturday is the first day of the week.
|
||
, doy: 12 // The week that contains Jan 1st is the first week of the year.
|
||
}
|
||
, meridiem: function (hour) {
|
||
return hour < 12 ? 'ق.ظ' : 'ب.ظ'
|
||
}
|
||
, jMonths:
|
||
{
|
||
'persian': ('فروردین_اردیبهشت_خرداد_تیر_امرداد_شهریور_مهر_آبان_آذر_دی_بهمن_اسفند').split('_'),
|
||
'persian-modern': ('فروردین_اردیبهشت_خرداد_تیر_مرداد_شهریور_مهر_آبان_آذر_دی_بهمن_اسفند').split('_')
|
||
}[dialect]
|
||
, jMonthsShort:
|
||
{
|
||
'persian': 'فرو_ارد_خرد_تیر_امر_شهر_مهر_آبا_آذر_دی_بهم_اسف'.split('_'),
|
||
'persian-modern': 'فرو_ارد_خرد_تیر_مرد_شهر_مهر_آبا_آذر_دی_بهم_اسف'.split('_')
|
||
}[dialect]
|
||
}
|
||
)
|
||
}
|
||
|
||
jMoment.jConvert = { toJalaali: toJalaali
|
||
, toGregorian: toGregorian
|
||
}
|
||
|
||
/************************************
|
||
Jalaali Conversion
|
||
************************************/
|
||
|
||
function toJalaali(gy, gm, gd) {
|
||
try {
|
||
var j = jalaali.toJalaali(gy, gm + 1, gd)
|
||
j.jm -= 1
|
||
return j
|
||
} catch (e) {
|
||
return {
|
||
jy: NaN
|
||
, jm: NaN
|
||
, jd: NaN
|
||
}
|
||
}
|
||
}
|
||
|
||
function toGregorian(jy, jm, jd) {
|
||
try {
|
||
var g = jalaali.toGregorian(jy, jm + 1, jd)
|
||
g.gm -= 1
|
||
return g
|
||
} catch (e) {
|
||
return {
|
||
gy: NaN
|
||
, gm: NaN
|
||
, gd: NaN
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
Utility helper functions.
|
||
*/
|
||
|
||
function div(a, b) {
|
||
return ~~(a / b)
|
||
}
|
||
|
||
function mod(a, b) {
|
||
return a - ~~(a / b) * b
|
||
}
|
||
});
|
||
|
||
if (typeof exports == "object") {
|
||
module.exports = require("moment-jalaali");
|
||
} else if (typeof define == "function" && define.amd) {
|
||
define([], function(){ return require("moment-jalaali"); });
|
||
} else {
|
||
this["moment"] = require("moment-jalaali");
|
||
}
|
||
})(); |