textbrowser 0.49.1 → 0.51.0

package/.ncurc.cjs

@@ -2,5 +2,8 @@
 
 module.exports = {
   reject: [
+    // Versions past 12 have some apparent node-sqlite3 issues,
+    //   interacting with rollup, so we can't run server script
+    'indexeddbshim'
   ]
 };

package/CHANGES.md

@@ -1,5 +1,19 @@
 # CHANGES to `textbrowser`
 
+## 0.51.0
+
+- feat: TS support
+- fix: `rememberRefusal` was not checking properly
+- fix: request permissions would have been erring out
+- fix: ensure `showEmptyInterlinear` and `showTitleOnSingleInterlinear` are
+    being passed on
+
+## 0.50.0
+
+- fix: revert apparent indexeddbshim regression
+
+Versions past 12 have some apparent node-sqlite3 issues (after rollup, can't run server script)
+
 ## 0.49.1
 
 - fix: apparent regression with `nodeActivate`

package/dist/WorkInfo-es.js

@@ -3195,12 +3195,23 @@ var i18n = function i18n() {
 };
 
 // Todo: remember this locales choice by cookie?
+
+/**
+ * @param {{
+ *   namespace: string,
+ *   preferredLocale: string
+ * }} cfg
+ */
 const getPreferredLanguages = ({namespace, preferredLocale}) => {
   // Todo: Add to this optionally with one-off tag input box
   // Todo: Switch to fallbackLanguages so can default to
   //    navigator.languages?
   const langCodes = localStorage.getItem(namespace + '-langCodes');
-  const lngs = (langCodes && JSON.parse(langCodes)) || [preferredLocale];
+  const lngs = /** @type {string[]} */ (
+    (langCodes && JSON.parse(langCodes)) || [preferredLocale]
+  );
+
+  /** @type {string[]} */
   const langArr = [];
   lngs.forEach((lng) => {
     // Todo: Check for multiple separate hyphenated
@@ -3234,14 +3245,46 @@ const getCurrDir = () => {
   return window.location.href.replace(/(index\.html)?#.*$/, '');
 };
 
+/**
+ * @typedef {{
+ *   "localization-strings": import('../../server/main.js').LocalizationStrings
+ *   table: {browse_fields: (string|{
+ *     name?: string,
+ *     set: string[],
+ *     presort?: boolean
+ *   })[]}
+ *   fields: {
+ *     [key: string]: {
+ *       prefer_alias: boolean,
+ *       lang: string,
+ *       'fieldvalue-aliases': {
+ *         localeKey: string,
+ *         [key: string]: string|string[]
+ *       }
+ *     }
+ *   }
+* }} MetadataObj
+ */
+
+/**
+ * @param {string[]} lang
+ * @param {MetadataObj} metadataObj
+ * @param {string|string[]} properties
+ * @param {boolean} [allowObjects]
+ * @returns {string|string[]|import('../../server/main.js').LocalizationStrings}
+ */
 const getMetaProp = function getMetaProp (lang, metadataObj, properties, allowObjects) {
   let prop;
   properties = typeof properties === 'string' ? [properties] : properties;
-  lang.some((lan) => {
+  for (const lan of lang) {
     const p = [...properties];
-    let strings = metadataObj['localization-strings'][lan];
+    let strings = /** @type {string | string[]|import('../../server/main.js').LocalizationStrings} */ (
+      metadataObj['localization-strings'][lan]
+    );
     while (strings && p.length) {
-      strings = strings[p.shift()];
+      strings = /** @type {import('../../server/main.js').LocalizationStrings} */ (
+        strings
+      )[/** @type {string} */ (p.shift())];
     }
     // Todo: Fix this allowance for allowObjects (as it does not properly
     //        fallback if an object is returned from a language because
@@ -3250,9 +3293,13 @@ const getMetaProp = function getMetaProp (lang, metadataObj, properties, allowOb
     prop = (typeof strings === 'string')
       ? strings
       : undefined;
-    return prop;
-  });
-  return prop;
+    if (prop) {
+      break;
+    }
+  }
+  return /** @type {string|string[]|import('../../server/main.js').LocalizationStrings} */ (
+    prop
+  );
 };
 
 // Use the following to dynamically add specific file schema in place of
@@ -3260,6 +3307,12 @@ const getMetaProp = function getMetaProp (lang, metadataObj, properties, allowOb
 //  filesSchema.properties.groups.items.properties.files.items.properties.
 //      file.anyOf.splice(1, 1, {$ref: schemaFile});
 // Todo: Allow use of dbs and fileGroup together in base directories?
+
+/**
+ * @param {string} file
+ * @param {string} property
+ * @param {string} basePath
+ */
 const getMetadata = async (file, property, basePath) => {
   const url = new URL(basePath || getCurrDir());
   url.search = ''; // Clear out query string, e.g., `?fbclid` from Facebook
@@ -3271,6 +3324,13 @@ const getMetadata = async (file, property, basePath) => {
       url.toString(),
       {
         loaderOptions: {
+          /**
+           * @param {{
+           *   text: string,
+           *   body: any
+           * }} res
+           * @param {(err?: Error, cbValue: any) => void} callback
+           */
           processContent (res, callback) {
             callback(undefined, JSON.parse(
               res.text ||
@@ -3286,16 +3346,37 @@ const getMetadata = async (file, property, basePath) => {
 
 // Todo: Incorporate other methods into this class
 class Metadata {
+  /**
+   * @param {{
+   *   metadataObj: MetadataObj
+   * }} cfg
+   */
   constructor ({metadataObj}) {
     this.metadataObj = metadataObj;
   }
 
+  /**
+   * @param {string} field
+   * @returns {string|undefined}
+   */
   getFieldLang (field) {
     const {metadataObj} = this;
     const fields = metadataObj && metadataObj.fields;
     return fields && fields[field] && fields[field].lang;
   }
 
+  /**
+   * @param {{
+   *   namespace: string,
+   *   preferredLocale: string,
+   *   schemaItems: {
+   *     title: string,
+   *     type: string
+   *   }[],
+   *   pluginsForWork: import('./Plugin.js').PluginsForWork
+   * }} cfg
+   * @returns {(field: string) => boolean}
+   */
   getFieldMatchesLocale ({
     namespace, preferredLocale, schemaItems,
     pluginsForWork
@@ -3322,7 +3403,9 @@ class Metadata {
       const hasFieldValue = localeStrings &&
                 Object.keys(localeStrings).some((lng) => {
                   const fv = localeStrings[lng] &&
-                        localeStrings[lng].fieldvalue;
+                        /** @type {import('../../server/main.js').LocalizationStrings} */
+                        (/** @type {import('../../server/main.js').LocalizationStrings} */
+                          (localeStrings[lng]).fieldvalue);
                   return fv && fv[field];
                 });
 
@@ -3335,11 +3418,17 @@ class Metadata {
   }
 }
 
+/**
+ * @param {string} pluginName
+ */
 const escapePluginComponent = (pluginName) => {
   return pluginName.replaceAll('^', '^^'). // Escape our escape
     replaceAll('-', '^0');
 };
 
+/**
+ * @param {string|undefined} pluginName
+ */
 const unescapePluginComponent = (pluginName) => {
   if (!pluginName) {
     return pluginName;
@@ -3354,18 +3443,50 @@ const unescapePluginComponent = (pluginName) => {
   ).replaceAll('^^', '^');
 };
 
+/**
+ * @param {{
+ *   pluginName: string,
+ *   applicableField: string,
+ *   targetLanguage: string
+ * }} cfg
+ */
 const escapePlugin = ({pluginName, applicableField, targetLanguage}) => {
   return escapePluginComponent(pluginName) +
         (applicableField ? '-' + escapePluginComponent(applicableField) : '-') +
         (targetLanguage ? '-' + escapePluginComponent(targetLanguage) : '');
 };
 
+/**
+ * @todo Complete
+ * @typedef {{}} PluginObject
+ */
+
 class PluginsForWork {
+  /**
+   * @param {{
+   *   pluginsInWork: [string, {
+   *     lang: string,
+   *     meta: any,
+   *     onByDefault: boolean
+   *   }][],
+   *   pluginFieldMappings: {
+   *     placement: string,
+   *     'applicable-fields': {
+   *     }
+   *   }[],
+   *   pluginObjects: PluginObject[]
+   * }} cfg
+   */
   constructor ({pluginsInWork, pluginFieldMappings, pluginObjects}) {
     this.pluginsInWork = pluginsInWork;
     this.pluginFieldMappings = pluginFieldMappings;
     this.pluginObjects = pluginObjects;
   }
+
+  /**
+   * @param {string} pluginName
+   * @returns {PluginObject}
+   */
   getPluginObject (pluginName) {
     const idx = this.pluginsInWork.findIndex(([name]) => {
       return name === pluginName;
@@ -3373,6 +3494,25 @@ class PluginsForWork {
     const plugin = this.pluginObjects[idx];
     return plugin;
   }
+
+  /**
+   * @param {(cfg: {
+   *   plugin: PluginObject,
+   *   placement: string,
+   *   applicableFields: {
+   *     [applicableField: string]: {
+   *       targetLanguage: string|string[],
+   *       onByDefault: boolean,
+   *       meta: any
+   *     }
+   *   },
+   *   pluginName: string,
+   *   pluginLang: string,
+   *   onByDefaultDefault: boolean,
+   *   meta: {}
+   * }) => void} cb
+   * @returns {void}
+   */
   iterateMappings (cb) {
     this.pluginFieldMappings.forEach(({
       placement,
@@ -3399,6 +3539,25 @@ class PluginsForWork {
       });
     });
   }
+
+  /**
+   * @param {{
+   *   [applicableField: string]: {
+   *     targetLanguage: string|string[],
+   *     onByDefault: boolean,
+   *     meta: any
+   *   }
+   * }} applicableFields
+   * @param {(cfg: {
+   *   applicableField: string,
+   *   targetLanguage: string,
+   *   onByDefault: boolean,
+   *   metaApplicableField: {
+   *     [key: string]: string
+   *   }
+   * }) => void} cb
+   * @returns {boolean}
+   */
   processTargetLanguages (applicableFields, cb) {
     if (!applicableFields) {
       return false;
@@ -3416,9 +3575,25 @@ class PluginsForWork {
     });
     return true;
   }
+
+  /**
+   * @param {{
+   *   namespace: string,
+   *   field: string
+   * }} cfg
+   * @returns {boolean}
+   */
   isPluginField ({namespace, field}) {
     return field.startsWith(`${namespace}-plugin-`);
   }
+
+  /**
+   * @param {{
+   *   namespace: string,
+   *   field: string
+   * }} cfg
+   * @returns {[string, string|undefined, string|undefined]}
+   */
   getPluginFieldParts ({namespace, field}) {
     field = field.replace(`${namespace}-plugin-`, '');
     let pluginName, applicableField, targetLanguage;
@@ -3427,20 +3602,64 @@ class PluginsForWork {
     } else {
       pluginName = field;
     }
-    return [pluginName, applicableField, targetLanguage].map(unescapePluginComponent);
+    return /** @type {[string, string|undefined, string|undefined]} */ (
+      [pluginName, applicableField, targetLanguage].map(unescapePluginComponent)
+    );
   }
 }
 
 /* globals process -- Node polyglot */
 
+/**
+ * @typedef {number} Integer
+ */
+/**
+ * @typedef {{
+ *   schema: {$ref: string},
+ *   metadata: {$ref: string},
+ *   data: (Integer|string)[]
+ * }} WorkTableContainer
+ */
+
+/**
+ * @typedef {{
+ *   file: {
+ *     $ref: string
+ *   },
+ *   schemaFile: string,
+ *   metadataFile: string,
+ *   name: string,
+ * }} FileData
+ */
+
+/**
+ * @typedef {{
+ *   files: FileData[],
+ *   baseDirectory?: string,
+ *   schemaBaseDirectory?: string,
+ *   metadataBaseDirectory?: string,
+ * }} FileGroup
+ */
+
+/**
+ * INCOMPLETE typing.
+ * @typedef {{
+ *   groups: FileGroup[],
+ *   plugins: {[key: string]: {path: string}},
+ *   baseDirectory?: string,
+ *   schemaBaseDirectory?: string,
+ *   metadataBaseDirectory?: string,
+ * }} FilesObject
+ */
+
 /**
  * Imported by the `dist/sw-helper.js`
  * @param {string} files The files.json file path
- * @returns {PlainObject}
+ * @returns {Promise<string[]>}
  */
 const getWorkFiles = async function getWorkFiles (files) {
-  const filesObj = await getJSON(files);
-  const dataFiles = [];
+  const filesObj = /** @type {FilesObject} */ (await getJSON(files));
+  const dataFiles = /** @type {string[]} */ ([]);
   filesObj.groups.forEach((fileGroup) => {
     fileGroup.files.forEach((fileData) => {
       const {file, schemaFile, metadataFile} =
@@ -3454,6 +3673,11 @@ const getWorkFiles = async function getWorkFiles (files) {
   return dataFiles;
 };
 
+/**
+ * @param {FilesObject} filesObj
+ * @param {FileGroup} fileGroup
+ * @param {FileData} fileData
+ */
 const getFilePaths = function getFilePaths (filesObj, fileGroup, fileData) {
   const baseDir = (filesObj.baseDirectory || '') + (fileGroup.baseDirectory || '') + '/';
   const schemaBaseDir = (filesObj.schemaBaseDirectory || '') +
@@ -3467,12 +3691,37 @@ const getFilePaths = function getFilePaths (filesObj, fileGroup, fileData) {
   return {file, schemaFile, metadataFile};
 };
 
+/**
+ * @typedef {{
+ *   lang: string[],
+ *   fallbackLanguages: string[],
+ *   work: string,
+ *   files: string,
+ *   allowPlugins: boolean|undefined,
+ *   basePath: string,
+ *   languages: import('./Languages.js').Languages,
+ *   preferredLocale: string
+ * }} GetWorkDataOptions
+ */
+
+/**
+ * @param {GetWorkDataOptions} cfg
+ */
 const getWorkData = async function ({
   lang, fallbackLanguages, work, files, allowPlugins, basePath,
   languages, preferredLocale
 }) {
   const filesObj = await getJSON(files);
-  const localizationStrings = filesObj['localization-strings'];
+  const localizationStrings =
+    /**
+     * @type {{
+     *   "localization-strings": {
+     *     [key: string]: {}
+     *   }
+     * }}
+     */ (
+      filesObj
+    )?.['localization-strings'];
 
   const workI18n = await i18n({
     messageStyle: 'plainNested',

package/dist/activateCallback-es.js

@@ -4,7 +4,19 @@
  */
 /* eslint-env worker -- Worker environment */
 
+/**
+ * @typedef {import('./utils/Metadata.js')} MetadataFile
+ */
+
+/**
+ * @typedef {number} Integer
+ */
 const {ceil} = Math;
+
+/**
+ * @param {any[]} arr
+ * @param {number} size
+ */
 const arrayChunk = (arr, size) => {
   return Array.from({length: ceil(arr.length / size)}, (_, i) => {
     const offset = i * size;
@@ -25,9 +37,9 @@ const arrayChunk = (arr, size) => {
 */
 
 /**
- * @param {PlainObject} cfg
+ * @param {object} cfg
  * @param {string} cfg.namespace
- * @param {string[]} cfg.files
+ * @param {string} cfg.files The files.json path
  * @param {Logger} cfg.log
  * @param {string} [cfg.basePath]
  * @returns {Promise<void>}
@@ -41,17 +53,34 @@ async function activateCallback ({
   //  already-running versions upon future sw updates
   log('Activate: Callback called');
   const r = await fetch(files);
-  const {groups} = await r.json();
+  const {groups} = /** @type {import('./utils/WorkInfo.js').FilesObject} */ (
+    await r.json()
+  );
 
+  /**
+   * @param {any[]} arr
+   * @param {string} path
+   */
   const addJSONFetch = (arr, path) => {
     arr.push(
       (async () => (await fetch(basePath + path)).json())()
     );
   };
 
+  /** @type {string[]} */
   const dataFileNames = [];
+
+  /** @type {import('./utils/WorkInfo.js').WorkTableContainer[]} */
   const dataFiles = [];
+
+  /**
+   * @typedef {import('json-schema').JSONSchema4} SchemaFile
+   */
+
+  /** @type {SchemaFile[]} */
   const schemaFiles = [];
+
+  /** @type {MetadataFile[]} */
   const metadataFiles = [];
   groups.forEach(
     ({files: fileObjs, metadataBaseDirectory, schemaBaseDirectory}) => {
@@ -59,8 +88,8 @@ async function activateCallback ({
         // We don't i18nize the name here
         dataFileNames.push(name);
         addJSONFetch(dataFiles, filePath);
-        addJSONFetch(metadataFiles, metadataBaseDirectory + '/' + metadataFile);
         addJSONFetch(schemaFiles, schemaBaseDirectory + '/' + schemaFile);
+        addJSONFetch(metadataFiles, metadataBaseDirectory + '/' + metadataFile);
       });
     }
   );
@@ -69,18 +98,20 @@ async function activateCallback ({
   ]);
   const chunked = arrayChunk(promises, dataFiles.length);
   const [
-    dataFileResponses, schemaFileResponses, metadataFileResponses
+    , schemaFileResponses, metadataFileResponses
   ] = chunked;
+  const dataFileResponses = /** @type {{data: (Integer|string)[][]}[]} */ (chunked[0]);
 
   log('Activate: Files fetched');
   const dbName = namespace + '-textbrowser-cache-data';
   indexedDB.deleteDatabase(dbName);
   return new Promise((resolve, reject) => {
     const req = indexedDB.open(dbName);
+    // @ts-expect-error Ok
     req.addEventListener('upgradeneeded', ({target: {result: db}}) => {
       db.onversionchange = () => {
         db.close();
-        const err = new Error('versionchange');
+        const err = /** @type {Error & {type: string}} */ (new Error('versionchange'));
         err.type = 'versionchange';
         reject(err);
       };
@@ -90,11 +121,27 @@ async function activateCallback ({
 
         const schemaFileResponse = schemaFileResponses[i];
         const metadataFileResponse = metadataFileResponses[i];
-        const fieldItems = schemaFileResponse.items.items;
+        const fieldItems = /** @type {{title: string}[]} */ (
+          schemaFileResponse.items.items
+        );
 
-        let browseFields = metadataFileResponse.table.browse_fields;
+        /**
+         * @typedef {{
+         *   name?: string,
+         *   presort?: boolean,
+         *   set: string[]
+         * }} NameSet
+         */
+
+        let browseFields =
+          /**
+           * @type {(string|NameSet)[]|NameSet}
+           */ (
+            metadataFileResponse.table.browse_fields
+          );
         browseFields = Array.isArray(browseFields) ? browseFields : [browseFields];
 
+        /** @type {string[]} */
         const columnIndexes = [];
         browseFields.forEach((browseFieldSetObj) => {
           if (typeof browseFieldSetObj === 'string') {
@@ -133,24 +180,39 @@ async function activateCallback ({
           // Todo: Optionally send notice when complete
           // To take advantage of indexes on our arrays, we
           //   need to transform them to objects! See https://github.com/w3c/IndexedDB/issues/209
+
+          /**
+           * @type {{
+           *   [key: string]: string|Integer|(Integer|string)[]
+           * }}
+           */
           const objRow = {
             value: tableRow
           };
           uniqueColumnIndexes.forEach((colIdx) => {
-            objRow[colIdx] = tableRow[colIdx.slice(1)];
+            objRow[colIdx] = tableRow[Number.parseInt(colIdx.slice(1))];
           });
           // log('objRow', objRow);
           store.put(objRow, j);
         });
       });
     });
+
+    // @ts-expect-error Ok
     req.addEventListener('success', ({target: {result: db}}) => {
       log('Activate: Database set-up complete', db);
       // Todo: Replace this with `ready()` check
       //   in calling code?
       resolve();
     });
-    const onerr = ({error = new Error('dbError')}) => {
+
+    /**
+     * @param {Event & {error?: Error}} ev
+     */
+    const onerr = (ev) => {
+      const error = /** @type {Error & {type: string}} */ (
+        ev.error ?? new Error('dbError')
+      );
       error.type = 'dbError';
       reject(error);
     };