addonova 1.0.0

package/template/tasks/task.js

@@ -0,0 +1,60 @@
+import {log} from './utils.js';
+import watch from './watch.js';
+
+class Task {
+    constructor(name, run) {
+        this.name = name;
+        this._run = run;
+    }
+
+    addWatcher(files, onChange) {
+        this._watchFiles = files;
+        this._onChange = onChange;
+        return this;
+    }
+
+    async _measureTime(fn) {
+        const start = Date.now();
+        await fn();
+        const end = Date.now();
+        log(`${this.name} (${(end - start).toFixed(0)}ms)`);
+    }
+
+    async run(options) {
+        await this._measureTime(
+            () => this._run(options)
+        );
+    }
+
+    async watch(platforms, isDebug) {
+        if (!this._watchFiles || !this._onChange) {
+            return;
+        }
+
+        const watcher = watch({
+            files: typeof this._watchFiles === 'function' ?
+                await this._watchFiles() :
+                this._watchFiles,
+            onChange: async (files) => {
+                await this._measureTime(
+                    () => this._onChange(files, watcher, platforms, isDebug)
+                );
+            },
+        });
+    }
+}
+
+export function createTask(name, run) {
+    return new Task(name, run);
+}
+
+export async function runTasks(tasks, options) {
+    for (const task of tasks) {
+        try {
+            await task.run(options);
+        } catch (err) {
+            log.error(`${task.name} error\n${err.stack || err}`);
+            throw err;
+        }
+    }
+}

package/template/tasks/translate.js

