opensource/galaxy
3
0
Fork 0
mirror of https://github.com/galaxyproject/galaxy.git synced 2026-09-24 16:30:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

Drop old i18n.js (unused)

Browse Source
This commit is contained in:
Dannon Baker
2023-02-14 12:59:27 -05:00
parent 29ec110e31
commit 9fd28585a0
1 changed files with 0 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client/src/i18n.js
-194
View File
@@ -1,194 +0,0 @@
/**
* @license i18n 2.0.6 Copyright jQuery Foundation and other contributors.
* Released under MIT license, http://github.com/requirejs/i18n/LICENSE
*/
/*jslint regexp: true */
/*global define: false */
/**
* This plugin handles i18n! prefixed modules. It does the following:
*
* 1) A regular module can have a dependency on an i18n bundle, but the regular
* module does not want to specify what locale to load. So it just specifies
* the top-level bundle, like 'i18n!nls/colors'.
*
* This plugin will load the i18n bundle at nls/colors, see that it is a root/master
* bundle since it does not have a locale in its name. It will then try to find
* the best match locale available in that master bundle, then request all the
* locale pieces for that best match locale. For instance, if the locale is 'en-us',
* then the plugin will ask for the 'en-us', 'en' and 'root' bundles to be loaded
* (but only if they are specified on the master bundle).
*
* Once all the bundles for the locale pieces load, then it mixes in all those
* locale pieces into each other, then finally sets the context.defined value
* for the nls/colors bundle to be that mixed in locale.
*
* 2) A regular module specifies a specific locale to load. For instance,
* i18n!nls/fr-fr/colors. In this case, the plugin needs to load the master bundle
* first, at nls/colors, then figure out what the best match locale is for fr-fr,
* since maybe only fr or just root is defined for that locale. Once that best
* fit is found, all of its locale pieces need to have their bundles loaded.
*
* Once all the bundles for the locale pieces load, then it mixes in all those
* locale pieces into each other, then finally sets the context.defined value
* for the nls/fr-fr/colors bundle to be that mixed in locale.
*/
(function () {
"use strict";
//regexp for reconstructing the master bundle name from parts of the regexp match
//nlsRegExp.exec('foo/bar/baz/nls/en-ca/foo') gives:
//['foo/bar/baz/nls/en-ca/foo', 'foo/bar/baz/nls/', '/', '/', 'en-ca', 'foo']
//nlsRegExp.exec('foo/bar/baz/nls/foo') gives:
//['foo/bar/baz/nls/foo', 'foo/bar/baz/nls/', '/', '/', 'foo', '']
//so, if match[5] is blank, it means this is the top bundle definition.
var nlsRegExp = /(^.*(^|\/)nls(\/|$))([^/]*)\/?([^/]*)/;
//Helper function to avoid repeating code. Lots of arguments in the
//desire to stay functional and support RequireJS contexts without having
//to know about the RequireJS contexts.
function addPart(locale, master, needed, toLoad, prefix, suffix) {
if (master[locale]) {
needed.push(locale);
if (master[locale] === true || master[locale] === 1) {
toLoad.push(prefix + locale + "/" + suffix);
}
}
}
function addIfExists(req, locale, toLoad, prefix, suffix) {
var fullName = prefix + locale + "/" + suffix;
if (require._fileExists(req.toUrl(fullName + ".js"))) {
toLoad.push(fullName);
}
}
/**
* Simple function to mix in properties from source into target,
* but only if target does not already have a property of the same name.
* This is not robust in IE for transferring methods that match
* Object.prototype names, but the uses of mixin here seem unlikely to
* trigger a problem related to that.
*/
function mixin(target, source, force) {
var prop;
for (prop in source) {
if (
Object.prototype.hasOwnProperty.call(source, prop) &&
(!Object.prototype.hasOwnProperty.call(target, prop) || force)
) {
target[prop] = source[prop];
} else if (typeof source[prop] === "object") {
if (!target[prop] && source[prop]) {
target[prop] = {};
}
mixin(target[prop], source[prop], force);
}
}
}
define(["module"], function (module) {
var masterConfig = module.config ? module.config() : {};
return {
version: "2.0.6",
/**
* Called when a dependency needs to be loaded.
*/
load: function (name, req, onLoad, config) {
config = config || {};
if (config.locale) {
masterConfig.locale = config.locale;
}
var masterName;
var match = nlsRegExp.exec(name);
var prefix = match[1];
var locale = match[4];
var suffix = match[5];
var parts = locale.split("-");
var toLoad = [];
var value = {};
var i;
var part;
var current = "";
//If match[5] is blank, it means this is the top bundle definition,
//so it does not have to be handled. Locale-specific requests
//will have a match[4] value but no match[5]
if (match[5]) {
//locale-specific bundle
prefix = match[1];
masterName = prefix + suffix;
} else {
//Top-level bundle.
masterName = name;
suffix = match[4];
locale = masterConfig.locale;
if (!locale) {
locale = masterConfig.locale =
typeof navigator === "undefined"
? "root"
: (
(navigator.languages && navigator.languages[0]) ||
navigator.language ||
navigator.userLanguage ||
"root"
).toLowerCase();
}
parts = locale.split("-");
}
if (config.isBuild) {
//Check for existence of all locale possible files and
//require them if exist.
toLoad.push(masterName);
addIfExists(req, "root", toLoad, prefix, suffix);
for (i = 0; i < parts.length; i++) {
part = parts[i];
current += (current ? "-" : "") + part;
addIfExists(req, current, toLoad, prefix, suffix);
}
req(toLoad, function () {
onLoad();
});
} else {
//First, fetch the master bundle, it knows what locales are available.
req([masterName], function (master) {
//Figure out the best fit
var needed = [];
var part;
//Always allow for root, then do the rest of the locale parts.
addPart("root", master, needed, toLoad, prefix, suffix);
for (i = 0; i < parts.length; i++) {
part = parts[i];
current += (current ? "-" : "") + part;
addPart(current, master, needed, toLoad, prefix, suffix);
}
//Load all the parts missing.
req(toLoad, function () {
var i;
var partBundle;
var part;
for (i = needed.length - 1; i > -1 && needed[i]; i--) {
part = needed[i];
partBundle = master[part];
if (partBundle === true || partBundle === 1) {
partBundle = req(prefix + part + "/" + suffix);
}
mixin(value, partBundle);
}
//All done, notify the loader.
onLoad(value);
});
});
}
},
};
});
})();