textbrowser 0.54.5 → 0.54.7

package/dist/resources/workDisplay.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @typedef {() => Promise<{
+ *   groupName: string | Text | DocumentFragment,
+ *   worksToFields: {
+ *     workName: string | Text | DocumentFragment,
+ *     shortcut: string,
+ *     fieldAliasOrNames: (
+ *       string|string[]|import('../server/main.js').LocalizationStrings
+ *     )[]|undefined
+ *   }[]
+ * }[]>} GetFieldAliasOrNames
+ */
+/**
+ * @typedef {(innerArg: {
+ *   form: HTMLFormElement,
+ *   random: {
+ *     checked: boolean
+ *   },
+ *   checkboxes: HTMLInputElement[],
+ *   type: string,
+ *   fieldAliasOrNames?: string[],
+ *   workName?: string,
+ * }) => string} SerializeParamsAsURL
+ */
+/**
+ * @typedef {(
+ *   key: string|string[],
+ *   substitutions?: Record<string, string>
+ * ) => string|Text|DocumentFragment} LDirectional
+ */
+/**
+ * @typedef {(
+ *   key: string,
+ *   tag: string,
+ *   attr: string,
+ *   atts: import('jamilih').JamilihAttributes,
+ *   children?: import('jamilih').JamilihChildren
+ * ) => import('jamilih').JamilihArray} LElement
+ */
+/**
+ * @this {import('./index.js').default}
+ * @param {{
+ *   l: import('intl-dom').I18NCallback,
+ *   languageParam: string,
+ *   lang: string[],
+ *   preferredLocale: string,
+ *   languages: import('./utils/Languages.js').Languages,
+ *   fallbackLanguages: string[],
+ *   $p: import('./utils/IntlURLSearchParams.js').default
+ * }} cfg
+ */
+export default function workDisplay(this: import("./index.js").default, { l, languageParam, lang, preferredLocale, languages, fallbackLanguages, $p }: {
+    l: import("intl-dom").I18NCallback;
+    languageParam: string;
+    lang: string[];
+    preferredLocale: string;
+    languages: import("./utils/Languages.js").Languages;
+    fallbackLanguages: string[];
+    $p: import("./utils/IntlURLSearchParams.js").default;
+}): Promise<void>;
+export type GetFieldAliasOrNames = () => Promise<{
+    groupName: string | Text | DocumentFragment;
+    worksToFields: {
+        workName: string | Text | DocumentFragment;
+        shortcut: string;
+        fieldAliasOrNames: (string | string[] | import("../server/main.js").LocalizationStrings)[] | undefined;
+    }[];
+}[]>;
+export type SerializeParamsAsURL = (innerArg: {
+    form: HTMLFormElement;
+    random: {
+        checked: boolean;
+    };
+    checkboxes: HTMLInputElement[];
+    type: string;
+    fieldAliasOrNames?: string[];
+    workName?: string;
+}) => string;
+export type LDirectional = (key: string | string[], substitutions?: Record<string, string>) => string | Text | DocumentFragment;
+export type LElement = (key: string, tag: string, attr: string, atts: import("jamilih").JamilihAttributes, children?: import("jamilih").JamilihChildren) => import("jamilih").JamilihArray;
+//# sourceMappingURL=workDisplay.d.ts.map

