textbrowser 0.45.2 → 0.46.1

package/resources/workDisplay.js

@@ -1,5 +1,4 @@
 /* eslint-env browser */
-import {IMF} from 'imf';
 import {getJSON} from 'simple-get-json';
 
 import {replaceHash, getParamsSetter, getSerializeParamsAsURL} from './utils/Params.js';
@@ -32,45 +31,40 @@ export default async function workDisplay ({
     );
 
   async function _displayWork ({
-    lf, metadataObj, getFieldAliasOrName, schemaObj, schemaItems, fieldInfo,
-    metadata, pluginsForWork, groupsToWorks
+    workI18n, metadataObj, getFieldAliasOrName, schemaObj, schemaItems,
+    fieldInfo, metadata, pluginsForWork, groupsToWorks
   }) {
-    const il = localizeParamNames
+    const lParam = localizeParamNames
       ? key => l(['params', key])
       : key => key;
-    const iil = localizeParamNames
+    const lIndexedParam = localizeParamNames
       ? key => l(['params', 'indexed', key])
       : key => key;
 
-    const localeFromLangData = languages.localeFromLangData.bind(languages);
-    const imfLang = IMF({
-      locales: lang.map(localeFromLangData),
-      fallbackLocales: fallbackLanguages.map(localeFromLangData)
-    });
-    const imfl = imfLang.getFormatter();
-
-    // Returns option element with localized option text (as Jamilih), with
+    // Returns element with localized option text (as Jamilih), with
     //   optional fallback direction
-    const le = (key, el, attToLocalize, atts, children = []) => {
-      atts[attToLocalize] = l({
-        key,
-        fallback ({message}) {
-          atts.dir = fallbackDirection;
-          return message;
-        }
-      });
+    const lElement = (key, el, attToLocalize, atts, children = []) => {
+      atts[attToLocalize] = l(
+        key
+        // Restore this if `intl-dom` supports
+        // fallback ({message}) {
+        //   atts.dir = fallbackDirection;
+        //   return message;
+        // }
+      );
       return [el, atts, children];
     };
 
     // Returns plain text node or element (as Jamilih) with fallback direction
-    const ld = (key, values, formats) =>
-      l({
+    const lDirectional = (key, substitutions) =>
+      l(
         key,
-        values,
-        formats,
-        fallback: ({message}) =>
-          Templates.workDisplay.bdo({fallbackDirection, message})
-      });
+        substitutions
+        // formats
+        // Restore if `intl-dom` supports
+        // fallback: ({message}) =>
+        //   Templates.workDisplay.bdo({fallbackDirection, message})
+      );
 
     const fieldMatchesLocale = metadata.getFieldMatchesLocale({
       namespace: this.namespace,
@@ -84,18 +78,18 @@ export default async function workDisplay ({
       callback ({browseFields, i}) {
         Templates.workDisplay.addBrowseFields({
           browseFields, fieldInfo,
-          ld, i, iil, $p, content
+          lDirectional, i, lIndexedParam, $p, content
         });
       }
     });
 
     /*
-        Templates.workDisplay.addRandomFormFields({
-            il, l, ld, le, $p, serializeParamsAsURL, content
-        });
-        */
-    const serializeParamsAsURL = getSerializeParamsAsURL({l, il, $p});
-    const paramsSetter = getParamsSetter({l, il, $p});
+      Templates.workDisplay.addRandomFormFields({
+          lParam, l, lDirectional, lElement, $p, serializeParamsAsURL, content
+      });
+    */
+    const serializeParamsAsURL = getSerializeParamsAsURL({l, lParam, $p});
+    const paramsSetter = getParamsSetter({l, lParam, $p});
 
     const {groups} = await getJSON(this.files);
 
@@ -127,15 +121,28 @@ export default async function workDisplay ({
       };
     })();
 
+    const displayNames = new Intl.DisplayNames(
+      [...lang, ...fallbackLanguages],
+      {
+        type: 'language',
+        // Dialect: "American English"
+        // Standard: "English (United States)"
+        languageDisplay: 'standard' // 'dialect'
+      }
+    );
+    const languageI18n = (code) => {
+      return displayNames.of(code);
+    };
+
     Templates.workDisplay.main({
-      languageParam, lang, lf,
+      languageParam, lang, workI18n,
       l, namespace: this.namespace, groups, heading,
-      imfl, fallbackDirection,
+      languageI18n, fallbackDirection,
       langs, fieldInfo, localizeParamNames,
       serializeParamsAsURL, paramsSetter, replaceHash,
       getFieldAliasOrNames,
       hideFormattingSection, $p,
-      metadataObj, il, le, ld, iil,
+      metadataObj, lParam, lElement, lDirectional, lIndexedParam,
       fieldMatchesLocale,
       preferredLocale, schemaItems, content,
       preferencesPlugin
@@ -143,21 +150,20 @@ export default async function workDisplay ({
   }
 
   try {
-    const {lf, fileData, metadataObj, ...args} = await this.getWorkData({
+    const {workI18n, fileData, metadataObj, ...args} = await this.getWorkData({
       lang, fallbackLanguages, preferredLocale,
       languages, work: $p.get('work')
     });
 
-    document.title = lf({
-      key: 'browserfile-workdisplay',
-      values: {
+    document.title = workI18n(
+      'browserfile-workdisplay',
+      {
         work: fileData
           ? getMetaProp(lang, metadataObj, 'alias')
           : ''
-      },
-      fallback: true
-    });
-    await _displayWork.call(this, {lf, metadataObj, ...args});
+      }
+    );
+    await _displayWork.call(this, {workI18n, metadataObj, ...args});
   } catch (err) {
     console.log('err', err);
     dialogs.alert(err);

package/resources/workSelect.js

@@ -1,6 +1,6 @@
 /* eslint-env browser */
 import {getJSON} from 'simple-get-json';
-import {IMF} from 'imf';
+import {i18n} from 'intl-dom';
 
 import {getMetaProp} from './utils/Metadata.js';
 import {dialogs} from './utils/dialogs.js';
@@ -13,42 +13,63 @@ export default async function workSelect ({
   // We use getJSON instead of JsonRefs as we do not necessarily need to
   //    resolve the file contents here
   try {
-    const dbs = await getJSON(files);
-    const localeFromFileData = (lan) =>
-      dbs['localization-strings'][lan];
+    const works = await getJSON(files);
+    const localizationStrings = works['localization-strings'];
 
-    const metadataObjs = await getJSON(dbs.groups.reduce((arr, fileGroup) => {
-      const metadataBaseDir = (dbs.metadataBaseDirectory || '') +
+    const metadataObjs = await getJSON(works.groups.reduce((arr, fileGroup) => {
+      const metadataBaseDir = (works.metadataBaseDirectory || '') +
                 (fileGroup.metadataBaseDirectory || '') + '/';
       return fileGroup.files.reduce((ar, fileData) =>
         [...ar, metadataBaseDir + fileData.metadataFile],
       arr);
     }, []));
-    const imfFile = IMF({
-      locales: lang.map(localeFromFileData),
-      fallbackLocales: fallbackLanguages.map(localeFromFileData)
+
+    const workI18n = await i18n({
+      messageStyle: 'plainNested',
+      locales: lang,
+      defaultLocales: fallbackLanguages,
+      // Todo: Could at least share this with `index.js`
+      localeStringFinder ({
+        locales, defaultLocales
+      }) {
+        const locale = [...locales, ...defaultLocales].find((language) => {
+          return language in localizationStrings;
+        });
+        return {
+          locale,
+          strings: {
+            head: {},
+            body: localizationStrings[locale]
+          }
+        };
+      }
     });
-    const lf = imfFile.getFormatter();
-    document.title = lf({key: 'browserfile-workselect', fallback: true});
+
+    document.title = workI18n('browserfile-workselect');
     /*
-        function ld (key, values, formats) {
-            return l({
-                key: key, values: values, formats: formats, fallback: ({message}) =>
-                    // Displaying as div with inline display instead of span since
-                    //    Firefox puts punctuation at left otherwise
-                    ['div', {
-                        style: 'display: inline;direction: ' + fallbackDirection
-                    }, [message]]
-            });
-        }
-        */
+    // Would need adapting now that not using IMF
+    function lDirectional (key, substitutions, formats) {
+      return workI18n(
+        key, substitutions,
+        formats,
+        fallback: ({message}) =>
+          // Displaying as div with inline display instead of span since
+          //    Firefox puts punctuation at left otherwise
+          ['div', {
+              style: 'display: inline;direction: ' + fallbackDirection
+          }, [message]]
+      });
+    }
+    */
 
     const metadataObjsIter = metadataObjs[Symbol.iterator]();
     const getNextAlias = () => {
       const metadataObj = metadataObjsIter.next().value;
       return getMetaProp(lang, metadataObj, 'alias');
     };
-    Templates.workSelect({groups: dbs.groups, lf, getNextAlias, $p, followParams});
+    Templates.workSelect({
+      groups: works.groups, workI18n, getNextAlias, $p, followParams
+    });
   } catch (err) {
     console.log('Error', err);
     dialogs.alert(err);

package/server/main.js

@@ -12,7 +12,7 @@ import {getJSON} from 'simple-get-json';
 
 import IntlURLSearchParams from '../resources/utils/IntlURLSearchParams.js';
 import {resultsDisplayServer} from '../resources/resultsDisplay.js';
-import getIMFFallbackResults from '../resources/utils/getIMFFallbackResults.js';
+import getLocaleFallbackResults from '../resources/utils/getLocaleFallbackResults.js';
 import {setServiceWorkerDefaults} from '../resources/utils/ServiceWorker.js';
 // import setGlobalVars from 'indexeddbshim/src/node-UnicodeIdentifiers.js';
 import {Languages} from '../resources/utils/Languages.js';
@@ -99,10 +99,8 @@ setGlobalVars(null, {
 
 if (userParams.nodeActivate) {
   global.fetch = fetch;
-  (async () => {
-    await activateCallback({...userParamsWithDefaults, basePath});
-    console.log('Activated');
-  })();
+  await activateCallback({...userParamsWithDefaults, basePath});
+  console.log('Activated');
 }
 console.log('past activate check');
 
@@ -196,40 +194,50 @@ const srv = http.createServer(async (req, res) => {
 
   const {lang, langs, fallbackLanguages} = languagesInstance.getLanguageInfo({$p});
 
-  getIMFFallbackResults({
+  const l = await getLocaleFallbackResults({
     $p,
-    basePath,
-    lang, langs, fallbackLanguages,
-    langData,
-    async resultsDisplay (resultsArgs, ...args) {
-      const serverOutput = $p.get('serverOutput', true);
-      let allowPlugins = $p.get('allowPlugins', true);
-      if (allowPlugins === '0') {
-        allowPlugins = false;
-      }
-      const isHTML = serverOutput === 'html';
-      res.writeHead(200, {'Content-Type': isHTML
-        ? 'text/html;charset=utf8'
-        : 'application/json;charset=utf8'
-      });
-      resultsArgs = {
-        ...resultsArgs,
+    lang, langs, langData, fallbackLanguages,
+    basePath
+  });
+
+  const resultsDisplay = async function () {
+    const serverOutput = $p.get('serverOutput', true);
+    let allowPlugins = $p.get('allowPlugins', true);
+    if (allowPlugins === '0') {
+      allowPlugins = false;
+    }
+    const isHTML = serverOutput === 'html';
+    res.writeHead(200, {'Content-Type': isHTML
+      ? 'text/html;charset=utf8'
+      : 'application/json;charset=utf8'
+    });
+    // Todo: Move sw-sample.js to bahaiwritings and test
+    const result = await resultsDisplayServer.call(
+      // Context
+      {
+        ...userParamsWithDefaults, lang, langs, fallbackLanguages
+      },
+      // resultsArgs
+      {
+        l,
+        lang,
+        fallbackLanguages,
+        locales: l.strings,
+        $p,
+        basePath,
         skipIndexedDB: false,
         allowPlugins,
         serverOutput,
         langData,
         prefI18n: $p.get('prefI18n', true)
-      };
-      // Todo: Move sw-sample.js to bahaiwritings and test
-      const result = await resultsDisplayServer.call(
-        {
-          ...userParamsWithDefaults, lang, langs, fallbackLanguages
-        }, resultsArgs, ...args
-      );
-      res.end(isHTML ? result : JSON.stringify(result));
-    }
-  });
+      }
+    );
+    res.end(isHTML ? result : JSON.stringify(result));
+  };
+
+  await resultsDisplay();
 });
+
 if (!userParams.domain) {
   srv.listen(port);
 } else {

package/sw-sample.js

@@ -77,7 +77,7 @@ function logError (error, ...messages) {
 async function tryAndRetry (cb, timeout, errMessage, time = 0) {
   time++;
   try {
-    // eslint-disable-next-line node/callback-return
+    // eslint-disable-next-line n/callback-return
     await cb(time);
     return undefined;
   } catch (err) {

package/resources/utils/getIMFFallbackResults.js

@@ -1,47 +0,0 @@
-import {IMF} from 'imf';
-
-export default function getIMFFallbackResults ({
-  $p,
-  lang, langs, langData, fallbackLanguages,
-  resultsDisplay,
-  basePath = '',
-  localeCallback = false
-}) {
-  return new Promise((resolve, reject) => {
-    const resultsCallback = (...args) => {
-      const [l10n] = args;
-      if (!$p.l10n) {
-        $p.l10n = l10n;
-      }
-      return resultsDisplay({
-        l: l10n,
-        lang,
-        fallbackLanguages,
-        imfLocales: imf.locales,
-        $p,
-        basePath
-      }, ...args);
-    };
-    const imf = IMF({
-      languages: lang,
-      fallbackLanguages,
-      localeFileResolver (code) {
-        // Todo: For editing of locales, we might instead resolve all
-        //    `$ref` (as with <https://github.com/whitlockjc/json-refs>) and
-        //    replace IMF() loadLocales behavior with our own now resolved
-        //    locales; see https://github.com/jdorn/json-editor/issues/132
-        return basePath + (langData.localeFileBasePath) + langs.find((l) =>
-          l.code === code
-        ).locale.$ref;
-      },
-      async callback (...args) {
-        if (localeCallback && localeCallback(...args)) {
-          resolve();
-          return;
-        }
-        await resultsCallback(...args);
-        resolve();
-      }
-    });
-  });
-}