@vacantthinker/firefox-addon-framework-easy 2026.5.2205 → 2026.5.2207

package/index.js

@@ -1,4 +1,10 @@
 export * from './src/baseService.js'
 export * from './src/baseRuntimeSetup.js'
+
+
 export * from './src/baseOp.js'
+export * from './src/baseOpTab.js'
+export * from './src/baseOpStorage.js'
+
+
 export * from './src/baseORM.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vacantthinker/firefox-addon-framework-easy",
-  "version": "2026.5.2205",
+  "version": "2026.5.2207",
   "description": "",
   "main": "index.js",
   "publishConfig": {
@@ -8,6 +8,8 @@
   },
   "scripts": {
     "npm_install": "npm install",
+    "git_acp": "git add . && git commit -m 'update' && git push",
+    "npm_publish": "npm publish",
     "webpack": "webpack",
     "webpack_pack": "webpack && node _zipit.js"
   },

package/src/baseORM.js

@@ -1,119 +1,228 @@
-import {
-  stoOpCheck,
-  stoOpGet,
-  stoOpQuery_startsWith,
-  stoOpRem,
-  stoOpSet
-} from "./baseOp.js";
+import {stoOpCheck, stoOpGet, stoOpQuery_startsWith, stoOpRem, stoOpSet} from "./baseOp.js";
+
 
 /**
  * eg:
  *
- * "domain www.abcdefg.com":{
+ * "domain ://abcdefg.com":{
  *   "keyAAA": "valueBBB"
  * }
- *
- * @returns {{getALLDomainKey: function(): Promise<string[]>, getALLDomainMap: function(): Promise<{domainList: *, domainKeyValueMap: {}}>, getDomain: function(string): Promise<{}>, updateDomainValueByOneKeyValue: function(string, string, string): Promise<{}>, clearThisDomain: function(*): Promise<{}>}}
  */
