zotero-plugin-scaffold 0.4.2 → 0.5.0

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 import process from 'node:process';
 import { Command } from 'commander';
-import { l as logger, E as ExitSignals, C as Config, B as Build, S as Serve, T as Test, R as Release } from './shared/zotero-plugin-scaffold.DGHktPRh.mjs';
+import { l as logger, E as ExitSignals, C as Config, B as Build, S as Serve, T as Test, R as Release } from './shared/zotero-plugin-scaffold.BhyPDymw.mjs';
 import { readFile } from 'node:fs/promises';
 import { pathExists } from 'fs-extra';
 import tinyUpdateNotifier from 'tiny-update-notifier';
@@ -13,11 +13,12 @@ import 'node:util';
 import 'std-env';
 import './shared/zotero-plugin-scaffold.v8dJZZ-v.mjs';
 import 'tinyglobby';
-import 'node:fs';
 import 'node:path';
 import 'adm-zip';
 import 'esbuild';
 import 'node:crypto';
+import 'node:fs';
+import '@fluent/syntax';
 import '@swc/core';
 import 'node:child_process';
 import 'bumpp';
@@ -31,7 +32,7 @@ import 'xvfb-ts';
 import 'node:http';
 
 const name = "zotero-plugin-scaffold";
-const version = "0.4.2";
+const version = "0.5.0";
 const pkg = {
 	name: name,
 	version: version};

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { B as Build, C as Config, R as Release, S as Serve, T as Test, d as defineConfig } from './shared/zotero-plugin-scaffold.DGHktPRh.mjs';
+export { B as Build, C as Config, R as Release, S as Serve, T as Test, d as defineConfig } from './shared/zotero-plugin-scaffold.BhyPDymw.mjs';
 import 'c12';
 import 'es-toolkit';
 import 'fs-extra/esm';
@@ -10,11 +10,12 @@ import 'std-env';
 import './shared/zotero-plugin-scaffold.v8dJZZ-v.mjs';
 import 'node:fs/promises';
 import 'tinyglobby';
-import 'node:fs';
 import 'node:path';
 import 'adm-zip';
 import 'esbuild';
 import 'node:crypto';
+import 'node:fs';
+import '@fluent/syntax';
 import '@swc/core';
 import 'node:child_process';
 import 'bumpp';

package/dist/shared/{zotero-plugin-scaffold.DGHktPRh.mjs → zotero-plugin-scaffold.BhyPDymw.mjs}

@@ -1,19 +1,20 @@
 import { loadConfig as loadConfig$1 } from 'c12';
 import { isPlainObject, kebabCase, mapValues, toMerged, escapeRegExp, debounce, delay } from 'es-toolkit';
-import { readJsonSync, outputFile, emptyDir, copy, readJSON, outputJSON, move, writeJson, pathExists, ensureDir, remove } from 'fs-extra/esm';
+import { readJsonSync, move, outputFile, emptyDir, copy, readJSON, outputJSON, writeJson, pathExists, ensureDir, remove } from 'fs-extra/esm';
 import { createHooks } from 'hookable';
 import process from 'node:process';
 import readline from 'node:readline';
 import util from 'node:util';
 import { isDebug, isCI, isWindows, isMacOS, isLinux } from 'std-env';
 import { p as parseRepoUrl, d as dateFormat, t as template, b as toArray, a as replaceInFile } from './zotero-plugin-scaffold.v8dJZZ-v.mjs';
-import { createReadStream, existsSync } from 'node:fs';
-import { readFile, writeFile, stat } from 'node:fs/promises';
-import { basename, dirname, join, resolve, extname } from 'node:path';
+import { dirname, basename, join, resolve, extname } from 'node:path';
 import AdmZip from 'adm-zip';
 import { build, context } from 'esbuild';
 import { glob, globSync } from 'tinyglobby';
 import { createHash } from 'node:crypto';
+import { createReadStream, existsSync } from 'node:fs';
+import { readFile, writeFile, stat } from 'node:fs/promises';
+import { parse, serialize, Transformer } from '@fluent/syntax';
 import { parseSync, printSync } from '@swc/core';
 import { execSync, spawn } from 'node:child_process';
 import { versionBump, ProgressEvent } from 'bumpp';
@@ -359,6 +360,192 @@ function generateHash(filePath, algorithm) {
   });
 }
 
