tor-browser

DisplayNames.js (9422B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/**
* Intl.DisplayNames internal properties.
*/
function displayNamesLocaleData() {
 // Intl.DisplayNames doesn't support any extension keys.
 return {};
}
var displayNamesInternalProperties = {
 localeData: displayNamesLocaleData,
 relevantExtensionKeys: [],
};

function mozDisplayNamesLocaleData() {
 return {
   ca: intl_availableCalendars,
   default: {
     ca: intl_defaultCalendar,
   },
 };
}
var mozDisplayNamesInternalProperties = {
 localeData: mozDisplayNamesLocaleData,
 relevantExtensionKeys: ["ca"],
};

/**
* Intl.DisplayNames ( [ locales [ , options ] ] )
*
* Compute an internal properties object from |lazyDisplayNamesData|.
*/
function resolveDisplayNamesInternals(lazyDisplayNamesData) {
 assert(IsObject(lazyDisplayNamesData), "lazy data not an object?");

 var internalProps = std_Object_create(null);

 var mozExtensions = lazyDisplayNamesData.mozExtensions;

 var DisplayNames = mozExtensions
   ? mozDisplayNamesInternalProperties
   : displayNamesInternalProperties;

 // Compute effective locale.

 // Step 7.
 var localeData = DisplayNames.localeData;

 // Step 10.
 var r = ResolveLocale(
   "DisplayNames",
   lazyDisplayNamesData.requestedLocales,
   lazyDisplayNamesData.opt,
   DisplayNames.relevantExtensionKeys,
   localeData
 );

 // Step 12.
 internalProps.style = lazyDisplayNamesData.style;

 // Step 14.
 var type = lazyDisplayNamesData.type;
 internalProps.type = type;

 // Step 16.
 internalProps.fallback = lazyDisplayNamesData.fallback;

 // Step 17.
 internalProps.locale = r.locale;

 // Step 25.
 if (type === "language") {
   internalProps.languageDisplay = lazyDisplayNamesData.languageDisplay;
 }

 if (mozExtensions) {
   // Note that special casing applies in DateTimeFormat.
   internalProps.calendar = r.ca;
 }

 // The caller is responsible for associating |internalProps| with the right
 // object using |setInternalProperties|.
 return internalProps;
}

/**
* Returns an object containing the DisplayNames internal properties of |obj|.
*/
function getDisplayNamesInternals(obj) {
 assert(IsObject(obj), "getDisplayNamesInternals called with non-object");
 assert(
   intl_GuardToDisplayNames(obj) !== null,
   "getDisplayNamesInternals called with non-DisplayNames"
 );

 var internals = getIntlObjectInternals(obj);
 assert(
   internals.type === "DisplayNames",
   "bad type escaped getIntlObjectInternals"
 );

 // If internal properties have already been computed, use them.
 var internalProps = maybeInternalProperties(internals);
 if (internalProps) {
   return internalProps;
 }

 // Otherwise it's time to fully create them.
 internalProps = resolveDisplayNamesInternals(internals.lazyData);
 setInternalProperties(internals, internalProps);
 return internalProps;
}

/**
* Intl.DisplayNames ( [ locales [ , options ] ] )
*
* Initializes an object as a DisplayNames.
*
* This method is complicated a moderate bit by its implementing initialization
* as a *lazy* concept.  Everything that must happen now, does -- but we defer
* all the work we can until the object is actually used as a DisplayNames.
* This later work occurs in |resolveDisplayNamesInternals|; steps not noted
* here occur there.
*/
function InitializeDisplayNames(displayNames, locales, options, mozExtensions) {
 assert(
   IsObject(displayNames),
   "InitializeDisplayNames called with non-object"
 );
 assert(
   intl_GuardToDisplayNames(displayNames) !== null,
   "InitializeDisplayNames called with non-DisplayNames"
 );

 // Lazy DisplayNames data has the following structure:
 //
 //   {
 //     requestedLocales: List of locales,
 //
 //     opt: // opt object computed in InitializeDisplayNames
 //       {
 //         localeMatcher: "lookup" / "best fit",
 //
 //         ca: string matching a Unicode extension type, // optional
 //       }
 //
 //     localeMatcher: "lookup" / "best fit",
 //
 //     style: "narrow" / "short" / "abbreviated" / "long",
 //
 //     type: "language" / "region" / "script" / "currency" / "weekday" /
 //           "month" / "quarter" / "dayPeriod" / "dateTimeField"
 //
 //     fallback: "code" / "none",
 //
 //     // field present only if type === "language":
 //     languageDisplay: "dialect" / "standard",
 //
 //     mozExtensions: true / false,
 //   }
 //
 // Note that lazy data is only installed as a final step of initialization,
 // so every DisplayNames lazy data object has *all* these properties, never a
 // subset of them.
 var lazyDisplayNamesData = std_Object_create(null);

 // Step 3.
 var requestedLocales = CanonicalizeLocaleList(locales);
 lazyDisplayNamesData.requestedLocales = requestedLocales;

 // Step 4.
 if (!IsObject(options)) {
   ThrowTypeError(
     JSMSG_OBJECT_REQUIRED,
     options === null ? "null" : typeof options
   );
 }

 // Step 5.
 var opt = NEW_RECORD();
 lazyDisplayNamesData.opt = opt;
 lazyDisplayNamesData.mozExtensions = mozExtensions;

 // Steps 7-8.
 var matcher = GetOption(
   options,
   "localeMatcher",
   "string",
   ["lookup", "best fit"],
   "best fit"
 );
 opt.localeMatcher = matcher;

 if (mozExtensions) {
   var calendar = GetOption(
     options,
     "calendar",
     "string",
     undefined,
     undefined
   );

   if (calendar !== undefined) {
     calendar = intl_ValidateAndCanonicalizeUnicodeExtensionType(
       calendar,
       "calendar",
       "ca"
     );
   }

   opt.ca = calendar;
 }

 // Step 10.
 var style;
 if (mozExtensions) {
   style = GetOption(
     options,
     "style",
     "string",
     ["narrow", "short", "abbreviated", "long"],
     "long"
   );
 } else {
   style = GetOption(
     options,
     "style",
     "string",
     ["narrow", "short", "long"],
     "long"
   );
 }

 // Step 11.
 lazyDisplayNamesData.style = style;

 // Step 12.
 var type;
 if (mozExtensions) {
   type = GetOption(
     options,
     "type",
     "string",
     [
       "language",
       "region",
       "script",
       "currency",
       "calendar",
       "dateTimeField",
       "weekday",
       "month",
       "quarter",
       "dayPeriod",
     ],
     undefined
   );
 } else {
   type = GetOption(
     options,
     "type",
     "string",
     ["language", "region", "script", "currency", "calendar", "dateTimeField"],
     undefined
   );
 }

 // Step 13.
 if (type === undefined) {
   ThrowTypeError(JSMSG_UNDEFINED_TYPE);
 }

 // Step 14.
 lazyDisplayNamesData.type = type;

 // Step 15.
 var fallback = GetOption(
   options,
   "fallback",
   "string",
   ["code", "none"],
   "code"
 );

 // Step 16.
 lazyDisplayNamesData.fallback = fallback;

 // Step 24.
 var languageDisplay = GetOption(
   options,
   "languageDisplay",
   "string",
   ["dialect", "standard"],
   "dialect"
 );

 // Step 25.
 if (type === "language") {
   lazyDisplayNamesData.languageDisplay = languageDisplay;
 }

 // We've done everything that must be done now: mark the lazy data as fully
 // computed and install it.
 initializeIntlObject(displayNames, "DisplayNames", lazyDisplayNamesData);
}

/**
* Returns the resolved options for a DisplayNames object.
*/
function Intl_DisplayNames_of(code) {
 // Step 1.
 var displayNames = this;

 // Steps 2-3.
 if (
   !IsObject(displayNames) ||
   (displayNames = intl_GuardToDisplayNames(displayNames)) === null
 ) {
   return callFunction(
     intl_CallDisplayNamesMethodIfWrapped,
     this,
     "Intl_DisplayNames_of"
   );
 }

 code = ToString(code);

 var internals = getDisplayNamesInternals(displayNames);

 // Unpack the internals object to avoid a slow runtime to selfhosted JS call
 // in |intl_ComputeDisplayName()|.
 var {
   locale,
   calendar = "",
   style,
   type,
   languageDisplay = "",
   fallback,
 } = internals;

 // Steps 5-10.
 return intl_ComputeDisplayName(
   displayNames,
   locale,
   calendar,
   style,
   languageDisplay,
   fallback,
   type,
   code
 );
}

/**
* Returns the resolved options for a DisplayNames object.
*/
function Intl_DisplayNames_resolvedOptions() {
 // Step 1.
 var displayNames = this;

 // Steps 2-3.
 if (
   !IsObject(displayNames) ||
   (displayNames = intl_GuardToDisplayNames(displayNames)) === null
 ) {
   return callFunction(
     intl_CallDisplayNamesMethodIfWrapped,
     this,
     "Intl_DisplayNames_resolvedOptions"
   );
 }

 var internals = getDisplayNamesInternals(displayNames);

 // Steps 4-5.
 var options = {
   locale: internals.locale,
   style: internals.style,
   type: internals.type,
   fallback: internals.fallback,
 };

 // languageDisplay is only present for language display names.
 assert(
   hasOwn("languageDisplay", internals) === (internals.type === "language"),
   "languageDisplay is present iff type is 'language'"
 );

 if (hasOwn("languageDisplay", internals)) {
   DefineDataProperty(options, "languageDisplay", internals.languageDisplay);
 }

 if (hasOwn("calendar", internals)) {
   DefineDataProperty(options, "calendar", internals.calendar);
 }

 // Step 6.
 return options;
}