package/dist/resources/workDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workDisplay.d.ts","sourceRoot":"","sources":["../../resources/workDisplay.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;GAKG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;GAWG;AACH,uJAVW;IACN,CAAC,EAAE,OAAO,UAAU,EAAE,YAAY,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,OAAO,sBAAsB,EAAE,SAAS,CAAC;IACpD,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,EAAE,EAAE,OAAO,gCAAgC,EAAE,OAAO,CAAA;CACrD,iBAwOH;mCA5RY,MAAM,OAAO,CAAC;IACtB,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,gBAAgB,CAAC;IAC5C,aAAa,EAAE;QACb,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,gBAAgB,CAAC;QAC3C,QAAQ,EAAE,MAAM,CAAC;QACjB,iBAAiB,EAAE,CACzB,MAAc,GAAC,MAAM,EAAE,GAAC,OAAO,mBAAmB,EAAE,mBAAmB,CAChE,EAAE,GAAC,SAAS,CAAA;KACd,EAAE,CAAA;CACJ,EAAE,CAAC;mCAIM,CAAC,QAAQ,EAAE;IACnB,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,EAAE;QACN,OAAO,EAAE,OAAO,CAAA;KACjB,CAAC;IACF,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,KAAK,MAAM;2BAIF,CACR,GAAG,EAAE,MAAM,GAAC,MAAM,EAAE,EACpB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KACnC,MAAM,GAAC,IAAI,GAAC,gBAAgB;uBAIvB,CACR,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,SAAS,EAAE,iBAAiB,EACzC,QAAQ,CAAC,EAAE,OAAO,SAAS,EAAE,eAAe,KACzC,OAAO,SAAS,EAAE,YAAY"}

package/dist/resources/workSelect.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {{
+ *   files: string,
+ *   lang: string[],
+ *   fallbackLanguages: string[],
+ *   $p: import('./utils/IntlURLSearchParams.js').default,
+ *   followParams: (formSelector: string, cb: () => void) => void
+ * }} cfg
+ */
+export default function workSelect({ files, lang, fallbackLanguages, $p, followParams }: {
+    files: string;
+    lang: string[];
+    fallbackLanguages: string[];
+    $p: import("./utils/IntlURLSearchParams.js").default;
+    followParams: (formSelector: string, cb: () => void) => void;
+}): Promise<void>;
+//# sourceMappingURL=workSelect.d.ts.map

package/dist/resources/workSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workSelect.d.ts","sourceRoot":"","sources":["../../resources/workSelect.js"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,yFARW;IACN,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,EAAE,EAAE,OAAO,gCAAgC,EAAE,OAAO,CAAC;IACrD,YAAY,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;CAC7D,iBAiFH"}

package/dist/rollup.config.d.ts

@@ -0,0 +1,19 @@
+declare const _default: (import("rollup").RollupOptions | {
+    input: string;
+    output: {
+        format: string;
+        file: string;
+        name: string;
+    };
+    plugins: any[];
+} | {
+    input: string;
+    output: {
+        format: string;
+        file: string;
+        name: string;
+    };
+    plugins?: undefined;
+})[];
+export default _default;
+//# sourceMappingURL=rollup.config.d.ts.map

package/dist/rollup.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.config.d.ts","sourceRoot":"","sources":["../rollup.config.js"],"names":[],"mappings":""}

package/dist/server/main.d.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+export type UserOptions = {
+    nodeActivate: boolean;
+    port: number;
+    domain: string;
+    basePath: string;
+    interlinearSeparator: string;
+    localizeParamNames: boolean;
+    trustFormatHTML: boolean;
+    allowPlugins: boolean;
+    showEmptyInterlinear: boolean;
+    showTitleOnSingleInterlinear: boolean;
+    serviceWorkerPath: string;
+    userJSON: string;
+    languages: string;
+    files: string;
+    namespace: string;
+    httpServer: string;
+    expressServer: string;
+};
+export type AnyValue = any;
+export type ResultsDisplayServerContext = import("../resources/utils/ServiceWorker.js").ServiceWorkerConfig & UserOptions & {
+    lang: string[];
+    langs: LanguageInfo[];
+    fallbackLanguages: string[];
+    log: (...args: AnyValue[]) => void;
+    nodeActivate?: boolean;
+    port?: number;
+    skipIndexedDB: false;
+    noDynamic: false;
+};
+export type LanguageInfo = {
+    code: string;
+    direction: "ltr" | "rtl";
+    locale: {
+        $ref: string;
+    };
+};
+export type LocalizationStrings = {
+    [key: string]: string | string[] | LocalizationStrings;
+};
+export type LanguagesData = {
+    languages: LanguageInfo[];
+    localeFileBasePath?: string;
+    "localization-strings": LocalizationStrings;
+};
+//# sourceMappingURL=main.d.ts.map

