hemfixarna-web-components 1.6.1 → 1.6.2

package/dist/hemfixarna-components/hemfixarna-superfront.entry.js

@@ -0,0 +1,20 @@
+import { r as registerInstance, h } from './index-f1a87cf1.js';
+import { W as WidgetStyle, B as Business } from './index-d90ad11b.js';
+
+const MyComponent = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.id = undefined;
+    this.loadFromQuery = undefined;
+    this.widgetStyle = WidgetStyle.standard;
+    this.buttonColor = undefined;
+    this.buttonBg = undefined;
+  }
+  render() {
+    return (h("hemfixarna-component", { widgetStyle: this.widgetStyle, buttonBg: this.buttonBg, buttonColor: this.buttonColor, loadFromQuery: Boolean(this.loadFromQuery), id: this.id, business: Business.superfront }));
+  }
+};
+
+export { MyComponent as hemfixarna_superfront };
+
+//# sourceMappingURL=hemfixarna-superfront.entry.js.map

package/dist/hemfixarna-components/hemfixarna-superfront.entry.js.map

@@ -0,0 +1 @@
+{"file":"hemfixarna-superfront.entry.esm.js","mappings":";;;;;;;;;;;;;;;;;;;","names":[],"sources":[],"sourcesContent":[],"version":3}

package/dist/hemfixarna-components/hemfixarna-tesla.entry.js

@@ -0,0 +1,21 @@
+import { r as registerInstance, h } from './index-f1a87cf1.js';
+import { W as WidgetStyle, B as Business } from './index-d90ad11b.js';
+
+const MyComponent = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.id = undefined;
+    this.loadFromQuery = 'true';
+    this.isDemo = false;
+    this.widgetStyle = WidgetStyle.standard;
+    this.buttonColor = undefined;
+    this.buttonBg = undefined;
+  }
+  render() {
+    return (h("hemfixarna-component", { widgetStyle: this.widgetStyle, buttonBg: this.buttonBg, buttonColor: this.buttonColor, nav: { url: 'https://www.tesla.com/sv_se/home-charging', logo: 'assets/tesla.svg' }, isDemo: this.isDemo, loadFromQuery: Boolean(this.loadFromQuery), id: this.id, business: Business.tesla }));
+  }
+};
+
+export { MyComponent as hemfixarna_tesla };
+
+//# sourceMappingURL=hemfixarna-tesla.entry.js.map

package/dist/hemfixarna-components/hemfixarna-tesla.entry.js.map

@@ -0,0 +1 @@
+{"file":"hemfixarna-tesla.entry.esm.js","mappings":";;;;;;;;;;;;;;;;;;;;","names":[],"sources":[],"sourcesContent":[],"version":3}

package/dist/hemfixarna-components/hemfixarna-traningspartner.entry.js

@@ -0,0 +1,20 @@
+import { r as registerInstance, h } from './index-f1a87cf1.js';
+import { W as WidgetStyle, B as Business } from './index-d90ad11b.js';
+
+const MyComponent = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.id = undefined;
+    this.loadFromQuery = undefined;
+    this.widgetStyle = WidgetStyle.standard;
+    this.buttonColor = undefined;
+    this.buttonBg = undefined;
+  }
+  render() {
+    return (h("hemfixarna-component", { widgetStyle: this.widgetStyle, buttonBg: this.buttonBg, buttonColor: this.buttonColor, loadFromQuery: Boolean(this.loadFromQuery), id: this.id, business: Business.traningspartner }));
+  }
+};
+
+export { MyComponent as hemfixarna_traningspartner };
+
+//# sourceMappingURL=hemfixarna-traningspartner.entry.js.map

package/dist/hemfixarna-components/hemfixarna-traningspartner.entry.js.map

@@ -0,0 +1 @@
+{"file":"hemfixarna-traningspartner.entry.esm.js","mappings":";;;;;;;;;;;;;;;;;;;","names":[],"sources":[],"sourcesContent":[],"version":3}

package/dist/hemfixarna-components/hemfixarna-zaptec.entry.js

@@ -0,0 +1,21 @@
+import { r as registerInstance, h } from './index-f1a87cf1.js';
+import { W as WidgetStyle, B as Business } from './index-d90ad11b.js';
+
+const MyComponent = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.id = undefined;
+    this.loadFromQuery = 'true';
+    this.isDemo = false;
+    this.widgetStyle = WidgetStyle.standard;
+    this.buttonColor = undefined;
+    this.buttonBg = undefined;
+  }
+  render() {
+    return (h("hemfixarna-component", { widgetStyle: this.widgetStyle, buttonBg: this.buttonBg, buttonColor: this.buttonColor, nav: { url: 'https://www.zaptec.com/sv/laddningslosningar/zaptec-go', logo: 'assets/zaptec.svg' }, isDemo: this.isDemo, loadFromQuery: Boolean(this.loadFromQuery), id: this.id, business: Business.zaptec }));
+  }
+};
+
+export { MyComponent as hemfixarna_zaptec };
+
+//# sourceMappingURL=hemfixarna-zaptec.entry.js.map