-export function baseORM() {
+export class BaseORM {
+    // Private class fields for encapsulation
+    #keyPrefix = `domain `;
+    #domainDefaultValue = {};
+
+    // Private helper method to generate the prefix key
+    #domainKey(k) {
+        return `${this.#keyPrefix}${k}`;
+    }
+
+    /**
+     * check domain exists, return true/false
+     * @param {string} domain
+     * @return {Promise<boolean>}
+     */
+    async #checkDomain(domain) {
+        return await stoOpCheck(this.#domainKey(domain));
+    }
+
+    /**
+     * @param {string} domain
+     * @return {Promise<void>}
+     */
+    async #addDomain(domain) {
+        await stoOpSet(this.#domainKey(domain), this.#domainDefaultValue);
+    }
+
+    /**
+     * @param {string} domain
+     * @return {Promise<void>}
+     */
+    async #removeDomain(domain) {
+        await stoOpRem(this.#domainKey(domain));
+    }
+
+    /**
+     * @param {string} domain
+     * @param {*} valueNew
+     * @return {Promise<void>}
+     */
+    async #updateDomain(domain, valueNew) {
+        await stoOpSet(this.#domainKey(domain), valueNew);
+    }
 
-  let keyPrefix = `domain `;
-  const domainKey = (k) => `${keyPrefix}${k}`;
-  const domainDefaultValue = {};
-
-  /**
-   * check domain exists, return true/false
-   * @param domain{string}
-   * @return {Promise<boolean>}
-   */
-  async function checkDomain(domain) {
-    return await stoOpCheck(domainKey(domain));
-  }
-
-  /**
-   * @param domain{string}
-   * @return {Promise<void>}
-   */
-  async function addDomain(domain) {
-    await stoOpSet(domainKey(domain), domainDefaultValue);
-  }
-
-  /**
-   * @param domain{string}
-   * @return {Promise<void>}
-   */
-  async function removeDomain(domain) {
-    await stoOpRem(domainKey(domain));
-  }
-
-  /**
-   * @param domain{string}
-   * @param valueNew
-   * @return {Promise<void>}
-   */
-  async function updateDomain(domain, valueNew) {
-    await stoOpSet(domainKey(domain), valueNew);
-  }
-
-  return {
     /**
      * eg: ['a.com', 'b.com', 'c.com']
      * @returns {Promise<string[]>}
      */
-    getALLDomainKey: async function () {
-      // stoOpQueryByPrefix
-      let strings = await stoOpQuery_startsWith(keyPrefix);
-      return strings.map(v => v.replaceAll(keyPrefix, ''));
-    },
-    getALLDomainMap: async function () {
-      let domainList = await this.getALLDomainKey();
-
-      // todo use for-loop not the reduce()!
-      const domainKeyValueMap = {}
-      for (let domain of domainList) {
-        domainKeyValueMap[domain] = await this.getDomain(domain)
-      }
-
-      return {domainList, domainKeyValueMap};
-    },
+    async getALLDomainKey() {
+        // stoOpQueryByPrefix
+        let strings = await stoOpQuery_startsWith(this.#keyPrefix);
+        return strings.map(v => v.replaceAll(this.#keyPrefix, ''));
+    }
 
     /**
-     *
-     * @param {string}domain
+     * @returns {Promise<{domainList: string[], domainKeyValueMap: {}}>}
+     */
+    async getALLDomainMap() {
+        let domainList = await this.getALLDomainKey();
+
+        const domainKeyValueMap = {};
+        for (let domain of domainList) {
+            domainKeyValueMap[domain] = await this.getDomain(domain);
+        }
+
+        return {domainList, domainKeyValueMap};
+    }
+
+    /**
+     * @param {string} domain
      * @returns {Promise<{}>}
      */
-    getDomain: async function (domain) {
-      if (!await checkDomain(domain)) {
-        await addDomain(domain);
-      }
-      return await stoOpGet(domainKey(domain));
-    },
+    async getDomain(domain) {
+        if (!(await this.#checkDomain(domain))) {
+            await this.#addDomain(domain);
+        }
+        return await stoOpGet(this.#domainKey(domain));
+    }
 
     /**
      * {a:a1} => {a:a222}
-     * @param {string}domain 'xxx.xxxxx.xxx'
-     * @param{string}key
-     * @param {string}valueToUpdate
+     * @param {string} domain 'xxx.xxxxx.xxx'
+     * @param {string} key
+     * @param {string} valueToUpdate
      * @return {Promise<{}>}
      */
-    updateDomainValueByOneKeyValue: async function (domain, key ,valueToUpdate) {
-      if (!await checkDomain(domain)) {
-        await addDomain(domain);
-      }
-      let domainValueGet = await this.getDomain(domain);
-      domainValueGet[key]=valueToUpdate;
-      await updateDomain(domain, domainValueGet);
-      return (await this.getDomain(domain));
-    },
+    async updateDomainValueByOneKeyValue(domain, key, valueToUpdate) {
+        if (!(await this.#checkDomain(domain))) {
+            await this.#addDomain(domain);
+        }
+        let domainValueGet = await this.getDomain(domain);
+        domainValueGet[key] = valueToUpdate;
+        await this.#updateDomain(domain, domainValueGet);
+        return await this.getDomain(domain);
+    }
 
     /**
-     * @param domain 'xxx.xxxxx.xxx'
+     * @param {string} domain 'xxx.xxxxx.xxx'
      * @return {Promise<{}>}
      */
-    clearThisDomain: async function (domain) {
-      let domainValue = await this.getDomain(domain);
-      await removeDomain(domain);
-      return domainValue;
-    },
-  };
+    async clearThisDomain(domain) {
+        let domainValue = await this.getDomain(domain);
+        await this.#removeDomain(domain);
+        return domainValue;
+    }
+}
+
+/**
+ * eg:
+ *
+ * "domain www.abcdefg.com":{
+ *   "keyAAA": "valueBBB"
+ * }
+ *
+ * @returns {{getALLDomainKey: function(): Promise<string[]>, getALLDomainMap: function(): Promise<{domainList: *, domainKeyValueMap: {}}>, getDomain: function(string): Promise<{}>, updateDomainValueByOneKeyValue: function(string, string, string): Promise<{}>, clearThisDomain: function(*): Promise<{}>}}
+ */
+export function baseORM() {
+
+    let keyPrefix = `domain `;
+    const domainKey = (k) => `${keyPrefix}${k}`;
+    const domainDefaultValue = {};
+
+    /**
+     * check domain exists, return true/false
+     * @param domain{string}
+     * @return {Promise<boolean>}
+     */
+    async function checkDomain(domain) {
+        return await stoOpCheck(domainKey(domain));
+    }
+
+    /**
+     * @param domain{string}
+     * @return {Promise<void>}
+     */
+    async function addDomain(domain) {
+        await stoOpSet(domainKey(domain), domainDefaultValue);
+    }
+
+    /**
+     * @param domain{string}
+     * @return {Promise<void>}
+     */
+    async function removeDomain(domain) {
+        await stoOpRem(domainKey(domain));
+    }
+
+    /**
+     * @param domain{string}
+     * @param valueNew
+     * @return {Promise<void>}
+     */
+    async function updateDomain(domain, valueNew) {
+        await stoOpSet(domainKey(domain), valueNew);
+    }
+
+    return {
+        /**
+         * eg: ['a.com', 'b.com', 'c.com']
+         * @returns {Promise<string[]>}
+         */
+        getALLDomainKey: async function () {
+            // stoOpQueryByPrefix
+            let strings = await stoOpQuery_startsWith(keyPrefix);
+            return strings.map(v => v.replaceAll(keyPrefix, ''));
+        },
+        getALLDomainMap: async function () {
+            let domainList = await this.getALLDomainKey();
+
+            // todo use for-loop not the reduce()!
+            const domainKeyValueMap = {}
+            for (let domain of domainList) {
+                domainKeyValueMap[domain] = await this.getDomain(domain)
+            }
+
+            return {domainList, domainKeyValueMap};
+        },
+
+        /**
+         *
+         * @param {string}domain
+         * @returns {Promise<{}>}
+         */
+        getDomain: async function (domain) {
+            if (!await checkDomain(domain)) {
+                await addDomain(domain);
+            }
+            return await stoOpGet(domainKey(domain));
+        },
+
+        /**
+         * {a:a1} => {a:a222}
+         * @param {string}domain 'xxx.xxxxx.xxx'
+         * @param{string}key
+         * @param {string}valueToUpdate
+         * @return {Promise<{}>}
+         */
+        updateDomainValueByOneKeyValue: async function (domain, key, valueToUpdate) {
+            if (!await checkDomain(domain)) {
+                await addDomain(domain);
+            }
+            let domainValueGet = await this.getDomain(domain);
+            domainValueGet[key] = valueToUpdate;
+            await updateDomain(domain, domainValueGet);
+            return (await this.getDomain(domain));
+        },
+
+        /**
+         * @param domain 'xxx.xxxxx.xxx'
+         * @return {Promise<{}>}
+         */
+        clearThisDomain: async function (domain) {
+            let domainValue = await this.getDomain(domain);
+            await removeDomain(domain);
+            return domainValue;
+        },
+    };
 }

package/src/baseOp.js

@@ -1,140 +1,3 @@
-export async function stoOpCheck(k) {
-    try {
-        let key = k.toString();
-
-        let objGet = await browser.storage.local.get(key);
-        let b = objGet.hasOwnProperty(key);
-        return b;
-    } catch (e) {
-        return false;
-    }
-}
-
-export async function stoOpGet(k) {
-    try {
-        let key = k.toString();
-        let objGet = await browser.storage.local.get(key);
-        let v = objGet[key];
-        return v;
-    } catch (e) {
-        return null;
-    }
-}
-
-export async function stoOpGetAll() {
-    try {
-        return await browser.storage.local.get();
-    } catch (e) {
-        return null;
-    }
-}
-
-export async function stoOpQuery_startsWith(k) {
-    try {
-        let objAll = await browser.storage.local.get();
-        let keys = Object.keys(objAll);
-        return keys.filter(value => value.startsWith(k.toString()));
-    } catch (e) {
-        return null;
-    }
-}
-
-export async function stoOpSet(k, v) {
-    let key = k.toString();
-
-    let objNew = {};
-    objNew[key] = v;
-    await browser.storage.local.set(objNew);
-}
-
-export async function stoOpRem(k) {
-    try {
-        let key = k.toString();
-        await browser.storage.local.remove(key);
-    } catch (e) {
-    }
-}
-
-export async function stoOpSetNull(k) {
-    await stoOpSet(k, null);
-}
-
-/**
- *
- * @param tabId
- * @return {Promise<browser.tabs.Tab>}
- */
-export async function tabOpGet(tabId) {
-    return await browser.tabs.get(tabId);
-}
-
-export async function tabOpQueryAll() {
-    return await browser.tabs.query({});
-}
-
-export async function tabOpQueryUrl(urlQuery) {
-    let tabs = await browser.tabs.query({url: urlQuery});
-    return tabs.map(v => v.id);
-}
-
-export async function tabOpQueryUrlThenRem(urlQuery) {
-    let ids = await tabOpQueryUrl(urlQuery);
-    ids.map(id => tabOpRem(id));
-}
-
-export async function tabOpReload(tabId) {
-    await browser.tabs.reload(tabId);
-}
-
-export async function tabOpCreate(args) {
-    try {
-        /**
-         * @type {browser.tabs._CreateCreateProperties}
-         */
-        let source = {active: false, muted: true};
-        Object.assign(args, source);
-        return await browser.tabs.create(args);
-    } catch (e) {
-    }
-}
-
-export async function tabOpCreateNormal(args) {
-    return await browser.tabs.create(args);
-}
-
-export async function tabOpRem(tabId) {
-    try {
-        await browser.tabs.remove(tabId);
-    } catch (e) {
-    }
-}
-
-export async function tabOpHide(tabId) {
-    try {
-        await browser.tabs.hide(tabId);
-    } catch (e) {
-    }
-}
-
-export async function tabOpUpdate(tabId, updateProperties) {
-    await browser.tabs.update(tabId, updateProperties);
-}
-
-export async function tabOpUpdateActiveFalse(tabId) {
-    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});
-
-    await tabOpUpdate(tabId,
-        {active: true, highlighted: true});
-}
 
 export function objectOpFindTrueStorageTypeRadio(obj) {
     return Object.keys(obj).find((k) => {

package/src/baseOpStorage.js

@@ -0,0 +1,60 @@
+export async function stoOpCheck(k) {
+    try {
+        let key = k.toString();
+
+        let objGet = await browser.storage.local.get(key);
+        let b = objGet.hasOwnProperty(key);
+        return b;
+    } catch (e) {
+        return false;
+    }
+}
+
+export async function stoOpGet(k) {
+    try {
+        let key = k.toString();
+        let objGet = await browser.storage.local.get(key);
+        let v = objGet[key];
+        return v;
+    } catch (e) {
+        return null;
+    }
+}
+
+export async function stoOpGetAll() {
+    try {
+        return await browser.storage.local.get();
+    } catch (e) {
+        return null;
+    }
+}
+
+export async function stoOpQuery_startsWith(k) {
+    try {
+        let objAll = await browser.storage.local.get();
+        let keys = Object.keys(objAll);
+        return keys.filter(value => value.startsWith(k.toString()));
+    } catch (e) {
+        return null;
+    }
+}
+
+export async function stoOpSet(k, v) {
+    let key = k.toString();
+
+    let objNew = {};
+    objNew[key] = v;
+    await browser.storage.local.set(objNew);
+}
+
+export async function stoOpRem(k) {
+    try {
+        let key = k.toString();
+        await browser.storage.local.remove(key);
+    } catch (e) {
+    }
+}
+
+export async function stoOpSetNull(k) {
+    await stoOpSet(k, null);
+}

package/src/baseOpTab.js

@@ -0,0 +1,96 @@
+/**
+ *
+ * @param tabId
+ * @return {Promise<browser.tabs.Tab>}
+ */
+export async function tabOpGet(tabId) {
+    return await browser.tabs.get(tabId);
+}
+
+export async function tabOpQueryAll() {
+    return await browser.tabs.query({});
+}
+
+export async function tabOpQueryUrl(urlQuery) {
+    let tabs = await browser.tabs.query({url: urlQuery});
+    return tabs.map(v => v.id);
+}
+
+export async function tabOpQueryUrlThenRemove(urlQuery) {
+    let ids = await tabOpQueryUrl(urlQuery);
+    ids.map(id => tabOpRemove(id));
+}
+
+export async function tabOpReload(tabId) {
+    await browser.tabs.reload(tabId);
+}
+
+export async function tabOpCreate(args) {
+    try {
+        /**
+         * @type {browser.tabs._CreateCreateProperties}
+         */
+        let source = {active: false, muted: true};
+        Object.assign(args, source);
+        return await browser.tabs.create(args);
+    } catch (e) {
+    }
+}
+
+export async function tabOpCreateNormal(args) {
+    return await browser.tabs.create(args);
+}
+
+export async function tabOpRemove(tabId) {
+    try {
+        await browser.tabs.remove(tabId);
+    } catch (e) {
+    }
+}
+
+export async function tabOpHide(tabId) {
+    try {
+        await browser.tabs.hide(tabId);
+    } catch (e) {
+    }
+}
+
+/**
+ *
+ * @param {number}tabId
+ * @param {browser.tabs._UpdateUpdateProperties}updateProperties
+ * @returns {Promise<void>}
+ */
+export async function tabOpUpdate(tabId, updateProperties) {
+    await browser.tabs.update(tabId, updateProperties);
+}
+
+export async function tabOpUpdateActiveFalse(tabId) {
+    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});
+
+    await tabOpUpdate(tabId,
+        {active: true, highlighted: true});
+}
+
+/**
+ *
+ * @param{number} tabId
+ * @param {string}code
+ * @param {function}thenDoWhat
+ * @returns {Promise<void>}
+ */
+export async function tabOpInsertCssCode(
+    tabId, code, thenDoWhat
+) {
+    await browser.tabs.insertCSS(tabId, {code})
+    thenDoWhat()
+}