package/dist/server/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../server/main.js"],"names":[],"mappings":";0BAqCa;IACR,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,eAAe,EAAE,OAAO,CAAC;IACzB,YAAY,EAAE,OAAO,CAAC;IACtB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,4BAA4B,EAAE,OAAO,CAAC;IACtC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAA;CACtB;uBA2CS,GAAG;0CAKH,OAAO,qCAAqC,EAAE,mBAAmB,GACzE,WAAW,GAAG;IACZ,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,KAAK,IAAI,CAAC;IACnC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,KAAK,CAAC;IACrB,SAAS,EAAE,KAAK,CAAC;CAClB;2BAwDO;IACR,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,KAAK,GAAC,KAAK,CAAC;IACvB,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;CACF;kCAIS;IACZ,CAAK,GAAG,EAAE,MAAM,GAAG,MAAM,GAAC,MAAM,EAAE,GAAC,mBAAmB,CAAA;CACnD;4BAIS;IACR,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAChC,sBAA0B,EAAE,mBAAmB,CAAA;CAC5C"}

package/dist/sw-helper.js

@@ -0,0 +1,355 @@
+import activateCallback from './activateCallback-es.js';
+import {getWorkFiles} from './WorkInfo-es.js';
+
+// VERSION 0.1.0
+
+const CURRENT_CACHES = {
+  prefetch: 'prefetch-cache-v'
+};
+const minutes = 60 * 1000;
+
+// UTILITIES
+
+/**
+ * @typedef {number} PositiveInteger
+ */
+
+/**
+ * @typedef {number} Float
+ */
+
+/**
+ * @param {string} url
+ */
+async function getJSON (url) {
+  const resp = await fetch(url);
+  return await resp.json();
+}
+
+/**
+ * @param {ServiceWorkerGlobalScope} self
+ */
+function swHelper (self) {
+  // These could be made configurable by argument too
+  const defaultUserStaticFiles = [
+    '/', // Needs a separate entry from `index.html` (at least in Chrome)
+    'index.html',
+    'files.json',
+    'site.json',
+    'resources/user.js'
+    // We do not put the user.json here as that is obtained live with this
+    //   service worker via `pathToUserJSON`
+  ];
+  // Todo: We could supply `new URL(fileName, moduleURL).href` to
+  //   get these as reliable full paths without hard-coding or needing to
+  //   actually be in `node_modules/textbrowser`; see `resources/index.js`
+  const textbrowserStaticResourceFiles = [
+    'node_modules/textbrowser/appdata/languages.json',
+
+    /*
+      // Only needed atm for browser validation
+      'node_modules/textbrowser/general-schemas/files.jsonschema',
+      'node_modules/textbrowser/general-schemas/languages.jsonschema',
+      'node_modules/textbrowser-data-schemas/schemas/locale.jsonschema',
+      'node_modules/textbrowser-data-schemas/schemas/metadata.jsonschema',
+      'node_modules/textbrowser-data-schemas/schemas/table.jsonschema', // Not currently using for validation or meta-data
+      */
+
+    'node_modules/intl-locale-textinfo-polyfill/lib/Locale.js',
+    'node_modules/textbrowser/dist/assets/languages-1sAACTKG.json',
+    'node_modules/textbrowser/dist/assets/index-_11XnUty.css',
+
+    'node_modules/textbrowser/dist/index-es.js'
+  ];
+
+  /**
+  * @typedef {object} ConfigObject
+  * @property {string} namespace
+  * @property {string} basePath
+  * @property {string} languages
+  * @property {string} files
+  * @property {string[]} userStaticFiles
+  */
+
+  /**
+   *
+   * @param {Partial<ConfigObject>} args
+   * @returns {Required<ConfigObject>}
+   * @todo Since some of these reused, move to external file (or
+   *         use `setServiceWorkerDefaults`?)
+   */
+  function getConfigDefaults (args) {
+    return {
+      namespace: 'textbrowser',
+      basePath: '',
+      languages: new URL('../appdata/languages.json', import.meta.url).href,
+      files: 'files.json',
+      userStaticFiles: defaultUserStaticFiles,
+      // Opportunity to override
+      ...args
+    };
+  }
+
+  /**
+   *
+   * @param {string[]} messages
+  * @returns {Promise<void>}
+   */
+  function log (...messages) {
+    const message = messages.join(' ');
+    console.log(message);
+    return post({message, type: 'log'});
+  }
+
+  /**
+   *
+   * @param {Error} error
+   * @param {string[]} messages
+  * @returns {Promise<void>} Resolves to `undefined`
+   */
+  function logError (error, ...messages) {
+    const message = messages.join(' ');
+    console.error(error, message);
+    return post({
+      message,
+      // errorType: error.type,
+      // name: error.name,
+      type: 'error'
+    });
+  }
+
+  /**
+   * @callback DelayCallback
+   * @param {Float} time
+   * @returns {void}
+   */
+
+  /**
+   *
+   * @param {DelayCallback} cb
+   * @param {PositiveInteger} timeout
+   * @param {string} errMessage
+   * @param {PositiveInteger} [time]
+   * @returns {Promise<void>}
+   */
+  async function tryAndRetry (cb, timeout, errMessage, time = 0) {
+    time++;
+    try {
+      await cb(time); // eslint-disable-line n/callback-return -- Needed for retries
+      return undefined;
+    } catch (err) {
+      console.log('errrr', err);
+      logError(
+        /** @type {Error} */
+        (err),
+        /** @type {Error} */
+        (err).message || errMessage
+      );
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(tryAndRetry(cb, timeout, errMessage, time));
+        }, timeout);
+      });
+    }
+  }
+
+  /**
+   *
+   * @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 clients = await self.clients.matchAll({
+      // Are there any uncontrolled within activate anyways?
+      includeUncontrolled: true,
+      type: 'window'
+    }) || [];
+    if (message.includes('Posting finished')) {
+      message += ` (count: ${clients.length})`;
+    }
+    clients.forEach((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 -- In worker
+      client.postMessage({message, type});
+    });
+  }
+
+  /**
+   *
+   * @param {PositiveInteger} time
+   * @throws {Error}
+   * @returns {Promise<void>}
+   */
+  async function install (time) {
+    post({type: 'beginInstall'});
+    log(`Install: Trying, attempt ${time}`);
+    const now = Date.now();
+    const json = await getJSON(/** @type {string} */ (pathToUserJSON));
+
+    const {
+      namespace, languages, files, userStaticFiles
+    } = getConfigDefaults(json);
+
+    const {version} = await getJSON('./package.json');
+
+    console.log('opening cache', namespace + CURRENT_CACHES.prefetch + version);
+    const [
+      cache,
+      userDataFiles,
+      {languages: langs}
+    ] = await Promise.all([
+      caches.open(namespace + CURRENT_CACHES.prefetch + version),
+      getWorkFiles(files),
+      getJSON(languages)
+    ]);
+    log('Install: Retrieved dependency values');
+
+    const langPathParts = languages.split('/');
+
+    // Todo: Ought to make these locales only conditionally required and
+    //      then only show those specified in languages menu or go directly
+    //      to work selection
+    // Todo: We might give option to only download
+    //        one locale and avoid language splash page
+    const localeFiles =
+    /**
+     * @type {{
+     *   code: string,
+     *   direction: "rtl"|"ltr",
+     *   locale: {$ref: string}
+     * }[]}
+     */ (langs).map(
+      ({locale: {$ref}}) => {
+        return (langPathParts.length > 1
+          ? langPathParts.slice(0, -1).join('/') + '/'
+          : ''
+        ) + $ref;
+      }
+    );
+
+    const urlsToPrefetch = [
+      ...textbrowserStaticResourceFiles,
+      ...localeFiles,
+      ...userStaticFiles,
+      ...userDataFiles,
+      ...stylesheets
+    ];
+    // .map((url) => url === 'index.html' ? new Request(url, {cache: 'reload'}) : url)
+    try {
+      const cachePromises = urlsToPrefetch.map(async (urlToPrefetch) => {
+        // This constructs a new URL object using the service worker's script
+        //   location as the base for relative URLs.
+        const url = new URL(urlToPrefetch, location.href);
+        url.search += (url.search ? '&' : '?') + 'cache-bust=' + now;
+        const request = new Request(url, {mode: 'no-cors'});
+        try {
+          const response = await fetch(request);
+          if (response.status >= 400) {
+            throw new Error('request for ' + urlToPrefetch +
+                        ' failed with status ' + response.statusText);
+          }
+          return cache.put(urlToPrefetch, response);
+        } catch (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(
+        /** @type {Error} */
+        (error),
+        `Install: Pre-fetching failed: ${error}`
+      );
+      // Failing gives chance for a new client to re-trigger install?
+      throw error;
+    }
+
+    // An install update event will not be reported until controlled,
+    //    so we need to inform the clients
+    log(`Install: Posting finished message to clients`);
+
+    // Although we only need one client to which to send
+    //   arguments, we want to signal phase complete to all
+    post({type: 'finishedInstall'});
+  }
+
+  /**
+   *
+   * @param {PositiveInteger} time
+   * @returns {Promise<void>}
+   */
+  async function activate (time) {
+    post({type: 'beginActivate'});
+    log(`Activate: Trying, attempt ${time}`);
+    const [json, cacheNames] = await Promise.all([
+      getJSON(/** @type {string} */ (pathToUserJSON)),
+      caches.keys()
+    ]);
+    const {namespace, files, basePath} = getConfigDefaults(json);
+    const {version} = await getJSON('./package.json');
+
+    const expectedCacheNames = Object.values(CURRENT_CACHES).map((n) => namespace + n + version);
+    cacheNames.map(async (cacheName) => {
+      if (!expectedCacheNames.includes(cacheName)) {
+        log('Activate: Deleting out of date cache:', cacheName);
+        await caches.delete(cacheName);
+      }
+    });
+
+    await activateCallback({namespace, files, basePath, log});
+    log('Activate: Database changes completed');
+
+    log(`Activate: Posting finished message to clients`);
+    // Signal phase complete to all clients
+    post({type: 'finishedActivate'});
+  }
+
+  // @ts-expect-error Ok
+  const params = new URL(location).searchParams;
+  const pathToUserJSON = params.get('pathToUserJSON');
+  const stylesheets = JSON.parse(params.get('stylesheets') || '[]');
+
+  console.log('sw info', pathToUserJSON);
+  console.log('sw stylesheets', stylesheets);
+
+  self.addEventListener('install', (e) => {
+    self.skipWaiting();
+    e.waitUntil(tryAndRetry(install, 5 * minutes, 'Error installing'));
+  });
+
+  self.addEventListener('activate', (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'));
+  });
+
+  // We cannot make this async as `e.respondWith` must be called synchronously
+  self.addEventListener('fetch', (e) => {
+    // DevTools opening will trigger these o-i-c requests
+    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 cached || fetch(request);
+    })());
+  });
+}
+
+export default swHelper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "textbrowser",
-  "version": "0.54.5",
+  "version": "0.54.7",
   "description": "Multilinear text browser",
   "type": "module",
   "main": "dist/index-es.min.js",

package/resources/index.js

@@ -477,10 +477,14 @@ class TextBrowser {
     } else {
       const worker = r.installing || r.waiting || r.active;
       if (!worker) {
-        // Todo: Why wouldn't there be a worker here?
-        console.error('Unexpected error: worker registration received without a worker.');
-        // If anything, would probably need to register though
-        await register();
+        console.warn('Worker registration returned with no worker; retrying registration.');
+        try {
+          await r.unregister();
+        } catch (err) {
+          console.warn('Unregister failed during retry', err);
+        }
+        Templates.permissions.main({siteI18n});
+        await prepareForServiceWorker.call(this);
         return;
       }