Inject name conditional (#1884)

* Add enum devices debugging

* Disable device enumeration remotely

* Fix lint

* Add frame flexibility

* Move to webCompat

* Conditional frame matching

* Test case

* Frame test changes, still not working

* Fix up frame testing

* Simplify test checks

* Remove bundle for debugging

* Add injectName conditional matching

* Improve comment

Author: jonathanKingston

injected/src/config-feature.js

@@ -78,6 +78,14 @@ export default class ConfigFeature {
         return this.#args?.featureSettings;
     }
 
+    /**
+     * Getter for injectName, will be overridden by subclasses (namely ContentFeature)
+     * @returns {string | undefined}
+     */
+    get injectName() {
+        return undefined;
+    }
+
     /**
      * Given a config key, interpret the value as a list of conditionals objects, and return the elements that match the current page
      * Consider in your feature using patchSettings instead as per `getFeatureSetting`.
@@ -122,6 +130,7 @@ export default class ConfigFeature {
      * @property {object} [context]
      * @property {boolean} [context.frame] - true if the condition applies to frames
      * @property {boolean} [context.top] - true if the condition applies to the top frame
+     * @property {string} [injectName] - the inject name to match against (e.g., "apple-isolated")
      */
 
     /**
@@ -151,6 +160,7 @@ export default class ConfigFeature {
             urlPattern: this._matchUrlPatternConditional,
             experiment: this._matchExperimentConditional,
             minSupportedVersion: this._matchMinSupportedVersion,
+            injectName: this._matchInjectNameConditional,
         };
 
         for (const key in conditionBlock) {
@@ -261,6 +271,19 @@ export default class ConfigFeature {
         return matchHostname(domain, conditionBlock.domain);
     }
 
+    /**
+     * Takes a condition block and returns true if the current inject name matches the injectName.
+     * @param {ConditionBlock} conditionBlock
+     * @returns {boolean}
+     */
+    _matchInjectNameConditional(conditionBlock) {
+        if (!conditionBlock.injectName) return false;
+        // Access injectName through the ContentFeature's getter
+        const currentInjectName = this.injectName;
+        if (!currentInjectName) return false;
+        return conditionBlock.injectName === currentInjectName;
+    }
+
     /**
      * Takes a condition block and returns true if the platform version satisfies the `minSupportedFeature`
      * @param {ConditionBlock} conditionBlock

injected/unit-test/content-feature.js

@@ -489,4 +489,108 @@ describe('ContentFeature class', () => {
             expect(object.someProp.toString.toString.toString()).not.toBe(fn.toString.toString.toString());
         });
     });
+
+    describe('injectName condition', () => {
+        it('should match when injectName condition is met', () => {
+            class MyTestFeature extends ContentFeature {
+                /** @returns {'apple-isolated'} */
+                get injectName() {
+                    return 'apple-isolated';
+                }
+
+                testMatchInjectNameConditional(conditionBlock) {
+                    return this._matchInjectNameConditional(conditionBlock);
+                }
+            }
+
+            const args = {
+                site: {
+                    domain: 'example.com',
+                    url: 'http://example.com',
+                },
+            };
+
+            const feature = new MyTestFeature('test', {}, args);
+            const result = feature.testMatchInjectNameConditional({
+                injectName: 'apple-isolated',
+            });
+            expect(result).toBe(true);
+        });
+
+        it('should not match when injectName condition is not met', () => {
+            class MyTestFeature extends ContentFeature {
+                /** @returns {'apple-isolated'} */
+                get injectName() {
+                    return 'apple-isolated';
+                }
+
+                testMatchInjectNameConditional(conditionBlock) {
+                    return this._matchInjectNameConditional(conditionBlock);
+                }
+            }
+
+            const args = {
+                site: {
+                    domain: 'example.com',
+                    url: 'http://example.com',
+                },
+            };
+
+            const feature = new MyTestFeature('test', {}, args);
+            const result = feature.testMatchInjectNameConditional({
+                injectName: 'firefox',
+            });
+            expect(result).toBe(false);
+        });
+
+        it('should handle undefined injectName gracefully', () => {
+            class MyTestFeature extends ContentFeature {
+                /** @returns {undefined} */
+                get injectName() {
+                    return undefined;
+                }
+
+                testMatchInjectNameConditional(conditionBlock) {
+                    return this._matchInjectNameConditional(conditionBlock);
+                }
+            }
+
+            const args = {
+                site: {
+                    domain: 'example.com',
+                    url: 'http://example.com',
+                },
+            };
+
+            const feature = new MyTestFeature('test', {}, args);
+            const result = feature.testMatchInjectNameConditional({
+                injectName: 'apple-isolated',
+            });
+            expect(result).toBe(false);
+        });
+
+        it('should handle missing injectName condition', () => {
+            class MyTestFeature extends ContentFeature {
+                /** @returns {'apple-isolated'} */
+                get injectName() {
+                    return 'apple-isolated';
+                }
+
+                testMatchInjectNameConditional(conditionBlock) {
+                    return this._matchInjectNameConditional(conditionBlock);
+                }
+            }
+
+            const args = {
+                site: {
+                    domain: 'example.com',
+                    url: 'http://example.com',
+                },
+            };
+
+            const feature = new MyTestFeature('test', {}, args);
+            const result = feature.testMatchInjectNameConditional({});
+            expect(result).toBe(false);
+        });
+    });
 });