package/dist/hemfixarna-components/hemfixarna-zaptec.entry.js.map

@@ -0,0 +1 @@
+{"file":"hemfixarna-zaptec.entry.esm.js","mappings":";;;;;;;;;;;;;;;;;;;;","names":[],"sources":[],"sourcesContent":[],"version":3}

package/dist/hemfixarna-components/index-b6a6e994.js

@@ -0,0 +1,256 @@
+import { f as getRenderingRef, i as forceUpdate } from './index-f1a87cf1.js';
+
+const appendToMap = (map, propName, value) => {
+    const items = map.get(propName);
+    if (!items) {
+        map.set(propName, [value]);
+    }
+    else if (!items.includes(value)) {
+        items.push(value);
+    }
+};
+const debounce = (fn, ms) => {
+    let timeoutId;
+    return (...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            timeoutId = 0;
+            fn(...args);
+        }, ms);
+    };
+};
+
+/**
+ * Check if a possible element isConnected.
+ * The property might not be there, so we check for it.
+ *
+ * We want it to return true if isConnected is not a property,
+ * otherwise we would remove these elements and would not update.
+ *
+ * Better leak in Edge than to be useless.
+ */
+const isConnected = (maybeElement) => !('isConnected' in maybeElement) || maybeElement.isConnected;
+const cleanupElements = debounce((map) => {
+    for (let key of map.keys()) {
+        map.set(key, map.get(key).filter(isConnected));
+    }
+}, 2000);
+const stencilSubscription = () => {
+    if (typeof getRenderingRef !== 'function') {
+        // If we are not in a stencil project, we do nothing.
+        // This function is not really exported by @stencil/core.
+        return {};
+    }
+    const elmsToUpdate = new Map();
+    return {
+        dispose: () => elmsToUpdate.clear(),
+        get: (propName) => {
+            const elm = getRenderingRef();
+            if (elm) {
+                appendToMap(elmsToUpdate, propName, elm);
+            }
+        },
+        set: (propName) => {
+            const elements = elmsToUpdate.get(propName);
+            if (elements) {
+                elmsToUpdate.set(propName, elements.filter(forceUpdate));
+            }
+            cleanupElements(elmsToUpdate);
+        },
+        reset: () => {
+            elmsToUpdate.forEach((elms) => elms.forEach(forceUpdate));
+            cleanupElements(elmsToUpdate);
+        },
+    };
+};
+
+const unwrap = (val) => (typeof val === 'function' ? val() : val);
+const createObservableMap = (defaultState, shouldUpdate = (a, b) => a !== b) => {
+    const unwrappedState = unwrap(defaultState);
+    let states = new Map(Object.entries(unwrappedState !== null && unwrappedState !== void 0 ? unwrappedState : {}));
+    const handlers = {
+        dispose: [],
+        get: [],
+        set: [],
+        reset: [],
+    };
+    const reset = () => {
+        var _a;
+        // When resetting the state, the default state may be a function - unwrap it to invoke it.
+        // otherwise, the state won't be properly reset
+        states = new Map(Object.entries((_a = unwrap(defaultState)) !== null && _a !== void 0 ? _a : {}));
+        handlers.reset.forEach((cb) => cb());
+    };
+    const dispose = () => {
+        // Call first dispose as resetting the state would
+        // cause less updates ;)
+        handlers.dispose.forEach((cb) => cb());
+        reset();
+    };
+    const get = (propName) => {
+        handlers.get.forEach((cb) => cb(propName));
+        return states.get(propName);
+    };
+    const set = (propName, value) => {
+        const oldValue = states.get(propName);
+        if (shouldUpdate(value, oldValue, propName)) {
+            states.set(propName, value);
+            handlers.set.forEach((cb) => cb(propName, value, oldValue));
+        }
+    };
+    const state = (typeof Proxy === 'undefined'
+        ? {}
+        : new Proxy(unwrappedState, {
+            get(_, propName) {
+                return get(propName);
+            },
+            ownKeys(_) {
+                return Array.from(states.keys());
+            },
+            getOwnPropertyDescriptor() {
+                return {
+                    enumerable: true,
+                    configurable: true,
+                };
+            },
+            has(_, propName) {
+                return states.has(propName);
+            },
+            set(_, propName, value) {
+                set(propName, value);
+                return true;
+            },
+        }));
+    const on = (eventName, callback) => {
+        handlers[eventName].push(callback);
+        return () => {
+            removeFromArray(handlers[eventName], callback);
+        };
+    };
+    const onChange = (propName, cb) => {
+        const unSet = on('set', (key, newValue) => {
+            if (key === propName) {
+                cb(newValue);
+            }
+        });
+        // We need to unwrap the defaultState because it might be a function.
+        // Otherwise we might not be sending the right reset value.
+        const unReset = on('reset', () => cb(unwrap(defaultState)[propName]));
+        return () => {
+            unSet();
+            unReset();
+        };
+    };
+    const use = (...subscriptions) => {
+        const unsubs = subscriptions.reduce((unsubs, subscription) => {
+            if (subscription.set) {
+                unsubs.push(on('set', subscription.set));
+            }
+            if (subscription.get) {
+                unsubs.push(on('get', subscription.get));
+            }
+            if (subscription.reset) {
+                unsubs.push(on('reset', subscription.reset));
+            }
+            if (subscription.dispose) {
+                unsubs.push(on('dispose', subscription.dispose));
+            }
+            return unsubs;
+        }, []);
+        return () => unsubs.forEach((unsub) => unsub());
+    };
+    const forceUpdate = (key) => {
+        const oldValue = states.get(key);
+        handlers.set.forEach((cb) => cb(key, oldValue, oldValue));
+    };
+    return {
+        state,
+        get,
+        set,
+        on,
+        onChange,
+        use,
+        dispose,
+        reset,
+        forceUpdate,
+    };
+};
+const removeFromArray = (array, item) => {
+    const index = array.indexOf(item);
+    if (index >= 0) {
+        array[index] = array[array.length - 1];
+        array.length--;
+    }
+};
+
+const createStore = (defaultState, shouldUpdate) => {
+    const map = createObservableMap(defaultState, shouldUpdate);
+    map.use(stencilSubscription());
+    return map;
+};
+
+const { state, onChange, } = createStore({
+  step: 1,
+  checkoutStep: 1,
+  checkoutEdit: false,
+  selectedCategory: null,
+  selectedService: null,
+  selectedProduct: null,
+  cart: [],
+  business: 'undefined',
+  options: null,
+  rut: true,
+  rot: true,
+  green: true,
+  token: null,
+  user: null,
+  modal: null,
+  rutOptions: null,
+  rotOptions: null,
+  greenOptions: null,
+  customer: null,
+  selectedCustomerCategory: null,
+  parentCategory: null,
+  creditSafeUser: null,
+  checkoutInvoice: false,
+  maleri: false,
+  sources: null,
+});
+onChange('cart', cart => {
+  window.sessionStorage.setItem(`hemfixarna-${state.business}-cart`, JSON.stringify(cart));
+});
+onChange('user', user => {
+  window.sessionStorage.setItem(`hemfixarna-${state.business}-user`, JSON.stringify(user));
+});
+onChange('creditSafeUser', user => {
+  window.sessionStorage.setItem(`hemfixarna-${state.business}-creditSafeUser`, JSON.stringify(user));
+});
+onChange('selectedProduct', product => {
+  if (!state.customer || !product)
+    return;
+  const categories = [...state.customer.categories, ...state.customer.categories.map(c => { var _a; return (_a = c.sub_categories) !== null && _a !== void 0 ? _a : []; })].flat();
+  const category = categories.find(c => c && c.id === product.category);
+  if (category) {
+    state.parentCategory = category;
+    return;
+  }
+  state.parentCategory = null;
+});
+onChange('selectedCustomerCategory', category => {
+  if (!state.customer || !category)
+    return;
+  if (category.parent) {
+    const parent = state.customer.categories.find(c => c.id === category.parent);
+    if (parent) {
+      state.parentCategory = parent;
+      return;
+    }
+  }
+  state.parentCategory = null;
+});
+
+export { state as s };
+
+//# sourceMappingURL=index-b6a6e994.js.map

