@vacantthinker/firefox-addon-framework-easy 2026.603.1511 → 2026.603.1932

package/README.md

@@ -17,7 +17,7 @@ You can download, clone, or view the complete source code for this application h
 
 Below is a list of all public functions found inside the `src` directory:
 
-### 📄 File: `src/baseORM.js`
+### 📄 File: `src/BaseORM.js`
 ```javascript
 export class BaseORM {  }
 
@@ -69,6 +69,12 @@ export function browserTabWaitReloadThenRemoveIt({  }
 
 ```
 
+### 📄 File: `src/DomainORM.js`
+```javascript
+export class DomainORM extends BaseORM {  }
+
+```
+
 ### 📄 File: `src/generate.js`
 ```javascript
 export function generateHtmlByUserSettings(

package/index.js

@@ -1,8 +1,9 @@
-export * from './src/baseORM.js'
+export * from './src/BaseORM.js'
 export * from './src/browserDownload.js'
 export * from './src/browserNotification.js'
 export * from './src/browserRuntime.js'
 export * from './src/browserTab.js'
+export * from './src/DomainORM.js'
 export * from './src/generate.js'
 export * from './src/opStorage.js'
 export * from './src/opTab.js'

package/package.json

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

package/src/BaseORM.js

@@ -0,0 +1,101 @@
+import {stoOpCheck, stoOpGet, stoOpRem, stoOpSet} from './opStorage.js';
+
+/**
+ * Abstract base class BaseORM (similar to Java's Abstract Class).
+ * Provides encapsulated CRUD operations for specific Key-Value pairs bound at instantiation.
+ */
+export class BaseORM {
+  // Private fields for data encapsulation
+  #fullStorageKey;
+  #defaultValue;
+
+  /**
+   * Constructor
+   * @param {string} prefix The prefix for the keys (e.g., 'magnetKey')
+   * @param {string} id The unique identifier for this instance (e.g., a specific hash or filename)
+   * @param {object} [defaultValue={}] Custom initial value for the instance, defaults to an empty object
+   */
+  constructor(prefix, id, defaultValue = {}) {
+    // Simulating Java's abstract class behavior: prevent direct instantiation of the base class
+    if (new.target === BaseORM) {
+      throw new TypeError(
+          'Cannot construct BaseORM instances directly (Abstract Class).');
+    }
+    if (!prefix || !id) {
+      throw new Error('Both prefix and id must be specified.');
+    }
+
+    // Automatically normalize the prefix format to ensure a clean trailing space
+    const formattedPrefix = prefix.endsWith(' ') ? prefix : `${prefix} `;
+
+    // Lock down the final storage key during instance construction
+    this.#fullStorageKey = `${formattedPrefix}${id}`;
+
+    // Deep clone the default value to protect against object reference shared-state bugs
+    this.#defaultValue = JSON.parse(JSON.stringify(defaultValue));
+  }
+
+  /**
+   * Protected Getter for subclasses to safely access the complete key.
+   * Can be used in subclasses as `this.storageKey`.
+   * @protected
+   * @return {string} The full storage key
+   */
+  get storageKey() {
+    return this.#fullStorageKey;
+  }
+
+  // Private helper method: checks if the bound key exists in the storage layer
+  async #exists() {
+    return await stoOpCheck(this.#fullStorageKey);
+  }
+
+  // Private helper method: populates the storage key with the designated initial layout
+  async #initDefaultObject() {
+    await stoOpSet(this.#fullStorageKey, this.#defaultValue);
+  }
+
+  /**
+   * [Read] Retrieve the value associated with the bound key.
+   * If it does not exist yet, it automatically initializes it with the default value first.
+   * @return {Promise<object>}
+   */
+  async get() {
+    if (!(await this.#exists())) {
+      await this.#initDefaultObject();
+    }
+    return await stoOpGet(this.#fullStorageKey);
+  }
+
+  /**
+   * [Create/Update] Overwrite the value of the bound key completely.
+   * @param {object} value The new Object data to store
+   * @return {Promise<void>}
+   */
+  async set(value) {
+    await stoOpSet(this.#fullStorageKey, value || this.#defaultValue);
+  }
+
+  /**
+   * [Delete] Wipe the bound key from storage and return its final state prior to deletion.
+   * @return {Promise<object>}
+   */
+  async delete() {
+    const previousValue = await this.get();
+    await stoOpRem(this.#fullStorageKey);
+    return previousValue;
+  }
+
+  /**
+   * [Partial Update] Modify a single targeted key-value pair nested deep within the stored object.
+   * @param {string} objectKey The internal key path inside the main value object
+   * @param {*} objectValue The new value to map to that key
+   * @return {Promise<object>} Returns the fully updated object structure
+   */
+  async updateValueKeyValue(objectKey, objectValue) {
+    const currentData = await this.get();
+    currentData[objectKey] = objectValue;
+    await this.set(currentData);
+    return currentData;
+  }
+}

package/src/DomainORM.js

@@ -0,0 +1,9 @@
+import {BaseORM} from './BaseORM.js';
+
+export class DomainORM extends BaseORM {
+  constructor(domain) {
+    super(`domain`, domain, {
+
+    });
+  }
+}

package/src/baseORM.js

@@ -1,121 +0,0 @@
-import {
-    stoOpCheck,
-    stoOpGet,
-    stoOpQueryStartWith,
-    stoOpRem,
-    stoOpSet,
-} from './opStorage.js';
-
-/**
- * eg:
- *
- * "domain ://abcdefg.com":{
- *   "keyAAA": "valueBBB"
- * }
- */
-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);
-  }
-
-  /**
-   * eg: ['a.com', 'b.com', 'c.com']
-   * @returns {Promise<string[]>}
-   */
-  async getALLDomainKey() {
-    // stoOpQueryByPrefix
-    let strings = await stoOpQueryStartWith(this.#keyPrefix);
-    return strings.map(v => v.replaceAll(this.#keyPrefix, ''));
-  }
-
-  /**
-   * @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<{}>}
-   */
-  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
-   * @return {Promise<{}>}
-   */
-  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 {string} domain 'xxx.xxxxx.xxx'
-   * @return {Promise<{}>}
-   */
-  async clearThisDomain(domain) {
-    let domainValue = await this.getDomain(domain);
-    await this.#removeDomain(domain);
-    return domainValue;
-  }
-}