@@ -0,0 +1,255 @@
+import fs from 'node:fs/promises';
+import * as readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import {readFile, writeFile, httpsRequest, timeout} from './utils.js';
+
+
+const LOCALES_ROOT = 'src/_locales';
+
+function toMessageId(message) {
+  if (typeof message !== 'string') return '';
+
+  return message
+    .trim()
+    .split(/\s+/)      // split by any whitespace
+    .slice(0, 3)       // only first 3 words
+    .map(word =>
+      word
+        .replace(/[^\w]/g, '') // remove special characters
+        .toLowerCase()
+    )
+    .filter(Boolean)   // remove empty results
+    .join('_');
+}
+
+async function getSupportedLocales() {
+    const fileList = await fs.readdir(LOCALES_ROOT);
+
+    const locales = [];
+
+    for (const file of fileList) {
+        if (file.endsWith('.i18n')) {
+            const locale = file.substring(0, file.lastIndexOf('.i18n'));
+            locales.push(locale);
+        }
+    }
+
+    return locales;
+}
+
+function stringifyLocale(messages) {
+    const lines = [];
+    messages.forEach((message, id) => {
+        lines.push(`@${id}`);
+        const hasDoubleNewLines = /\n\n/.test(message);
+        message.split('\n')
+            .filter((line) => line.trim())
+            .forEach((line, index, filtered) => {
+                lines.push(line);
+                if (hasDoubleNewLines && index < filtered.length - 1) {
+                    lines.push('');
+                }
+            });
+        lines.push('');
+    });
+    return lines.join('\n');
+}
+
+function parseLocale(content) {
+    const messages = new Map();
+    const lines = content.split('\n');
+    let id = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith('@')) {
+            id = line.substring(1);
+        } else if (line.startsWith('#')) {
+            // Ignore
+        } else if (messages.has(id)) {
+            const message = messages.get(id);
+            messages.set(id, `${message}\n${line}`);
+        } else {
+            messages.set(id, line);
+        }
+    }
+    messages.forEach((value, id) => {
+        messages.set(id, value.trim());
+    });
+    return messages;
+}
+
+async function translate(text, lang) {
+    const url = new URL('https://translate.googleapis.com/translate_a/single');
+    url.search = (new URLSearchParams({
+        client: 'gtx',
+        sl: 'en-US',
+        tl: lang,
+        dt: 't',
+        dj: '1',
+        q: text,
+    })).toString();
+    const response = await httpsRequest(url.toString());
+    const translation = JSON.parse(response.text());
+    return translation.sentences.map((s) => s.trans).join('\n').replaceAll(/\n+/g, '\n');
+}
+
+async function deleteMessage(messageId) {
+  const supportedLocales = await getSupportedLocales();
+
+  if (!messageId || !messageId.trim()) {
+    console.log('⚠ Message key cannot be empty.');
+    return;
+  }
+
+  const id = messageId.trim();
+  let foundAnywhere = false;
+
+  for (const locale of supportedLocales) {
+    const locFile = `${LOCALES_ROOT}/${locale}.i18n`;
+    const locContent = await readFile(locFile);
+    const locMessages = parseLocale(locContent);
+
+    if (!locMessages.has(id)) {
+      continue;
+    }
+
+    locMessages.delete(id);
+    const output = stringifyLocale(locMessages);
+    await writeFile(locFile, output);
+
+    console.log(`✔ Removed from ${locale}.i18n`);
+    foundAnywhere = true;
+  }
+
+  if (!foundAnywhere) {
+    console.log('⚠ Message key not found in any locale.');
+  } else {
+    console.log('🗑 Deletion completed.');
+  }
+}
+
+
+async function translateEnMessage(message, customId) {
+  console.log(`Translating message: ${message}`);
+
+  const supportedLocales = await getSupportedLocales();
+  const messageId = customId && customId.trim()
+    ? customId.trim()
+    : toMessageId(message);
+
+  // 1️⃣ Update English first
+  const enFile = `${LOCALES_ROOT}/en.i18n`;
+  const enContent = await readFile(enFile);
+  const enMessages = parseLocale(enContent);
+
+  if (!enMessages.has(messageId)) {
+    enMessages.set(messageId, message);
+    const output = stringifyLocale(enMessages);
+    await writeFile(enFile, output);
+    console.log(`en: ${message}`);
+  } else {
+    console.log('Message already exists in en.i18n');
+  }
+
+  // 2️⃣ Translate other locales
+  for (const locale of supportedLocales) {
+    if (locale === 'en') continue;
+
+    await timeout(1000);
+
+    const locFile = `${LOCALES_ROOT}/${locale}.i18n`;
+    const locContent = await readFile(locFile);
+    const locMessages = parseLocale(locContent);
+
+    if (locMessages.has(messageId)) {
+      console.log(`Already exists in: ${locFile}`);
+      continue;
+    }
+
+    const translated = await translate(message, locale);
+    locMessages.set(messageId, translated);
+
+    const output = stringifyLocale(locMessages);
+    await writeFile(locFile, output);
+
+    console.log(`${locale}: ${translated}`);
+  }
+}
+
+async function main() {
+  const rl = readline.createInterface({ input, output });
+
+  try {
+    while (true) {
+      console.log('\n=== Message Manager ===');
+      console.log('[1] Add new message');
+      console.log('[2] Delete message');
+      console.log('[0] Exit');
+
+      const choice = (await rl.question('Select option: '))
+        .trim()
+        .toLowerCase();
+
+      switch (choice) {
+        case '1': {
+          const newMessage = (await rl.question('Enter new message: '))
+            .trim();
+
+          if (!newMessage) {
+            console.log('⚠ Message cannot be empty.');
+            break;
+          }
+
+          const newMessageId = (await rl.question(
+            'Enter new message key (leave empty for auto-generation): '
+          )).trim();
+
+          await translateEnMessage(
+            newMessage,
+            newMessageId || undefined
+          );
+
+          console.log('✔ Message processed successfully.');
+          break;
+        }
+
+        case '2': {
+            const messageId = (await rl.question(
+                'Enter message key to delete: '
+            )).trim();
+
+            if (!messageId) {
+                console.log('⚠ Message key cannot be empty.');
+                break;
+            }
+
+            const confirm = (await rl.question(
+                `Are you sure you want to delete "${messageId}" from all locales? (y/n): `
+            ))
+                .trim()
+                .toLowerCase();
+
+            if (confirm !== 'y') {
+                console.log('Deletion cancelled.');
+                break;
+            }
+
+            await deleteMessage(messageId);
+            break;
+        }
+
+        case '0':
+        case 'exit': {
+          console.log('Exiting...');
+          return;
+        }
+
+        default: {
+          console.log('Invalid selection. Please try again.');
+        }
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}main();

package/template/tasks/utils.js

@@ -0,0 +1,134 @@
+import {accessSync, existsSync} from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import https from 'node:https';
+import { pathToFileURL } from 'node:url';
+import {absolutePath} from './paths.js';
+
+
+const colors = Object.entries({
+    gray: '\x1b[90m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+}).reduce((map, [key, value]) => Object.assign(map, {[key]: (text) => `${value}${text}\x1b[0m`}), {});
+
+export function logWithTime(text) {
+    const now = new Date();
+    const hours = now.getHours();
+    const minutes = now.getMinutes();
+    const seconds = now.getSeconds();
+    const leftpad = (/** @type {number} */n) => String(n).padStart(2, '0');
+    return console.log(`${colors.gray([hours, minutes, seconds].map(leftpad).join(':'))} ${text}`);
+}
+
+export const log = Object.assign((text) => logWithTime(text), {
+    ok: (text) => logWithTime(colors.green(text)),
+    warn: (text) => logWithTime(colors.yellow(text)),
+    error: (text) => logWithTime(colors.red(text)),
+});
+
+export async function pathExists(dest) {
+    try {
+        accessSync(dest);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export async function mkDirIfMissing(dest) {
+    const dir = path.dirname(dest);
+    if (!(await pathExists(dir))) {
+        await fs.mkdir(dir, {recursive: true});
+    }
+}
+
+export async function readFile(src, encoding = 'utf8') {
+    return await fs.readFile(src, encoding);
+}
+
+export async function writeFile(dest, content, encoding = 'utf8') {
+    await mkDirIfMissing(dest);
+    await fs.writeFile(dest, content, encoding);
+}
+
+export async function readJSON(path) {
+    const file = await readFile(path);
+    return JSON.parse(file);
+}
+
+export async function writeJSON(dest, content, space = 4) {
+    const string = JSON.stringify(content, null, space);
+    return await writeFile(dest, string);
+}
+
+export async function getConfig(platform) {
+    const config = {};
+    const targetConfigPath = path.resolve(`config/${platform}.js`);
+    if (existsSync(targetConfigPath)) {
+        const targetConfig = await import(
+            pathToFileURL(targetConfigPath).href
+        );
+        Object.assign(config, targetConfig.default ?? targetConfig);
+    }
+    return config;
+}
+
+export async function getAllFiles(folderPath){
+  const {globby} = await import('globby');
+    return await globby(folderPath);
+}
+
+export async function removeFolder(dir) {
+    if (await pathExists(dir)) {
+        await fs.rm(dir, {recursive: true});
+    }
+}
+
+export async function createFolder(dir) {
+    if (!(await pathExists(dir))) {
+        await fs.mkdir(dir, {recursive: true});
+    }
+}
+
+export async function copyFile(src, dest) {
+    await mkDirIfMissing(dest);
+    await fs.copyFile(src, dest);
+}
+
+export async function fileExistsInConfig(config, absoluteFilePath) {
+    const normalizedTarget = absolutePath(absoluteFilePath);
+    for (const [dest, src] of Object.entries(config)) {
+        for (const file of src) {
+            const relativePath = absolutePath(file);
+            // console.log(`Checking if ${relativePath} == ${normalizedTarget} or ${absoluteFilePath}`);
+            if (relativePath == normalizedTarget || relativePath == absoluteFilePath) {
+                return JSON.parse(`{"${dest}":["${file}"]}`);
+            }
+        }
+    }
+    return false;
+}
+
+export function timeout(delay) {
+    return new Promise((resolve) => setTimeout(resolve, delay));
+}
+
+export function httpsRequest(url) {
+    return new Promise((resolve) => {
+        const data = [];
+        https.get(url, (response) => {
+            response
+                .on('data', (chunk) => data.push(chunk))
+                .on('end', () => {
+                    const buffer = Buffer.concat(data);
+                    resolve({
+                        buffer: () => buffer,
+                        text: (encoding = 'utf8') => buffer.toString(encoding),
+                        type: () => response.headers['content-type'] || '',
+                    });
+                });
+        });
+    });
+}

package/template/tasks/watch.js

@@ -0,0 +1,46 @@
+import {watch as chokidarWatch} from 'chokidar';
+
+import {log} from './utils.js';
+
+const DEBOUNCE = 200;
+
+function watch(options) {
+    const queue = new Set();
+    let timeoutId = null;
+
+    function onChange(path) {
+        queue.add(path);
+
+        if (timeoutId !== null) {
+            return;
+        }
+
+        timeoutId = setTimeout(async () => {
+            timeoutId = null;
+            try {
+                const changedFiles = Array.from(queue).sort();
+                log.ok(`🔄 Files changed:${changedFiles.map((path) => `\n${path}`)}`);
+                queue.clear();
+                await options.onChange(changedFiles);
+            } catch (err) {
+                log.error(err);
+            }
+        }, DEBOUNCE);
+    }
+
+    const watcher = chokidarWatch(options.files, {ignoreInitial: true})
+        .on('add', onChange)
+        .on('change', onChange)
+        .on('unlink', onChange);
+
+    function stop() {
+        watcher.close();
+    }
+
+    process.on('exit', stop);
+    process.on('SIGINT', stop);
+
+    return watcher;
+}
+
+export default watch;

package/template/tasks/zip.js

@@ -0,0 +1,66 @@
+import {exec} from 'node:child_process';
+import fs from 'node:fs';
+
+import yazl from 'yazl';
+
+import {getDestDir, absolutePath} from './paths.js';
+import {createTask} from './task.js';
+
+import {getAllFiles, getConfig, readJSON} from './utils.js';
+
+function archiveFiles({files, dest, cwd, date, mode}) {
+    return new Promise((resolve) => {
+        const archive = new yazl.ZipFile();
+        files.sort();
+        files.forEach((file) => archive.addFile(
+            file,
+            file.startsWith(`${cwd}/`) ? file.substring(cwd.length + 1) : file,
+            {mtime: date, mode}
+        ));
+        const writeStream = fs.createWriteStream(dest);
+        archive.outputStream.pipe(writeStream).on('close', resolve);
+        archive.end();
+    });
+}
+
+async function getLastCommitTime() {
+    return new Promise((resolve) =>
+    exec('git log -1 --format=%ct', (_, stdout) => resolve(new Date(
+        Math.max(0, Number(stdout) + (new Date()).getTimezoneOffset() * 60) * 1000
+    ))));
+}
+
+async function archiveDirectory({dir, dest, date, mode}) {
+    const files = await getAllFiles(`${dir}/**/*.*`);
+    await archiveFiles({files, dest, cwd: dir, date, mode});
+}
+
+
+async function zip({platforms, isDebug, version}) {
+    if (isDebug) {
+        throw new Error('zip task does not support debug builds');
+    }
+    version = version ? `-${version}` : '';
+    const releaseDir = 'build/release';
+    const promises = [];
+    const date = await getLastCommitTime();
+    const xpiPlatforms = ["firefox", "thunderbird"];
+    for (const platform of platforms) {
+        const config = await getConfig(platform);
+        if (config && Object.keys(config).length != 0){
+            const packageJSON = await readJSON(absolutePath("package.json"));
+            const format = xpiPlatforms.includes(platform) ? 'xpi' : 'zip';
+            const dest = `${releaseDir}/${packageJSON.name}-${platform}${version}.${format}`;
+            promises.push(archiveDirectory({
+                dir: getDestDir({isDebug, platform}),
+                dest,
+                date,
+                mode: 0o644
+            }));
+            await Promise.all(promises);
+        }
+    }
+}
+
+const zipTask = createTask('zip', zip,);
+export default zipTask;

package/template/tools/json2i18n.js

@@ -0,0 +1,33 @@
+import { mkdirSync, readdirSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+const localesDir = join(__dirname, "_locales");
+const outputDir = join(__dirname, "output", "_locales");
+
+mkdirSync(outputDir, { recursive: true });
+
+console.log("Output directory ready.");
+
+const languages = readdirSync(localesDir);
+
+languages.forEach((lang) => {
+  const messagesPath = join(localesDir, lang, "messages.json");
+
+  if (!existsSync(messagesPath)) return;
+
+  const input = JSON.parse(readFileSync(messagesPath, "utf8"));
+
+  let output = "";
+
+  for (const key in input) {
+    output += `@${key}\n`;
+    output += `${input[key].message}\n\n`;
+  }
+
+  const outputPath = join(outputDir, `${lang}.i18n`);
+  writeFileSync(outputPath, output);
+
+  console.log(`${lang}.i18n created`);
+});
+
+console.log("All conversions completed.");