@coveops/abi 1.3.1 → 1.5.0

package/dist/cjs/abi.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const index = require('./index-355878fc.js');
+const index = require('./index-3cecd23d.js');
 
 /*
  Stencil Client Patch Browser v2.17.3 | MIT Licensed | https://stenciljs.com
@@ -15,5 +15,5 @@ const patchBrowser = () => {
 };
 
 patchBrowser().then(options => {
-  return index.bootstrapLazy([["faq-popup-component.cjs",[[1,"faq-popup-component",{"result":[32]}]]],["results-manager.cjs",[[0,"results-manager"]]],["sample-component.cjs",[[1,"sample-component",{"pagerState":[32],"statusState":[32]}]]],["standalone-searchbox-listener.cjs",[[1,"standalone-searchbox-listener",null,[[8,"header/searchbox/query","handleStandaloneSearchbox"]]]]],["strip-html-component.cjs",[[1,"strip-html-component",{"result":[32]}]]]], options);
+  return index.bootstrapLazy([["faq-popup-component.cjs",[[1,"faq-popup-component",{"origin":[1],"result":[32]}]]],["recs-initialization-helper.cjs",[[1,"recs-initialization-helper",{"userCountry":[1,"user-country"]}]]],["recs-results-manager.cjs",[[0,"recs-results-manager"]]],["results-manager.cjs",[[0,"results-manager"]]],["sample-component.cjs",[[1,"sample-component",{"pagerState":[32],"statusState":[32]}]]],["standalone-searchbox-listener.cjs",[[1,"standalone-searchbox-listener",null,[[8,"header/searchbox/query","handleStandaloneSearchbox"]]]]],["strip-html-component.cjs",[[1,"strip-html-component",{"result":[32]}]]]], options);
 });

package/dist/cjs/faq-popup-component.cjs.entry.js

@@ -2,12 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const index = require('./index-355878fc.js');
-const index$1 = require('./index-20ac4bdb.js');
+const index = require('./index-3cecd23d.js');
+const index$1 = require('./index-d1493bab.js');
 const resultTemplateDecorators881a4c8e = require('./result-template-decorators-881a4c8e-4ff46481.js');
 require('./headless.esm-085e70ed-f2e18485.js');
 
-const faqPopupComponentCss = "b{color:var(--atomic-primary)}:host{color:#CAA144 !important;font-size:1.7rem !important;max-height:unset !important;line-height:normal !important}";
+const faqPopupComponentCss = "b{color:var(--atomic-primary)}.search-css{color:#CAA144 !important;font-size:1.7rem !important;max-height:unset !important;line-height:normal !important}:host{cursor:pointer}";
 
 const FaqPopupComponent = class {
   constructor(hostRef) {
@@ -134,7 +134,8 @@ const FaqPopupComponent = class {
     if (!this.result) {
       return;
     }
-    return (index.h(index.Host, { className: "clickable-host", onClick: () => this.openFAQModal(this.result) }, this.result.title));
+    const cssCondition = this.origin === 'searchResult' ? 'search-css' : '';
+    return (index.h(index.Host, { className: `clickable-host ${cssCondition}`, onClick: () => this.openFAQModal(this.result) }, this.result.title));
   }
   get host() { return index.getElement(this); }
 };

package/dist/cjs/{index-355878fc.js → index-3cecd23d.js}

@@ -707,7 +707,7 @@ const updateComponent = async (hostRef, instance, isInitialLoad) => {
 };
 const callRender = (hostRef, instance, elm) => {
     try {
-        instance = instance.render() ;
+        instance = instance.render && instance.render();
         {
             hostRef.$flags$ &= ~16 /* isQueuedForUpdate */;
         }
@@ -830,6 +830,11 @@ const addHydratedFlag = (elm) => elm.classList.add('hydrated')
 const parsePropertyValue = (propValue, propType) => {
     // ensure this value is of the correct prop type
     if (propValue != null && !isComplexType(propValue)) {
+        if (propType & 1 /* String */) {
+            // could have been passed as a number or boolean
+            // but we still want it as a string
+            return String(propValue);
+        }
         // redundant return here for better minification
         return propValue;
     }
@@ -844,7 +849,7 @@ const setValue = (ref, propName, newVal, cmpMeta) => {
     const oldVal = hostRef.$instanceValues$.get(propName);
     const flags = hostRef.$flags$;
     const instance = hostRef.$lazyInstance$ ;
-    newVal = parsePropertyValue(newVal);
+    newVal = parsePropertyValue(newVal, cmpMeta.$members$[propName][0]);
     // explicitly check for NaN on both sides, as `NaN === NaN` is always false
     const areBothNaN = Number.isNaN(oldVal) && Number.isNaN(newVal);
     const didValueChange = newVal !== oldVal && !areBothNaN;
@@ -879,13 +884,76 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                     },
                     set(newValue) {
                         // proxyComponent, set value
-                        setValue(this, memberName, newValue);
+                        setValue(this, memberName, newValue, cmpMeta);
                     },
                     configurable: true,
                     enumerable: true,
                 });
             }
         });