package/dist/hemfixarna-components/index-b6a6e994.js.map

@@ -0,0 +1 @@
+{"file":"index-b6a6e994.js","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","names":[],"sources":[],"sourcesContent":[],"version":3}

package/dist/{collection/types/index.js → hemfixarna-components/index-d90ad11b.js}

@@ -1,4 +1,4 @@
-export var Business;
+var Business;
 (function (Business) {
   Business["kund"] = "kund";
   Business["byggmax"] = "byggmax";
@@ -21,15 +21,18 @@ export var Business;
   Business["traningspartner"] = "traningspartner";
   Business["superfront"] = "superfront";
 })(Business || (Business = {}));
-export var WidgetStyle;
+var WidgetStyle;
 (function (WidgetStyle) {
   WidgetStyle["standard"] = "standard";
   WidgetStyle["alternative"] = "alternative";
   WidgetStyle["alternative_2"] = "alternative_2";
   WidgetStyle["alternative_3"] = "alternative_3";
 })(WidgetStyle || (WidgetStyle = {}));
-export var TopCategory;
+var TopCategory;
 (function (TopCategory) {
   TopCategory["byggmax"] = "category/bygg";
 })(TopCategory || (TopCategory = {}));
-//# sourceMappingURL=index.js.map
+
+export { Business as B, TopCategory as T, WidgetStyle as W };
+
+//# sourceMappingURL=index-d90ad11b.js.map

package/dist/hemfixarna-components/index-d90ad11b.js.map

@@ -0,0 +1 @@
+{"file":"index-d90ad11b.js","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","names":[],"sources":[],"sourcesContent":[],"version":3}