Tech, emailconfirmed, Administrators (Semantic MediaWiki), Curators (Semantic MediaWiki), Administrators
12,456
edits
More actions
m
Bongolium500 moved page MediaWiki:I18n-js/code.js to MediaWiki:Gadget-I18n-js.js without leaving a redirect
mNo edit summary |
Bongolium500 (talk | contribs) m (Bongolium500 moved page MediaWiki:I18n-js/code.js to MediaWiki:Gadget-I18n-js.js without leaving a redirect) |
||
| (124 intermediate revisions by 13 users not shown) | |||
| Line 1: | Line 1: | ||
/* <nowiki> | /* <nowiki> | ||
* | |||
* Originally from https://dev.fandom.com/wiki/MediaWiki:I18n-js/code.js | |||
* Documentation: https://dev.fandom.com/wiki/I18n-js | |||
* This is present here largely to ensure that scripts taken from the Dev Wiki work with minimal modification | |||
* | |||
* Library for accessing i18n messages for use in Dev Wiki scripts. | * Library for accessing i18n messages for use in Dev Wiki scripts. | ||
* See [[I18n-js]] for documentation. | * See [[w:c:Dev:I18n-js]] for documentation. | ||
* | |||
* @author Cqm <https://dev.fandom.com/User:Cqm> | |||
* @author OneTwoThreeFall <https://dev.fandom.com/User:OneTwoThreeFall> | |||
* | * | ||
* @ | * @version 0.6.7 | ||
* | * | ||
* @notes Also used by SOAP Wiki for their reporting forms (with a non-dev i18n.json page) | |||
* @notes This is apparently a commonly used library for a number of scripts and also | |||
* includes a check to prevent double loading. This can make it painful to test from your | |||
* JS console. To get around this, add ?usesitejs=0&useuserjs=0 to your URL. | |||
*/ | */ | ||
| Line 10: | Line 22: | ||
/*jshint bitwise:true, camelcase:true, curly:true, eqeqeq:true, es3:false, | /*jshint bitwise:true, camelcase:true, curly:true, eqeqeq:true, es3:false, | ||
forin:true, immed:true, indent:4, latedef:true, newcap:true, | |||
noarg:true, noempty:true, nonew:true, plusplus:true, quotmark:single, | |||
undef:true, unused:true, strict:true, trailing:true, | |||
browser:true, devel:false, jquery:true, | |||
onevar:true | |||
*/ | */ | ||
(function (window, $, mw, undefined) { | |||
'use strict'; | |||
window.dev = window.dev || {}; | |||
window.dev.i18n = window.dev.i18n || {}; | |||
// Prevent double loading and loss of cache | |||
if (window.dev.i18n.loadMessages !== undefined) { | |||
return; | |||
} | |||
/* | |||
* Cache of mw config variables. | |||
* | |||
* @var {object} conf Cache of mw config variables: | |||
* - {boolean} debug | |||
* - {string} wgContentLanguage Site language | |||
* Be careful to use this: | |||
* - In languages with variants, this will block the language conversion; | |||
* see <https://www.mediawiki.org/wiki/Writing_systems>. | |||
* - In multilingual wikis like "Feed The Beast", this will block both the | |||
* multilingual content providing and language conversion. | |||
* - {string} wgPageContentLanguage Page Language or Content Modal Language | |||
* or Site Language or 'en' | |||
* Be careful to use this: | |||
* - In Special: pages, this will be the user language. | |||
* This behavior will be kept. | |||
* - In Module: pages, this will be the content modal language 'en'. | |||
* This behavior will be overridden below. | |||
* - {string} wgPageContentModel Page content modal. This is used to detect | |||
* non-wikitext pages/namespaces | |||
* - {string} wgUserLanguage | |||
* - {(string|null)} wgUserVariant The language variant user currently using, | |||
* 'null' when the page lannguage doesn't have language variants. | |||
*/ | |||
var conf = mw.config.get([ | |||
'debug', | |||
'wgContentLanguage', | |||
'wgPageContentLanguage', | |||
'wgPageContentModel', | |||
'wgUserLanguage', | |||
'wgUserVariant' | |||
]), | |||
/* | |||
* @var {number} Current time in milliseconds, used to set and check cache age. | |||
*/ | |||
now = Date.now(), | |||
/* | |||
* @var {number} Length of one day in milliseconds, used in cache age calculations. | |||
*/ | |||
oneDay = 1000 * 60 * 60 * 24, | |||
/* | |||
* @var {string} Prefix used for localStorage keys that contain i18n-js cache data. | |||
*/ | |||
cachePrefix = 'i18n-cache-', | |||
/* | |||
* @var {boolean} Whether a fallback loop warning been shown | |||
*/ | |||
warnedAboutFallbackLoop = false, | |||
/* | |||
* @var {object} Cache of loaded I18n instances. | |||
*/ | |||
cache = {}, | |||
/* | |||
* Initial overrides object, initialised below with the i18n global variable. | |||
* Allows end-users to override specific messages. | |||
* See documentation for how to use. | |||
* | |||
* @var {(null|object)} overrides | |||
*/ | |||
overrides = null, | |||
/* | |||
* Mapping of deprecated language codes that were used in previous | |||
* versions of MediaWiki to up-to-date, current language codes. | |||
* | |||
* These codes shouldn't be used to store translations unless there are | |||
* language changes to /includes/language/LanguageCode.php in mediawiki/core. | |||
* | |||
* These may or may not be valid BCP 47 codes; they are included here | |||
* because MediaWiki renamed these particular codes at some point. | |||
* | |||
* Note that 'als' is actually a valid ISO 639 code (Tosk Albanian), but it | |||
* was previously used in MediaWiki for Alsatian, which comes under 'gsw'. | |||
* | |||
* @var {object.<string, string>} Mapping from deprecated MediaWiki-internal | |||
* language code to replacement MediaWiki-internal language code. | |||
* | |||
* @see /includes/language/LanguageCode.php in MediaWiki core | |||
* @see https://meta.wikimedia.org/wiki/Special_language_codes | |||
*/ | |||
deprecatedCodes = { | |||
'als': 'gsw', // T25215 | |||
'bat-smg': 'sgs', // T27522 | |||
'be-x-old': 'be-tarask', // T11823 | |||
'fiu-vro': 'vro', // T31186 | |||
'roa-rup': 'rup', // T17988 | |||
'zh-classical': 'lzh', // T30443 | |||
'zh-min-nan': 'nan', // T30442 | |||
'zh-yue': 'yue' // T30441 | |||
}, | |||
/** | |||
* Mapping of non-standard language codes used in MediaWiki to | |||
* standardized BCP 47 codes. | |||
* | |||
* @var {object.<string, string>} Mapping from nonstandard | |||
* MediaWiki-internal codes to BCP 47 codes | |||
* | |||
* @see /includes/language/LanguageCode.php in MediaWiki core | |||
* @see https://meta.wikimedia.org/wiki/Special_language_codes | |||
* @see https://phabricator.wikimedia.org/T125073 | |||
*/ | |||
nonStandardCodes = { | |||
'cbk-zam': 'cbk', // T124657 | |||
'crh-ro': 'crh-Latn-RO', | |||
'de-formal': 'de-x-formal', | |||
'eml': 'egl', // T36217 | |||
'en-rtl': 'en-x-rtl', | |||
'es-formal': 'es-x-formal', | |||
'hu-formal': 'hu-x-formal', | |||
'kk-cn': 'kk-Arab-CN', | |||
'kk-tr': 'kk-Latn-TR', | |||
'map-bms': 'jv-x-bms', // [[wikipedia:en:Banyumasan_dialect]] T125073 | |||
'mo': 'ro-Cyrl-MD', // T125073 | |||
'nrm': 'nrf', // [[wikipedia:en:Norman_language]] T25216 | |||
'nl-informal': 'nl-x-informal', | |||
'roa-tara': 'nap-x-tara', // [[wikipedia:en:Tarantino_dialect]] | |||
'simple': 'en-simple', | |||
'sr-ec': 'sr-Cyrl', // T117845 | |||
'sr-el': 'sr-Latn', // T117845 | |||
'zh-cn': 'zh-Hans-CN', | |||
'zh-sg': 'zh-Hans-SG', | |||
'zh-my': 'zh-Hans-MY', | |||
'zh-tw': 'zh-Hant-TW', | |||
'zh-hk': 'zh-Hant-HK', | |||
'zh-mo': 'zh-Hant-MO' | |||
}, | |||
/* | |||
* Language fallbacks for those that don't only fallback to 'en' or have no | |||
* fallbacks ('en'). | |||
* | |||
* Current revision: mediawiki-core 7609761ab4e | |||
* | |||
* Shouldn't need updating unless there're language fallback chain changes | |||
* to /languages/messages files in mediawiki/core. | |||
* | |||
* To generate this, use `$ grep -R "fallback =" /path/to/messages/`, | |||
* pipe the result to a text file and format the result. | |||
* | |||
* Another way to generate the list is to copy from | |||
* https://github.com/wikimedia/jquery.i18n/blob/master/src/jquery.i18n.fallbacks.js | |||
* AND remove deprecated codes from the copied list. | |||
* | |||
* Please note that there's bidirectional/multidirectional fallback in languages, | |||
* including 'cdo' <=> 'nan', 'pt' <=> 'pt-br', 'zh' <=> 'zh-hans' <=> 'zh-hant' | |||
* | |||
* @var {object.<string, string[]>} Mapping from language codes to fallback | |||
* language codes | |||
*/ | |||
fallbacks = { | |||
'ab': ['ru'], | |||
'abs': ['id'], | |||
'ace': ['id'], | |||
'acm': ['ar'], | |||
'ady': ['ady-cyrl'], | |||
'aeb': ['aeb-arab'], | |||
'aeb-arab': ['ar'], | |||
'aln': ['sq'], | |||
'alt': ['ru'], | |||
'ami': ['zh-tw', 'zh-hant', 'zh', 'zh-hans'], | |||
'an': ['es'], | |||
'anp': ['hi'], | |||
'arn': ['es'], | |||
'arq': ['ar'], | |||
'ary': ['ar'], | |||
'arz': ['ar'], | |||
'ast': ['es'], | |||
'atj': ['fr'], | |||
'av': ['ru'], | |||
'avk': ['fr', 'es', 'ru'], | |||
'awa': ['hi'], | |||
'ay': ['es'], | |||
'azb': ['fa'], | |||
'ba': ['ru'], | |||
'ban': ['id'], | |||
'ban-bali': ['ban'], | |||
'bar': ['de'], | |||
'bbc': ['bbc-latn'], | |||
'bbc-latn': ['id'], | |||
'bcc': ['fa'], | |||
'bci': ['fr'], | |||
'be-tarask': ['be'], | |||
'bgn': ['fa'], | |||
'bh': ['bho'], | |||
'bjn': ['id'], | |||
'blk': ['my'], | |||
'bm': ['fr'], | |||
'bpy': ['bn'], | |||
'bqi': ['fa'], | |||
'btm': ['id'], | |||
'bug': ['id'], | |||
'bxr': ['ru'], | |||
'ca': ['oc'], | |||
'cbk-zam': ['es'], | |||
'cdo': ['nan', 'zh-hant', 'zh', 'zh-hans'], | |||
'ce': ['ru'], | |||
'co': ['it'], | |||
'crh': ['crh-latn'], | |||
'crh-cyrl': ['ru'], | |||
'crh-ro': ['ro'], | |||
'cs': ['sk'], | |||
'csb': ['pl'], | |||
'cv': ['ru'], | |||
'de-at': ['de'], | |||
'de-ch': ['de'], | |||
'de-formal': ['de'], | |||
'dsb': ['hsb', 'de'], | |||
'dtp': ['ms'], | |||
'dty': ['ne'], | |||
'egl': ['it'], | |||
'eml': ['it'], | |||
'es-formal': ['es'], | |||
'ext': ['es'], | |||
'fit': ['fi'], | |||
'fon': ['fr'], | |||
'frc': ['fr'], | |||
'frp': ['fr'], | |||
'frr': ['de'], | |||
'fur': ['it'], | |||
'gag': ['tr'], | |||
'gan': ['gan-hant', 'gan-hans', 'zh-hant', 'zh', 'zh-hans'], | |||
'gan-hans': ['gan', 'gan-hant', 'zh-hans', 'zh', 'zh-hant'], | |||
'gan-hant': ['gan', 'gan-hans', 'zh-hant', 'zh', 'zh-hans'], | |||
'gcr': ['fr'], | |||
'gl': ['pt'], | |||
'gld': ['ru'], | |||
'glk': ['fa'], | |||
'gn': ['es'], | |||
'gom': ['gom-deva', 'gom-latn'], | |||
'gom-deva': ['gom-latn'], | |||
'gor': ['id'], | |||
'gsw': ['de'], | |||
'guc': ['es'], | |||
'hak': ['zh-hant', 'zh', 'zh-hans'], | |||
'hif': ['hif-latn'], | |||
'hrx': ['de'], | |||
'hsb': ['dsb', 'de'], | |||
'hsn': ['zh-cn', 'zh-hans', 'zh', 'zh-hant'], | |||
'ht': ['fr'], | |||
'hu-formal': ['hu'], | |||
'hyw': ['hy'], | |||
'ii': ['zh-cn', 'zh-hans', 'zh', 'zh-hant'], | |||
'ike-cans': ['iu'], | |||
'ike-latn': ['iu'], | |||
'inh': ['ru'], | |||
'io': ['eo'], | |||
'iu': ['ike-cans'], | |||
'jut': ['da'], | |||
'jv': ['id'], | |||
'kaa': ['kk-latn', 'kk-cyrl'], | |||
'kab': ['fr'], | |||
'kbd': ['kbd-cyrl'], | |||
'kbp': ['fr'], | |||
'kea': ['pt'], | |||
'khw': ['ur'], | |||
'kiu': ['tr'], | |||
'kjh': ['ru'], | |||
'kjp': ['my'], | |||
'kk': ['kk-cyrl'], | |||
'kk-arab': ['kk', 'kk-cyrl'], | |||
'kk-cn': ['kk-arab', 'kk', 'kk-cyrl'], | |||
'kk-cyrl': ['kk'], | |||
'kk-kz': ['kk-cyrl', 'kk'], | |||
'kk-latn': ['kk', 'kk-cyrl'], | |||
'kk-tr': ['kk-latn', 'kk', 'kk-cyrl'], | |||
'kl': ['da'], | |||
'ko-kp': ['ko'], | |||
'koi': ['ru'], | |||
'krc': ['ru'], | |||
'krl': ['fi'], | |||
'ks': ['ks-arab'], | |||
'ksh': ['de'], | |||
'ksw': ['my'], | |||
'ku': ['ku-latn'], | |||
'ku-arab': ['ku', 'ckb'], | |||
'ku-latn': ['ku'], | |||
'kum': ['ru'], | |||
'kv': ['ru'], | |||
'lad': ['es'], | |||
'lb': ['de'], | |||
'lbe': ['ru'], | |||
'lez': ['ru', 'az'], | |||
'li': ['nl'], | |||
'lij': ['it'], | |||
'liv': ['et'], | |||
'lki': ['fa'], | |||
'lld': ['it', 'rm', 'fur'], | |||
'lmo': ['pms', 'eml', 'lij', 'vec', 'it'], | |||
'ln': ['fr'], | |||
'lrc': ['fa'], | |||
'ltg': ['lv'], | |||
'luz': ['fa'], | |||
'lzh': ['zh-hant', 'zh', 'zh-hans'], | |||
'lzz': ['tr'], | |||
'mad': ['id'], | |||
'mag': ['hi'], | |||
'mai': ['hi'], | |||
'map-bms': ['jv', 'id'], | |||
'mdf': ['myv', 'ru'], | |||
'mg': ['fr'], | |||
'mhr': ['mrj', 'ru'], | |||
'min': ['id'], | |||
'mnw': ['my'], | |||
'mo': ['ro'], | |||
'mrj': ['mhr', 'ru'], | |||
'ms-arab': ['ms'], | |||
'mwl': ['pt'], | |||
'myv': ['mdf', 'ru'], | |||
'mzn': ['fa'], | |||
'nah': ['es'], | |||
'nan': ['cdo', 'zh-hant', 'zh', 'zh-hans'], | |||
'nap': ['it'], | |||
'nb': ['no', 'nn'], | |||
'nds': ['de'], | |||
'nds-nl': ['nl'], | |||
'nia': ['id'], | |||
'nl-informal': ['nl'], | |||
'nn': ['no', 'nb'], | |||
'no': ['nb'], | |||
'nrm': ['nrf', 'fr'], | |||
'oc': ['ca', 'fr'], | |||
'olo': ['fi'], | |||
'os': ['ru'], | |||
'pcd': ['fr'], | |||
'pdc': ['de'], | |||
'pdt': ['de'], | |||
'pfl': ['de'], | |||
'pms': ['it'], | |||
'pnt': ['el'], | |||
'pt': ['pt-br'], | |||
'pt-br': ['pt'], | |||
'pwn': ['zh-tw', 'zh-hant', 'zh', 'zh-hans'], | |||
'qu': ['qug', 'es'], | |||
'qug': ['qu', 'es'], | |||
'rgn': ['it'], | |||
'rmy': ['ro'], | |||
'roa-tara': ['it'], | |||
'rsk': ['sr-cyrl', 'sr-ec'], | |||
'rue': ['uk', 'ru'], | |||
'rup': ['ro'], | |||
'ruq': ['ruq-latn', 'ro'], | |||
'ruq-cyrl': ['mk'], | |||
'ruq-latn': ['ro'], | |||
'sa': ['hi'], | |||
'sah': ['ru'], | |||
'scn': ['it'], | |||
'sdc': ['it'], | |||
'sdh': ['cbk', 'fa'], | |||
'se': ['nb', 'fi'], | |||
'se-fi': ['se', 'fi', 'sv'], | |||
'se-no': ['se', 'nb', 'nn'], | |||
'se-se': ['se', 'sv'], | |||
'ses': ['fr'], | |||
'sg': ['fr'], | |||
'sgs': ['lt'], | |||
'sh': ['sh-latn', 'sh-cyrl', 'bs', 'sr-latn', 'sr-el', 'hr'], | |||
'sh-cyrl': ['sr-cyrl', 'sr-ec', 'sh', 'sh-latn'], | |||
'sh-latn': ['sh', 'sh-cyrl', 'bs', 'sr-latn', 'sr-el', 'hr'], | |||
'shi': ['shi-latn', 'fr'], | |||
'shi-latn': ['shi', 'fr'], | |||
'shi-tfng': ['shi', 'shi-latn', 'fr'], | |||
'shy': ['shy-latn'], | |||
'shy-latn': ['fr'], | |||
'sjd': ['ru'], | |||
'sk': ['cs'], | |||
'skr': ['skr-arab'], | |||
'skr-arab': ['skr'], | |||
'sli': ['de'], | |||
'sma': ['sv', 'nb'], | |||
'smn': ['fi'], | |||
'sr': ['sr-cyrl', 'sr-ec'], | |||
'sr-cyrl': ['sr-ec', 'sr'], | |||
'sr-ec': ['sr-cyrl', 'sr'], | |||
'sr-el': ['sr-latn', 'sr'], | |||
'sr-latn': ['sr-el', 'sr'], | |||
'srn': ['nl'], | |||
'sro': ['it'], | |||
'stq': ['de'], | |||
'sty': ['ru'], | |||
'su': ['id'], | |||
'szl': ['pl'], | |||
'szy': ['zh-tw', 'zh-hant', 'zh', 'zh-hans'], | |||
'tay': ['zh-tw', 'zh-hant', 'zh', 'zh-hans'], | |||
'tcy': ['kn'], | |||
'tet': ['pt'], | |||
'tg': ['tg-cyrl'], | |||
'tg-cyrl': ['tg'], | |||
'tg-latn': ['tg', 'tg-cyrl'], | |||
'trv': ['zh-tw', 'zh-hant', 'zh', 'zh-hans'], | |||
'tt': ['tt-cyrl', 'ru'], | |||
'tt-cyrl': ['ru'], | |||
'ty': ['fr'], | |||
'tyv': ['ru'], | |||
'udm': ['ru'], | |||
'ug': ['ug-arab'], | |||
'vec': ['it'], | |||
'vep': ['et'], | |||
'vls': ['nl'], | |||
'vmf': ['de'], | |||
'vmw': ['pt'], | |||
'vot': ['fi'], | |||
'vro': ['et'], | |||
'wa': ['fr'], | |||
'wls': ['fr'], | |||
'wo': ['fr'], | |||
'wuu': ['wuu-hans', 'wuu-hant', 'zh-hans', 'zh', 'zh-hant'], | |||
'wuu-hans': ['wuu', 'wuu-hant', 'zh-hans', 'zh', 'zh-hant'], | |||
'wuu-hant': ['wuu', 'wuu-hans', 'zh-hant', 'zh', 'zh-hans'], | |||
'xal': ['ru'], | |||
'xmf': ['ka'], | |||
'yi': ['he'], | |||
'yue': ['yue-hant', 'yue-hans'], | |||
'yue-hans': ['yue', 'yue-hant'], | |||
'yue-hant': ['yue', 'yue-hans'], | |||
'za': ['zh-hans', 'zh', 'zh-hant'], | |||
'zea': ['nl'], | |||
'zgh': ['kab'], | |||
'zh': ['zh-hans', 'zh-hant', 'zh-cn', 'zh-tw', 'zh-hk'], | |||
'zh-cn': ['zh-hans', 'zh', 'zh-hant'], | |||
'zh-hans': ['zh-cn', 'zh', 'zh-hant'], | |||
'zh-hant': ['zh-tw', 'zh-hk', 'zh', 'zh-hans'], | |||
'zh-hk': ['zh-hant', 'zh-tw', 'zh', 'zh-hans'], | |||
'zh-mo': ['zh-hk', 'zh-hant', 'zh-tw', 'zh', 'zh-hans'], | |||
'zh-my': ['zh-sg', 'zh-hans', 'zh-cn', 'zh', 'zh-hant'], | |||
'zh-sg': ['zh-hans', 'zh-cn', 'zh', 'zh-hant'], | |||
'zh-tw': ['zh-hant', 'zh-hk', 'zh', 'zh-hans'] | |||
}; | |||
/* | |||
* Override the if wgPageContentModel is not wikitext. | |||
* This is to fix the behavior in non-wikitext pages like Scribunto Lua | |||
* module pages | |||
* | |||
* - {string} conf.wgPageContentModel The content modal of the current page. | |||
* - {string} conf.wgPageContentLanguage The page language. | |||
* - {string} conf.wgContentLanguage The site language. | |||
*/ | |||
if ( conf.wgPageContentModel && conf.wgPageContentModel !== 'wikitext' ) { | |||
conf.wgPageContentLanguage = conf.wgContentLanguage; | |||
} | |||
/* | |||
* Get the normalised IETF/BCP 47 language tag. | |||
* | |||
* mediawiki.language.bcp47 doesn't handle deprecated language codes, and | |||
* some non-standard language codes are missed from LanguageCode.php, so | |||
* this function is added to override the behavior. | |||
* | |||
* @param {string} lang The language code to convert. | |||
* @return {string} The language code complying with BCP 47 standards. | |||
* | |||
* @see https://gerrit.wikimedia.org/r/c/mediawiki/core/+/376506/ | |||
* @see /resources/src/mediawiki.language/mediawiki.language.js in MediaWiki core | |||
* @see /includes/language/LanguageCode.php in MediaWiki core | |||
*/ | |||
function bcp47(lang) { | |||
if (nonStandardCodes[lang]) { | |||
return nonStandardCodes[lang]; | |||
} | |||
if (deprecatedCodes[lang]) { | |||
return bcp47(deprecatedCodes[lang]); | |||
} | |||
/* | |||
* @var {string[]} formatted | |||
* @var {boolean} isFirstSegment Whether is the first segment | |||
* @var {boolean} isPrivate Whether the code of the segment is private use | |||
* @var {string[]} segments The segments of language code | |||
*/ | |||
var formatted, | |||
isFirstSegment = true, | |||
isPrivate = false, | |||
segments = lang.split('-'); | |||
formatted = segments.map(function (segment) { | |||
/* | |||
* @var {string} newSegment The converted segment of language code | |||
*/ | |||
var newSegment; | |||
// when previous segment is x, it is a private segment and should be lc | |||
if (isPrivate) { | |||
newSegment = segment.toLowerCase(); | |||
// ISO 3166 country code | |||
} else if (segment.length === 2 && !isFirstSegment) { | |||
newSegment = segment.toUpperCase(); | |||
// ISO 15924 script code | |||
} else if (segment.length === 4 && !isFirstSegment) { | |||
newSegment = segment.charAt(0).toUpperCase() + segment.substring(1).toLowerCase(); | |||
// Use lowercase for other cases | |||
} else { | |||
newSegment = segment.toLowerCase(); | |||
} | |||
isPrivate = segment.toLowerCase() === 'x'; | |||
isFirstSegment = false; | |||
return newSegment; | |||
}); | |||
return formatted.join('-'); | |||
} | |||
/* | |||
* Log a warning message to the browser console if the language fallback chain is | |||
* about to start a loop. Only logs once to prevent flooding the browser console. | |||
* | |||
* @param {string} lang Language in use when loop was found. | |||
* @param {string[]} fallbackChain Array of languages involved in the loop. | |||
*/ | |||
function warnOnFallbackLoop(lang, fallbackChain) { | |||
if (warnedAboutFallbackLoop) { | |||
return; | |||
} | |||
warnedAboutFallbackLoop = true; | |||
fallbackChain.push(lang); | |||
console.error('[I18n-js] Duplicated fallback language found. Please leave a message at <https://dev.fandom.com/wiki/Talk:I18n-js> and include the following line: \nLanguage fallback chain:', fallbackChain.join(', ')); | |||
} | |||
/* | |||
* Get a translation of a message from the messages object in the requested | |||
* language. | |||
* | |||
* - Missing `messages`, `msgName`, `lang` parameters: `return false;` . | |||
* - Didn't find message in the current language: Try the fallback list. | |||
* - Didn't find a fallback list for current language: Try to find `en` message. | |||
* - Didn't find message in the current fallback language: Try to find message | |||
* in the next fallback language. | |||
* - Found duplicated language code in the fallback list: | |||
* `warnOnFallbackLoop(lang, fallbackChain)`. | |||
* - Didn't find more language code in the fallback list: Try to find `en` message. | |||
* - Didn't find message in `en`: `return false;`. | |||
* | |||
* @param {object} messages The message object to look translations up in. | |||
* @param {string} msgName The name of the message to get. | |||
* @param {string} lang The language to get the message in. | |||
* @param {string[]} fallbackChain Array of languages that have already been checked. | |||
* Used to detect if the fallback chain is looping. | |||
* @return {(string|boolean)} The requested translation or `false` if no message could be found. | |||
*/ | |||
function getMsg(messages, msgName, lang, fallbackChain) { | |||
if (!lang || !messages || !msgName) { | |||
return false; | |||
} | |||
if (deprecatedCodes[lang]) { | |||
return getMsg(messages, msgName, deprecatedCodes[lang], fallbackChain); | |||
} | |||
if (messages[lang] && messages[lang][msgName]) { | |||
return messages[lang][msgName]; | |||
} | |||
if (!fallbackChain) { | |||
fallbackChain = []; | |||
} | |||
/* | |||
* Try to find fallback messages by using the fallback chain. | |||
* We need to check whether the lang is defined in the fallback list before | |||
* trying to go through them. | |||
* | |||
* @var {number} i The current index in fallbacks[lang] | |||
*/ | |||
for (var i = 0; (fallbacks[lang] && i < fallbacks[lang].length); i += 1) { | |||
/* | |||
* @var {string} fallbackLang | |||
*/ | |||
var fallbackLang = fallbacks[lang][i]; | |||
if (messages[fallbackLang] && messages[fallbackLang][msgName]) { | |||
return messages[fallbackLang][msgName]; | |||
} | |||
if (fallbackChain.indexOf(fallbackLang) !== -1) { | |||
/* | |||
* Duplicated language code in fallback list. | |||
* Try to find next fallback language from list. | |||
*/ | |||
warnOnFallbackLoop(fallbackLang, fallbackChain); | |||
continue; | |||
} | |||
fallbackChain.push(fallbackLang); | |||
} | |||
// "No language" or "no more languages" in fallback list - switch to 'en' | |||
if (messages.en && messages.en[msgName]) { | |||
return messages.en[msgName]; | |||
} | |||
return false; | |||
} | |||
/* | |||
* Substitute arguments into the string, where arguments are represented | |||
* as $n where n > 0. | |||
* | |||
* @param {string} message The message to substitute arguments into | |||
* @param {array} arguments The arguments to substitute in. | |||
* @return {string} The resulting message. | |||
*/ | |||
function handleArgs(message, args) { | |||
args.forEach(function (elem, index) { | |||
/* | |||
* @var {RegExp} rgx | |||
*/ | |||
var rgx = new RegExp('\\$' + (index + 1), 'g'); | |||
message = message.replace(rgx, elem); | |||
}); | |||
return message; | |||
} | |||
/* | |||
* Generate a HTML link using the supplied parameters. | |||
* | |||
* @param {string} href The href of the link which will be converted to | |||
* '/wiki/href'. | |||
* @param {string} text The text and title of the link. If this is not supplied, it | |||
* will default to href. | |||
* @param {boolean} hasProtocol True if the href parameter already includes the | |||
* protocol (i.e. it begins with 'http://', 'https://', or '//'). | |||
* @return {string} The generated link. | |||
*/ | |||
function makeLink(href, text, hasProtocol) { | |||
text = text || href; | |||
href = hasProtocol ? href : mw.util.getUrl(href); | |||
text = mw.html.escape(text); | |||
href = mw.html.escape(href); | |||
return '<a href="' + href + '" title="' + text + '">' + text + '</a>'; | |||
} | |||
/* | |||
* Allow basic inline HTML tags in wikitext.does not support <a> as that's handled by the | |||
* wikitext links instead. | |||
* | |||
* Supports the following tags: | |||
* - <i> | |||
* - <b> | |||
* - <s> | |||
* - <br> | |||
* - <em> | |||
* - <strong> | |||
* - <span> | |||
* | |||
* Supports the following tag attributes: | |||
* - title | |||
* - style | |||
* - class | |||
* | |||
* @param html | |||
* @return The sanitised HTML code. | |||
*/ | |||
function sanitiseHtml(html) { | |||
/* | |||
* @var context | |||
*/ | |||
var context = document.implementation.createHTMLDocument(''), | |||
$html = $.parseHTML(html, /* document */ context, /* keepscripts */ false), | |||
$div = $('<div>', context).append($html), | |||
allowedAttrs = [ | |||
'title', | |||
'style', | |||
'class' | |||
], | |||
allowedTags = [ | |||
'i', | |||
'b', | |||
's', | |||
'br', | |||
'em', | |||
'strong', | |||
'span', | |||
]; | |||
$div.find('*').each(function () { | |||
var $this = $(this), | |||
tagname = $this.prop('tagName').toLowerCase(), | |||
attrs, | |||
array, | |||
style; | |||
if (allowedTags.indexOf(tagname) === -1) { | |||
mw.log('[I18n-js] Disallowed tag in message: ' + tagname); | |||
$this.remove(); | |||
return; | |||
} | |||
attrs = $this.prop('attributes'); | |||
array = Array.prototype.slice.call(attrs); | |||
array.forEach(function (attr) { | |||
if (allowedAttrs.indexOf(attr.name) === -1) { | |||
mw.log('[I18n-js] Disallowed attribute in message: ' + attr.name + ', tag: ' + tagname); | |||
$this.removeAttr(attr.name); | |||
return; | |||
} | |||
// Make sure there's nothing nasty in style attributes | |||
if (attr.name === 'style') { | |||
style = $this.attr('style'); | |||
if (style.indexOf('url(') > -1) { | |||
mw.log('[I18n-js] Disallowed url() in style attribute'); | |||
$this.removeAttr('style'); | |||
// https://phabricator.wikimedia.org/T208881 | |||
} else if (style.indexOf('var(') > -1) { | |||
mw.log('[I18n-js] Disallowed var() in style attribute'); | |||
$this.removeAttr('style'); | |||
} | |||
} | |||
}); | |||
}); | |||
return $div.prop('innerHTML'); | |||
} | |||
/* | |||
* Parse some basic wikitext into HTML. Also supports basic inline HTML tags. | |||
* | |||
* Will process: | |||
* - [url text] | |||
* - [[pagename]] | |||
* - [[pagename|text]] | |||
* - {{PLURAL:count|singular|plural}} | |||
* - {{GENDER:gender|masculine|feminine|neutral}} | |||
* | |||
* @param {string} message The message to process. | |||
* @return {string} The resulting string. | |||
*/ | |||
function parse(message) { | |||
// [url text] -> [$1 $2] | |||
var urlRgx = /\[((?:https?:)?\/\/.+?) (.+?)\]/g, | |||
// [[pagename]] -> [[$1]] | |||
simplePageRgx = /\[\[([^|]*?)\]\]/g, | |||
// [[pagename|text]] -> [[$1|$2]] | |||
pageWithTextRgx = /\[\[(.+?)\|(.+?)\]\]/g, | |||
// {{PLURAL:count|singular|plural}} -> {{PLURAL:$1|$2}} | |||
pluralRgx = /\{\{PLURAL:(\d+)\|(.+?)\}\}/gi, | |||
// {{GENDER:gender|masculine|feminine|neutral}} -> {{GENDER:$1|$2}} | |||
genderRgx = /\{\{GENDER:([^|]+)\|(.+?)\}\}/gi; | |||
if (message.indexOf('<') > -1) { | |||
message = sanitiseHtml(message); | |||
} | |||
return message | |||
.replace(urlRgx, function (_match, href, text) { | |||
return makeLink(href, text, true); | |||
}) | |||
.replace(simplePageRgx, function (_match, href) { | |||
return makeLink(href); | |||
}) | |||
.replace(pageWithTextRgx, function (_match, href, text) { | |||
return makeLink(href, text); | |||
}) | |||
.replace(pluralRgx, function (_match, count, forms) { | |||
return mw.language.convertPlural(Number(count), forms.split('|')); | |||
}) | |||
.replace(genderRgx, function (_match, gender, forms) { | |||
return mw.language.gender(gender, forms.split('|')); | |||
}); | |||
} | |||
/* | |||
* Create a new Message instance. | |||
* | |||
* @param {object} messages The message object to look translations up in. | |||
* @param {string} lang The language to get the message in. | |||
* @param {array} args Any arguments to substitute into the message, [0] is message name. | |||
* @param {string} name The name of the script the messages are for. | |||
* @return | |||
*/ | |||
function message(messages, lang, args, name) { | |||
if (!args.length) { | |||
return; | |||
} | |||
/* | |||
* @var msgName | |||
* @var {string} descriptiveMsgName | |||
* @var {object} msg | |||
* @var {boolean} msgExists | |||
*/ | |||
var msgName = args.shift(), | |||
descriptiveMsgName = 'i18njs-' + name + '-' + msgName, | |||
msg = getMsg(messages, msgName, lang), | |||
msgExists = msg !== false; | |||
if (!msgExists) { | |||
// use name wrapped in < > for missing message, per MediaWiki convention | |||
msg = '<' + descriptiveMsgName + '>'; | |||
} | |||
if (conf.wgUserLanguage === 'qqx' && msgExists) { | |||
// https://www.mediawiki.org/wiki/Help:System_message#Finding_messages_and_documentation | |||
msg = '(' + descriptiveMsgName + ')'; | |||
} else if (overrides[name] && overrides[name][msgName]) { | |||
// if the message has been overridden, use that without checking the language | |||
msg = overrides[name][msgName]; | |||
msgExists = true; | |||
} | |||
if (args.length) { | |||
msg = handleArgs(msg, args); | |||
} | |||
return { | |||
/* | |||
* @return {boolean} Representing whether the message exists. | |||
*/ | |||
exists: msgExists, | |||
/* | |||
* Parse wikitext links in the message and return the result. | |||
* | |||
* @return {string} The resulting string. | |||
*/ | |||
parse: function () { | |||
/* | |||
* Skip parsing if the message wasn't found; otherwise | |||
* the sanitisation will mess with it. | |||
*/ | |||
if (!this.exists) { | |||
return this.escape(); | |||
} | |||
return parse(msg); | |||
}, | |||
/* | |||
* Escape any HTML in the message and return the result. | |||
* | |||
* @return {string} The resulting string. | |||
*/ | |||
escape: function () { | |||
return mw.html.escape(msg); | |||
}, | |||
/* | |||
* Return the message as is. | |||
* | |||
* @return {string} The resulting string. | |||
*/ | |||
plain: function () { | |||
return msg; | |||
} | |||
}; | |||
} | |||
/* | |||
* Create a new i18n object. | |||
* | |||
* @param {object} messages The message object to look translations up in. | |||
* @param {string} name The name of the script the messages are for. | |||
* @param {object} options Options set by the loading script. | |||
* @return {object} | |||
*/ | |||
function i18n(messages, name, options) { | |||
var defaultLang = options.language, | |||
tempLang = null; | |||
return { | |||
/* | |||
* Set the default language. | |||
* | |||
* @deprecated since v0.6 (2020-08-25), no longer supported. | |||
*/ | |||
useLang: function () { | |||
console.warn('[I18n-js] “useLang()” is no longer supported by I18n-js (used in “' + name + '”) - using user language.'); | |||
this.useUserLang(); | |||
}, | |||
/* | |||
* Set the language for the next msg call. | |||
* | |||
* @param {string} lang The language code to use for the next `msg` call. | |||
* | |||
* @return {object} The current object for use in chaining. | |||
*/ | |||
inLang: function (lang) { | |||
if (!options.cacheAll) { | |||
console.warn('[I18n-js] “inLang()” is not supported without configuring `options.cacheAll` (used in “' + name + '”) - using user language.'); | |||
lang = options.language; | |||
} | |||
tempLang = lang; | |||
return this; | |||
}, | |||
/* | |||
* Set the default language to the content language. | |||
*/ | |||
useContentLang: function () { | |||
defaultLang = conf.wgContentLanguage; | |||
}, | |||
/* | |||
* Set the language for the next `msg` call to the content language. | |||
* | |||
* @return {object} The current object for use in chaining. | |||
*/ | |||
inContentLang: function () { | |||
tempLang = conf.wgContentLanguage; | |||
return this; | |||
}, | |||
/* | |||
* Set the default language to the page language. | |||
*/ | |||
usePageLang: function () { | |||
defaultLang = conf.wgPageContentLanguage; | |||
}, | |||
/* | |||
* Set the language for the next `msg` call to the page language. | |||
* | |||
* @return {object} The current object for use in chaining. | |||
*/ | |||
inPageLang: function () { | |||
tempLang = conf.wgPageContentLanguage; | |||
return this; | |||
}, | |||
/* | |||
* Set the default language to the page view language. | |||
* This is also known as the user language variant. | |||
*/ | |||
usePageViewLang: function () { | |||
defaultLang = conf.wgUserVariant || conf.wgPageContentLanguage || conf.wgContentLanguage; | |||
}, | |||
/* | |||
* Set the language for the next `msg` call to the page view language. | |||
* This is also known as the user language variant. | |||
* | |||
* @return {object} The current object for use in chaining. | |||
*/ | |||
inPageViewLang: function () { | |||
tempLang = conf.wgUserVariant || conf.wgPageContentLanguage || conf.wgContentLanguage; | |||
return this; | |||
}, | |||
/* | |||
* Set the default language to the user's language. | |||
*/ | |||
useUserLang: function () { | |||
defaultLang = options.language; | |||
}, | |||
/* | |||
* Set the language for the next msg call to the user's language. | |||
* | |||
* @return {object} The current object for use in chaining. | |||
*/ | |||
inUserLang: function () { | |||
tempLang = options.language; | |||
return this; | |||
}, | |||
/* | |||
* Create a new instance of Message. | |||
* | |||
* @return {object} | |||
*/ | |||
msg: function () { | |||
var args = Array.prototype.slice.call(arguments), | |||
lang = defaultLang; | |||
if (tempLang !== null) { | |||
lang = tempLang; | |||
tempLang = null; | |||
} | |||
return message(messages, lang, args, name); | |||
}, | |||
/* | |||
* For accessing the raw messages. | |||
* Scripts should not rely on it or any of its properties existing. | |||
*/ | |||
_messages: messages | |||
}; | |||
} | |||
/* | |||
* Preprocess each message's fallback chain for the user and content languages. | |||
* This allows us to save only those messages needed to the cache. | |||
* | |||
* @param {string} name The name of the script the messages are for. | |||
* @param {object} messages The message object to look translations up in. | |||
* @param {object} options Options set by the loading script. | |||
*/ | |||
function optimiseMessages(name, messages, options) { | |||
var existingLangs = cache[name] && cache[name]._messages._isOptimised, | |||
langs = [options.language], | |||
msgKeys = Object.keys(messages.en || {}), | |||
optimised = {}; | |||
if (!msgKeys.length) { | |||
// No English messages, don't bother optimising | |||
return messages; | |||
} | |||
/* | |||
* @var addMsgsForLanguage | |||
*/ | |||
var addMsgsForLanguage = function (lang) { | |||
if (optimised[lang]) { | |||
// Language already exists | |||
return; | |||
} | |||
optimised[lang] = {}; | |||
msgKeys.forEach(function (msgName) { | |||
/* | |||
* @var msg | |||
*/ | |||
var msg = getMsg(messages, msgName, lang); | |||
if (msg !== false) { | |||
optimised[lang][msgName] = msg; | |||
} | |||
}); | |||
}; | |||
if (langs.indexOf(conf.wgContentLanguage) === -1) { | |||
langs.push(conf.wgContentLanguage); | |||
} | |||
/* | |||
* If cache exists and is optimised, preserve existing languages. | |||
* This allows an optimised cache even when using different | |||
* language wikis on same domain (i.e. sharing same cache). | |||
*/ | |||
if (existingLangs) { | |||
existingLangs.forEach(function (lang) { | |||
if (langs.indexOf(lang) === -1) { | |||
langs.push(lang); | |||
} | |||
}); | |||
} | |||
langs.forEach(addMsgsForLanguage); | |||
/* | |||
* `cacheAll` is an array of message names for which translations | |||
* should not be optimised - save all translations of these messages | |||
*/ | |||
if (Array.isArray(options.cacheAll)) { | |||
msgKeys = options.cacheAll; | |||
Object.keys(messages).forEach(addMsgsForLanguage); | |||
} | |||
optimised._isOptimised = langs; | |||
return optimised; | |||
} | |||
/* | |||
* Check that the cache for a script exists and, if optimised, contains the | |||
* necessary languages. | |||
* | |||
* @param {string} name The name of the script to check for. | |||
* @param {object} options Options set by the loading script. | |||
* @return {boolean} Whether the cache should be used. | |||
*/ | |||
function cacheIsSuitable(name, options) { | |||
var messages = cache[name] && cache[name]._messages; | |||
// Nothing in cache | |||
if (!messages) { | |||
return false; | |||
} | |||
/* | |||
* Optimised messages missing user or content language. | |||
* We'll need to load from server in this case. | |||
*/ | |||
if ( | |||
messages._isOptimised && | |||
!(messages[options.language] && messages[conf.wgContentLanguage]) | |||
) { | |||
return false; | |||
} | |||
return true; | |||
} | |||
/* | |||
* Remove out-of-date entries in the i18n cache (those older than two days). | |||
* | |||
* This can never be perfect: it will only work on wikis that are visited. | |||
*/ | |||
function removeOldCacheEntries() { | |||
var isCacheKey = new RegExp('^(' + cachePrefix + '.+)-content$'), | |||
storageKeys = []; | |||
try { | |||
storageKeys = Object.keys(localStorage); | |||
} catch (e) {} | |||
storageKeys.filter(function (key) { | |||
return isCacheKey.test(key); | |||
}).forEach(function (key) { | |||
var keyPrefix = key.match(isCacheKey)[1], | |||
cacheTimestamp; | |||
try { | |||
cacheTimestamp = Number(localStorage.getItem(keyPrefix + '-timestamp')); | |||
} catch (e) {} | |||
if (now - cacheTimestamp < oneDay * 2) { | |||
// Cached within last two days, keep it | |||
return; | |||
} | |||
try { | |||
localStorage.removeItem(keyPrefix + '-content'); | |||
localStorage.removeItem(keyPrefix + '-timestamp'); | |||
localStorage.removeItem(keyPrefix + '-version'); | |||
} catch (e) {} | |||
}); | |||
} | |||
/* | |||
* Strip block comments from a JSON string which are illegal under the JSON spec. | |||
* This is a bit basic, so will remove comments inside strings too. | |||
* | |||
* @param {string} json The JSON string. | |||
* @return {string} The JSON string after any comments have been removed. | |||
*/ | |||
function stripComments(json) { | |||
json = json | |||
.trim() | |||
.replace(/\/\*[\s\S]*?\*\//g, ''); | |||
return json; | |||
} | |||
/* | |||
* Save messages string to local storage for caching. | |||
* | |||
* @param {string} name The name of the script the messages are for. | |||
* @param {object} json The JSON object. | |||
* @param {number} cacheVersion Cache version requested by the loading script. | |||
*/ | |||
function saveToCache(name, json, cacheVersion) { | |||
/* | |||
* @var {string} keyPrefix | |||
*/ | |||
var keyPrefix = cachePrefix + name; | |||
// Don't cache empty JSON | |||
if (Object.keys(json).length === 0) { | |||
return; | |||
} | |||
try { | |||
localStorage.setItem(keyPrefix + '-content', JSON.stringify(json)); | |||
localStorage.setItem(keyPrefix + '-timestamp', now); | |||
localStorage.setItem(keyPrefix + '-version', cacheVersion || 0); | |||
} catch (e) {} | |||
} | |||
/* | |||
* Parse JSON string loaded from page and create an i18n object. | |||
* | |||
* @param {string} name The name of the script the messages are for. | |||
* @param {string} res The JSON string. | |||
* @param {object} options Options set by the loading script. | |||
* @return {object} The resulting i18n object. | |||
*/ | |||
function parseMessagesToObject(name, res, options) { | |||
var json = {}, | |||
obj, | |||
msg; | |||
// Handle parse errors gracefully | |||
try { | |||
res = stripComments(res); | |||
json = JSON.parse(res); | |||
} catch (e) { | |||
msg = e.message; | |||
if (msg === 'Unexpected end of JSON input') { | |||
msg += '. This may be caused by a non-existent i18n.json page.'; | |||
} | |||
console.warn('[I18n-js] SyntaxError in messages: ' + msg); | |||
} | |||
if ( | |||
options.useCache && | |||
!options.loadedFromCache && | |||
options.cacheAll !== true | |||
) { | |||
json = optimiseMessages(name, json, options); | |||
} | |||
obj = i18n(json, name, options); | |||
// Cache the result in case it's used multiple times | |||
cache[name] = obj; | |||
if (!options.loadedFromCache) { | |||
saveToCache(name, json, options.cacheVersion); | |||
} | |||
return obj; | |||
} | |||
/* | |||
* Load messages string from local storage cache and add to cache object. | |||
* | |||
* @param {string} name The name of the script the messages are for. | |||
* @param {object} options Options set by the loading script. | |||
*/ | |||
function loadFromCache(name, options) { | |||
var keyPrefix = cachePrefix + name, | |||
cacheContent, | |||
cacheVersion; | |||
try { | |||
cacheContent = localStorage.getItem(keyPrefix + '-content'); | |||
cacheVersion = Number(localStorage.getItem(keyPrefix + '-version')); | |||
} catch (e) {} | |||
// Cache exists, and its version is greater than or equal to requested version | |||
if (cacheContent && cacheVersion >= options.cacheVersion) { | |||
options.loadedFromCache = true; | |||
parseMessagesToObject(name, cacheContent, options); | |||
} | |||
} | |||
/* | |||
* Load messages stored as JSON on a page. | |||
* | |||
* @param {string} name The name of the script the messages are for. This will be | |||
* used to get messages from | |||
* https://dev.fandom.com/wiki/MediaWiki:Custom-name/i18n.json. | |||
* Use `u:<subdomain>` or `u:<language-path>.<subdomain>` to set other Fandom | |||
* wikis as the source. | |||
* @param {object} options Options set by the loading script: | |||
* - {string} apiEndpoint: Use `u:<subdomain>` or `u:<language-path>.<subdomain>` | |||
* to set other sites as the API endpoint of the source. Currently only | |||
* support Fandom wikis. | |||
* - {string} page: Set other format of the full page name for the i18n JSON. | |||
* Use $1 for the placeholder of name. | |||
* - {(array|boolean)} cacheAll: Either an array of message names for which | |||
* translations should not be optimised, or `true` to disable the optimised cache. | |||
* - {number} cacheVersion: Minimum cache version requested by the loading script. | |||
* - {string} language: Set a default language for the script to use, instead of wgUserLanguage. | |||
* - noCache: Never load i18n from cache (not recommended for general use). | |||
* | |||
* @return {object} A jQuery.Deferred instance. | |||
*/ | |||
function loadMessages(name, options) { | |||
/* | |||
* @var {object} deferred | |||
* @var {string} apiEndpoint | |||
* @var {RegExp} apiEndpointRgx | |||
* @var {string} page | |||
* @var {object} params | |||
*/ | |||
var deferred = $.Deferred(), | |||
customSource = name.match(/^u:(?:([a-z-]+)\.)?([a-z0-9-]+):/), | |||
apiEndpoint = 'https://dev.fandom.com/api.php', | |||
apiEndpointRgx = new RegExp( | |||
// '^(https:\/\/(([a-z0-9-]+)\.fandom\.com(?:\/([a-z-]+))?|(([a-z-]+)\.wikipedia\.org\/w))\/api\.php)$' | |||
'^(https:\/\/(([a-z0-9-]+)\.fandom\.com(?:\/([a-z-]+))?)\/api\.php)$' | |||
), | |||
page = 'MediaWiki:Custom-' + name + '/i18n.json', | |||
params; | |||
options = options || {}; | |||
if (options.apiEndpoint && apiEndpointRgx.test(options.apiEndpoint)) { | |||
options.apiEndpoint = options.apiEndpoint; | |||
} else { | |||
options.apiEndpoint = apiEndpoint; | |||
} | |||
options.page = (options.page && options.page.replace(/\$1/g, name)) || page; | |||
options.cacheVersion = Number(options.cacheVersion) || 0; | |||
options.language = options.language || conf.wgUserLanguage; | |||
options.useCache = (options.noCache || conf.debug) !== true; | |||
if (options.useCache) { | |||
loadFromCache(name, options); | |||
if (cacheIsSuitable(name, options)) { | |||
return deferred.resolve(cache[name]); | |||
} | |||
} | |||
// Cache isn't suitable - loading from server | |||
options.loadedFromCache = false; | |||
/* | |||
* Allow custom i18n pages to be specified on other wikis. | |||
* Mainly for SOAP Wiki to keep their own JSON file. | |||
* Note this only supports loading from wikis on fandom.com. | |||
*/ | |||
if (customSource) { | |||
apiEndpoint = apiEndpoint.replace('dev', customSource[2]); | |||
page = name.slice(customSource[0].length); | |||
// adjust endpoint when loading from interlanguage wiki | |||
if (customSource[1]) { | |||
apiEndpoint = apiEndpoint.replace( | |||
/api\.php$/, | |||
customSource[1] + '/$&' | |||
); | |||
} | |||
} | |||
params = { | |||
action: 'query', | |||
format: 'json', | |||
prop: 'revisions', | |||
rvprop: 'content', | |||
rvslots: 'main', | |||
titles: page, | |||
indexpageids: 1, | |||
origin: '*', | |||
// Cache results for 5 minutes in CDN and browser | |||
maxage: 300, | |||
smaxage: 300 | |||
}; | |||
/* | |||
* 'site' and 'user' are dependencies so end-users can set overrides in their local JS | |||
* and have it take effect before we load the messages. | |||
* Generally, we will implicitly depend on those anyway due to where/when this is loaded. | |||
*/ | |||
mw.loader.using(['mediawiki.language', 'mediawiki.util'/*, 'site', 'user'*/], function () { | |||
$.ajax(apiEndpoint, { | |||
data: params, | |||
}).always(function (data) { | |||
var res = '', | |||
revisionData = data.query && data.query.pages[data.query.pageids[0]].revisions; | |||
if (revisionData) { | |||
res = revisionData[0].slots.main['*']; | |||
} | |||
deferred.resolve(parseMessagesToObject(name, res, options)); | |||
}); | |||
}); | |||
return deferred; | |||
} | |||
// Expose under the dev global | |||
window.dev.i18n = $.extend(window.dev.i18n, { | |||
loadMessages: loadMessages, | |||
/* | |||
* "Hidden" functions to allow testing and debugging | |||
* they may be changed or removed without warning. | |||
* Scripts should not rely on these existing or their output being in any particular format. | |||
*/ | |||
_bcp47: bcp47, | |||
_stripComments: stripComments, | |||
_saveToCache: saveToCache, | |||
_getMsg: getMsg, | |||
_handleArgs: handleArgs, | |||
_parse: parse, | |||
_fallbacks: fallbacks, | |||
_cache: cache | |||
}); | |||
// Initialise overrides object | |||
window.dev.i18n.overrides = window.dev.i18n.overrides || {}; | |||
overrides = window.dev.i18n.overrides; | |||
/* | |||
* Fire an event on load. | |||
* Alternatively, use $.getScript (or mw.loader) and use the returned promise. | |||
*/ | |||
mw.hook('dev.i18n').fire(window.dev.i18n); | |||
// Tidy the localStorage cache of old entries | |||
removeOldCacheEntries(); | |||
}(this, jQuery, mediaWiki)); | } (this, jQuery, mediaWiki)); | ||