tor-browser

ListFormat.js (7636B)

---

/* 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/. */

/**
* ListFormat internal properties.
*/
function listFormatLocaleData() {
 // ListFormat don't support any extension keys.
 return {};
}
var listFormatInternalProperties = {
 localeData: listFormatLocaleData,
 relevantExtensionKeys: [],
};

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

 var internalProps = std_Object_create(null);

 var ListFormat = listFormatInternalProperties;

 // Compute effective locale.

 // Step 9.
 var localeData = ListFormat.localeData;

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

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

 // Step 13.
 internalProps.type = lazyListFormatData.type;

 // Step 15.
 internalProps.style = lazyListFormatData.style;

 // Steps 16-23 (not applicable in our implementation).

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

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

 var internals = getIntlObjectInternals(obj);
 assert(
   internals.type === "ListFormat",
   "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 = resolveListFormatInternals(internals.lazyData);
 setInternalProperties(internals, internalProps);
 return internalProps;
}

/**
* Intl.ListFormat ( [ locales [ , options ] ] )
*
* Initializes an object as a ListFormat.
*
* 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 ListFormat.
* This later work occurs in |resolveListFormatInternals|; steps not noted
* here occur there.
*/
function InitializeListFormat(listFormat, locales, options) {
 assert(IsObject(listFormat), "InitializeListFormat called with non-object");
 assert(
   intl_GuardToListFormat(listFormat) !== null,
   "InitializeListFormat called with non-ListFormat"
 );

 // Lazy ListFormat data has the following structure:
 //
 //   {
 //     requestedLocales: List of locales,
 //     type: "conjunction" / "disjunction" / "unit",
 //     style: "long" / "short" / "narrow",
 //
 //     opt: // opt object computed in InitializeListFormat
 //       {
 //         localeMatcher: "lookup" / "best fit",
 //       }
 //   }
 //
 // Note that lazy data is only installed as a final step of initialization,
 // so every ListFormat lazy data object has *all* these properties, never a
 // subset of them.
 var lazyListFormatData = std_Object_create(null);

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

 // Steps 4-5.
 if (options === undefined) {
   options = std_Object_create(null);
 } else if (!IsObject(options)) {
   ThrowTypeError(
     JSMSG_OBJECT_REQUIRED,
     options === null ? "null" : typeof options
   );
 }

 // Step 6.
 var opt = NEW_RECORD();
 lazyListFormatData.opt = opt;

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

 // Compute formatting options.

 // Steps 12-13.
 var type = GetOption(
   options,
   "type",
   "string",
   ["conjunction", "disjunction", "unit"],
   "conjunction"
 );
 lazyListFormatData.type = type;

 // Steps 14-15.
 var style = GetOption(
   options,
   "style",
   "string",
   ["long", "short", "narrow"],
   "long"
 );
 lazyListFormatData.style = style;

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

/**
* StringListFromIterable ( iterable )
*/
function StringListFromIterable(iterable, methodName) {
 // Step 1.
 if (iterable === undefined) {
   return [];
 }

 // Step 3.
 var list = [];

 // Steps 2, 4-5.
 for (var element of allowContentIter(iterable)) {
   // Step 5.b.ii.
   if (typeof element !== "string") {
     ThrowTypeError(
       JSMSG_NOT_EXPECTED_TYPE,
       methodName,
       "string",
       typeof element
     );
   }

   // Step 5.b.iii.
   DefineDataProperty(list, list.length, element);
 }

 // Step 6.
 return list;
}

/**
* Intl.ListFormat.prototype.format ( list )
*/
function Intl_ListFormat_format(list) {
 // Step 1.
 var listFormat = this;

 // Steps 2-3.
 if (
   !IsObject(listFormat) ||
   (listFormat = intl_GuardToListFormat(listFormat)) === null
 ) {
   return callFunction(
     intl_CallListFormatMethodIfWrapped,
     this,
     list,
     "Intl_ListFormat_format"
   );
 }

 // Step 4.
 var stringList = StringListFromIterable(list, "format");

 // We can directly return if |stringList| contains less than two elements.
 if (stringList.length < 2) {
   return stringList.length === 0 ? "" : stringList[0];
 }

 // Ensure the ListFormat internals are resolved.
 getListFormatInternals(listFormat);

 // Step 5.
 return intl_FormatList(listFormat, stringList, /* formatToParts = */ false);
}

/**
* Intl.ListFormat.prototype.formatToParts ( list )
*/
function Intl_ListFormat_formatToParts(list) {
 // Step 1.
 var listFormat = this;

 // Steps 2-3.
 if (
   !IsObject(listFormat) ||
   (listFormat = intl_GuardToListFormat(listFormat)) === null
 ) {
   return callFunction(
     intl_CallListFormatMethodIfWrapped,
     this,
     list,
     "Intl_ListFormat_formatToParts"
   );
 }

 // Step 4.
 var stringList = StringListFromIterable(list, "formatToParts");

 // We can directly return if |stringList| contains less than two elements.
 if (stringList.length < 2) {
   return stringList.length === 0
     ? []
     : [{ type: "element", value: stringList[0] }];
 }

 // Ensure the ListFormat internals are resolved.
 getListFormatInternals(listFormat);

 // Step 5.
 return intl_FormatList(listFormat, stringList, /* formatToParts = */ true);
}

/**
* Returns the resolved options for a ListFormat object.
*/
function Intl_ListFormat_resolvedOptions() {
 // Step 1.
 var listFormat = this;

 // Steps 2-3.
 if (
   !IsObject(listFormat) ||
   (listFormat = intl_GuardToListFormat(listFormat)) === null
 ) {
   return callFunction(
     intl_CallListFormatMethodIfWrapped,
     this,
     "Intl_ListFormat_resolvedOptions"
   );
 }

 var internals = getListFormatInternals(listFormat);

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

 // Step 6.
 return result;
}