+class Base {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  get logger() {
+    return this.ctx.logger;
+  }
+}
+
+async function buildLocale(dist, namespace, options) {
+  const ignores = toArray(options.ignore);
+  const localeNames = await getLocales(dist);
+  const messageManager = new MessageManager(ignores);
+  await Promise.all(localeNames.map(async (locale) => {
+    const paths = await glob(`${dist}/addon/locale/${locale}/**/*.ftl`);
+    await Promise.all(paths.map(async (path) => {
+      const fm = new FluentManager();
+      await fm.read(path);
+      messageManager.addMessages(locale, fm.getMessages());
+      if (options.prefixFluentMessages) {
+        fm.prefixMessages(namespace);
+        await fm.write(path);
+      }
+      if (options.prefixLocaleFiles) {
+        const newPath = `${dirname(path)}/${namespace}-${basename(path)}`;
+        await move(path, newPath);
+        logger.debug(`Renamed FTL: ${path} \u2192 ${newPath}`);
+      }
+    }));
+  }));
+  const htmlPaths = await glob([`${dist}/addon/**/*.xhtml`, `${dist}/addon/**/*.html`]);
+  await Promise.all(htmlPaths.map(async (htmlPath) => {
+    const content = await readFile(htmlPath, "utf-8");
+    const { processedContent, foundMessages } = processHTMLFile(
+      content,
+      namespace,
+      messageManager.getFTLMessages(),
+      ignores,
+      htmlPath
+    );
+    messageManager.addMessages("html", foundMessages);
+    if (options.prefixFluentMessages) {
+      await writeFile(htmlPath, processedContent);
+    }
+  }));
+  messageManager.validateMessages();
+}
+async function getLocales(dist) {
+  const localePaths = await glob(`${dist}/addon/locale/*`, { onlyDirectories: true });
+  return localePaths.map((p) => basename(p));
+}
+class FluentManager {
+  source;
+  resource;
+  messages = [];
+  constructor() {
+  }
+  // Parse Fluent source into an AST and extract messages
+  parse(source) {
+    this.source = source;
+    this.resource = parse(source, {});
+  }
+  // Read a file, parse its content, and extract messages
+  async read(path) {
+    const content = await readFile(path, "utf-8");
+    this.parse(content);
+  }
+  // Extract message IDs from the parsed resource
+  getMessages() {
+    if (!this.resource) {
+      throw new Error("Resource must be parsed first.");
+    }
+    this.messages.length = 0;
+    this.messages.push(
+      ...this.resource.body.filter((entry) => entry.type === "Message").map((message) => message.id.name)
+    );
+    return this.messages;
+  }
+  // Apply namespace prefix to message IDs in the resource
+  prefixMessages(namespace) {
+    if (!this.resource) {
+      throw new Error("Resource must be parsed before applying prefix.");
+    }
+    new FluentTransformer(namespace).genericVisit(this.resource);
+  }
+  // Serialize the resource back into a string
+  serialize() {
+    if (!this.resource) {
+      throw new Error("Resource not parsed. Cannot serialize.");
+    }
+    return serialize(this.resource, {});
+  }
+  // Write the serialized resource to a file
+  async write(path) {
+    const result = this.serialize();
+    if (result !== this.source)
+      await writeFile(path, this.serialize());
+  }
+}
+class FluentTransformer extends Transformer {
+  constructor(prefix) {
+    super();
+    this.prefix = prefix;
+  }
+  needsPrefix(name) {
+    return !!this.prefix && !name.startsWith(this.prefix);
+  }
+  visitMessage(node) {
+    if (this.needsPrefix(node.id.name)) {
+      node.id.name = `${this.prefix}-${node.id.name}`;
+    }
+    return this.genericVisit(node);
+  }
+  visitMessageReference(node) {
+    if (this.needsPrefix(node.id.name)) {
+      node.id.name = `${this.prefix}-${node.id.name}`;
+    }
+    return this.genericVisit(node);
+  }
+}
+class MessageManager {
+  ftlMessages = /* @__PURE__ */ new Map();
+  htmlMessages = /* @__PURE__ */ new Set();
+  ignores;
+  constructor(ignores) {
+    this.ignores = ignores;
+  }
+  // Add a set of messages (FTL or HTML) for a specific locale or for HTML globally
+  addMessages(target, messages) {
+    if (target === "html") {
+      messages.forEach((msg) => this.htmlMessages.add(msg));
+    } else {
+      let ftlLocaleMessages = this.ftlMessages.get(target);
+      if (!ftlLocaleMessages) {
+        ftlLocaleMessages = /* @__PURE__ */ new Set();
+        this.ftlMessages.set(target, ftlLocaleMessages);
+      }
+      messages.forEach((msg) => ftlLocaleMessages.add(msg));
+    }
+  }
+  validateMessages() {
+    this.htmlMessages.forEach((msg) => {
+      if (this.ignores.includes(msg))
+        return;
+      const missingLocales = [...this.ftlMessages.entries()].filter(([_, messages]) => !messages.has(msg)).map(([locale]) => locale);
+      if (missingLocales.length > 0)
+        logger.warn(`I10N id ${styleText.blue(msg)} missing in locale: ${missingLocales.join(", ")}`);
+    });
+  }
+  getFTLMessages() {
+    const allMessages = /* @__PURE__ */ new Set();
+    this.ftlMessages.forEach((messages) => messages.forEach((msg) => allMessages.add(msg)));
+    return allMessages;
+  }
+  // Get all FTL messages for a specific locale
+  getFTLMessagesByLocale(locale) {
+    return this.ftlMessages.get(locale) || /* @__PURE__ */ new Set();
+  }
+  // Get all HTML messages
+  getHTMLMessages() {
+    return this.htmlMessages;
+  }
+}
+function processHTMLFile(content, namespace, allMessages, ignores, filePath) {
+  const foundMessages = /* @__PURE__ */ new Set();
+  const L10N_PATTERN = new RegExp(`(data-l10n-id)="((?!${namespace})\\S*)"`, "g");
+  const processed = content.replace(L10N_PATTERN, (match, attr, id) => {
+    foundMessages.add(id);
+    if (ignores.includes(id)) {
+      logger.debug(`Skipped ignored ID: ${styleText.blue(id)} in ${styleText.gray(filePath)}`);
+      return match;
+    }
+    if (!allMessages.has(id)) {
+      logger.warn(`I10N id ${styleText.blue(id)} in path ${styleText.gray(filePath)} does not exist in any locale, skip renaming it.`);
+      return match;
+    }
+    return `${attr}="${namespace}-${id}"`;
+  });
+  return { processedContent: processed, foundMessages: [...foundMessages] };
+}
+
+function is32BitNumber(n) {
+  return Number.isInteger(n) && n >= -2147483648 && n <= 2147483647;
+}
+
 class PrefsManager {
   namespace;
   prefs = {};
@@ -580,6 +767,62 @@ class PrefsManager {
     return _prefs;
   }
 }
