@telia-ace/knowledge-widget-types-grid 1.0.12 → 1.0.15

package/dist/index.js

@@ -0,0 +1,686 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { Widget } from "@telia-ace/widget-types-grid";
+export { Component, DetachedComponent, NotFound, genericComponentStyling } from "@telia-ace/widget-types-grid";
+import { DialogItemType, WidgetRenderState } from "@telia-ace/knowledge-widget-core";
+import { removeNullAndUndefinedValues, shallowCompare, deepClone } from "@telia-ace/widget-utilities";
+import { FormBuilder } from "@telia-ace/widget-forms";
+const convertLegacySymbol = (symbol) => {
+  if (symbol) {
+    const { Type, Content } = symbol;
+    if (Type && Content) {
+      return { type: Type, content: Content };
+    }
+  }
+};
+const mapLegacyCategoriesRecursively = (categories) => {
+  return categories.map((c) => {
+    const category = {
+      id: c.Id.toString(),
+      title: c.Name,
+      symbol: convertLegacySymbol(c.DefaultIcon),
+      activeSymbol: c.ActiveIcon && convertLegacySymbol(c.ActiveIcon),
+      description: c.Description || c.Attributes && c.Attributes.description || "",
+      matches: c.GuidesCount
+    };
+    if (c.Children && c.Children.length) {
+      category.items = mapLegacyCategoriesRecursively(c.Children);
+    }
+    return category;
+  });
+};
+const mapNotices = (source, type) => {
+  return source.filter(({ Type }) => Type === type).map(({ Id, Title, Body }) => ({
+    id: Id.toString(),
+    title: Title,
+    body: Body
+  }));
+};
+const mapNotificationLists = (source) => {
+  return source.map(({ Id, Title, DefaultIcon, ListNotices, Notices }) => ({
+    id: Id.toString(),
+    title: Title,
+    symbol: convertLegacySymbol(DefaultIcon),
+    defaultHeaderOptions: {
+      visible: !!ListNotices.length
+    },
+    notifications: (ListNotices || []).concat(Notices || []).map(({ Id: Id2, Title: Title2, Body, Type, Modified }) => ({
+      id: Id2.toString(),
+      title: Title2,
+      body: Body,
+      modified: Modified,
+      expandable: Type === "listNotice"
+    }))
+  }));
+};
+const mapContactMethodSettings = ({
+  Id,
+  Title,
+  DefaultIcon,
+  Exits: [Exit],
+  ExitType,
+  ConfirmationText,
+  ExpandFormAutomatically,
+  Form,
+  Description
+}, Validation) => {
+  const { Adapter } = Exit || { Adapter: {} };
+  const { ClientName = "", Settings = {}, CustomClientName = "" } = Adapter;
+  const settings = {
+    id: Id.toString(),
+    title: Title,
+    description: Description,
+    symbol: convertLegacySymbol(DefaultIcon),
+    clientName: ClientName === "custom.adapter" ? CustomClientName : ClientName,
+    expanded: true,
+    inline: true,
+    body: {}
+  };
+  if (ClientName.indexOf("phone") > -1 || ClientName.indexOf("freetext") > -1) {
+    const { displayTextBeforeClick, textBeforeClick } = Settings;
+    if (displayTextBeforeClick === "true") {
+      settings.expanded = false;
+      settings.title = textBeforeClick;
+    }
+    if (ClientName.indexOf("phone.text") > -1) {
+      settings.body.phoneNumber = Settings.phoneNumber;
+    } else {
+      settings.body.freetext = Settings.freetext;
+    }
+  }
+  if (ClientName.indexOf("chat.popup") > -1 || ClientName.indexOf("link") > -1 || ClientName === "custom.adapter" && ExitType === "custom") {
+    settings.body = Settings;
+    settings.body.confirmationFallback = ConfirmationText;
+  }
+  if (ClientName.indexOf("ace") > -1) {
+    settings.body = Settings;
+  }
+  if (Form && Form.HasValueComponents) {
+    if (Validation) {
+      settings.body.form = FormBuilder.fromLegacyForm(Id.toString(), Form, Validation).get();
+    } else {
+      settings.body.form = FormBuilder.fromLegacyForm(Id.toString(), Form).get();
+    }
+    if (!ExpandFormAutomatically) {
+      settings.expanded = settings.inline = false;
+    }
+  }
+  return settings;
+};
+const mapTags = (tags = []) => {
+  return tags.map(({ Id, Title, TotalMatches, Symbol: Symbol2, DefaultIcon, ActiveIcon }) => ({
+    id: Id.toString(),
+    title: Title,
+    matches: TotalMatches,
+    symbol: convertLegacySymbol(DefaultIcon || Symbol2),
+    defaultIcon: convertLegacySymbol(DefaultIcon),
+    activeIcon: convertLegacySymbol(ActiveIcon)
+  }));
+};
+const mapGuides = (guides) => {
+  return guides.map(({ Id, Title, Tags, FirstPublishedDate, Modified }) => ({
+    id: Id.toString(),
+    title: Title,
+    tags: mapTags(Tags),
+    published: FirstPublishedDate,
+    modified: Modified
+  }));
+};
+const formatLegacyData = (type, data) => {
+  switch (type) {
+    case ServiceClientQueryType.MatchByCategory:
+    case ServiceClientQueryType.Match: {
+      const result = {
+        guides: [],
+        matches: 0,
+        topNotifications: [],
+        middleNotifications: [],
+        bottomNotifications: [],
+        notificationLists: [],
+        tags: [],
+        byCategory: []
+      };
+      const {
+        Matches,
+        TotalMatches,
+        Notices,
+        NoticeLists,
+        Tags,
+        ByCategory
+      } = data;
+      result.guides = mapGuides(Matches);
+      result.matches = TotalMatches;
+      result.byCategory = (ByCategory || []).map(({ Id, Matches: Matches2, TotalMatches: TotalMatches2 }) => ({
+        id: Id,
+        guides: mapGuides(Matches2),
+        matches: TotalMatches2
+      }));
+      result.tags = mapTags(Tags);
+      result.notificationLists = mapNotificationLists(NoticeLists || []);
+      result.topNotifications = mapNotices(Notices || [], "noticeRowTop");
+      result.middleNotifications = mapNotices(Notices || [], "noticeRowMiddle");
+      result.bottomNotifications = mapNotices(Notices || [], "footerNotice");
+      return result;
+    }
+    case ServiceClientQueryType.Categories: {
+      const { Children, GuidesCountTotal } = data;
+      const result = {
+        categories: mapLegacyCategoriesRecursively(Children || []),
+        matches: GuidesCountTotal
+      };
+      return result;
+    }
+    case ServiceClientQueryType.Guide: {
+      const {
+        Id,
+        Title,
+        Body,
+        Related,
+        Options,
+        ConnectionId,
+        ContactMethods,
+        EnableFeedback,
+        HandoverExists,
+        FirstPublishedDate,
+        Modified,
+        ModifiedByDisplayName,
+        FirstPublishedByDisplayName,
+        Categories,
+        Tags,
+        SeoMetaDescription,
+        SeoAllowIndex,
+        Perspectives,
+        PerspectiveKey,
+        Translations
+      } = data;
+      const perspective = PerspectiveKey || Object.values(Perspectives).find((connection) => connection === ConnectionId) || Perspectives["Default"] || null;
+      const result = {
+        guide: {
+          id: Id.toString(),
+          title: Title,
+          body: Body,
+          modified: Modified,
+          published: FirstPublishedDate,
+          modifiedBy: ModifiedByDisplayName,
+          publishedBy: FirstPublishedByDisplayName,
+          connection: ConnectionId,
+          categories: Categories,
+          hasHandover: HandoverExists,
+          allowFeedback: EnableFeedback,
+          seoMetaDescription: SeoMetaDescription,
+          seoAllowIndex: SeoAllowIndex,
+          perspectives: Perspectives,
+          perspective,
+          translations: Object.keys(Translations || {}).reduce((acc, key) => {
+            acc[key] = Translations[key].toString();
+            return acc;
+          }, {})
+        },
+        related: mapGuides(Related || []),
+        dialog: [],
+        contactMethods: (ContactMethods || []).map((cm) => mapContactMethodSettings(cm)),
+        tags: mapTags(Tags)
+      };
+      (Options || []).forEach(({ CanAccess, Description, ConnectionId: ConnectionId2, Properties }) => {
+        if (!CanAccess) {
+          return;
+        }
+        const item = {
+          id: Id.toString(),
+          title: Description,
+          connection: ConnectionId2,
+          type: DialogItemType.default,
+          parent: {
+            id: Id.toString(),
+            title: Title,
+            tags: mapTags(Tags)
+          }
+        };
+        if (Properties.Type === "Guide" || Properties.Type === "Link") {
+          Properties.Id && (item.id = Properties.Id.toString());
+          Properties.Uri && (item.href = Properties.Uri);
+          Properties.Target && (item.target = Properties.Target);
+          switch (Properties.Type) {
+            case "Guide":
+              item.type = DialogItemType.guide;
+              break;
+            case "Link":
+              item.type = DialogItemType.link;
+              break;
+          }
+        }
+        result.dialog.push(item);
+      });
+      return result;
+    }
+    case ServiceClientQueryType.Contacts: {
+      const { Children, Matches, Notices, NoticeLists } = data;
+      const result = {
+        contactMethods: (Matches || []).map((cm) => mapContactMethodSettings(cm)),
+        categories: mapLegacyCategoriesRecursively(Children || []),
+        topNotifications: mapNotices(Notices || [], "noticeRowTop"),
+        middleNotifications: mapNotices(Notices || [], "noticeRowMiddle"),
+        bottomNotifications: mapNotices(Notices || [], "footerNotice"),
+        notificationLists: mapNotificationLists(NoticeLists || [])
+      };
+      return result;
+    }
+    case ServiceClientQueryType.ContactMethod: {
+      const { ContactMethod: ContactMethod2 } = data;
+      return mapContactMethodSettings(ContactMethod2 || {});
+    }
+    case ServiceClientQueryType.Tags:
+    case ServiceClientQueryType.TagsOnGuides: {
+      return mapTags(data || []);
+    }
+    case ServiceClientQueryType.Notifications: {
+      const { Notices, NoticeLists } = data;
+      return {
+        topNotifications: mapNotices(Notices || [], "noticeRowTop"),
+        middleNotifications: mapNotices(Notices || [], "noticeRowMiddle"),
+        bottomNotifications: mapNotices(Notices || [], "footerNotice"),
+        notificationLists: mapNotificationLists(NoticeLists || [])
+      };
+    }
+    default:
+      return {};
+  }
+};
+var DataType = /* @__PURE__ */ ((DataType2) => {
+  DataType2["Guide"] = "guide";
+  DataType2["Guides"] = "guides";
+  DataType2["GuidesByCategory"] = "guides-by-category";
+  DataType2["RowNotifications"] = "row-notices";
+  DataType2["NotificationLists"] = "notification-lists";
+  DataType2["GuideCategories"] = "guide-categories";
+  DataType2["ContactMethodCategories"] = "contact-method-categories";
+  DataType2["ContactMethod"] = "contact-method";
+  DataType2["ContactMethods"] = "contact-methods";
+  DataType2["Tags"] = "tags";
+  DataType2["TagsOnGuides"] = "tagsonguides";
+  return DataType2;
+})(DataType || {});
+var ServiceClientQueryType = /* @__PURE__ */ ((ServiceClientQueryType2) => {
+  ServiceClientQueryType2["Match"] = "match";
+  ServiceClientQueryType2["Categories"] = "categories";
+  ServiceClientQueryType2["Guide"] = "guide";
+  ServiceClientQueryType2["Contacts"] = "contacts";
+  ServiceClientQueryType2["ContactMethod"] = "contact-method";
+  ServiceClientQueryType2["MatchByCategory"] = "match-by-category";
+  ServiceClientQueryType2["Tags"] = "tags";
+  ServiceClientQueryType2["TagsOnGuides"] = "tagsonguides";
+  ServiceClientQueryType2["Notifications"] = "notifications";
+  return ServiceClientQueryType2;
+})(ServiceClientQueryType || {});
+var FeedbackType = /* @__PURE__ */ ((FeedbackType2) => {
+  FeedbackType2["Positive"] = "Positive";
+  FeedbackType2["Negative"] = "Negative";
+  return FeedbackType2;
+})(FeedbackType || {});
+var SortingType = /* @__PURE__ */ ((SortingType2) => {
+  SortingType2["POPULARITY_DESCENDING"] = "popularity-descending";
+  SortingType2["ALPHABETIC_ASCENDING"] = "alphabetic-ascending";
+  SortingType2["ALPHABETIC_DESCENDING"] = "alphabetic-descending";
+  SortingType2["MODIFIED_ASCENDING"] = "modified-ascending";
+  SortingType2["MODIFIED_DESCENDING"] = "modified-descending";
+  SortingType2["PUBLISHED_ASCENDING"] = "published-ascending";
+  SortingType2["PUBLISHED_DESCENDING"] = "published-descending";
+  return SortingType2;
+})(SortingType || {});
+const determineServiceClientQueryType = (type) => {
+  switch (type) {
+    case "guides":
+      return "match";
+    case "guides-by-category":
+      return "match-by-category";
+    case "guide":
+      return "guide";
+    case "guide-categories":
+      return "categories";
+    case "contact-method-categories":
+    case "contact-methods":
+      return "contacts";
+    case "contact-method":
+      return "contact-method";
+    case "tags":
+      return "tags";
+    case "tagsonguides":
+      return "tagsonguides";
+    case "notification-lists":
+    case "row-notices":
+      return "notifications";
+    default:
+      throw "error";
+  }
+};
+const widgetIsHidden = (container) => __async(this, null, function* () {
+  const { invoke } = container.get("$widget");
+  const renderState = yield invoke("renderState");
+  return renderState === WidgetRenderState.hidden;
+});
+class DataClient {
+  constructor(container, matchingClient) {
+    this.container = container;
+    this.matchingClient = matchingClient;
+    this.queries = /* @__PURE__ */ new Map();
+    this.lastTake = 0;
+    this.getUnresolvedQueries = () => {
+      let unresolvedCount = 0;
+      this.queries.forEach((queries, type) => {
+        const hasUnresolved = queries.some((query) => !query.resolved);
+        if (hasUnresolved) {
+          unresolvedCount = 1;
+        }
+      });
+      return unresolvedCount;
+    };
+    this.events = container.get("$widget").events;
+    this.events.subscribe("widget:settings-updated", () => this.queries = /* @__PURE__ */ new Map());
+    this.events.subscribe("widget:render-state-changed", (event, { next, previous }) => {
+      if (previous === WidgetRenderState.hidden && next === WidgetRenderState.open) {
+        this.fetchAllUnresolvedQueries();
+      }
+    });
+  }
+  static getInstance(container) {
+    return container.getAsync("dataClient");
+  }
+  fetch(type, params) {
+    return new Promise((resolve, reject) => {
+      if (params.take) {
+        this.lastTake = +(params.take || 0);
+      }
+      removeNullAndUndefinedValues(params);
+      const serviceClientQueryType = determineServiceClientQueryType(type);
+      const queries = this.queries.get(serviceClientQueryType) || [];
+      const query = queries.find((q) => shallowCompare(q.params, params));
+      if (query) {
+        const index = queries.indexOf(query);
+        if (query.resolved) {
+          this.events.dispatch("data-client:fetched", {
+            params,
+            type: serviceClientQueryType,
+            response: query.data,
+            unresolvedQueries: this.getUnresolvedQueries()
+          });
+          this.track(query.data, serviceClientQueryType, query.error);
+          if (query.data && query.error) {
+            reject({ error: query.error });
+          } else {
+            resolve(query.data);
+          }
+        } else {
+          query.resolvers.push({ resolve, reject });
+        }
+        queries.splice(index, 1);
+        queries.push(query);
+        this.queries.set(serviceClientQueryType, queries);
+        if (!query.loading && !query.resolved) {
+          return this.runQuery(serviceClientQueryType, params);
+        }
+      } else {
+        queries.push({
+          params,
+          resolved: false,
+          loading: true,
+          data: {},
+          resolvers: [{ resolve, reject }]
+        });
+        this.queries.set(serviceClientQueryType, queries);
+        return this.runQuery(serviceClientQueryType, params);
+      }
+    }).then((res) => deepClone(res));
+  }
+  read(type, options) {
+    const { select } = options;
+    const serviceClientQueryType = determineServiceClientQueryType(type);
+    const queries = this.queries.get(serviceClientQueryType) || [];
+    const result = queries.reduce((acc, query) => {
+      if (typeof select === "function") {
+        const match = select(query.data);
+        if (match) {
+          acc.push(match);
+        }
+      } else {
+        acc.push(query.data);
+      }
+      return acc;
+    }, []);
+    return result;
+  }
+  feedback(id, connection, feedback) {
+    return this.matchingClient.giveFeedback(id, connection, feedback);
+  }
+  setLoadingStatus(type, params, loading) {
+    const queries = this.queries.get(type) || [];
+    const query = queries.find((q) => shallowCompare(q.params, params));
+    if (query) {
+      query.loading = loading;
+    }
+    this.queries.set(type, queries);
+  }
+  runQuery(type, params) {
+    return __async(this, null, function* () {
+      const {
+        searchPhrase = "",
+        categories = "0",
+        contactMethodCategoryId = "0",
+        contactMethodId = "0",
+        tagId = void 0,
+        take = 5,
+        connection = "",
+        guideId,
+        expandCategories = "descendants",
+        currentCategory,
+        sorting = "popularity-descending",
+        guideIds = []
+      } = params;
+      const trimmedPhrase = searchPhrase.toString().trim();
+      if (yield widgetIsHidden(this.container)) {
+        return Promise.resolve();
+      }
+      switch (type) {
+        case "match": {
+          const formatSortingValues = (sorting2) => {
+            const [type2, direction] = sorting2.split("-");
+            const sortKeysMap = /* @__PURE__ */ new Map([
+              ["popularity", "popularity"],
+              ["alphabetic", "title"],
+              ["modified", "lastModified"],
+              ["published", "firstPublished"]
+            ]);
+            return {
+              type: sortKeysMap.get(type2),
+              direction
+            };
+          };
+          if (guideIds.length) {
+            return this.matchingClient.customRequest("guides", "POST", {
+              configuration: { ids: guideIds, take: +take }
+            }).then((matches) => matches && this.handleResponse(matches, type, params));
+          }
+          return this.matchingClient.match(trimmedPhrase, {
+            categories: categories === "0" ? [] : Array.isArray(categories) ? categories : [+categories],
+            take: +take,
+            tags: tagId,
+            sorting: formatSortingValues(sorting),
+            ids: guideIds
+          }).then((matches) => matches && this.handleResponse(matches, type, params));
+        }
+        case "match-by-category": {
+          return this.matchingClient.match(trimmedPhrase, {
+            groupByCategory: true,
+            categories: categories === "0" ? [] : Array.isArray(categories) ? categories : [+categories],
+            take: +take,
+            tags: tagId
+          }).then((matches) => matches && this.handleResponse(matches, type, params));
+        }
+        case "guide": {
+          return this.matchingClient.getGuide(guideId, { connectionId: connection }).then((guide) => {
+            if (guide) {
+              this.handleResponse(guide, type, params);
+            }
+          }).catch((e) => {
+            const error = {
+              message: "Something went wrong.",
+              status: e.status || 400
+            };
+            if (error.status === 404) {
+              error.message = "The guide could not be found.";
+            }
+            this.handleResponse({}, type, params, error);
+          });
+        }
+        case "categories": {
+          return this.matchingClient.getCategories({ phrase: trimmedPhrase, expand: expandCategories, tags: tagId }).then((categories2) => categories2 && this.handleResponse(categories2, type, params));
+        }
+        case "contacts": {
+          if (guideId) {
+            return this.matchingClient.contactMethods(+guideId, { phrase: trimmedPhrase }).then((result) => result && this.handleResponse(result, type, params));
+          }
+          return this.matchingClient.contacts(+contactMethodCategoryId, { phrase: trimmedPhrase }).then((result) => result && this.handleResponse(result, type, params));
+        }
+        case "contact-method": {
+          return this.matchingClient.getContactMethod(+contactMethodId, { guideId, currentCategory }).then((result) => result && this.handleResponse(result, type, params));
+        }
+        case "tags": {
+          return this.matchingClient.customRequest("tags", "GET", {
+            configuration: {
+              take: 999999,
+              phrase: trimmedPhrase,
+              categories: categories === "0" ? [] : Array.isArray(categories) ? categories : [+categories]
+            }
+          }).then((result) => result && this.handleResponse(result, type, params));
+        }
+        case "tagsonguides": {
+          return this.matchingClient.customRequest("tagsonguides", "GET", {
+            configuration: {
+              take: 999999,
+              phrase: trimmedPhrase,
+              categories: categories === "0" ? [] : Array.isArray(categories) ? categories : [+categories],
+              tags: tagId
+            }
+          }).then((result) => result && this.handleResponse(result, type, params));
+        }
+        case "notifications": {
+          return this.matchingClient.customRequest("notices", "GET", {
+            configuration: {
+              phrase: trimmedPhrase,
+              categories: categories === "0" ? [] : Array.isArray(categories) ? categories : [+categories]
+            }
+          }).then((result) => result && this.handleResponse(result, type, params));
+        }
+      }
+    });
+  }
+  handleResponse(data = {}, type, params, error) {
+    const queries = this.queries.get(type) || [];
+    const existing = queries.find((q) => shallowCompare(q.params, params));
+    if (existing) {
+      const formatted = error ? error : formatLegacyData(type, data);
+      this.track(formatted, type, error);
+      existing.resolvers.forEach((r) => {
+        if (error) {
+          r.reject({ error: formatted });
+        } else {
+          r.resolve(formatted);
+        }
+      });
+      const index = queries.indexOf(existing);
+      if (index > -1) {
+        queries.splice(index, 1);
+      }
+      queries.push(__spreadProps(__spreadValues({}, existing), { error, resolvers: [], data: formatted, resolved: true }));
+      this.setLoadingStatus(type, params, false);
+      this.queries.set(type, queries);
+      if (!error) {
+        this.events.dispatch("data-client:fetched", {
+          type,
+          params,
+          response: formatted,
+          unresolvedQueries: this.getUnresolvedQueries()
+        });
+      }
+    }
+  }
+  fetchAllUnresolvedQueries() {
+    for (const [queryType, queries] of this.queries) {
+      queries.filter((query) => !query.resolved).forEach((query) => {
+        this.runQuery(queryType, query.params);
+      });
+    }
+  }
+  track(data = {}, type, error) {
+    const widget = this.container.get("$widget");
+    if (widget && !error) {
+      widget.events.dispatch("tracking:service-client-response", {
+        type,
+        data
+      });
+    } else if (widget) {
+      widget.events.dispatch("tracking:service-client-error", {
+        type,
+        error
+      });
+    }
+  }
+  static create(container) {
+    return container.getAsync("matchingClient").then((matchingClient) => new DataClient(container, matchingClient));
+  }
+}
+const createContactMethodPlatform = (container) => {
+  return import("@telia-ace/knowledge-widget-adapters").then(({ ContactMethodPlatform }) => {
+    return ContactMethodPlatform.create(container);
+  });
+};
+const createDataClient = (container) => {
+  return import("./index2.js").then(({ DataClient: DataClient2 }) => {
+    return DataClient2.create(container);
+  });
+};
+class ExtendedWidget extends Widget {
+  constructor(container) {
+    super(container);
+    this.container.registerAsync("contactMethods", () => createContactMethodPlatform(this.container));
+    this.container.registerAsync("dataClient", () => createDataClient(this.container));
+  }
+}
+export { DataClient, DataType, FeedbackType, ExtendedWidget as GridWidget, ServiceClientQueryType, SortingType, determineServiceClientQueryType, formatLegacyData };
+//# sourceMappingURL=index.js.map