@vacantthinker/firefox-addon-framework-easy 2026.5.2212 → 2026.524.1751

package/src/browserRuntime.js

@@ -0,0 +1,61 @@
+import {tabOpCreate} from './opTab.js';
+import {browserNotificationCreate} from './browserNotification.js';
+
+export function browserRuntimeReload() {
+  browser.runtime.reload();
+}
+
+/**
+ *
+ * @param url{string}
+ */
+export async function browserRuntimeSetUninstallURL(
+    url = 'https://addons.mozilla.org/en-US/firefox/user/17783213/',
+) {
+  await browser.runtime.setUninstallURL(url);
+}
+
+/**
+ *
+ * @param doWhat{function}
+ */
+export function browserRuntimeOnUpdateAvailable(doWhat = null) {
+  browser.runtime.onUpdateAvailable.addListener(async (details) => {
+    if (doWhat) {
+      await doWhat(details);
+    }
+    else {
+      try {
+        let id = await browserNotificationCreate(
+            'There is a new version!',
+        );
+        browser.notifications.onClicked.addListener(async (notificationId) => {
+          if (notificationId === id) {
+            await tabOpCreate('https://addons.mozilla.org/en-US/firefox/user/17783213/');
+          }
+        });
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  });
+}
+
+/**
+ * @returns {browser._manifest.ExtensionID}
+ */
+export function browserRuntimeGeckoId() {
+  return browser.runtime.getManifest().browser_specific_settings.gecko.id;
+}
+
+/**
+ *
+ * @returns {Promise<browser.runtime.PlatformInfo>}
+ */
+export async function browserRuntimePlatformInfo() {
+  return await browser.runtime.getPlatformInfo();
+}
+
+export function browserRuntimeManifestVersion() {
+  return browser.runtime.getManifest().version;
+}

package/src/generate.js

@@ -0,0 +1,146 @@
+import {stoOpGet, stoOpSet} from './opStorage.js';
+
+/**
+ * this function can use when you use serviceUserSettings.js
+ *
+ *
+ * searchEngine: {
+ *     optionType: 'checkbox',
+ *     options: ['Searcher1', 'Searcher2'],
+ *     selected: ['Searcher1', 'Searcher2'],
+ *     queryTitle: {
+ *       'Searcher1': 'https://y2down.cc/',
+ *       'Searcher2': 'https://ssyou.online',
+ *     },
+ *   },
+ *   videoQuality: {
+ *     options: ['360', '480', '720', '1080', '1440', '2160'],
+ *     selected: '720',
+ *   },
+ * @param userSettings{{}}
+ * @param radioItemClickFn{function}
+ * @returns {HTMLFieldSetElement[]}
+ */
+export function generateHtmlByUserSettings(
+    userSettings,
+    radioItemClickFn,
+) {
+
+  // todo generate html by data
+  return Object.keys(userSettings).map(
+      /**
+       *
+       * @param k{string}
+       * @returns {HTMLFieldSetElement}
+       */
+      (k) => {
+        /**
+         * @type{{optionType:'checkbox'|'radio',options:[string], selected: string, }}
+         */
+        let v = userSettings[k];
+
+        let optionType = v.optionType;
+        if (optionType === undefined) {
+          optionType = 'radio';
+        }
+
+        /**
+         *
+         * @type {string[]}
+         */
+        let options = v.options;
+        // /**
+        //  *
+        //  * @type {string}
+        //  */
+        // let selected = v.selected;
+
+        let eleWrap = document.createElement('fieldset');
+
+        let eleTitle = document.createElement('legend');
+        eleTitle.textContent = k;
+        eleWrap.append(eleTitle);
+
+        // console.info(`optionType=${optionType} options=${options}`)
+        options.map(
+            /**
+             *
+             * @param option{string}
+             */
+            option => {
+
+              let eleLabel = document.createElement('label');
+              eleLabel.textContent = option;
+
+              let eleInput = document.createElement('input');
+              eleInput.name = k;
+              eleInput.type = optionType;
+              eleInput.value = option;
+
+              if (optionType === 'checkbox') {
+                stoOpGet(k).then(
+                    /**
+                     *
+                     * @param v{string}
+                     */
+                    v => {
+                      let strings = Array.from(v);
+                      console.info(`strings=${strings} option=${option}`);
+                      const set = new Set(strings);
+                      eleInput.checked = set.has(option);
+
+                    });
+              }
+              else if (optionType === 'radio') {
+                stoOpGet(k).then(
+                    /**
+                     *
+                     * @param v{string}
+                     */
+                    v => {
+                      if (option === v) {
+                        eleInput.checked = true;
+                      }
+                    });
+              }
+
+              eleLabel.append(eleInput);
+
+              if (optionType === 'checkbox') {
+                eleInput.addEventListener('change', async () => {
+                  let textCurrent = eleLabel.textContent;
+
+                  let optionsCurrent = await stoOpGet(k);
+                  console.info('optionsCurrent=', optionsCurrent);
+
+                  let optionsArr = Array.from(optionsCurrent);
+                  let set = new Set(optionsArr);
+                  if (eleInput.checked) {
+                    set.add(textCurrent);
+                  }
+                  else {
+                    set.delete(textCurrent);
+                  }
+
+                  let valueNew = Array.from(set);
+                  console.info(
+                      `k=${k} text=${textCurrent} eleInput.checked=${eleInput.checked} valueNew=${valueNew}`);
+                  await stoOpSet(k, valueNew);
+
+                });
+              }
+              else if (optionType === 'radio') {
+                eleLabel.onclick = function() {
+                  stoOpSet(k, option).then(() => {
+                    console.info(`k=${k} option=${option}`);
+                    radioItemClickFn(k, option);
+                  });
+                };
+              }
+              return eleLabel;
+
+            }).forEach(ele => eleWrap.append(ele));
+
+        return eleWrap;
+      });
+}

package/src/opStorage.js

@@ -0,0 +1,99 @@
+/**
+ *
+ * @param k{string}
+ * @returns {Promise<boolean>}
+ */
+export async function stoOpCheck(k) {
+  try {
+    let key = k.toString();
+
+    let objGet = await browser.storage.local.get(key);
+    let b = objGet.hasOwnProperty(key);
+    console.info(`key=${key} exists ${b}`);
+    return b;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ *
+ * @param k{string}
+ * @returns {Promise<any|null>}
+ */
+export async function stoOpGet(k) {
+  try {
+    let key = k.toString();
+    let objGet = await browser.storage.local.get(key);
+    let v = objGet[key];
+    console.info(`key=${k} value=\n`, v);
+    return v;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ *
+ * @returns {Promise<{[p: string]: any}|null>}
+ */
+export async function stoOpGetAll() {
+  try {
+    return await browser.storage.local.get();
+  } catch (e) {
+    console.error(e);
+    return null;
+  }
+}
+
+/**
+ *
+ * @param k{string}
+ * @returns {Promise<string[]|null>}
+ */
+export async function stoOpQueryStartWith(k) {
+  try {
+    let objAll = await browser.storage.local.get();
+    let keys = Object.keys(objAll);
+    return keys.filter(value => value.startsWith(k.toString()));
+  } catch (e) {
+    console.error(e);
+    return null;
+  }
+}
+
+/**
+ *
+ * @param k{string}
+ * @param v{any}
+ * @returns {Promise<void>}
+ */
+export async function stoOpSet(k, v) {
+  let key = k.toString();
+
+  let objNew = {};
+  objNew[key] = v;
+  await browser.storage.local.set(objNew);
+}
+
+/**
+ *
+ * @param k{string}
+ * @returns {Promise<void>}
+ */
+export async function stoOpRem(k) {
+  try {
+    let key = k.toString();
+    await browser.storage.local.remove(key);
+  } catch (e) {
+  }
+}
+
+/**
+ *
+ * @param k{string}
+ * @returns {Promise<void>}
+ */
+export async function stoOpSetNull(k) {
+  await stoOpSet(k, null);
+}

package/src/opTab.js

@@ -0,0 +1,178 @@
+/**
+ *
+ * @param tabId{number}
+ * @return {Promise<browser.tabs.Tab>}
+ */
+export async function tabOpGet(tabId) {
+  return await browser.tabs.get(tabId);
+}
+
+/**
+ *
+ * @returns {Promise<browser.tabs.Tab[]>}
+ */
+export async function tabOpQueryAll() {
+  return await browser.tabs.query({});
+}
+
+/**
+ *
+ * @param urlQuery{string}
+ * @returns {Promise<number[]>}
+ */
+export async function tabOpQueryUrl(urlQuery) {
+  let tabs = await browser.tabs.query({url: urlQuery});
+  return tabs.map(v => v.id);
+}
+
+/**
+ *
+ * @param urlQuery{string}
+ * @returns {Promise<void>}
+ */
+export async function tabOpQueryUrlThenRemove(urlQuery) {
+  let ids = await tabOpQueryUrl(urlQuery);
+  ids.map(id => tabOpRemove(id));
+}
+
+/**
+ *
+ * @param tabId{number}
+ * @returns {Promise<void>}
+ */
+export async function tabOpReload(tabId) {
+  await browser.tabs.reload(tabId);
+}
+
+/**
+ * {active: false, muted: true}
+ * Creates a normal tab using either a URL string or a properties object.
+ * @param urlOrArgs{string|browser.tabs._CreateCreateProperties}
+ * @returns {Promise<(browser.tabs.Tab & {tabId: number})>}
+ */
+export async function tabOpCreate(urlOrArgs) {
+  try {
+    /**
+     * @type {browser.tabs._CreateCreateProperties}
+     */
+    let source = {active: false, muted: true};
+    // If it's a string, wrap it in an object
+    if (typeof urlOrArgs === 'string') {
+      let tab = await browser.tabs.create(Object.assign(
+          {url: urlOrArgs}, source,
+      ));
+      return tabOpEnhance(tab);
+    }
+    Object.assign(urlOrArgs, source);
+    let tab = await browser.tabs.create(urlOrArgs);
+    return tabOpEnhance(tab)
+  } catch (e) {
+  }
+}
+
+/**
+ * Creates a normal tab using either a URL string or a properties object.
+ *
+ * @param {string|browser.tabs._CreateCreateProperties} urlOrArgs
+ * @returns {Promise<(browser.tabs.Tab & {tabId: number})>}
+ */
+export async function tabOpCreateNormal(urlOrArgs) {
+  // If it's a string, wrap it in an object
+  if (typeof urlOrArgs === 'string') {
+    let tab = await browser.tabs.create({url: urlOrArgs});
+    return tabOpEnhance(tab)
+  }
+
+  // Otherwise, assume it is already a properties object
+  let tab = await browser.tabs.create(urlOrArgs);
+  return tabOpEnhance(tab)
+}
+
+/**
+ *
+ * @param tabId{number}
+ * @returns {Promise<void>}
+ */
+export async function tabOpRemove(tabId) {
+  try {
+    await browser.tabs.remove(tabId);
+  } catch (e) {
+    console.error(e);
+  }
+}
+
+/**
+ *
+ * @param tabId{number}
+ * @returns {Promise<void>}
+ */
+export async function tabOpHide(tabId) {
+  try {
+    await browser.tabs.hide(tabId);
+  } catch (e) {
+    console.error(e);
+  }
+}
+
+/**
+ * Creates a normal tab using either a URL string or a properties object.
+ *
+ * @param tab{browser.tabs.Tab}
+ * @returns {Promise<(browser.tabs.Tab & {tabId: number})>}
+ */
+async function tabOpEnhance(tab) {
+  return Object.assign(tab, {tabId: tab.id});
+}
+
+/**
+ *
+ * @param {number}tabId
+ * @param {browser.tabs._UpdateUpdateProperties}updateProperties
+ * @returns {Promise<browser.tabs.Tab&{tabId: number}>}
+ */
+export async function tabOpUpdate(tabId, updateProperties) {
+  let tab = await browser.tabs.update(tabId, updateProperties);
+  return tabOpEnhance(tab);
+}
+
+/**
+ * active: false, muted: true
+ * @param tabId{number}
+ * @returns {Promise<browser.tabs.Tab&{tabId: number}>}
+ */
+export async function tabOpUpdateActiveFalse(tabId) {
+  return await tabOpUpdate(tabId, {active: false, muted: true});
+}
+
+/**
+ * @param tabId
+ */
+export async function tabOpFocus(tabId) {
+  let tab = await tabOpGet(tabId);
+  let windowId = tab.windowId;
+  await browser.windows.update(windowId, {focused: true});
+
+  let updateProperties = {active: true, highlighted: true};
+  let tabUpdated = await tabOpUpdate(tabId, updateProperties);
+  return tabOpEnhance(tabUpdated)
+}
+
+/**
+ *
+ * @param{number} tabId
+ * @param {string}code
+ * @returns {Promise<void>}
+ */
+export async function tabOpInsertCssCode(tabId, code) {
+  await browser.tabs.insertCSS(tabId, {code});
+}
+
+/**
+ *
+ * @param{number} tabId
+ * @param {string}code
+ * @returns {Promise<void>}
+ */
+export async function tabOpRemoveCssCode(tabId, code) {
+  await browser.tabs.removeCSS(tabId, {code});
+}

package/src/serviceFetch.js

@@ -0,0 +1,31 @@
+/**
+ *
+ * @param serverUrl{string}
+ * @param message{{}}
+ * @param handleError{function}
+ * @returns {Promise<Response>}
+ */
+export async function servicePostJson(
+    serverUrl,
+    message,
+    handleError,
+) {
+
+  try {
+    let body = JSON.stringify(message);
+    const fetchResponse = await fetch(serverUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: body,
+    });
+
+    console.info('fetchResponse');
+    console.info(fetchResponse);
+    return fetchResponse;
+  } catch (e) {
+    handleError(e);
+  }
+
+}

package/src/serviceGet.js

@@ -0,0 +1,34 @@
+/**
+ *
+ * @param url{string}
+ * @returns {string}
+ */
+export function serviceGetDomainByUrl(url) {
+  let urlWrap = new URL(url);
+  let domain = urlWrap.hostname;
+  console.info('serviceGetDomainByUrl()', `domain=\n`,
+      domain);
+
+  return domain;
+}
+
+/**
+ * eg 2222_12_25_11h_47m_24s_302
+ * @return {string}
+ */
+export function serviceGetCurrentDateYYYYMMDDHHMMSS() {
+  let date = new Date();
+  let m = [
+    [date.getFullYear(), ''].join(''),
+    [date.getMonth() + 1, ''].join(''),
+    [date.getDate(), ''].join(''),
+
+    [date.getHours(), 'h'].join(''),
+    [date.getMinutes(), 'm'].join(''),
+    [date.getSeconds(), 's'].join(''),
+    date.getMilliseconds(),
+  ];
+  let r = m.join('_');
+  return r;
+}
+

package/src/serviceOpContent.js

@@ -0,0 +1,48 @@
+
+/**
+ *
+ * @param{string} content
+ */
+export function serviceCopyContentToClipboard(content) {
+  window.navigator.clipboard.writeText(content).then(r => null);
+}
+
+/**
+ * eg: fnName('this is content', 'this is a filename without ext', 'txt')
+ * @param {string} content
+ * @param {string} filename eg: abc
+ * @param {string} ext txt json cmd js ...
+ */
+export function serviceSaveContentToLocal(content, filename, ext = 'txt') {
+  const eleBtn = document.createElement('button');
+  eleBtn.addEventListener(
+      'click',
+      function() {
+        const eleA = document.createElement('a');
+        let type = 'text/plain';
+        // let type = 'application/json';
+
+        const file = new Blob([content], {type});
+        eleA.href = URL.createObjectURL(file);
+        eleA.download = [filename, ext].join('.');
+        eleA.click();
+        URL.revokeObjectURL(eleA.href);
+      },
+      false,
+  );
+  eleBtn.click();
+  // eleBtn.previousElementSibling
+}
+
+/**
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+export function serviceRemoveIllegalWord(value) {
+  let searchValue = /[\/\\\[\]\-"『』<>›:：；❗”“'|丨｜⦇⦈?？!！「」【】─\(\)（）《》*#$@&%、,，。+·•]/g;
+  let name0 = value.trim().split(/\r?\n/).shift();
+  let name1 = name0.replace(searchValue, ' ');
+  let name2 = name1.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, ' ');
+  return name2;
+}

package/src/servicePureVideolink.js

@@ -0,0 +1,24 @@
+/**
+ *
+ * @param {string}videolinkOrigin
+ * @returns {{
+ *      videolink: string,
+ *      vid: string
+ *
+ *      }|null}
+ */
+export function servicePureVideolinkYTB(videolinkOrigin) {
+  if (!videolinkOrigin) {
+    return null;
+  }
+
+  const u = new URL(videolinkOrigin);
+  let vid = u.searchParams.get('v');
+
+  let searchValue = '/shorts/';
+  if (u.pathname.startsWith(searchValue)) {
+    vid = u.pathname.replace(searchValue, '');
+  }
+  let videolink = `https://www.youtube.com/watch?v=${vid}`;
+  return {videolink, vid};
+}