+
+async function buildPrefs(dist, options) {
+  const { dts, prefixPrefKeys, prefix } = options;
+  if (!prefixPrefKeys && !dts)
+    return;
+  const prefsFilePath = join(dist, "addon", "prefs.js");
+  if (!existsSync(prefsFilePath))
+    return;
+  const prefsManager = new PrefsManager("pref");
+  await prefsManager.read(prefsFilePath);
+  const prefsWithPrefix = prefsManager.getPrefsWithPrefix(prefix);
+  const prefsWithoutPrefix = prefsManager.getPrefsWithoutPrefix(prefix);
+  const prefs = prefsManager.getPrefs();
+  Object.entries(prefs).forEach(([key, value]) => {
+    if (typeof value === "number") {
+      if (!is32BitNumber(value)) {
+        logger.warn(`Pref key '${styleText.blue(key)}' is a number, but is more than 4 bytes, which can be problematic on some OS.`);
+      }
+    }
+  });
+  if (dts) {
+    const dtsContent = renderPluginPrefsDts(prefsWithoutPrefix);
+    await outputFile(dts, dtsContent, "utf-8");
+  }
+  if (prefixPrefKeys) {
+    prefsManager.clearPrefs();
+    prefsManager.setPrefs(prefsWithPrefix);
+    await prefsManager.write(prefsFilePath);
+  }
+  if (prefixPrefKeys) {
+    const HTML_PREFERENCE_PATTERN = /preference="(\S*)"/g;
+    const xhtmlPaths = await glob(`${dist}/addon/**/*.xhtml`);
+    await Promise.all(xhtmlPaths.map(async (path) => {
+      let content = await readFile(path, "utf-8");
+      const matchs = [...content.matchAll(HTML_PREFERENCE_PATTERN)];
+      for (const match of matchs) {
+        const [matched, key] = match;
+        if (key.startsWith(prefix)) {
+          logger.debug(`Pref key '${styleText.blue(key)}' is already starts with '${prefix}', skip prefixing it.`);
+          continue;
+        } else if (key.startsWith("extensions.")) {
+          logger.warn(`Pref key '${styleText.blue(key)}' in ${styleText.gray(path)} starts with 'extensions.' but not '${styleText.blue(prefix)}', skip prefixing it.`);
+          continue;
+        } else if (!(key in prefsWithPrefix) && !(key in prefsWithoutPrefix)) {
+          logger.warn(`Pref key '${styleText.blue(key)}' in ${styleText.gray(path)} is not found in prefs.js, skip prefixing it.`);
+          continue;
+        } else {
+          const prefixed = `${prefix}.${key}`;
+          logger.debug(`Pref key '${styleText.blue(key)}' in ${styleText.gray(path)} is prefixed to ${styleText.blue(prefixed)}.`);
+          content = content.replace(matched, `preference="${prefixed}"`);
+        }
+      }
+      await outputFile(path, content, "utf-8");
+    }));
+  }
+}
 function renderPluginPrefsDts(prefs) {
   return `// Generated by zotero-plugin-scaffold
 /* prettier-ignore */
@@ -599,16 +842,6 @@ declare namespace _ZoteroTypes {
 `;
 }
 
