@telia-ace/widget-utilities 1.0.0 → 1.0.3

package/dist/index.js

@@ -0,0 +1,802 @@
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function uniqueClassArray(classNames) {
+  const classArray = [];
+  classNames.forEach((c) => {
+    if (classArray.indexOf(c) === -1) {
+      classArray.push(c);
+    }
+  });
+  return classArray;
+}
+function append(className1 = "", className2 = "") {
+  const classNames = className1.split(" ").concat(className2.split(" "));
+  return uniqueClassArray(classNames).join(" ").trim();
+}
+function handleFunctionArgument(expression, classes) {
+  if (Boolean(expression)) {
+    if (typeof classes === "string") {
+      return classes;
+    }
+    if (Array.isArray(classes)) {
+      let className = "";
+      classes.forEach((c) => className = append(className, c));
+      return className;
+    }
+  }
+}
+function appendClassNames(...args) {
+  let className = "";
+  if (args.length) {
+    args.forEach((argument) => {
+      if (typeof argument === "string") {
+        className = append(className, argument);
+      } else if (Array.isArray(argument)) {
+        className = append(className, handleFunctionArgument(...argument));
+      } else
+        ;
+    });
+  }
+  return className;
+}
+const createBatch = (delay, createFallback) => {
+  let timeout;
+  let queue = [];
+  return (fn) => {
+    clearTimeout(timeout);
+    return new Promise((resolve, reject) => {
+      queue.push([fn, resolve, reject]);
+      timeout = setTimeout(() => {
+        let acc = createFallback();
+        queue.forEach(([fn2, resolve2, reject2]) => {
+          acc = fn2(acc);
+        });
+        queue = [];
+        resolve(acc);
+      }, delay);
+    });
+  };
+};
+function camilize(obj) {
+  const camilizedObject = {};
+  if (typeof obj === "number" || typeof obj === "string") {
+    return obj;
+  }
+  for (const prop in obj) {
+    if (obj.hasOwnProperty(prop)) {
+      const p = obj[prop];
+      const camilizedProp = prop.substring(0, 1).toLowerCase() + prop.substring(1);
+      if (Object.prototype.toString.call(p) === "[object Array]") {
+        camilizedObject[camilizedProp] = [];
+        for (let i = 0, c = p.length; i < c; i++) {
+          camilizedObject[camilizedProp].push(camilize(p[i]));
+        }
+      } else if (p !== null && typeof p === "object") {
+        camilizedObject[camilizedProp] = camilize(p);
+      } else {
+        camilizedObject[camilizedProp] = p;
+      }
+    }
+  }
+  return camilizedObject;
+}
+function createParams(args = {}) {
+  const _a = args, {
+    phrase = "",
+    category,
+    guideCategory,
+    contactCategory,
+    take,
+    connectionKey,
+    accordion,
+    id,
+    uriName,
+    sorting,
+    tag,
+    tagId,
+    tagTitle
+  } = _a, other = __objRest(_a, [
+    "phrase",
+    "category",
+    "guideCategory",
+    "contactCategory",
+    "take",
+    "connectionKey",
+    "accordion",
+    "id",
+    "uriName",
+    "sorting",
+    "tag",
+    "tagId",
+    "tagTitle"
+  ]);
+  const params = {};
+  Object.keys(other).forEach((k) => {
+    if (typeof args[k] === "string") {
+      params[k] = args[k];
+    }
+  });
+  if (typeof phrase === "string" && phrase.length) {
+    params.phrase = phrase;
+  }
+  if (phrase === null) {
+    params.phrase = phrase;
+  }
+  if (typeof guideCategory === "string" && guideCategory !== "0") {
+    params.guideCategory = guideCategory;
+  }
+  if (typeof guideCategory === "number" && guideCategory !== 0) {
+    params.guideCategory = guideCategory;
+  }
+  if (typeof guideCategory === "object" && guideCategory !== null) {
+    if (typeof guideCategory.id === "string" && guideCategory.id !== "0") {
+      params.guideCategory = guideCategory.id;
+    }
+    if (typeof guideCategory.id === "number" && guideCategory.id !== 0) {
+      params.guideCategory = guideCategory.id;
+    }
+  }
+  if (typeof contactCategory === "string" && contactCategory !== "0") {
+    params.contactCategory = contactCategory;
+  }
+  if (typeof contactCategory === "number" && contactCategory !== 0) {
+    params.contactCategory = contactCategory;
+  }
+  if (typeof contactCategory === "object" && contactCategory !== null) {
+    if (typeof contactCategory.id === "string" && contactCategory.id !== "0") {
+      params.contactCategory = contactCategory.id;
+    }
+    if (typeof contactCategory.id === "number" && contactCategory.id !== 0) {
+      params.contactCategory = contactCategory.id;
+    }
+  }
+  if (typeof category === "string" && category !== "0") {
+    params.category = category;
+  }
+  if (typeof category === "number" && category !== 0) {
+    params.category = category;
+  }
+  if (typeof category === "object" && category !== null) {
+    if (typeof category.id === "string" && category.id !== "0") {
+      params.category = category.id;
+    }
+    if (typeof category.id === "number" && category.id !== 0) {
+      params.category = category.id;
+    }
+  }
+  if (id) {
+    params.id = id;
+  }
+  if (uriName && (!!+params.category || !!+params.guideCategory || !!+params.guide || !!+params.contactCategory || !!+params.contactMethod)) {
+    params.uriName = uriName;
+  }
+  if (connectionKey) {
+    params.connectionKey = connectionKey;
+  }
+  if (take) {
+    params.take = take;
+  }
+  if (sorting) {
+    params.sorting = sorting;
+  }
+  if (typeof accordion === "string" && accordion.length > 0) {
+    params.accordion = accordion;
+  }
+  if (typeof tag === "string" && tag !== "0") {
+    params.tag = tag;
+  }
+  if (typeof tag === "number" && tag !== 0) {
+    params.tag = tag;
+  }
+  if (typeof tagId === "string" || typeof tagId === "number") {
+    params.tagId = tagId;
+  }
+  if (typeof tagTitle === "string") {
+    params.tagTitle = tagTitle;
+  }
+  return params;
+}
+function* processData(data) {
+  if (!data) {
+    return;
+  }
+  for (let i = 0; i < data.length; i++) {
+    const val = data[i];
+    yield val;
+    if (val.items) {
+      yield* processData(val.items);
+    }
+  }
+}
+const findCategoryById = (id, categories) => {
+  const it = processData(categories);
+  let res = it.next();
+  let found = null;
+  while (!res.done) {
+    if (res.value.id === id) {
+      found = res.value;
+    }
+    res = it.next();
+  }
+  return found;
+};
+const formatUrl = (url) => {
+  if (!url) {
+    return "";
+  }
+  const replacements = [
+    { from: /[äæǽ]+/gi, to: "ae" },
+    { from: /[öœ]+/gi, to: "oe" },
+    { from: /[ü]+/gi, to: "ue" },
+    { from: /[Ä]+/gi, to: "Ae" },
+    { from: /[Ü]+/gi, to: "Ue" },
+    { from: /[Ö]+/gi, to: "Oe" },
+    { from: /[ÀÁÂÃÄÅǺĀĂĄǍΑΆẢẠẦẪẨẬẰẮẴẲẶА]+/gi, to: "A" },
+    { from: /[àáâãåǻāăąǎªαάảạầấẫẩậằắẵẳặа]+/gi, to: "a" },
+    { from: /[Б]+/gi, to: "B" },
+    { from: /[б]+/gi, to: "b" },
+    { from: /[ÇĆĈĊČ]+/gi, to: "C" },
+    { from: /[çćĉċč]+/gi, to: "c" },
+    { from: /[Д]+/gi, to: "D" },
+    { from: /[д]+/gi, to: "d" },
+    { from: /[ÐĎĐΔ]+/gi, to: "Dj" },
+    { from: /[ðďđδ]+/gi, to: "dj" },
+    { from: /[ÈÉÊËĒĔĖĘĚΕΈẼẺẸỀẾỄỂỆЕЭ]+/gi, to: "E" },
+    { from: /[èéêëēĕėęěέεẽẻẹềếễểệеэ]+/gi, to: "e" },
+    { from: /[Ф]+/gi, to: "F" },
+    { from: /[ф]+/gi, to: "f" },
+    { from: /[ĜĞĠĢΓГҐ]+/gi, to: "G" },
+    { from: /[ĝğġģγгґ]+/gi, to: "g" },
+    { from: /[ĤĦ]+/gi, to: "H" },
+    { from: /[ĥħ]+/gi, to: "h" },
+    { from: /[ÌÍÎÏĨĪĬǏĮİΗΉΊΙΪỈỊИЫ]+/gi, to: "I" },
+    { from: /[ìíîïĩīĭǐįıηήίιϊỉịиыї]+/gi, to: "i" },
+    { from: /[Ĵ]+/gi, to: "J" },
+    { from: /[ĵ]+/gi, to: "j" },
+    { from: /[ĶΚК]+/gi, to: "K" },
+    { from: /[ķκк]+/gi, to: "k" },
+    { from: /[ĹĻĽĿŁΛЛ]+/gi, to: "L" },
+    { from: /[ĺļľŀłλл]+/gi, to: "l" },
+    { from: /[М]+/gi, to: "M" },
+    { from: /[м]+/gi, to: "m" },
+    { from: /[ÑŃŅŇΝН]+/gi, to: "N" },
+    { from: /[ñńņňʼnνн]+/gi, to: "n" },
+    { from: /[ÒÓÔÕŌŎǑŐƠØǾΟΌΩΏỎỌỒỐỖỔỘỜỚỠỞỢО]+/gi, to: "O" },
+    { from: /[òóôõōŏǒőơøǿºοόωώỏọồốỗổộờớỡởợо]+/gi, to: "o" },
+    { from: /[П]+/gi, to: "P" },
+    { from: /[п]+/gi, to: "p" },
+    { from: /[ŔŖŘΡР]+/gi, to: "R" },
+    { from: /[ŕŗřρр]+/gi, to: "r" },
+    { from: /[ŚŜŞȘŠΣС]+/gi, to: "S" },
+    { from: /[śŝşșšſσςс]+/gi, to: "s" },
+    { from: /[ȚŢŤŦτТ]+/gi, to: "T" },
+    { from: /[țţťŧт]+/gi, to: "t" },
+    { from: /[ÙÚÛŨŪŬŮŰŲƯǓǕǗǙǛŨỦỤỪỨỮỬỰУ]+/gi, to: "U" },
+    { from: /[ùúûũūŭůűųưǔǖǘǚǜυύϋủụừứữửựу]+/gi, to: "u" },
+    { from: /[ÝŸŶΥΎΫỲỸỶỴЙ]+/gi, to: "Y" },
+    { from: /[ýÿŷỳỹỷỵй]+/gi, to: "y" },
+    { from: /[В]+/gi, to: "V" },
+    { from: /[в]+/gi, to: "v" },
+    { from: /[Ŵ]+/gi, to: "W" },
+    { from: /[ŵ]+/gi, to: "w" },
+    { from: /[ŹŻŽΖЗ]+/gi, to: "Z" },
+    { from: /[źżžζз]+/gi, to: "z" },
+    { from: /[ÆǼ]+/gi, to: "AE" },
+    { from: /[ß]+/gi, to: "ss" },
+    { from: /[IJ]+/gi, to: "IJ" },
+    { from: /[ij]+/gi, to: "ij" },
+    { from: /[Œ]+/gi, to: "OE" },
+    { from: /[ƒ]+/gi, to: "f" },
+    { from: /[ξ]+/gi, to: "ks" },
+    { from: /[π]+/gi, to: "p" },
+    { from: /[β]+/gi, to: "v" },
+    { from: /[μ]+/gi, to: "m" },
+    { from: /[ψ]+/gi, to: "ps" },
+    { from: /[Ё]+/gi, to: "Yo" },
+    { from: /[ё]+/gi, to: "yo" },
+    { from: /[Є]+/gi, to: "Ye" },
+    { from: /[є]+/gi, to: "ye" },
+    { from: /[Ї]+/gi, to: "Yi" },
+    { from: /[Ж]+/gi, to: "Zh" },
+    { from: /[ж]+/gi, to: "zh" },
+    { from: /[Х]+/gi, to: "Kh" },
+    { from: /[х]+/gi, to: "kh" },
+    { from: /[Ц]+/gi, to: "Ts" },
+    { from: /[ц]+/gi, to: "ts" },
+    { from: /[Ч]+/gi, to: "Ch" },
+    { from: /[ч]+/gi, to: "ch" },
+    { from: /[Ш]+/gi, to: "Sh" },
+    { from: /[ш]+/gi, to: "sh" },
+    { from: /[Щ]+/gi, to: "Shch" },
+    { from: /[щ]+/gi, to: "shch" },
+    { from: /[ЪъЬь]+/gi, to: "" },
+    { from: /[Ю]+/gi, to: "Yu" },
+    { from: /[ю]+/gi, to: "yu" },
+    { from: /[Я]+/gi, to: "Ya" },
+    { from: /[я]+/gi, to: "ya" }
+  ];
+  const alphanumericExpression = /[^a-zA-Z0-9]+/g;
+  const trailingDashExpression = /[-]$/;
+  let parsed = url;
+  for (const i in replacements) {
+    if (replacements.hasOwnProperty(i) && replacements[i].from.test(url)) {
+      parsed = parsed.replace(replacements[i].from, replacements[i].to);
+    }
+  }
+  parsed = parsed.replace(alphanumericExpression, "-");
+  parsed = parsed.replace(trailingDashExpression, "");
+  parsed = parsed.toLowerCase();
+  return parsed || "humany";
+};
+function childParentStructure(items, structure = {}, parent) {
+  items.forEach((item) => {
+    if (parent) {
+      structure[+item.id] = parent;
+    }
+    if (item.items) {
+      childParentStructure(item.items, structure, item.id);
+    }
+  });
+  return structure;
+}
+function categoryTrail(id, items, ids = [id], structure = childParentStructure(items)) {
+  const addAncestors = (id2) => {
+    const parentId2 = structure[+id2];
+    if (parentId2) {
+      ids.unshift(parentId2);
+      addAncestors(parentId2);
+    }
+  };
+  const parentId = structure[+id];
+  if (parentId) {
+    ids.unshift(parentId);
+    addAncestors(parentId);
+  }
+  return ids;
+}
+const getCategoryTrailAsObjects = (trail, categories) => {
+  if (typeof trail === "undefined" || typeof categories === "undefined") {
+    return /* @__PURE__ */ new Map();
+  }
+  return new Map(trail.map((categoryId) => {
+    const category = findCategoryById(categoryId, categories);
+    return [categoryId, category];
+  }));
+};
+const buildCategoryTrail = (routeName, categoryIds, container, dataType = "guide-categories") => {
+  return container.getAsync("dataClient").then((dataClient) => {
+    return dataClient.fetch(dataType, { expandCategories: "descendants" }).then(({ categories }) => {
+      const buildTrail = (id) => {
+        const trail = categoryTrail(id, categories);
+        const objectTrail = getCategoryTrailAsObjects(trail, categories);
+        const result = [];
+        trail.forEach((categoryId) => {
+          const category = objectTrail.get(categoryId);
+          if (category) {
+            result.push({
+              routeName,
+              title: category.title,
+              symbol: category.symbol,
+              id: category.id,
+              routeParams: dataType === "contact-method-categories" ? createParams({
+                contactCategory: category.id,
+                uriName: formatUrl(category.title)
+              }) : createParams({
+                guideCategory: category.id,
+                uriName: formatUrl(category.title)
+              })
+            });
+          }
+        });
+        return result;
+      };
+      if (Array.isArray(categoryIds)) {
+        return categoryIds.reduce((acc, id) => {
+          const result = buildTrail(id);
+          if (result.length > 0) {
+            acc.push(result);
+          }
+          return acc;
+        }, []);
+      }
+      return buildTrail(categoryIds);
+    });
+  });
+};
+const dataURItoBlob = (dataURI) => {
+  let byteString;
+  let mimestring;
+  if (dataURI.split(",")[0].indexOf("base64") !== -1) {
+    byteString = atob(dataURI.split(",")[1]);
+  } else {
+    byteString = decodeURI(dataURI.split(",")[1]);
+  }
+  mimestring = dataURI.split(",")[0].split(":")[1].split(";")[0];
+  const content = [];
+  for (let i = 0; i < byteString.length; i++) {
+    content[i] = byteString.charCodeAt(i);
+  }
+  return new Blob([new Uint8Array(content)], { type: mimestring });
+};
+function debugLog(...args) {
+  return false;
+}
+const print = (print2, msgOrObj, ...args) => {
+  if (typeof msgOrObj === "string") {
+    return print2(`[humany] ${msgOrObj}`, ...args);
+  }
+  return print2(msgOrObj, ...args);
+};
+const _Logger = class {
+  constructor() {
+    this.keys = [];
+    this.log = (key, ...args) => this.lookup(key, () => _Logger.log(...args));
+    this.warn = (key, ...args) => this.lookup(key, () => _Logger.warn(...args));
+    this.error = (key, ...args) => this.lookup(key, () => _Logger.error(...args));
+    this.info = (key, ...args) => this.lookup(key, () => _Logger.info(...args));
+  }
+  lookup(key, fn) {
+    if (this.keys.indexOf(key) === -1) {
+      this.keys.push(key);
+      fn();
+    }
+  }
+};
+let Logger = _Logger;
+Logger.log = (...args) => print(console.log, ...args);
+Logger.warn = (...args) => print(console.warn, ...args);
+Logger.error = (...args) => print(console.error, ...args);
+Logger.info = (...args) => print(console.info, ...args);
+const deepClone = (data) => {
+  let out = {};
+  let value;
+  let key;
+  if (typeof data !== "object" || data === null) {
+    return data;
+  }
+  out = Array.isArray(data) ? [] : {};
+  for (key in data) {
+    value = data[key];
+    out[key] = typeof value === "object" && value !== null ? deepClone(value) : value;
+  }
+  return out;
+};
+var findAndActivateStoredWidgets = (implementation) => {
+  if (!implementation) {
+    return null;
+  }
+  const implementationStorage = localStorage.getItem(`humany_${hash(implementation.tenant + implementation.name)}`);
+  if (implementationStorage) {
+    const { activeStickyWidget } = JSON.parse(implementationStorage);
+    if (activeStickyWidget && activeStickyWidget.value) {
+      const widget = implementation.widgets.get(activeStickyWidget.value);
+      if (widget) {
+        const el = document.createElement("a");
+        el.setAttribute("href", `//${implementation.bindings[0]}/${activeStickyWidget.value}`);
+        document.body.appendChild(el);
+      }
+    }
+  }
+};
+var formatDate = (date, includeTime = false) => {
+  const d = new Date(date);
+  let month = `${d.getMonth() + 1}`;
+  let day = `${d.getDate()}`;
+  const year = d.getFullYear();
+  if (month.length < 2)
+    month = `0${month}`;
+  if (day.length < 2)
+    day = `0${day}`;
+  if (includeTime) {
+    let hours = `${d.getHours()}`;
+    let minutes = `${d.getMinutes()}`;
+    if (hours.length < 2)
+      hours = `0${hours}`;
+    if (minutes.length < 2)
+      minutes = `0${minutes}`;
+    return `${[year, month, day].join("-")} ${[hours, minutes].join(":")}`;
+  }
+  return [year, month, day].join("-");
+};
+function getCookie(cookieName) {
+  const documentCookie = document.cookie;
+  if (documentCookie.length > 0) {
+    let start = documentCookie.indexOf(`${cookieName}=`);
+    if (start !== -1) {
+      start = start + cookieName.length + 1;
+      let end = documentCookie.indexOf(";", start);
+      if (end === -1) {
+        end = documentCookie.length;
+      }
+      return unescape(documentCookie.substring(start, end));
+    }
+  }
+  return null;
+}
+function hash(s) {
+  let hash2 = 0;
+  if (s.length === 0) {
+    return hash2.toString();
+  }
+  for (let i = 0; i < s.length; i++) {
+    const char = s.charCodeAt(i);
+    hash2 = (hash2 << 5) - hash2 + char;
+    hash2 = hash2 & hash2;
+  }
+  return hash2.toString();
+}
+var htmlParentContains = (parent, child) => {
+  if (!parent || !child) {
+    return true;
+  }
+  let node = child.parentNode;
+  let hasChild = false;
+  while (node !== null) {
+    if (node === parent) {
+      hasChild = true;
+    }
+    node = node.parentNode;
+  }
+  return hasChild;
+};
+function kebabCase(string) {
+  return string.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/\s+/g, "-").toLowerCase();
+}
+class Queue {
+  constructor(lockWarningTime, lockErrorTime) {
+    this.lockWarningTime = lockWarningTime;
+    this.lockErrorTime = lockErrorTime;
+    this.tasks = [];
+    this.current = Promise.resolve();
+    this.next = this.next.bind(this);
+  }
+  add(task, resolve, reject, done) {
+    this.tasks.push({ task, resolve, reject, done });
+    this.next();
+  }
+  next() {
+    this.current = this.current.then(() => {
+      const next = this.tasks.shift();
+      if (next) {
+        let errorTimeout;
+        const warningTimeout = setTimeout(() => {
+          errorTimeout = setTimeout(() => {
+            next.reject("lock timeout exceeded");
+          }, this.lockErrorTime);
+        }, this.lockWarningTime);
+        const taskPromise = Promise.resolve(next.task()).then((result) => {
+          clearTimeout(warningTimeout);
+          clearTimeout(errorTimeout);
+          return result;
+        });
+        return Promise.resolve(taskPromise).then(this.next).then(() => taskPromise.then((data) => {
+          next.done();
+          next.resolve(data);
+        })).catch((reason) => {
+          next.done();
+          next.reject(reason);
+          return this.next();
+        });
+      }
+      return Promise.resolve();
+    });
+  }
+}
+const locks = /* @__PURE__ */ new WeakMap();
+function lock(key, lockWarningTime = 5e3, lockErrorTime = 1e3) {
+  if (!locks.has(key)) {
+    locks.set(key, new Queue(lockWarningTime, lockErrorTime));
+  }
+  return (task) => {
+    return new Promise((resolve, reject) => {
+      const queue = locks.get(key);
+      queue.add(task, resolve, reject, () => {
+        if (!queue.tasks.length) {
+          locks.delete(key);
+        }
+      });
+    });
+  };
+}
+const isObject = (item) => {
+  return !!item && typeof item === "object" && !Array.isArray(item);
+};
+const mergeDeep = (target, ...sources) => {
+  const clonedTarget = deepClone(target);
+  const clonedSources = deepClone(sources);
+  return mergeDeepRecursive(clonedTarget, ...clonedSources);
+};
+const mergeDeepRecursive = (target, ...sources) => {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key])
+          Object.assign(target, { [key]: {} });
+        mergeDeepRecursive(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+  return mergeDeepRecursive(target, ...sources);
+};
+const watchForLoadingComplete = (container, widgetDOMElement) => {
+  const isLoading = () => widgetDOMElement.querySelectorAll("[data-loading=true]").length > 0;
+  const complete = () => {
+    let dispatched = false;
+    return () => {
+      if (dispatched) {
+        return;
+      }
+      const widget = container.get("$widget");
+      widget.events.dispatch("widget:data-loaded", {
+        element: widgetDOMElement
+      });
+      dispatched = true;
+    };
+  };
+  const handleComplete = complete();
+  if (!isLoading()) {
+    return handleComplete();
+  }
+  const observer = new MutationObserver((mutations, observer2) => {
+    const check = mutations.find((mutation) => mutation.type === "attributes" && mutation.attributeName === "data-loading");
+    if (check && !isLoading()) {
+      observer2.disconnect();
+      handleComplete();
+    }
+  });
+  observer.observe(widgetDOMElement, {
+    attributes: true,
+    childList: true,
+    subtree: true
+  });
+};
+const notifyDataLoaded = (viewOutletContainer, widgetDOMElement) => {
+  const widget = viewOutletContainer.get("$widget");
+  widget.container.getAsync("components").then((components) => {
+    components.events.subscribeOnce("components:component-model-initialized", () => {
+      let waitingFor = components.nodes.visible.reduce((acc, node) => {
+        if (!node.name || !node.type || node.type === "view" || node.type === "root" || node.attributes.layout.size === "none" || widgetDOMElement.querySelector(`[data-name="${node.name}"]`)) {
+          return acc;
+        }
+        acc.push(node.name);
+        return acc;
+      }, []);
+      let complete = false;
+      const observer = new MutationObserver((mutations, observer2) => {
+        mutations.forEach((mutation) => {
+          if (mutation.addedNodes) {
+            const componentElements = Array.from(mutation.addedNodes).reduce((acc, element) => {
+              const dataName = element.getAttribute && element.getAttribute("data-name");
+              if (dataName && waitingFor.indexOf(dataName) > -1) {
+                acc.push(dataName);
+              }
+              return acc;
+            }, []);
+            waitingFor = waitingFor.filter((name) => {
+              return componentElements.indexOf(name) === -1;
+            });
+            if (!complete && waitingFor.length === 0) {
+              complete = true;
+              watchForLoadingComplete(viewOutletContainer, widgetDOMElement);
+              observer2.disconnect();
+            }
+          }
+        });
+      });
+      observer.observe(widgetDOMElement, {
+        attributes: false,
+        characterData: false,
+        childList: true,
+        subtree: true,
+        attributeOldValue: false,
+        characterDataOldValue: false
+      });
+    });
+  });
+};
+const removeNullAndUndefinedValues = (object = {}) => {
+  Object.keys(object).forEach((key) => {
+    if (object[key] === null || typeof object[key] === "undefined") {
+      delete object[key];
+    }
+  });
+  return object;
+};
+function setCookie(cookieName, value, days) {
+  let expires = "";
+  if (days) {
+    const date = new Date();
+    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1e3);
+    expires = `; expires=${date.toUTCString()}`;
+  }
+  document.cookie = `${cookieName}=${value}${expires}; path=/`;
+}
+var shallowCompare = (a, b) => {
+  let equal = true;
+  if (Object.keys(a).length !== Object.keys(b).length) {
+    return false;
+  }
+  const missingKey = Object.keys(a).some((key) => {
+    const found = Object.keys(b).some((bKey) => {
+      return key === bKey;
+    });
+    return !found;
+  });
+  if (missingKey) {
+    return false;
+  }
+  Object.keys(a).forEach((key) => {
+    if (equal) {
+      const c = typeof a[key] === "undefined" ? "" : a[key];
+      const d = typeof b[key] === "undefined" ? "" : b[key];
+      equal = c.toString() === d.toString();
+    }
+  });
+  return equal;
+};
+const s4 = () => {
+  return Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
+};
+function uuid() {
+  return s4() + s4() + "-" + s4() + "-" + s4() + "-" + s4() + "-" + s4() + s4() + s4();
+}
+class WaitFor {
+  constructor(options) {
+    this.queue = [];
+    this.queueAttemptCalls = 0;
+    this.callCount = 5;
+    this.add = (action) => {
+      this.queue.push(action);
+      this.queueAttempt = setInterval(this.processQueue, 1e3);
+    };
+    this.processQueue = () => {
+      if (this.queue.length > 0) {
+        const indexOfActionsEmitted = [];
+        this.queue.forEach((queuedAction, index) => {
+          const evaluate = queuedAction();
+          if (typeof evaluate === "function") {
+            evaluate();
+            indexOfActionsEmitted.push(index);
+          }
+        });
+        this.queue = this.queue.filter((_, index) => {
+          if (indexOfActionsEmitted.indexOf(index) > -1) {
+            return false;
+          }
+          return true;
+        });
+        if (this.queueAttempt) {
+          clearInterval(this.queueAttempt);
+        }
+      }
+      if (this.queueAttemptCalls > this.callCount) {
+        clearInterval(this.queueAttempt);
+        this.queueAttemptCalls = 0;
+      }
+      this.queueAttemptCalls = this.queueAttemptCalls + 1;
+    };
+    if (options && options.callCount) {
+      this.callCount = options.callCount;
+    }
+  }
+}
+export { Logger, WaitFor, appendClassNames, buildCategoryTrail, camilize, categoryTrail, createBatch, createParams, dataURItoBlob, debugLog, deepClone, findAndActivateStoredWidgets, findCategoryById, formatDate, formatUrl, getCategoryTrailAsObjects, getCookie, hash, htmlParentContains, kebabCase, lock, mergeDeep, notifyDataLoaded, removeNullAndUndefinedValues, setCookie, shallowCompare, uuid };
+//# sourceMappingURL=index.js.map