@vacantthinker/firefox-addon-framework-easy 2026.609.706 → 2026.610.749

package/README.md

@@ -69,13 +69,16 @@ export function browserRuntimeOnMessageCommon(act, message, sendResponse) {  }
 
 ### 📄 File: `src/browserTab.js`
 ```javascript
-export async function browserTabSendMessage(tabId, message) {  }
+export async function browserTabSendMessage(
+    tabId,
+    message,
+) {  }
 
 export function browserTabWaitReloadThenSendMessageToContentJs(message) {  }
 
 export async function browserTabCreateToDownload(message) {  }
 
-export async function browserTabCreateNearSendMessageToContentJs(message) {  }
+export async function browserTabCreateNearSendMessageToContentJs(message = {  }
 
 export function browserTabWaitReloadThenRemoveIt({  }
 
@@ -89,12 +92,6 @@ export class DomainORM extends BaseORM {  }
 
 ### 📄 File: `src/generate.js`
 ```javascript
-export async function generateHtmlByUserSettings(
-    userSettings,
-    radioItemClickCallback,
-    checkboxItemClickCallback,
-) {  }
-
 export function generateMkvScriptForSystemWindows({  }
 
 export function generateMkvScriptForSystemFedora({  }
@@ -121,7 +118,7 @@ export async function stoOpSetNull(k) {  }
 
 ### 📄 File: `src/opTab.js`
 ```javascript
-export async function tabOpEnhance(tab) {  }
+export function tabOpEnhance(tab) {  }
 
 export async function tabOpCreate(properties) {  }
 
@@ -131,31 +128,40 @@ export async function tabOpCreateActiveFalse(properties) {  }
 
 export async function tabOpCreateByWindow(url) {  }
 
-export async function tabOpGet(tabId) {  }
+export function tabOpGet(tabId) {  }
 
-export async function tabOpQueryAll() {  }
+export function tabOpQueryAll() {  }
 
 export async function tabOpQueryUrl(urlQuery) {  }
 
 export async function tabOpQueryUrlThenRemove(urlQuery) {  }
 
-export async function tabOpReload(tabId) {  }
+export function tabOpReload(tabId) {  }
 
-export async function tabOpReloadByPassCacheTrue(tabId) {  }
+export function tabOpReloadByPassCacheTrue(tabId) {  }
 
-export async function tabOpRemove(tabId) {  }
+export function tabOpRemove(tabId) {  }
 
-export async function tabOpHide(tabId) {  }
+export function tabOpHide(tabId) {  }
 
-export async function tabOpUpdate(tabId, updateProperties) {  }
+export async function tabOpUpdate(
+    tabId,
+    updateProperties,
+) {  }
 
-export async function tabOpUpdateActiveFalse(tabId) {  }
+export function tabOpUpdateActiveFalse(tabId) {  }
 
 export async function tabOpFocus(tabId) {  }
 
-export async function tabOpInsertCssCode(tabId, code) {  }
+export function tabOpInsertCssCode(
+    tabId,
+    code,
+) {  }
 
-export async function tabOpRemoveCssCode(tabId, code) {  }
+export function tabOpRemoveCssCode(
+    tabId,
+    code,
+) {  }
 
 ```
 
@@ -227,11 +233,3 @@ export async function serviceUpdataALLNodeBackgroundColor(message) {  }
 
 ```
 
-### 📄 File: `src/serviceUserSettings.js`
-```javascript
-export async function serviceInitUserSettings(userSettings) {  }
-
-export async function serviceGetUserSettings(userSettings) {  }
-
-```
-

package/index.js

@@ -15,4 +15,3 @@ export * from './src/serviceOpContent.js'
 export * from './src/serviceOpJavascript.js'
 export * from './src/servicePure.js'
 export * from './src/serviceUpdateTabStyle.js'
-export * from './src/serviceUserSettings.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vacantthinker/firefox-addon-framework-easy",
-  "version": "2026.0609.0706",
+  "version": "2026.0610.0749",
   "description": "",
   "main": "index.js",
   "publishConfig": {

package/src/browserRuntime.js

@@ -30,7 +30,7 @@ export function browserRuntimeOnUpdateAvailable(doWhat = null) {
  * @returns {string}
  */
 export function browserRuntimeGetURL(path) {
-  return browser.runtime.getURL(path)
+  return browser.runtime.getURL(path);
 }
 
 /**

package/src/browserTab.js

@@ -1,16 +1,21 @@
 // @ts-check
 
-import {browserNotificationCreate} from './browserNotification.js';
 import {tabOpCreateNear, tabOpGet, tabOpRemove} from './opTab.js';
 
-export async function browserTabSendMessage(tabId, message) {
+export async function browserTabSendMessage(
+    tabId,
+    message,
+) {
   await browser.tabs.sendMessage(tabId, message);
 }
 
 export function browserTabWaitReloadThenSendMessageToContentJs(message) {
   let tabId = message.tabId;
   browser.tabs.onUpdated.addListener(
-      async function lis(tabId, changeInfo) {
+      async function lis(
+          tabId,
+          changeInfo,
+      ) {
         if (changeInfo.status === 'complete') {
           browser.tabs.onUpdated.removeListener(lis);
           await browserTabSendMessage(tabId, message);
@@ -47,7 +52,10 @@ export async function browserTabCreateToDownload(message) {
 
   let {tabId} = await tabOpCreateNear(properties);
   browser.tabs.onUpdated.addListener(
-      async function lis(tabId, changeInfo) {
+      async function lis(
+          tabId,
+          changeInfo,
+      ) {
         if (changeInfo.status === 'complete') {
           browser.tabs.onUpdated.removeListener(lis);
           // todo code here
@@ -58,18 +66,21 @@ export async function browserTabCreateToDownload(message) {
 }
 
 /**
- * must has, tabId, url
- * @param message
- * @param message.tabId{number}
- * @param message.url{string}
- * @param message.options.focusNewTab{boolean}
+ * Safely handles incoming messages to create tabs and send messages to content scripts.
+ * * @param {Object} message - The message payload.
+ * @param {number} [message.tabId] - Optional Tab ID to attach to.
+ * @param {string} [message.url] - The URL to open.
+ * @param {Object} [message.options] - Additional options.
+ * @param {boolean} [message.options.focusNewTab] - Whether the newly created tab should be active.
  * @returns {Promise<void>}
  */
-export async function browserTabCreateNearSendMessageToContentJs(message) {
+export async function browserTabCreateNearSendMessageToContentJs(message = {}) {
   let properties = {
     url: message.url,
   };
-  if (message.tabId) {
+
+  // Strictly check for tabId presence to prevent passing undefined.
+  if (message.tabId !== undefined) {
     let tabId = message.tabId;
     try {
       await tabOpGet(tabId);
@@ -78,22 +89,32 @@ export async function browserTabCreateNearSendMessageToContentJs(message) {
       delete message.tabId;
     }
   }
-  if (message.options) {
-    let focusNewTab = message.options.focusNewTab;
-    Object.assign(properties, {active: focusNewTab});
+
+  // Use optional chaining to safely extract nested properties.
+  // Only assign 'active' if 'focusNewTab' was explicitly provided.
+  if (message?.options?.focusNewTab !== undefined) {
+    Object.assign(properties, {active: message.options.focusNewTab});
   }
 
   let {tabId} = await tabOpCreateNear(properties);
+
   browser.tabs.onUpdated.addListener(
-      async function lis(tabId, changeInfo) {
+      async function lis(
+          updatedTabId,
+          changeInfo,
+      ) {
         if (changeInfo.status === 'complete') {
           browser.tabs.onUpdated.removeListener(lis);
-          // todo code here
+
+          // Execute further logic once the tab is completely loaded.
           await browserTabSendMessage(
-              tabId, Object.assign({}, message, {tabId}));
+              updatedTabId,
+              Object.assign({}, message, {tabId: updatedTabId}),
+          );
         }
-      }
-      , {tabId, properties: ['status']});
+      },
+      {tabId, properties: ['status']},
+  );
 }
 
 /**
@@ -103,7 +124,10 @@ export async function browserTabCreateNearSendMessageToContentJs(message) {
  */
 export function browserTabWaitReloadThenRemoveIt({tabId}) {
   browser.tabs.onUpdated.addListener(
-      async function lis(tabId, changeInfo) {
+      async function lis(
+          tabId,
+          changeInfo,
+      ) {
         if (changeInfo.status === 'complete') {
           browser.tabs.onUpdated.removeListener(lis);
           // todo code here

package/src/generate.js

@@ -1,204 +1,3 @@
-import {stoOpGet, stoOpSet} from './opStorage.js';
-
-// [Optimization 1] Introduce a debounce function to prevent triggering storage writes on every keystroke.
-function debounce(func, wait) {
-  let timeout;
-  return function(...args) {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => func.apply(this, args), wait);
-  };
-}
-
-/**
- * Generates HTML elements based on a user settings schema object.
- *
- * @param   {Object}                    userSettings
- * @param   {Function}                  radioItemClickCallback
- * @returns {Promise<DocumentFragment>}
- */
-export async function generateHtmlByUserSettings(
-    userSettings,
-    radioItemClickCallback,
-    checkboxItemClickCallback,
-) {
-  const elementsMap = {};
-
-  // [Optimization 2] Use a DocumentFragment for off-screen DOM construction to improve rendering performance.
-  const fragment = document.createDocumentFragment();
-
-  const keys = Object.keys(userSettings);
-
-  // [Optimization 3] Batch fetch all stored values.
-  // Wait for all queries to complete to prevent async callbacks from interrupting the rendering pipeline.
-  const valuesArray = await Promise.all(keys.map((key) => stoOpGet(key)));
-  const storageData = {};
-  keys.forEach((key, index) => {
-    storageData[key] = valuesArray[index];
-  });
-
-  // First pass: Pre-create all container wrappers.
-  // This ensures all target elements exist in the DOM references before executing triggerVisibility later.
-  keys.forEach((storageKey) => {
-    const eleWrap = document.createElement('fieldset');
-    const eleTitle = document.createElement('legend');
-    eleTitle.textContent = storageKey;
-    eleWrap.append(eleTitle);
-
-    elementsMap[storageKey] = eleWrap;
-    fragment.append(eleWrap);
-  });
-
-  // Second pass: Synchronously populate form content and attach event listeners.
-  keys.forEach((storageKey) => {
-    const storageValue = userSettings[storageKey];
-    const type = storageValue.type || 'text';
-    const eleWrap = elementsMap[storageKey];
-
-    // Retrieve pre-loaded value; fallback to the schema's default value if undefined.
-    const storedValue = storageData[storageKey];
-    const initialValue =
-        storedValue !== undefined && storedValue !== null
-            ? storedValue
-            : storageValue.selected;
-
-    // --- CONDITION 1: CHECKBOX & RADIO ---
-    if (type === 'checkbox' || type === 'radio') {
-      /** @type {string[]} */
-      const options = storageValue.options || [];
-
-      options.forEach((option) => {
-        const eleLabel = document.createElement('label');
-        eleLabel.textContent = option;
-        const eleInput = document.createElement('input');
-        eleInput.name = storageKey;
-        eleInput.type = type;
-        eleInput.value = option;
-
-        if (type === 'checkbox') {
-          const initialArray = Array.from(initialValue || []);
-          const set = new Set(initialArray);
-          eleInput.checked = set.has(option); // Apply state synchronously
-
-          eleInput.addEventListener('change', async () => {
-            // Derive state in real-time from the DOM (faster than reading from storage again)
-            const allCheckboxes = eleWrap.querySelectorAll(
-                'input[type="checkbox"]',
-            );
-            const valueNew = Array.from(allCheckboxes)
-                .filter((cb) => cb.checked)
-                .map((cb) => cb.value);
-
-            await stoOpSet(storageKey, valueNew);
-            if (typeof checkboxItemClickCallback === 'function') {
-              checkboxItemClickCallback(storageKey, option);
-            }
-            triggerVisibility(storageKey, valueNew);
-          });
-        }
-        else if (type === 'radio') {
-          if (option === initialValue) {
-            eleInput.checked = true; // Apply state synchronously
-          }
-
-          // It is recommended to bind the 'change' event to the input rather than 'onclick' to the label
-          eleInput.addEventListener('change', () => {
-            stoOpSet(storageKey, option).then(() => {
-              if (typeof radioItemClickCallback === 'function') {
-                radioItemClickCallback(storageKey, option);
-              }
-              triggerVisibility(storageKey, option);
-            });
-          });
-        }
-
-        // Fix: Native HTML typically places the input element before the text node inside a label.
-        eleLabel.prepend(eleInput);
-        eleWrap.append(eleLabel);
-      });
-    }
-
-    // --- CONDITION 2: TOGGLE BUTTON ---
-    else if (type === 'button') {
-      const eleButton = document.createElement('button');
-      eleButton.type = 'button';
-
-      let currentStatus = initialValue === true || initialValue === 'true';
-      eleButton.textContent = String(currentStatus); // Apply state synchronously
-
-      eleButton.addEventListener('click', async () => {
-        currentStatus = !currentStatus;
-        eleButton.textContent = String(currentStatus);
-        await stoOpSet(storageKey, currentStatus);
-        triggerVisibility(storageKey, currentStatus);
-      });
-
-      eleWrap.append(eleButton);
-    }
-
-    // --- CONDITION 3: NUMBER & TEXT INPUTS ---
-    else if (type === 'number' || type === 'text') {
-      const eleInput = document.createElement('input');
-      eleInput.type = type;
-      eleInput.name = storageKey;
-      eleInput.value = initialValue !== undefined ? initialValue : ''; // Apply state synchronously
-
-      // [Optimization 4] Wrap the write operation with debounce, delaying storage writes by 500ms.
-      // This eliminates UI freezing regardless of typing speed.
-      const debouncedSave = debounce(async (val) => {
-        const finalizedValue = type === 'number' ? Number(val) : val;
-        await stoOpSet(storageKey, finalizedValue);
-      }, 500);
-
-      eleInput.addEventListener('input', () => {
-        const rawValue = eleInput.value;
-        debouncedSave(rawValue);
-        triggerVisibility(storageKey, rawValue); // Visual UI updates do not require a delay
-      });
-
-      eleWrap.append(eleInput);
-    }
-
-    // --- CONDITION 4: SPAN / READ-ONLY TEXT ---
-    else if (type === 'span') {
-      const eleSpan = document.createElement('span');
-      eleSpan.textContent = String(initialValue); // Apply state synchronously
-      eleWrap.append(eleSpan);
-    }
-  });
-
-  // [Optimization 5] Third pass: Globally trigger a single visibility check.
-  // At this point, all DOM elements exist and all initialValues are fully derived,
-  // preventing undefined errors or invalid target hiding.
-  keys.forEach((storageKey) => {
-    const storedValue = storageData[storageKey];
-    const initialValue =
-        storedValue !== undefined && storedValue !== null
-            ? storedValue
-            : userSettings[storageKey].selected;
-
-    triggerVisibility(storageKey, initialValue);
-  });
-
-  /**
-   * Evaluates the visibility rules for a given source key based on its current
-   * value.
-   */
-  function triggerVisibility(sourceKey, currentValue) {
-    const config = userSettings[sourceKey];
-    if (config && config.visibilityControl) {
-      const {targetField, expectedValue} = config.visibilityControl;
-      const targetElement = elementsMap[targetField];
-
-      if (targetElement) {
-        const shouldBeVisible = String(currentValue) === String(expectedValue);
-        targetElement.style.display = shouldBeVisible ? '' : 'none';
-      }
-    }
-  }
-
-  return fragment;
-}
-
 export function generateMkvScriptForSystemWindows({vid, title}) {
   let args = {vid, title};
 

package/src/opTab.js

@@ -1,198 +1,237 @@
 /**
- * Creates a normal tab using either a URL string or a properties object.
+ * Enhances a tab object by explicitly attaching its ID to the 'tabId' property.
  *
- * @param tab{browser.tabs.Tab}
- * @returns {Promise<(browser.tabs.Tab & {tabId: number})>}
+ * @param {browser.tabs.Tab} tab
+ * @returns {browser.tabs.Tab & {tabId: number}|null}
  */
-export async function tabOpEnhance(tab) {
-  return Object.assign({}, tab, {tabId: tab.id});
+export function tabOpEnhance(tab) {
+  if (!tab || typeof tab.id !== 'number') return null;
+  return {...tab, tabId: tab.id};
 }
 
 /**
- * Creates a normal tab using either a URL string or a properties object.
+ * Creates a normal tab using a properties object.
  *
- * @param {browser.tabs._CreateCreateProperties} properties
- * @returns {Promise<(browser.tabs.Tab & {tabId: number})>}
+ * @param {Object} properties
+ * @returns {Promise<browser.tabs.Tab & {tabId: number}>}
  */
 export async function tabOpCreate(properties) {
-  // Otherwise, assume it is already a properties object
-  let tab = await browser.tabs.create(properties);
+  const tab = await browser.tabs.create(properties);
   return tabOpEnhance(tab);
 }
 
 /**
+ * Creates a new tab positioned immediately after a specified existing tab.
+ * Does not mutate the original properties object.
  *
- * @param {browser.tabs._CreateCreateProperties & {tabId: number} } properties
- * @returns {Promise<(browser.tabs.Tab & {tabId: number})>}
+ * @param {Object & {tabId?: number}} properties
+ * @returns {Promise<browser.tabs.Tab & {tabId: number}>}
  */
 export async function tabOpCreateNear(properties) {
-  if (properties.tabId) {
-    let tabPrev = await tabOpGet(properties.tabId);
-    delete properties.tabId;
-    Object.assign(properties, {
-      index: tabPrev.index + 1,
-      openerTabId: tabPrev.id,
-    });
+  // Destructure tabId out to avoid mutating the original properties object
+  const {tabId, ...restProperties} = properties;
+
+  if (tabId) {
+    const tabPrev = await tabOpGet(tabId);
+    if (tabPrev) {
+      Object.assign(restProperties, {
+        index: tabPrev.index + 1,
+        openerTabId: tabPrev.id,
+      });
+    }
   }
 
-  let tab = await tabOpCreate(properties);
+  const tab = await browser.tabs.create(restProperties);
   return tabOpEnhance(tab);
 }
 
 /**
- * {active: false, muted: true}
- * @param properties{browser.tabs._CreateCreateProperties}
- * @returns {Promise<(browser.tabs.Tab & {tabId: number})>}
+ * Creates a tab in the background (inactive and muted).
+ *
+ * @param {Object} properties
+ * @returns {Promise<browser.tabs.Tab & {tabId: number}>}
  */
 export async function tabOpCreateActiveFalse(properties) {
-  /**
-   * @type {browser.tabs._CreateCreateProperties}
-   */
-  let source = {active: false, muted: true};
-  Object.assign(properties, source);
-  let tab = await browser.tabs.create(properties);
+  const mergedProperties = {
+    ...properties,
+    active: false,
+    muted: true,
+  };
+  const tab = await browser.tabs.create(mergedProperties);
   return tabOpEnhance(tab);
 }
 
 /**
- * Creates a normal tab using either a URL string or a properties object.
+ * Creates a completely new window and returns its initial tab.
  *
  * @param {string} url
- * @returns {Promise<(browser.tabs.Tab & {tabId: number})>}
+ * @returns {Promise<(browser.tabs.Tab & {tabId: number})|undefined>}
  */
 export async function tabOpCreateByWindow(url) {
-  // If it's a string, wrap it in an object
-  if (typeof url === 'string') {
-    let window = await browser.windows.create({
-      url,
-    });
-    let tab = window.tabs.shift();
-    return tabOpEnhance(tab);
+  if (typeof url !== 'string') return undefined;
+
+  const window = await browser.windows.create({url});
+  if (window && window.tabs && window.tabs.length > 0) {
+    return tabOpEnhance(window.tabs[0]);
   }
+  return undefined;
 }
 
 /**
+ * Retrieves details about the specified tab.
  *
- * @param tabId{number}
- * @return {Promise<browser.tabs.Tab>}
+ * @param {number} tabId
+ * @returns {Promise<browser.tabs.Tab>}
  */
-export async function tabOpGet(tabId) {
-  return await browser.tabs.get(tabId);
+export function tabOpGet(tabId) {
+  return browser.tabs.get(tabId);
 }
 
 /**
+ * Retrieves all tabs across all windows.
  *
  * @returns {Promise<browser.tabs.Tab[]>}
  */
-export async function tabOpQueryAll() {
-  return await browser.tabs.query({});
+export function tabOpQueryAll() {
+  return browser.tabs.query({});
 }
 
 /**
+ * Retrieves an array of tab IDs that match the specified URL pattern.
  *
- * @param urlQuery{string}
+ * @param {string} urlQuery
  * @returns {Promise<number[]>}
  */
 export async function tabOpQueryUrl(urlQuery) {
-  let tabs = await browser.tabs.query({url: urlQuery});
-  return tabs.map(v => v.id);
+  const tabs = await browser.tabs.query({url: urlQuery});
+  return tabs.map(tab => tab.id);
 }
 
 /**
+ * Finds all tabs matching the URL pattern and removes them simultaneously.
+ * [Optimization]: browser.tabs.remove accepts an array of numbers, which is
+ * significantly faster than looping and awaiting individually.
  *
- * @param urlQuery{string}
+ * @param {string} urlQuery
  * @returns {Promise<void>}
  */
 export async function tabOpQueryUrlThenRemove(urlQuery) {
-  let ids = await tabOpQueryUrl(urlQuery);
-  ids.map(id => tabOpRemove(id));
+  const ids = await tabOpQueryUrl(urlQuery);
+  if (ids.length > 0) {
+    await browser.tabs.remove(ids);
+  }
 }
 
 /**
+ * Reloads the given tab.
  *
- * @param tabId{number}
+ * @param {number} tabId
  * @returns {Promise<void>}
  */
-export async function tabOpReload(tabId) {
-  await browser.tabs.reload(tabId, {bypassCache: true});
+export function tabOpReload(tabId) {
+  return browser.tabs.reload(tabId);
 }
 
 /**
+ * Reloads the given tab, bypassing the local web cache.
  *
- * @param tabId{number}
+ * @param {number} tabId
  * @returns {Promise<void>}
  */
-export async function tabOpReloadByPassCacheTrue(tabId) {
-  await browser.tabs.reload(tabId, {bypassCache: true});
+export function tabOpReloadByPassCacheTrue(tabId) {
+  return browser.tabs.reload(tabId, {bypassCache: true});
 }
 
 /**
+ * Closes one or more tabs.
  *
- * @param tabId{number}
+ * @param {number|number[]} tabId
  * @returns {Promise<void>}
  */
-export async function tabOpRemove(tabId) {
-  await browser.tabs.remove(tabId);
+export function tabOpRemove(tabId) {
+  return browser.tabs.remove(tabId);
 }
 
 /**
+ * Hides one or more tabs (Firefox specific API).
  *
- * @param tabId{number}
- * @returns {Promise<void>}
+ * @param {number|number[]} tabId
+ * @returns {Promise<number[]>}
  */
-export async function tabOpHide(tabId) {
-  await browser.tabs.hide(tabId);
+export function tabOpHide(tabId) {
+  return browser.tabs.hide(tabId);
 }
 
 /**
+ * Modifies the properties of a tab.
  *
- * @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);
+ * @param {number} tabId
+ * @param {Object} updateProperties
+ * @returns {Promise<browser.tabs.Tab & {tabId: number}>}
+ */
+export async function tabOpUpdate(
+    tabId,
+    updateProperties,
+) {
+  const tab = await browser.tabs.update(tabId, updateProperties);
   return tabOpEnhance(tab);
 }
 
 /**
- * active: false, muted: true
- * @param tabId{number}
- * @returns {Promise<browser.tabs.Tab&{tabId: number}>}
+ * Updates a tab to be inactive and muted.
+ *
+ * @param {number} tabId
+ * @returns {Promise<browser.tabs.Tab & {tabId: number}>}
  */
-export async function tabOpUpdateActiveFalse(tabId) {
-  return await tabOpUpdate(tabId, {active: false, muted: true});
+export function tabOpUpdateActiveFalse(tabId) {
+  return tabOpUpdate(tabId, {active: false, muted: true});
 }
 
 /**
- * @param tabId
+ * Focuses the window containing the tab, then highlights and activates the tab.
+ *
+ * @param {number} tabId
+ * @returns {Promise<browser.tabs.Tab & {tabId: number}>}
  */
 export async function tabOpFocus(tabId) {
-  let tab = await tabOpGet(tabId);
-  let windowId = tab.windowId;
-  await browser.windows.update(windowId, {focused: true});
+  const tab = await tabOpGet(tabId);
+  if (!tab || !tab.windowId) throw new Error(`Tab ${tabId} not found.`);
+
+  await browser.windows.update(tab.windowId, {focused: true});
+
+  const tabUpdated = await browser.tabs.update(tabId, {
+    active: true,
+    highlighted: true,
+  });
 
-  let updateProperties = {active: true, highlighted: true};
-  let tabUpdated = await tabOpUpdate(tabId, updateProperties);
   return tabOpEnhance(tabUpdated);
 }
 
 /**
+ * Injects CSS code into a page.
+ * Note: Check manifest version compatibility for 'insertCSS'.
  *
- * @param{number} tabId
- * @param {string}code
+ * @param {number} tabId
+ * @param {string} code
  * @returns {Promise<void>}
  */
-export async function tabOpInsertCssCode(tabId, code) {
-  await browser.tabs.insertCSS(tabId, {code});
+export function tabOpInsertCssCode(
+    tabId,
+    code,
+) {
+  return browser.tabs.insertCSS(tabId, {code});
 }
 
 /**
+ * Removes CSS code that was previously injected into a page.
  *
- * @param{number} tabId
- * @param {string}code
+ * @param {number} tabId
+ * @param {string} code
  * @returns {Promise<void>}
  */
-export async function tabOpRemoveCssCode(tabId, code) {
-  await browser.tabs.removeCSS(tabId, {code});
+export function tabOpRemoveCssCode(
+    tabId,
+    code,
+) {
+  return browser.tabs.removeCSS(tabId, {code});
 }

package/src/serviceUserSettings.js

@@ -1,33 +0,0 @@
-import {stoOpGet, stoOpSet} from './opStorage.js';
-
-export async function serviceInitUserSettings(userSettings) {
-  const initPromises = Object.entries(userSettings)
-      .map(async ([key, setting]) => {
-        const oldValue = await stoOpGet(key);
-
-        // FIX: Check strictly for null or undefined.
-        // This allows `false` and `0` to be recognized as valid saved values.
-        if (oldValue === null || oldValue === undefined) {
-          await stoOpSet(key, setting.selected);
-        }
-      });
-
-  await Promise.all(initPromises);
-}
-
-/**
- * // todo
- * @param userSettings{{}}
- * @returns {Promise<{Object}>}
- */
-export async function serviceGetUserSettings(userSettings) {
-  const red = {};
-  for (let k of Object.keys(userSettings)) {
-    red[k] = await stoOpGet(k);
-  }
-  return red;
-}
-
-
-
-