-class Base {
-  ctx;
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  get logger() {
-    return this.ctx.logger;
-  }
-}
-
 class Build extends Base {
   buildTime;
   isPreRelease;
@@ -711,119 +944,11 @@ class Build extends Base {
   }
   async prepareLocaleFiles() {
     const { dist, namespace, build } = this.ctx;
-    const ignores = toArray(build.fluent.ignore);
-    const FTL_MESSAGE_PATTERN = /^(?<message>[a-z]\S*)( *= *)(?<pattern>.*)$/gim;
-    const HTML_DATAI10NID_PATTERN = new RegExp(`(data-l10n-id)="((?!${namespace})\\S*)"`, "g");
-    const localePaths = await glob(`${dist}/addon/locale/*`, { onlyDirectories: true });
-    const localeNames = localePaths.map((locale) => basename(locale));
-    this.logger.debug(`Locale names:", ${localeNames}`);
-    const allMessages = /* @__PURE__ */ new Set();
-    const messagesByLocale = /* @__PURE__ */ new Map();
-    for (const localeName of localeNames) {
-      const localeMessages = /* @__PURE__ */ new Set();
-      const ftlPaths = await glob(`${dist}/addon/locale/${localeName}/**/*.ftl`);
-      await Promise.all(ftlPaths.map(async (ftlPath) => {
-        let ftlContent = await readFile(ftlPath, "utf-8");
-        const matches = [...ftlContent.matchAll(FTL_MESSAGE_PATTERN)];
-        for (const match of matches) {
-          const [matched, message, _pattern] = match;
-          if (message) {
-            localeMessages.add(message);
-            allMessages.add(message);
-            ftlContent = ftlContent.replace(new RegExp(`^${escapeRegExp(matched)}`, "gm"), `${namespace}-${matched}`);
-          }
-        }
-        if (build.fluent.prefixFluentMessages)
-          await writeFile(ftlPath, ftlContent);
-        if (build.fluent.prefixLocaleFiles === true) {
-          await move(ftlPath, `${dirname(ftlPath)}/${namespace}-${basename(ftlPath)}`);
-          this.logger.debug(`FTL file '${ftlPath}' is renamed to '${namespace}-${basename(ftlPath)}'.`);
-        }
-      }));
-      messagesByLocale.set(localeName, localeMessages);
-    }
-    const messagesInHTML = /* @__PURE__ */ new Set();
-    const htmlPaths = await glob([
-      `${dist}/addon/**/*.xhtml`,
-      `${dist}/addon/**/*.html`
-    ]);
-    await Promise.all(htmlPaths.map(async (htmlPath) => {
-      let htmlContent = await readFile(htmlPath, "utf-8");
-      const matches = [...htmlContent.matchAll(HTML_DATAI10NID_PATTERN)];
-      for (const match of matches) {
-        const [matched, attrKey, attrVal] = match;
-        if (ignores.includes(attrVal)) {
-          this.logger.debug(`HTML data-i10n-id ${attrVal} is in ignore list, skip to namespace`);
-          continue;
-        }
-        if (!allMessages.has(attrVal)) {
-          this.logger.warn(`HTML data-i10n-id '${styleText.blue(attrVal)}' in ${styleText.gray(htmlPath)} do not exist in any FTL message, skip to namespace it.`);
-          continue;
-        }
-        messagesInHTML.add(attrVal);
-        const namespacedAttr = `${namespace}-${attrVal}`;
-        htmlContent = htmlContent.replace(matched, `${attrKey}="${namespacedAttr}"`);
-        this.logger.debug(`HTML data-i10n-id '${styleText.blue(attrVal)}' in ${styleText.gray(htmlPath)} is namespaced to ${styleText.blue(namespacedAttr)}.`);
-      }
-      if (build.fluent.prefixFluentMessages)
-        await writeFile(htmlPath, htmlContent);
-    }));
-    messagesInHTML.forEach((messageInHTML) => {
-      if (ignores.includes(messageInHTML))
-        return;
-      const missingLocales = [...messagesByLocale.entries()].filter(([_, messages]) => !messages.has(messageInHTML)).map(([locale]) => locale);
-      if (missingLocales.length > 0) {
-        this.logger.warn(`HTML data-l10n-id '${styleText.blue(messageInHTML)}' is missing in locales: ${missingLocales.join(", ")}.`);
-      }
-    });
+    await buildLocale(dist, namespace, build.fluent);
   }
   async preparePrefs() {
-    const { dts, prefixPrefKeys, prefix } = this.ctx.build.prefs;
     const { dist } = this.ctx;
-    if (!prefixPrefKeys && !dts)
-      return;
-    const prefsFilePath = join(dist, "addon", "prefs.js");
-    if (!existsSync(prefsFilePath))
-      return;
-    const prefsManager = new PrefsManager("pref");
-    await prefsManager.read(prefsFilePath);
-    const prefsWithPrefix = prefsManager.getPrefsWithPrefix(prefix);
-    const prefsWithoutPrefix = prefsManager.getPrefsWithoutPrefix(prefix);
-    if (dts) {
-      const dtsContent = renderPluginPrefsDts(prefsWithoutPrefix);
-      await outputFile(dts, dtsContent, "utf-8");
-    }
-    if (prefixPrefKeys) {
-      prefsManager.clearPrefs();
-      prefsManager.setPrefs(prefsWithPrefix);
-      await prefsManager.write(prefsFilePath);
-    }
-    if (prefixPrefKeys) {
-      const HTML_PREFERENCE_PATTERN = /preference="(\S*)"/g;
-      const xhtmlPaths = await glob(`${dist}/addon/**/*.xhtml`);
-      await Promise.all(xhtmlPaths.map(async (path) => {
-        let content = await readFile(path, "utf-8");
-        const matchs = [...content.matchAll(HTML_PREFERENCE_PATTERN)];
-        for (const match of matchs) {
-          const [matched, key] = match;
-          if (key.startsWith(prefix)) {
-            this.logger.debug(`Pref key '${styleText.blue(key)}' is already starts with '${prefix}', skip prefixing it.`);
-            continue;
-          } else if (key.startsWith("extensions.")) {
-            this.logger.warn(`Pref key '${styleText.blue(key)}' in ${styleText.gray(path)} starts with 'extensions.' but not '${styleText.blue(prefix)}', skip prefixing it.`);
-            continue;
-          } else if (!(key in prefsWithPrefix) && !(key in prefsWithoutPrefix)) {
-            this.logger.warn(`Pref key '${styleText.blue(key)}' in ${styleText.gray(path)} is not found in prefs.js, skip prefixing it.`);
-            continue;
-          } else {
-            const prefixed = `${prefix}.${key}`;
-            this.logger.debug(`Pref key '${styleText.blue(key)}' in ${styleText.gray(path)} is prefixed to ${styleText.blue(prefixed)}.`);
-            content = content.replace(matched, `preference="${prefixed}"`);
-          }
-        }
-        await outputFile(path, content, "utf-8");
-      }));
-    }
+    await buildPrefs(dist, this.ctx.build.prefs);
   }
   esbuild() {
     const { dist, build: { esbuildOptions } } = this.ctx;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zotero-plugin-scaffold",
   "type": "module",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "A scaffold for Zotero plugin development.",
   "author": "northword",
   "license": "AGPL-3.0-or-later",
@@ -63,6 +63,7 @@
     }
   },
   "dependencies": {
+    "@fluent/syntax": "^0.19.0",
     "@swc/core": "^1.11.16",
     "adm-zip": "^0.5.16",
     "bumpp": "^10.1.0",