+        if ((flags & 1 /* isElementConstructor */)) {
+            const attrNameToPropName = new Map();
+            prototype.attributeChangedCallback = function (attrName, _oldValue, newValue) {
+                plt.jmp(() => {
+                    const propName = attrNameToPropName.get(attrName);
+                    //  In a web component lifecycle the attributeChangedCallback runs prior to connectedCallback
+                    //  in the case where an attribute was set inline.
+                    //  ```html
+                    //    <my-component some-attribute="some-value"></my-component>
+                    //  ```
+                    //
+                    //  There is an edge case where a developer sets the attribute inline on a custom element and then
+                    //  programmatically changes it before it has been upgraded as shown below:
+                    //
+                    //  ```html
+                    //    <!-- this component has _not_ been upgraded yet -->
+                    //    <my-component id="test" some-attribute="some-value"></my-component>
+                    //    <script>
+                    //      // grab non-upgraded component
+                    //      el = document.querySelector("#test");
+                    //      el.someAttribute = "another-value";
+                    //      // upgrade component
+                    //      customElements.define('my-component', MyComponent);
+                    //    </script>
+                    //  ```
+                    //  In this case if we do not unshadow here and use the value of the shadowing property, attributeChangedCallback
+                    //  will be called with `newValue = "some-value"` and will set the shadowed property (this.someAttribute = "another-value")
+                    //  to the value that was set inline i.e. "some-value" from above example. When
+                    //  the connectedCallback attempts to unshadow it will use "some-value" as the initial value rather than "another-value"
+                    //
+                    //  The case where the attribute was NOT set inline but was not set programmatically shall be handled/unshadowed
+                    //  by connectedCallback as this attributeChangedCallback will not fire.
+                    //
+                    //  https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties
+                    //
+                    //  TODO(STENCIL-16) we should think about whether or not we actually want to be reflecting the attributes to
+                    //  properties here given that this goes against best practices outlined here
+                    //  https://developers.google.com/web/fundamentals/web-components/best-practices#avoid-reentrancy
+                    if (this.hasOwnProperty(propName)) {
+                        newValue = this[propName];
+                        delete this[propName];
+                    }
+                    else if (prototype.hasOwnProperty(propName) &&
+                        typeof this[propName] === 'number' &&
+                        this[propName] == newValue) {
+                        // if the propName exists on the prototype of `Cstr`, this update may be a result of Stencil using native
+                        // APIs to reflect props as attributes. Calls to `setAttribute(someElement, propName)` will result in
+                        // `propName` to be converted to a `DOMString`, which may not be what we want for other primitive props.
+                        return;
+                    }
+                    this[propName] = newValue === null && typeof this[propName] === 'boolean' ? false : newValue;
+                });
+            };
+            // create an array of attributes to observe
+            // and also create a map of html attribute name to js property name
+            Cstr.observedAttributes = members
+                .filter(([_, m]) => m[0] & 15 /* HasAttribute */) // filter to only keep props that should match attributes
+                .map(([propName, m]) => {
+                const attrName = m[1] || propName;
+                attrNameToPropName.set(attrName, propName);
+                return attrName;
+            });
+        }
     }
     return Cstr;
 };
@@ -987,6 +1055,17 @@ const connectedCallback = (elm) => {
                     }
                 }
             }
+            // Lazy properties
+            // https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties
+            if (cmpMeta.$members$) {
+                Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => {
+                    if (memberFlags & 31 /* Prop */ && elm.hasOwnProperty(memberName)) {
+                        const value = elm[memberName];
+                        delete elm[memberName];
+                        elm[memberName] = value;
+                    }
+                });
+            }
             {
                 initializeComponent(elm, hostRef, cmpMeta);
             }