[SOLVED] analytics script is not sending data from shadow DOM

Best Practice

Firstly, the spirit of using Shadow DOM concepts is to provide scope/closure for web components, so that people can't just go poking at them and messing them up. In principle, it is similar to having a local scoped variable inside a function that a higher scope can't touch. In practice, it is possible to get around this "wall" and have your way with it, but it breaks the "spirit" of shadow DOM, which IMO is bad practice.

So, if I were to advise some best practice about any of this, my first advice is to as much as possible, respect the spirit of web components that utilize shadow DOM, and treat them like the black box they strive to be. Meaning, you should go to the web developers in charge of the web component and ask them to provide an interface for you to use.

For example, Adobe Launch has the ability to listen for custom events broadcast to the (light) DOM, so the site developers can add to their web component, create a custom event and broadcast it on click of the button.

Note: Launch's custom event listener will only listen for custom event broadcasts starting at document.body, not document, so make sure to create and broadcast custom events on document.body or deeper.

"But the devs won't do anything so I have to take matters into my own hands..."

Sadly, this is a reality more often than not, so you gotta do what you gotta do. If this is the case, well, Launch does not currently have any native features to really make life easier for you in this regard (for the "core" part of the below stuff, anyways), and as of this post, AFAIK there are no public extensions that offer anything for this, either. But that doesn't mean you're SoL.

But I want to state that I'm not sure I would be quick to call the rest of this answer "Best Practice" so much as "It's 'a' solution..". Mostly because this largely involves just dumping a lot of pure javascript into a custom code box and calling it a day, which is more of a "catch-all, last resort" solution.

Meanwhile, in general, it's best practice to avoid using custom code boxes when it comes to tag managers unless you have to. The whole point of tag managers is to abstract away the code.

I think the TL;DR here is basically me reiterating this something that should ideally be put on the site devs' plate to do. But if you still really need to do it all in Launch because Reasons^TM, keep on reading.

'A' Solution...

Note: This is a really basic example with a simple open-mode shadow DOM scenario - in reality your scenario is almost certainly a lot more complex. I expect you to know what you're doing with javascript if you're diving into this!

Let's say you have the following on the page. Simple example of a custom html element with a button added to its shadow DOM.

<script>
class MyComponent extends HTMLElement {
    constructor() {
        super();
        this._shadowRoot = this.attachShadow({
            mode: 'open'
        });
        var button = document.createElement('button');
        button.id = 'myButton';
        button.value = 'my button value';
        button.innerText = 'My Button';
        this._shadowRoot.appendChild(button);
    }
}
customElements.define('my-component', MyComponent);
</script>
<my-component id='myComponentContainer'></my-component>

Let's say you want to trigger a rule when a visitor clicks on the button.

Quick Solution Example

At this point I should probably say that you can get away with doing a Launch click event rule with query selector my-component#myComponentContainer with a custom code condition along the lines of:

return event.nativeEvent.path[0].matches('button#myButton');

Something like this should work for this scenario because there are a lot of stars aligned here:

The shadow dom is open mode, so no hacks to overwrite things
There are easily identifiable unique css selectors for both light and shadow DOM levels
You just want to listen for the click event, which bubbles up and acts like a click happened on the shadow root's light DOM root.

In practice though, your requirements probably aren't going to be this easy. Maybe you need to attach some other event listener, such as a video play event. Unfortunately, there is no "one size fits all" solution at this point; it just depends on what your actual tracking requirements are.

But in general, the goal is pretty much the same as what you would have asked the devs to do: create and broadcast a custom (light) DOM event within the context of the shadow DOM.

Better Solution Example

Using the same component example and requirement as above, you could for example create a rule to trigger on DOM Ready. Name it something like "My Component Tracking - Core" or whatever. No conditions, unless you want to do something like check if the web component's root light DOM element exists or whatever.

Overall, this is the core code for attaching the event listener to the button and dispatching a custom event for Launch to listen for. Note, this code is based on our example component and tracking requirements above. It is unique to this example. You will need to write similar code based on your own setup.

Add a custom js container with something along the lines of this:

// get the root (light dom) element of the component
var rootElement = document.querySelector('#myComponentContainer');
if (rootElement && rootElement.shadowRoot) {
    // get a reference to the component's shadow dom
    var rootElementDOM = rootElement.shadowRoot;

    // try and look for the button 
    var elem = rootElementDOM.querySelector('button#myButton');
    if (elem) {
        // add a click event listener to the button
        elem.addEventListener('click', function(e) {
            // optional payload of data to send to the custom event, e.g. the button's value
            var data = {
                value: e.target.value
            };

            // create a custom event 'MyButtonClick' to broadcast
            var ev = new CustomEvent('MyButtonClick', {
                detail: data
            });

            // broadcast the event (remember, natively, Launch can only listen for custom events starting on document.body, not document!
            document.body.dispatchEvent(ev);
        }, false);
    }
}

From here, you can create a new rule that listens for the custom event broadcast.

Custom Event Rule Example

Rule name: My Button clicks

Events

Extension: Core
Event Type: Custom Event
Name: MyButtonClick
Custom Event Type: MyButtonClick
Elements matching the CSS selector: body

Conditions

*None for this scenario*

From here, you can set whatever Actions you want (set Adobe Analytics variables, send beacon, etc.).

Note: In this example, I sent a data payload to the custom event. You can reference the payload in any custom (javascript) code box with event.detail, e.g. event.detail.value. You can also reference them in Launch fields with the % syntax, e.g. %event.detail.value%.