unicode-input-toolconverter 0.2.0 → 0.2.3

package/sw.js

@@ -1,5 +1,4 @@
 /* eslint-disable no-console -- Debugging */
-/* eslint-env serviceworker -- Service worker */
 
 import {getJSON} from './browser_action/utils/FetchUtils.js';
 import activateCallback from
@@ -10,20 +9,23 @@ const CURRENT_CACHES = {
 };
 const minutes = 60 * 1000;
 
+// v1
+
 // Utilities
 
 /**
  *
- * @param {PlainObject} args
- * @param {
- *   "log"|"error"|"beginInstall"|"finishedInstall"|"beginActivate"|
+ * @param {object} args
+ * @param {"log"|"error"|"beginInstall"|"finishedInstall"|"beginActivate"|
  *   "finishedActivate"
  * } args.type
  * @param {string} [args.message]
  * @returns {Promise<void>}
  */
 async function post ({type, message = type}) {
-  const windowClients = await self.clients.matchAll({
+  const windowClients = await /** @type {ServiceWorkerGlobalScope} */ (
+    /** @type {unknown} */ (globalThis)
+  ).clients.matchAll({
     // Are there any uncontrolled within activate anyways?
     includeUncontrolled: true,
     type: 'window'
@@ -31,17 +33,21 @@ async function post ({type, message = type}) {
   if (message.includes('Posting finished')) {
     message += ` (count: ${windowClients.length})`;
   }
-  windowClients.forEach((client) => {
+  windowClients.forEach(/**
+                         * @param {WindowClient} client
+                         * @returns {void}
+                         */ (client) => {
     // Although we only need one client to which to send
     //   arguments, we want to signal phase complete to all
     // eslint-disable-next-line unicorn/require-post-message-target-origin -- Rule being reviewed: https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1396
-    client.postMessage({message, type});
-  });
+      client.postMessage({message, type});
+    }
+  );
 }
 
 /**
  * @callback Logger
- * @param {string[]} messages
+ * @param {...string[]} messages
  * @returns {Promise<void>}
  */
 
@@ -64,10 +70,21 @@ function logError (error, ...messages) {
   const message = messages.join(' ');
   console.error(error, message);
   return post({
-    message, errorType: error.type, name: error.name, type: 'error'
+    message,
+    // errorType: error.type,
+    // name: error.name,
+    type: 'error'
   });
 }
 
+/**
+ * @typedef {number} PositiveInteger
+ */
+
+/**
+ * @typedef {number} Float
+ */
+
 /**
  * @callback DelayCallback
  * @param {Float} time
@@ -91,7 +108,9 @@ async function tryAndRetry (cb, timeout, errMessage, time = 0) {
     return undefined;
   } catch (err) {
     console.log('errrr', err);
-    logError(err, err.message || errMessage);
+    logError(/** @type {Error} */ (err), /** @type {Error} */ (
+      err
+    ).message || errMessage);
     // eslint-disable-next-line promise/avoid-new -- Need timeout
     return new Promise((resolve) => {
       setTimeout(() => {
@@ -107,6 +126,14 @@ const pathToLocaleJSON = './browser_action/service-worker/sw-locales.json';
 const pathToUnicodeDataJSON =
   './browser_action/service-worker/sw-unicode-data.json';
 
+// Auto-updated by `npm run service-worker` (see tools/write-sw-version.js).
+//   Keeping this in sync with `package.json`'s version ensures this file's
+//   own bytes change on every release, so browsers with an already-
+//   installed service worker actually detect the update (the update check
+//   is a byte-for-byte diff of this script) instead of silently continuing
+//   to serve a stale cache indefinitely.
+const BUILD_VERSION = '0.2.2';
+
 console.log('sw info', pathToStaticJSON);
 
 /**
@@ -119,9 +146,8 @@ async function install (time) {
   post({type: 'beginInstall'});
   log(`Install: Trying, attempt ${time}`);
   const now = Date.now();
-  const {version} = await getJSON('./package.json');
 
-  const cacheKey = namespace + CURRENT_CACHES.prefetch + version;
+  const cacheKey = namespace + CURRENT_CACHES.prefetch + BUILD_VERSION;
 
   console.log('opening cache', cacheKey);
   const [
@@ -131,9 +157,9 @@ async function install (time) {
     unicodeDataFiles
   ] = await Promise.all([
     caches.open(cacheKey),
-    getJSON(pathToStaticJSON),
-    getJSON(pathToLocaleJSON),
-    getJSON(pathToUnicodeDataJSON)
+    /** @type {Promise<string[]>} */ (getJSON(pathToStaticJSON)),
+    /** @type {Promise<string[]>} */ (getJSON(pathToLocaleJSON)),
+    /** @type {Promise<string[]>} */ (getJSON(pathToUnicodeDataJSON))
   ]);
   log('Install: Retrieved dependency values');
 
@@ -164,14 +190,20 @@ async function install (time) {
         }
         return cache.put(urlToPrefetch, resp);
       } catch (error) {
-        logError(error, 'Not caching ' + urlToPrefetch + ' due to ' + error);
+        logError(
+          /** @type {Error} */ (error),
+          `Not caching ${urlToPrefetch} due to ${error}`
+        );
         throw error;
       }
     });
     await Promise.all(cachePromises);
     log('Install: Pre-fetching complete.');
   } catch (error) {
-    logError(error, `Install: Pre-fetching failed: ${error}`);
+    logError(
+      /** @type {Error} */ (error),
+      `Install: Pre-fetching failed: ${error}`
+    );
     // Failing gives chance for a new client to re-trigger install?
     throw error;
   }
@@ -194,28 +226,24 @@ async function activate (time) {
   post({type: 'beginActivate'});
   log(`Activate: Trying, attempt ${time}`);
 
-  const [
-    cacheNames,
-    {version}
-  ] = await Promise.all([
-    caches.keys(),
-    getJSON('./package.json')
-  ]);
+  const cacheNames = await caches.keys();
 
   const expectedCacheNames = Object.values(
     CURRENT_CACHES
-  ).map((n) => namespace + n + version);
+  ).map((n) => namespace + n + BUILD_VERSION);
   cacheNames.forEach(async (cacheName) => {
-    if (!expectedCacheNames.includes(cacheName)) {
-      log('Activate: Deleting out of date cache:', cacheName);
-      await caches.delete(cacheName);
+    if (expectedCacheNames.includes(cacheName)) {
+      return;
     }
+
+    log('Activate: Deleting out of date cache:', cacheName);
+    await caches.delete(cacheName);
   });
 
   // Todo: Use `namespace` in indexedDB db
   await activateCallback({
-    namespace,
-    log
+    namespace
+    // log
   });
   // log('Activate: Database changes completed');
 
@@ -224,36 +252,49 @@ async function activate (time) {
   post({type: 'finishedActivate'});
 }
 
-self.addEventListener('install', (e) => {
-  self.skipWaiting();
-  e.waitUntil(
-    tryAndRetry(install, 5 * minutes, 'Error installing')
-  );
-});
+const sw = /** @type {ServiceWorkerGlobalScope} */ (
+  /** @type {unknown} */ (globalThis)
+);
 
-self.addEventListener('activate', (e) => {
+sw.addEventListener('install', /**
+                                * @param {ExtendableEvent} e
+                                * @returns {void}
+                                */ (e) => {
+    sw.skipWaiting();
+    e.waitUntil(
+      tryAndRetry(install, 5 * minutes, 'Error installing')
+    );
+  });
+
+sw.addEventListener('activate', /**
+                                 * @param {ExtendableEvent} e
+                                 * @returns {void}
+                                 */ (e) => {
   // Erring is of no present use here:
   //   https://github.com/w3c/ServiceWorker/issues/659#issuecomment-384919053
-  e.waitUntil(tryAndRetry(activate, 5 * minutes, 'Error activating'));
-});
+    e.waitUntil(tryAndRetry(activate, 5 * minutes, 'Error activating'));
+  });
 
 // We cannot make this async as `e.respondWith` must be called synchronously
-self.addEventListener('fetch', (e) => {
+sw.addEventListener('fetch', /**
+                              * @param {FetchEvent} e
+                              * @returns {void}
+                              */ (e) => {
   // DevTools opening will trigger these o-i-c requests
-  const {request} = e;
-  const {cache, mode, url} = request;
-  if (
-    cache === 'only-if-cached' &&
+    const {request} = e;
+    const {cache, mode, url} = request;
+    if (
+      cache === 'only-if-cached' &&
     mode !== 'same-origin'
-  ) {
-    return;
-  }
-  console.log('fetching', url);
-  e.respondWith((async () => {
-    const cached = await caches.match(request);
-    if (!cached) {
-      console.log('no cached found', url);
+    ) {
+      return;
     }
-    return cached || fetch(request);
-  })());
-});
+    console.log('fetching', url);
+    e.respondWith((async () => {
+      const cached = await caches.match(request);
+      if (!cached) {
+        console.log('no cached found', url);
+      }
+      return cached || fetch(request);
+    })());
+  });

package/tools/entities-import.js

@@ -2,7 +2,7 @@
 //  this file for the browser, but we're keeping this file for demonstrating
 //  an approach for live-obtaining the live version.
 
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
 
 // eslint-disable-next-line no-shadow -- Clearer
 import fetch from 'node-fetch';
@@ -14,6 +14,9 @@ const args = process.argv.slice(2);
 const targetDir = `${process.cwd()}/download/entities`;
 const entityBasePath = 'https://www.w3.org/2003/entities/2007/';
 
+/**
+ * @param {string} file
+ */
 const getText = async (file) => {
   return await (await fetch(
     file

package/tools/findEsResources.js

@@ -1,4 +1,7 @@
 const queryModule = {
+  /**
+   * @param {import('estree').Literal} node
+   */
   [
   // Entity files
   'ArrayExpression > Literal[value="optgroup"] + ObjectExpression + ' +
@@ -10,19 +13,39 @@ const queryModule = {
     ];
   },
   // Dynamically imported stylesheets
+  /**
+   * @param {import('estree').Property} node
+   */
   'Property[key.name="stylesheets"]' (node) {
-    return (node.value.elements || []).flatMap((element) => {
-      if (element.type === 'Literal') {
+    return (
+      ('elements' in node.value && node.value.elements) || []
+    ).flatMap((element) => {
+      if (element?.type === 'Literal') {
         return element.value;
       }
-      // if (element.type === 'ArrayExpression') {
-      return element.elements.flatMap((arrayItem) => {
-        if (arrayItem.type === 'Literal') {
-          return arrayItem.value;
-        }
-        // Ignore
-        return [];
-      });
+      if (element?.type === 'ArrayExpression') {
+        return element.elements.flatMap((arrayItem) => {
+          if (arrayItem?.type === 'Literal') {
+            return arrayItem.value;
+          }
+          if (
+            arrayItem?.type === 'ConditionalExpression' &&
+            arrayItem.alternate.type === 'Literal'
+          ) {
+            return arrayItem.alternate.value;
+          }
+          // Ignore
+          return [];
+        });
+      }
+      if (
+        element?.type === 'ConditionalExpression' &&
+        element.alternate.type === 'Literal'
+      ) {
+        return element.alternate.value;
+      }
+
+      return [];
     });
   }
 };

package/tools/fix-sw-resources-vendor-paths.js

@@ -0,0 +1,60 @@
+import fs from 'node:fs/promises';
+
+// `find-es-resources` resolves bare specifiers (e.g., `import ... from
+//   'jamilih'`) via plain Node resolution, which always lands in
+//   `node_modules` -- it has no notion of `browser_action/index.html`'s
+//   `importmap`, which is what actually redirects those specifiers to
+//   `/vendor/...` builds in the browser. `node_modules` is gitignored, so
+//   any `node_modules` entry here would 404 once deployed.
+const html = await fs.readFile('browser_action/index.html', 'utf8');
+const importmapMatch = html.match(
+  /<script type="importmap">([\s\S]*?)<\/script>/v
+);
+if (!importmapMatch) {
+  throw new Error(
+    'Could not find `<script type="importmap">` in browser_action/index.html'
+  );
+}
+const {imports} = JSON.parse(importmapMatch[1]);
+
+const indexHtmlUrl = new URL(
+  'https://example.invalid/browser_action/index.html'
+);
+const vendorPathBySpecifier = new Map(
+  Object.entries(imports).map(([specifier, relativePath]) => {
+    return [specifier, new URL(relativePath, indexHtmlUrl).pathname];
+  })
+);
+
+const swResourcesPath = 'browser_action/service-worker/sw-resources.json';
+const resources = /** @type {string[]} */ (
+  JSON.parse(await fs.readFile(swResourcesPath, 'utf8'))
+);
+
+const nodeModulesPattern = /^\/node_modules\/((?:@[^\/]+\/)?[^\/]+)\//v;
+
+const fixedResources = [...new Set(resources.flatMap((resource) => {
+  const nodeModulesMatch = resource.match(nodeModulesPattern);
+  if (!nodeModulesMatch) {
+    return [resource];
+  }
+  const [, packageName] = nodeModulesMatch;
+  const fullSpecifier = resource.replace(/^\/node_modules\//v, '');
+  const vendorPath = vendorPathBySpecifier.get(fullSpecifier) ||
+    vendorPathBySpecifier.get(packageName);
+  if (!vendorPath) {
+    // Only reachable by following a `node_modules` package's own source
+    //   (e.g., a sub-dependency); nothing deployed actually imports it
+    //   this way, so drop it.
+    // eslint-disable-next-line no-console -- CLI
+    console.log(`Dropping undeployable resource: ${resource}`);
+    return [];
+  }
+  return [vendorPath];
+// eslint-disable-next-line unicorn/require-array-sort-compare -- Consistency
+}))].toSorted();
+
+await fs.writeFile(
+  swResourcesPath,
+  JSON.stringify(fixedResources, null, 2) + '\n'
+);

package/tools/list-locales.js

@@ -1,4 +1,4 @@
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
 
 const dirs = await fs.readdir('_locales');
 
@@ -6,7 +6,7 @@ const json = dirs.filter((dir) => {
   return dir !== '.DS_Store';
 }).map((dir) => {
   return `/_locales/${dir}/messages.json`;
-}).sort();
+}).toSorted((a, b) => a.localeCompare(b));
 
 // eslint-disable-next-line no-console -- CLI
 console.log('json', json);