@spteck/license-manager-react-components 1.0.0

package/dist/license-manager-react-components.esm.js

@@ -0,0 +1,1406 @@
+import React__default, { createElement, Fragment, isValidElement, useState, useCallback, useMemo, useEffect } from 'react';
+import { webLightTheme, tokens, Text, CardFooter, Button, makeStyles, shorthands, Subtitle1, Caption1, Body1Strong, Body1, Field, Input, MessageBar, FluentProvider, Dialog, DialogSurface, DialogTitle, TabList, Tab, DialogActions, MessageBarBody, MessageBarTitle, MessageBarActions, IdPrefixProvider, teamsLightTheme } from '@fluentui/react-components';
+import { EStatus, useLicenseManager, useUser } from '@spteck/react-hooks-library';
+import { Dismiss24Regular, Clock20Regular, Key20Regular, Apps20Regular } from '@fluentui/react-icons';
+import { atom, useAtomValue, useAtom } from 'jotai';
+import { css } from '@emotion/css';
+import { SHA256 } from 'crypto-js';
+import { Icon } from '@iconify/react';
+import { z } from 'zod';
+import { ErrorBoundary } from 'react-error-boundary';
+import { differenceInDays } from 'date-fns';
+
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return e;
+  };
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.value;
+    },
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), t[e];
+  }
+  try {
+    define({}, "");
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
+    };
+  }
+  function wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
+  }
+  function tryCatch(t, e, r) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(e, r)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var p = {};
+  define(p, a, function () {
+    return this;
+  });
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
+      });
+    });
+  }
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
+        });
+      }
+      a(c.arg);
+    }
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
+        function callInvokeWithMethodAndArg() {
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
+          });
+        }
+        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: !0
+        };
+      }
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
+          }
+        }
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
+          return {
+            value: p.arg,
+            done: n.done
+          };
+        }
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
+    };
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+  }
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
+  }
+  function Context(t) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+            return next.value = t, next.done = !0, next;
+          };
+        return i.next = i;
+      }
+    }
+    throw new TypeError(typeof e + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: !0
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: !0
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return this;
+  }), define(g, "toString", function () {
+    return "[object Generator]";
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+    },
+    stop: function () {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      }
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+          } else {
+            if (!u) throw Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
+          break;
+        }
+      }
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+    },
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+    },
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+      }
+    },
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
+          }
+          return o;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function (e, r, n) {
+      return this.delegate = {
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
+function _taggedTemplateLiteralLoose(e, t) {
+  return t || (t = e.slice(0)), e.raw = t, e;
+}
+
+var ETabsOptions;
+(function (ETabsOptions) {
+  ETabsOptions["Trial"] = "trial";
+  ETabsOptions["License"] = "license";
+  ETabsOptions["Apps"] = "apps";
+})(ETabsOptions || (ETabsOptions = {}));
+
+var SUPPORT_EMAIL = "geral@spteck.com";
+var EMAIL_BODY_TEMPLATE = "Subject: Support Request from {0} {1}\n\nDear Support Team,\n\nI am reaching out to you because I am experiencing issues with my license. Here are my details:\n\n ** Tenant ID **:   {2}\n ** Application ID **:   {3} - {4}\n ** User First Name **:  {5}\n ** User Last Name **:  {6}\n ** Email**: {7}\n\n {8}\n\nBest regards,\n{9} {10}";
+var EMAIL_BODY_TEMPLATE_REQUEST_LICENSE = "Subject: Request for New License {0} {1}\n\nDear Support Team,\n\nI am just contacting you to request a license for the following product. Here are my details:\n\n ** Tenant ID **:   {2}\n ** Application ID **:   {3} - {4}\n ** User First Name **:  {5}\n ** User Last Name **:  {6}\n ** Email **: {7}\n\nBest regards,\n{8} {9}";
+
+var Mailto = function Mailto(props) {
+  var to = props.to,
+    from = props.from,
+    subject = props.subject,
+    body = props.body,
+    children = props.children,
+    Component = props.as,
+    _props$componentProps = props.componentProps,
+    componentProps = _props$componentProps === void 0 ? {} : _props$componentProps;
+  // Construct the mailto link
+  var mailtoLink = "mailto:" + to + "?" + (from ? "from=" + encodeURIComponent(from) + "&" : "") + (subject ? "subject=" + encodeURIComponent(subject) + "&" : "") + (body ? "body=" + encodeURIComponent(body) : "");
+  // Ensure the correct element type is rendered
+  var RenderedComponent = Component || "a";
+  // Handle the click event
+  var handleClick = function handleClick(e) {
+    e.preventDefault();
+    window.open(mailtoLink, "_blank");
+  };
+  return React__default.createElement(RenderedComponent, Object.assign({
+    href: mailtoLink,
+    "aria-label": "Send an email to " + to,
+    onClick: handleClick
+  }, componentProps), children);
+};
+
+var openDialog = "Open campaign dialog";
+var deleteCampaign = "Delete this campaign?";
+var tenantInformation = "Tenant Information";
+var licensingType = "Licensing Type";
+var startDate = "Start Date";
+var endDate = "End Date";
+var licenseKey = "License Key";
+var generate = "Generate";
+var cancel = "Cancel";
+var tenantId = "Tenant Id";
+var tenantUrl = "Tenant Url";
+var applicationId = "Application Id";
+var dateError = "End date must be after start date.";
+var submit = "Generate";
+var placeHolderTitle = "Try or Buy Application";
+var placeHolderText = "To use this application, you need to buy a license. Please click on the button below to register and buy a license, or get 'Trial' license to try the application for free.";
+var placeHolderTrialButton = "Try";
+var placeHolderBuyButton = "Buy";
+var placeHolderRegistryButton = "Buy";
+var companyName = "Company Name";
+var contactFirstName = "Contact First Name";
+var contactLastName = "Contact Last Name";
+var contactEmail = "Contact Email";
+var register = "Register";
+var messageLicenseWarning = "The License {0} will expire in {1} day(s) (expires on {2});";
+var trial = "Trial";
+var license = "License";
+var apps = "Apps";
+var contactFirstNameError = "First name is required";
+var contactLastNameError = "Last name is required";
+var contactEmailError = "format Email is invalid";
+var companyNameError = "Company name is required";
+var trialLicenseTitle = "Register for a trial license";
+var trialLicenseText = "To use this application, you need to register for a trial license. Please fill in the form below to get a trial license.";
+var firstName = "First Name";
+var firstnamePlaceholder = "Enter your first name";
+var lastName = "Last Name";
+var lastnamePlaceholder = "Enter your last name";
+var email = "Email";
+var emailPlaceholder = "Enter your email";
+var company = "Company";
+var companyPlaceholder = "Enter your company";
+var messageStatusBlocked = "Your  {0} license has been blocked. Please contact support for assistance.";
+var messageStatusExpired = "Your  {0} license has expired at  {1}. Please renew it to continue using the application.";
+var messageStatusInvalid = "Your  {0} license is invalid. This could be due to incorrect information or an issue with the license itself. Please contact support to request a new license.";
+var messageStatusNotFound = "No valid license was found. This could be because you haven't yet requested. Please contact our support team to request a license and gain access to all features.";
+var messageStatusGenericError = "An error occurred while validating your  {0} license. Please contact support for assistance";
+var messageStatusValid = "Your {0} license is valid until  {1}. You have full access to the application.";
+var messageStatusBlockedShort = "Your {0} license has been blocked.";
+var messageStatusExpiredShort = "Your {0} license has expired at {1}";
+var messageStatusInvalidShort = "Your {0} license is invalid.";
+var messageStatusNotFoundShort = "No valid license was found, Start a trial or request a license for full access.";
+var messageStatusGenericErrorShort = "An error occurred while validating your  {0} license.";
+var details = "Details";
+var buyLicense = "Buy License";
+var requestLicense = "Request License";
+var stringsLocEn = {
+	openDialog: openDialog,
+	deleteCampaign: deleteCampaign,
+	tenantInformation: tenantInformation,
+	licensingType: licensingType,
+	startDate: startDate,
+	endDate: endDate,
+	licenseKey: licenseKey,
+	generate: generate,
+	cancel: cancel,
+	tenantId: tenantId,
+	tenantUrl: tenantUrl,
+	applicationId: applicationId,
+	dateError: dateError,
+	submit: submit,
+	placeHolderTitle: placeHolderTitle,
+	placeHolderText: placeHolderText,
+	placeHolderTrialButton: placeHolderTrialButton,
+	placeHolderBuyButton: placeHolderBuyButton,
+	placeHolderRegistryButton: placeHolderRegistryButton,
+	companyName: companyName,
+	contactFirstName: contactFirstName,
+	contactLastName: contactLastName,
+	contactEmail: contactEmail,
+	register: register,
+	messageLicenseWarning: messageLicenseWarning,
+	trial: trial,
+	license: license,
+	apps: apps,
+	contactFirstNameError: contactFirstNameError,
+	contactLastNameError: contactLastNameError,
+	contactEmailError: contactEmailError,
+	companyNameError: companyNameError,
+	trialLicenseTitle: trialLicenseTitle,
+	trialLicenseText: trialLicenseText,
+	firstName: firstName,
+	firstnamePlaceholder: firstnamePlaceholder,
+	lastName: lastName,
+	lastnamePlaceholder: lastnamePlaceholder,
+	email: email,
+	emailPlaceholder: emailPlaceholder,
+	company: company,
+	companyPlaceholder: companyPlaceholder,
+	messageStatusBlocked: messageStatusBlocked,
+	messageStatusExpired: messageStatusExpired,
+	messageStatusInvalid: messageStatusInvalid,
+	messageStatusNotFound: messageStatusNotFound,
+	messageStatusGenericError: messageStatusGenericError,
+	messageStatusValid: messageStatusValid,
+	messageStatusBlockedShort: messageStatusBlockedShort,
+	messageStatusExpiredShort: messageStatusExpiredShort,
+	messageStatusInvalidShort: messageStatusInvalidShort,
+	messageStatusNotFoundShort: messageStatusNotFoundShort,
+	messageStatusGenericErrorShort: messageStatusGenericErrorShort,
+	details: details,
+	buyLicense: buyLicense,
+	requestLicense: requestLicense
+};
+
+var appGlobalStateAtom = /*#__PURE__*/atom({
+  theme: webLightTheme,
+  language: "en",
+  strings: stringsLocEn,
+  refresh: false
+});
+
+var _templateObject, _templateObject2, _templateObject3;
+var useLicenseControlStyles = function useLicenseControlStyles() {
+  return {
+    container: css(_templateObject || (_templateObject = _taggedTemplateLiteralLoose(["\n      display: flex;\n      flex-direction: column;\n      row-gap: 10px;\n      margin-top: 10px;\n      padding: 7px;\n      background-color: ", ";\n      flex: 1;\n    "])), tokens.colorNeutralBackground1),
+    title: css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteralLoose(["\n      display: flex;\n      flex-direction: row;\n      gap: 10px;\n      align-items: center;\n      justify-content: start;\n    "]))),
+    footer: css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteralLoose(["\n         justify-content: end;\n        position: absolute;\n        bottom: 20px;\n        right: 20px;\n        "])))
+  };
+};
+
+var useUtils = function useUtils() {
+  var formatString = React__default.useCallback(function (template) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    return template.replace(/{(\d+)}/g, function (match, number) {
+      return typeof args[number] !== "undefined" ? args[number] : match;
+    });
+  }, []);
+  var generateSalt = React__default.useCallback(function (tenantId, appId) {
+    // Concatenate the inputs with a delimiter
+    var inputData = tenantId + ":" + appId;
+    // Create a SHA-256 hash
+    var hash = SHA256(inputData).toString();
+    return hash;
+  }, []);
+  return {
+    formatString: formatString,
+    generateSalt: generateSalt
+  };
+};
+
+var LicenseControl = function LicenseControl(_ref) {
+  var licenseStatus = _ref.licenseStatus,
+    onDismiss = _ref.onDismiss,
+    licenseType = _ref.licenseType,
+    expiryDate = _ref.expiryDate;
+  var styles = useLicenseControlStyles();
+  var formatDate = new Date(expiryDate).toLocaleDateString();
+  var appglobalState = useAtomValue(appGlobalStateAtom);
+  var tenantId = appglobalState.tenantId,
+    applicationId = appglobalState.applicationId,
+    applicationName = appglobalState.applicationName,
+    userInformation = appglobalState.userInformation,
+    strings = appglobalState.strings;
+  var _useUtils = useUtils(),
+    formatString = _useUtils.formatString;
+  var getMessageAndAction = React__default.useCallback(function () {
+    switch (licenseStatus) {
+      case EStatus.blocked:
+        return {
+          message: formatString(strings.messageStatusBlocked, licenseType),
+          actionLabel: "Contact Support"
+        };
+      case EStatus.expired:
+        return {
+          message: formatString(strings.messageStatusExpired, licenseType, formatDate),
+          actionLabel: "Renew License"
+        };
+      case EStatus.invalid:
+        return {
+          message: formatString(strings.messageStatusInvalid, licenseType),
+          actionLabel: "Request New License"
+        };
+      case EStatus.notFound:
+        return {
+          message: strings.messageStatusNotFound,
+          actionLabel: "Request License"
+        };
+      case EStatus.genericError:
+        return {
+          message: formatString(strings.messageStatusGenericError, ""),
+          actionLabel: "Contact Support"
+        };
+      case EStatus.valid:
+        return {
+          message: formatString(strings.messageStatusValid, licenseType, formatDate),
+          actionLabel: undefined
+        };
+      default:
+        return undefined;
+    }
+  }, [licenseStatus]);
+  var content = React__default.useMemo(function () {
+    return getMessageAndAction();
+  }, [getMessageAndAction]);
+  // utils.ts
+  var generateBodyText = React__default.useCallback(function () {
+    var _content;
+    var mail = userInformation.mail,
+      givenName = userInformation.givenName,
+      surname = userInformation.surname;
+    var body = EMAIL_BODY_TEMPLATE;
+    if (licenseStatus === EStatus.notFound) {
+      body = EMAIL_BODY_TEMPLATE_REQUEST_LICENSE;
+      content = {
+        actionLabel: "Request License",
+        message: ""
+      };
+    }
+    var message = formatString(body, givenName, surname, tenantId, applicationId, applicationName, givenName, surname, mail, (_content = content) == null ? void 0 : _content.message, givenName, surname);
+    return message;
+  }, [tenantId, applicationId, userInformation, content]);
+  if (!content) return React__default.createElement(React__default.Fragment, null);
+  return React__default.createElement("div", {
+    className: styles.container
+  }, React__default.createElement(Text, null, content.message), React__default.createElement(CardFooter, {
+    className: styles.footer
+  }, content.actionLabel && React__default.createElement(Mailto, {
+    to: SUPPORT_EMAIL,
+    from: userInformation == null ? void 0 : userInformation.mail,
+    subject: "Support request - " + applicationName,
+    body: generateBodyText(),
+    as: Button,
+    componentProps: {
+      appearance: "primary",
+      target: "_blank"
+    }
+  }, content.actionLabel), React__default.createElement(Button, {
+    appearance: "secondary",
+    onClick: onDismiss
+  }, "Close")));
+};
+
+var useRenderHeaderStyles = /*#__PURE__*/makeStyles({
+  closeButton: {
+    marginLeft: "auto",
+    position: "absolute",
+    top: "10px",
+    right: "10px",
+    zIndex: 99999
+  },
+  divider: {
+    width: "100%",
+    height: "1px",
+    backgroundColor: tokens.colorNeutralStroke1,
+    marginTop: "6px"
+  },
+  renderHeaderContent: {
+    display: "flex",
+    flexDirection: "column",
+    justifyContent: "flex-start",
+    alignItems: "stretch",
+    width: "100%"
+  },
+  renderHeaderHeader: /*#__PURE__*/_extends({
+    display: "flex",
+    flexDirection: "column",
+    justifyContent: "flex-start"
+  }, /*#__PURE__*/shorthands.padding("10px"), {
+    gap: "20px"
+  }),
+  renderHeaderFooter: /*#__PURE__*/_extends({
+    display: "flex",
+    flexDirection: "row",
+    justifyContent: "flex-start"
+  }, /*#__PURE__*/shorthands.padding("20px"), {
+    gap: "20px"
+  }),
+  renderHeaderBody: /*#__PURE__*/_extends({
+    display: "flex",
+    flexDirection: "column",
+    justifyContent: "flex-start"
+  }, /*#__PURE__*/shorthands.padding("20px"), {
+    gap: "20px"
+  }),
+  renderHeaderTitleContainer: {
+    display: "flex",
+    flexDirection: "row",
+    justifyContent: "flex-start",
+    alignItems: "center"
+  },
+  renderHeaderTitle: {
+    display: "-webkit-box",
+    "-webkit-line-clamp": "1",
+    "-webkit-box-orient": "vertical",
+    textAlign: "start",
+    textOverflow: "ellipsis",
+    wordBreak: "break-word"
+  },
+  renderHeaderDescription: {
+    display: "-webkit-box",
+    "-webkit-line-clamp": "4",
+    "-webkit-box-orient": "vertical",
+    textAlign: "start",
+    textOverflow: "ellipsis",
+    wordBreak: "break-word"
+  },
+  dialogTitleAndDescriptionContainer: {
+    display: "flex",
+    flexDirection: "column",
+    justifyContent: "start",
+    alignItems: "start",
+    paddingLeft: "10px",
+    paddingRight: "20px"
+  }
+});
+
+var RenderHeader = function RenderHeader(props) {
+  var onDismiss = props.onDismiss,
+    title = props.title,
+    description = props.description,
+    icon = props.icon;
+  var styles = useRenderHeaderStyles();
+  return createElement(Fragment, null, createElement("div", {
+    className: styles.renderHeaderContent
+  }, createElement("div", {
+    className: styles.renderHeaderHeader
+  }, createElement(Button, {
+    appearance: "subtle",
+    className: styles.closeButton,
+    onClick: function onClick(ev) {
+      ev.stopPropagation();
+      ev.preventDefault();
+      onDismiss(false);
+    },
+    icon: createElement(Dismiss24Regular, null)
+  }), createElement("div", {
+    className: styles.renderHeaderTitleContainer
+  }, isValidElement(icon) ? icon : createElement(Icon, {
+    icon: icon
+  }), createElement("div", {
+    className: styles.dialogTitleAndDescriptionContainer
+  }, isValidElement(title) ? title : createElement(Subtitle1, {
+    className: styles.renderHeaderTitle
+  }, title), isValidElement(description) ? description : createElement(Caption1, {
+    className: styles.renderHeaderDescription
+  }, description)))), createElement("div", {
+    className: styles.divider
+  })));
+};
+
+var useRenderLabelStyles = /*#__PURE__*/makeStyles({
+  labelContainer: /*#__PURE__*/_extends({
+    display: "flex",
+    flexDirection: "row",
+    justifyContent: "flex-start",
+    alignItems: "center"
+  }, /*#__PURE__*/shorthands.gap("6px")),
+  iconStyles: {
+    width: "26px"
+  },
+  item: {
+    paddingLeft: "15px"
+  }
+});
+
+var RenderLabel = function RenderLabel(props) {
+  var label = props.label,
+    icon = props.icon,
+    isRequired = props.isRequired;
+  var styles = useRenderLabelStyles();
+  return createElement(Fragment, null, createElement("div", {
+    className: styles.labelContainer
+  }, icon && isValidElement(icon) ? icon : createElement(Icon, {
+    icon: icon,
+    className: styles.iconStyles,
+    width: "20px",
+    height: "20px",
+    color: tokens.colorBrandForeground1
+  }), createElement(Caption1, {
+    style: {
+      color: tokens.colorBrandForeground1
+    }
+  }, label), createElement(Caption1, {
+    style: {
+      color: tokens.colorPaletteRedForeground1
+    }
+  }, isRequired ? " *" : "")));
+};
+
+var _templateObject$1, _templateObject2$1, _templateObject3$1;
+var useStyles = function useStyles() {
+  return {
+    container: css(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteralLoose(["\n      display: flex;\n      flex-direction: column;\n      row-gap: 10px;\n      margin-top: 10px;\n      padding: 7px;\n      background-color: ", ";\n    "])), tokens.colorNeutralBackground1),
+    title: css(_templateObject2$1 || (_templateObject2$1 = _taggedTemplateLiteralLoose(["\n      display: flex;\n      flex-direction: row;\n      gap: 10px;\n      align-items: center;\n      justify-content: start;\n    "]))),
+    cardFooter: css(_templateObject3$1 || (_templateObject3$1 = _taggedTemplateLiteralLoose(["\n       align-self: flex-end;\n       margin-top: 15px;\n    "])))
+  };
+};
+
+var TrialLicense = function TrialLicense(props) {
+  var _React$useState = useState({}),
+    errors = _React$useState[0],
+    setErrors = _React$useState[1];
+  var onTrialLicenseAdded = props.onTrialLicenseAdded,
+    onDismiss = props.onDismiss;
+  var appGlobalState = useAtomValue(appGlobalStateAtom);
+  var userInformation = appGlobalState.userInformation,
+    strings = appGlobalState.strings,
+    tenantId = appGlobalState.tenantId,
+    context = appGlobalState.context;
+  var _useUtils = useUtils(),
+    generateSalt = _useUtils.generateSalt;
+  var _React$useState2 = useState(undefined),
+    error = _React$useState2[0],
+    setError = _React$useState2[1];
+  var _useLicenseManager = useLicenseManager(tenantId, context == null ? void 0 : context.manifest.id, generateSalt(tenantId, context == null ? void 0 : context.manifest.id), context),
+    requestTrialLicense = _useLicenseManager.requestTrialLicense;
+  // Define Zod schema for validation
+  var trialLicenseSchema = z.object({
+    contactFirstName: z.string().min(1, strings.contactFirstNameError),
+    contactLastName: z.string().min(1, strings.contactLastNameError),
+    contactEmail: z.string().email(strings.contactEmailError),
+    contactCompany: z.string().min(1, strings.contactCompanyError)
+  });
+  var _React$useState3 = useState({
+      contactFirstName: userInformation == null ? void 0 : userInformation.givenName,
+      contactLastName: userInformation == null ? void 0 : userInformation.surname,
+      contactEmail: userInformation == null ? void 0 : userInformation.mail,
+      contactCompany: ""
+    }),
+    formData = _React$useState3[0],
+    setFormData = _React$useState3[1];
+  var handleInputChange = useCallback(function (e) {
+    var _e$target = e.target,
+      name = _e$target.name,
+      value = _e$target.value;
+    setFormData(function (prev) {
+      var _extends2;
+      return _extends({}, prev, (_extends2 = {}, _extends2[name] = value, _extends2));
+    });
+  }, []);
+  var styles = useStyles();
+  var handleSubmit = useCallback(/*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(e) {
+      var validation, fieldErrors;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            e.preventDefault();
+            // Validate form data using Zod schema
+            validation = trialLicenseSchema.safeParse(formData);
+            if (validation.success) {
+              _context.next = 8;
+              break;
+            }
+            // Map errors for display
+            fieldErrors = {};
+            validation.error.errors.forEach(function (error) {
+              var fieldName = error.path[0];
+              fieldErrors[fieldName] = error.message;
+            });
+            setErrors(fieldErrors);
+            _context.next = 19;
+            break;
+          case 8:
+            // Clear errors and call the parent function
+            setErrors({});
+            _context.prev = 9;
+            _context.next = 12;
+            return requestTrialLicense(tenantId, context.manifest.id, formData.contactFirstName, formData.contactLastName, formData.contactEmail, formData.contactCompany);
+          case 12:
+            onTrialLicenseAdded();
+            _context.next = 19;
+            break;
+          case 15:
+            _context.prev = 15;
+            _context.t0 = _context["catch"](9);
+            console.error(_context.t0);
+            setError(_context.t0);
+          case 19:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[9, 15]]);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }(), [formData, onTrialLicenseAdded]);
+  return createElement("div", {
+    className: styles.container
+  }, createElement("div", null, createElement(Body1Strong, {
+    className: styles.title
+  }, strings.trialLicenseTitle), createElement(Body1, null, strings.trialLicenseText)), createElement(Fragment, null, createElement(Field, {
+    label: createElement(RenderLabel, {
+      label: strings.firstName,
+      isRequired: true
+    }),
+    validationState: errors.contactFirstName ? "error" : "none",
+    validationMessage: errors.contactFirstName || undefined
+  }, createElement(Input, {
+    name: "contactFirstName",
+    value: formData.contactFirstName,
+    onChange: handleInputChange,
+    placeholder: strings.firstNamePlaceholder
+  })), createElement(Field, {
+    label: createElement(RenderLabel, {
+      label: strings.lastName,
+      isRequired: true
+    }),
+    validationState: errors.contactLastName ? "error" : "none",
+    validationMessage: errors.contactLastName || undefined
+  }, createElement(Input, {
+    name: "contactLastName",
+    value: formData.contactLastName,
+    onChange: handleInputChange,
+    placeholder: strings.lastNamePlaceholder
+  })), createElement(Field, {
+    label: createElement(RenderLabel, {
+      label: strings.email,
+      isRequired: true
+    }),
+    validationState: errors.contactEmail ? "error" : "none",
+    validationMessage: errors.contactEmail || undefined
+  }, createElement(Input, {
+    name: "contactEmail",
+    value: formData.contactEmail,
+    onChange: handleInputChange,
+    placeholder: strings.emailPlaceholder
+  })), createElement(Field, {
+    label: createElement(RenderLabel, {
+      label: strings.company,
+      isRequired: true
+    }),
+    validationState: errors.contactCompany ? "error" : "none",
+    validationMessage: errors.contactCompany || undefined
+  }, createElement(Input, {
+    name: "contactCompany",
+    value: formData.contactCompany,
+    onChange: handleInputChange,
+    placeholder: strings.companyPlaceholder
+  })), error && createElement(MessageBar, {
+    style: {
+      marginTop: 10,
+      marginBottom: 10
+    },
+    intent: "error"
+  }, " ", error.message), createElement(CardFooter, {
+    className: styles.cardFooter
+  }, createElement(Button, {
+    appearance: "primary",
+    onClick: handleSubmit
+  }, strings.register), createElement(Button, {
+    appearance: "secondary",
+    onClick: onDismiss
+  }, strings.cancel))));
+};
+
+var RegisterDialog = function RegisterDialog(props) {
+  var licenseStatus = props.licenseStatus,
+    open = props.open,
+    onDismiss = props.onDismiss,
+    licenseType = props.licenseType,
+    expiryDate = props.expiryDate;
+  var _useAtom = useAtom(appGlobalStateAtom),
+    appGlobalState = _useAtom[0],
+    setAppGlobalState = _useAtom[1];
+  var theme = appGlobalState.theme,
+    applicationName = appGlobalState.applicationName,
+    applicationIcon = appGlobalState.applicationIcon,
+    strings = appGlobalState.strings,
+    _appGlobalState$showA = appGlobalState.showApps,
+    showApps = _appGlobalState$showA === void 0 ? false : _appGlobalState$showA;
+  var _React$useState = React__default.useState("trial"),
+    selectedValue = _React$useState[0],
+    setSelectedValue = _React$useState[1];
+  var tabs = React__default.useMemo(function () {
+    var defaultTabs = [{
+      id: "trial",
+      value: "trial",
+      label: strings.trial,
+      icon: React__default.createElement(Clock20Regular, null)
+    }, {
+      id: "license",
+      value: "license",
+      label: strings.license,
+      icon: React__default.createElement(Key20Regular, null)
+    }];
+    if (showApps) {
+      tabs.push({
+        id: "apps",
+        value: "apps",
+        label: strings.apps,
+        icon: React__default.createElement(Apps20Regular, null)
+      });
+    }
+    return defaultTabs;
+  }, [strings]);
+  var onTabSelect = React__default.useCallback(function (_event, data) {
+    setSelectedValue(data.value);
+  }, []);
+  React__default.useEffect(function () {
+    var _statusToTab;
+    var statusToTab = (_statusToTab = {}, _statusToTab[EStatus.notFound] = ETabsOptions.Trial, _statusToTab[EStatus.expired] = ETabsOptions.License, _statusToTab[EStatus.invalid] = ETabsOptions.License, _statusToTab[EStatus.blocked] = ETabsOptions.License, _statusToTab[EStatus.genericError] = ETabsOptions.License, _statusToTab[EStatus.valid] = ETabsOptions.License, _statusToTab);
+    setSelectedValue(statusToTab[licenseStatus] || ETabsOptions.Trial);
+  }, [licenseStatus]);
+  var renderPanel = React__default.useMemo(function () {
+    switch (selectedValue) {
+      case "trial":
+        return React__default.createElement(TrialLicense, {
+          onTrialLicenseAdded: function onTrialLicenseAdded() {
+            setAppGlobalState(_extends({}, appGlobalState, {
+              refresh: true
+            }));
+            onDismiss();
+          },
+          onDismiss: onDismiss
+        });
+      case "license":
+        return React__default.createElement(LicenseControl, {
+          licenseStatus: licenseStatus,
+          onDismiss: onDismiss,
+          licenseType: licenseType,
+          expiryDate: expiryDate
+        });
+      case "apps":
+        return React__default.createElement("div", null, "Apps");
+      default:
+        return React__default.createElement(React__default.Fragment, null);
+    }
+  }, [selectedValue, licenseStatus, licenseType, expiryDate]);
+  var filterTabs = React__default.useCallback(function (tab) {
+    if ((licenseType == null ? void 0 : licenseType.toLocaleLowerCase()) === ETabsOptions.Trial.toLocaleLowerCase() || licenseStatus.toLocaleLowerCase() === EStatus.genericError.toLocaleLowerCase()) {
+      return tab.id.toLocaleLowerCase() !== ETabsOptions.Trial.toLocaleLowerCase();
+    }
+    return true;
+  }, [licenseType, licenseStatus]);
+  return React__default.createElement(FluentProvider, {
+    theme: theme
+  }, React__default.createElement(Dialog, {
+    open: open,
+    modalType: "modal"
+  }, React__default.createElement(DialogSurface, {
+    style: {
+      minHeight: 300
+    }
+  }, React__default.createElement(DialogTitle, null, React__default.createElement(RenderHeader, {
+    icon: applicationIcon,
+    title: applicationName,
+    onDismiss: onDismiss
+  })), React__default.createElement(TabList, {
+    selectedValue: selectedValue,
+    onTabSelect: onTabSelect,
+    selectTabOnFocus: true,
+    size: "medium"
+  }, tabs.filter(filterTabs).map(function (tab) {
+    return React__default.createElement(Tab, {
+      key: tab.id,
+      value: tab.value,
+      icon: tab.icon
+    }, tab.label);
+  })), renderPanel, React__default.createElement(DialogActions, null))));
+};
+
+var _templateObject$2, _templateObject2$2, _templateObject3$2, _templateObject4, _templateObject5, _templateObject6;
+var useStyles$1 = function useStyles() {
+  return {
+    container: css(_templateObject$2 || (_templateObject$2 = _taggedTemplateLiteralLoose(["\n      display: flex;\n      flex-direction: column;\n      row-gap: 10px;\n      margin-top: 10px;\n      margin-bottom: 30px;\n    "]))),
+    titleContainer: css(_templateObject2$2 || (_templateObject2$2 = _taggedTemplateLiteralLoose(["\n      display: flex;\n      flex-direction: column;\n      width: 100%;\n      justify-content: center;\n      align-items: center;\n      gap: 10px;\n    "]))),
+    titleAndIcon: css(_templateObject3$2 || (_templateObject3$2 = _taggedTemplateLiteralLoose(["\n      display: flex;\n      flex-direction: row;\n      gap: 10px;\n      align-items: center;\n    "]))),
+    informationPanel: css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteralLoose(["\n      padding: 20px;\n      display: flex;\n      flex-direction: column;\n      gap: 10px;\n      background-color: ", ";\n    "])), tokens.colorNeutralBackground3),
+    infoRow: css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteralLoose(["\n      display: flex;\n      gap: 10px;\n      justify-content: center;\n      align-items: center;\n      width: 100%;\n    "]))),
+    title: css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteralLoose(["\n      display: flex;\n      flex-direction: row;\n      gap: 10px;\n      align-items: center;\n    "])))
+  };
+};
+
+var LicensePlaceHolder = function LicensePlaceHolder(props) {
+  var appglobalState = useAtomValue(appGlobalStateAtom);
+  var theme = appglobalState.theme,
+    applicationName = appglobalState.applicationName,
+    applicationIcon = appglobalState.applicationIcon,
+    placeHolderText = appglobalState.placeHolderText,
+    strings = appglobalState.strings;
+  var styles = useStyles$1();
+  var _React$useState = useState(false),
+    isOpenLicenseForm = _React$useState[0],
+    setIsOpenLicenseForm = _React$useState[1];
+  var licenseStatus = props.licenseStatus,
+    licenseType = props.licenseType,
+    expiryDate = props.expiryDate;
+  var _useUtils = useUtils(),
+    formatString = _useUtils.formatString;
+  var onDissmiss = useCallback(function () {
+    setIsOpenLicenseForm(false);
+  }, []);
+  var formatDate = useMemo(function () {
+    return new Date(expiryDate).toLocaleDateString();
+  }, [expiryDate]);
+  var getMessageAndAction = useCallback(function () {
+    switch (licenseStatus) {
+      case EStatus.blocked:
+        return {
+          message: formatString(strings.messageStatusBlockedShort, licenseType),
+          actionLabel: strings.details
+        };
+      case EStatus.expired:
+        return {
+          message: formatString(strings.messageStatusExpiredShort, licenseType, formatDate),
+          actionLabel: strings.buyLicense
+        };
+      case EStatus.invalid:
+        return {
+          message: formatString(strings.messageStatusInvalidShort, licenseType != null ? licenseType : ""),
+          actionLabel: strings.details
+        };
+      case EStatus.notFound:
+        return {
+          message: formatString(strings.messageStatusNotFoundShort),
+          actionLabel: strings.requestLicense
+        };
+      case EStatus.genericError:
+        return {
+          message: formatString(strings.messageStatusGenericErrorShort, licenseType != null ? licenseType : ""),
+          actionLabel: strings.details
+        };
+      default:
+        return undefined;
+    }
+  }, [licenseStatus]);
+  var content = useMemo(function () {
+    return getMessageAndAction();
+  }, [getMessageAndAction]);
+  return createElement(Fragment, null, createElement(FluentProvider, {
+    theme: theme
+  }, createElement("div", {
+    className: styles.informationPanel
+  }, createElement("div", {
+    className: styles.infoRow
+  }, createElement("div", {
+    className: styles.title
+  }, createElement("div", {
+    className: styles.titleContainer
+  }, createElement("div", {
+    className: styles.titleAndIcon
+  }, applicationIcon, " ", createElement(Subtitle1, null, " ", applicationName), " "), createElement(Body1, null, placeHolderText)))), createElement("div", {
+    className: styles.infoRow
+  }, createElement(Body1Strong, null, " ", content == null ? void 0 : content.message)), createElement("div", {
+    className: styles.infoRow
+  }, createElement(DialogActions, {
+    style: {
+      marginTop: 15
+    }
+  }, createElement(Button, {
+    appearance: "primary",
+    onClick: function onClick() {
+      setIsOpenLicenseForm(true);
+    }
+  }, content == null ? void 0 : content.actionLabel)), isOpenLicenseForm && createElement(RegisterDialog, {
+    licenseStatus: licenseStatus,
+    licenseType: licenseType,
+    expiryDate: expiryDate,
+    open: isOpenLicenseForm,
+    onDismiss: onDissmiss
+  })))));
+};
+
+var InformationBar = function InformationBar(props) {
+  var message = props.message,
+    onAction = props.onAction;
+  return createElement(Fragment, null, createElement(MessageBar, {
+    intent: "warning"
+  }, createElement(MessageBarBody, null, createElement(MessageBarTitle, null, "License Manager"), message), createElement(MessageBarActions, null, createElement(Button, {
+    onClick: onAction
+  }, "Details"))));
+};
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+function ErrorIcon(props) {
+  return React__default.createElement("svg", Object.assign({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: "1em",
+    height: "1em",
+    viewBox: "0 0 24 24"
+  }, props), React__default.createElement("g", {
+    fill: "none",
+    stroke: "currentColor",
+    strokeWidth: 1.5
+  }, React__default.createElement("path", {
+    d: "M2 6.95c0-.883 0-1.324.07-1.692A4 4 0 0 1 5.257 2.07C5.626 2 6.068 2 6.95 2c.386 0 .58 0 .766.017a4 4 0 0 1 2.18.904c.144.119.28.255.554.529L11 4c.816.816 1.224 1.224 1.712 1.495a4 4 0 0 0 .848.352C14.098 6 14.675 6 15.828 6h.374c2.632 0 3.949 0 4.804.77q.119.105.224.224c.77.855.77 2.172.77 4.804V14c0 3.771 0 5.657-1.172 6.828S17.771 22 14 22h-4c-3.771 0-5.657 0-6.828-1.172S2 17.771 2 14z"
+  }), React__default.createElement("path", {
+    strokeLinecap: "round",
+    d: "m10.5 15l3-3m0 3l-3-3"
+  })));
+}
+
+var styles = {
+  container: /*#__PURE__*/css(/*#__PURE__*/_extends({
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "center",
+    justifyContent: "center",
+    height: "100%",
+    textAlign: "center",
+    backgroundColor: tokens.colorNeutralBackground2,
+    borderRadius: tokens.borderRadiusMedium
+  }, /*#__PURE__*/shorthands.padding(tokens.spacingVerticalXL, tokens.spacingHorizontalXL), {
+    color: tokens.colorNeutralForeground1
+  })),
+  icon: /*#__PURE__*/css({
+    marginTop: tokens.spacingHorizontalXL,
+    fontSize: "50px",
+    marginBottom: tokens.spacingHorizontalXL,
+    color: tokens.colorBrandBackground
+  }),
+  message: /*#__PURE__*/css({
+    marginBottom: tokens.spacingHorizontalXL
+  })
+};
+var ShowError = function ShowError(_ref) {
+  var message = _ref.message;
+  return React__default.createElement("div", {
+    className: styles.container
+  }, React__default.createElement(Subtitle1, null, "News Feed - Application"), React__default.createElement(ErrorIcon, {
+    className: styles.icon
+  }), React__default.createElement(Body1Strong, {
+    className: styles.message
+  }, message));
+};
+
+var NUMBER_DAYS_WARNING = 30;
+var LicenseProvider = function LicenseProvider(props) {
+  var _props$theme = props.theme,
+    theme = _props$theme === void 0 ? teamsLightTheme : _props$theme,
+    context = props.context,
+    children = props.children,
+    tenantId = props.tenantId,
+    _props$language = props.language,
+    language = _props$language === void 0 ? "en" : _props$language,
+    applicationId = props.applicationId;
+  /*  const instanceId = context?.instanceId as string;
+  const tenantId = context?.pageContext.legacyPageContext.aadTenantId; */
+  var _React$useState = useState(undefined),
+    error = _React$useState[0],
+    setError = _React$useState[1];
+  var _React$useState2 = useState(true),
+    isLoading = _React$useState2[0],
+    setIsLoading = _React$useState2[1];
+  var _React$useState3 = useState(),
+    licensingResponse = _React$useState3[0],
+    setLicenseResponse = _React$useState3[1];
+  var _useAtom = useAtom(appGlobalStateAtom),
+    appglobalState = _useAtom[0],
+    setAppGlobalState = _useAtom[1];
+  var _useUser = useUser(context),
+    userInformation = _useUser.userInformation;
+  var _React$useState4 = useState(false),
+    isOpenRegisterDialog = _React$useState4[0],
+    setIsOpenRegisterDialog = _React$useState4[1];
+  var _useUtils = useUtils(),
+    formatString = _useUtils.formatString;
+  var strings = appglobalState.strings,
+    refresh = appglobalState.refresh;
+  var _useUtils2 = useUtils(),
+    generateSalt = _useUtils2.generateSalt;
+  var _ref = licensingResponse || {},
+    status = _ref.status,
+    licenseType = _ref.licenseType,
+    expiryDate = _ref.expiryDate;
+  var _useLicenseManager = useLicenseManager(tenantId, applicationId, generateSalt(tenantId, applicationId), context),
+    checkAndUpdateLicensing = _useLicenseManager.checkAndUpdateLicensing;
+  var styles = useMemo(function () {
+    return {
+      root: css({
+        backgroundColor: "transparent",
+        padding: 20
+      })
+    };
+  }, []);
+  useEffect(function () {
+    _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      var stringsLoc, result;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return import("./loc/" + language + ".json");
+          case 3:
+            stringsLoc = _context.sent;
+            setAppGlobalState(function (prev) {
+              return _extends({}, prev, props, {
+                strings: stringsLoc,
+                userInformation: userInformation
+              });
+            });
+            _context.next = 7;
+            return checkAndUpdateLicensing();
+          case 7:
+            result = _context.sent;
+            setLicenseResponse(result);
+            setIsLoading(false);
+            _context.next = 16;
+            break;
+          case 12:
+            _context.prev = 12;
+            _context.t0 = _context["catch"](0);
+            if (_context.t0 instanceof Error) setError(_context.t0);
+            setIsLoading(false);
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[0, 12]]);
+    }))();
+  }, [userInformation]);
+  var fallbackRender = useCallback(function (_ref3) {
+    var error = _ref3.error;
+    console.error("[LicenseManager:Error: " + error.message);
+    return createElement(ShowError, {
+      message: error.message
+    });
+  }, []);
+  var onMessageBarAction = useCallback(function () {
+    setIsOpenRegisterDialog(true);
+  }, []);
+  //  ipdate liecense status on refresh
+  useEffect(function () {
+    _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var result;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            setAppGlobalState(function (prev) {
+              return _extends({}, prev, {
+                refresh: false
+              });
+            });
+            _context2.next = 4;
+            return checkAndUpdateLicensing();
+          case 4:
+            result = _context2.sent;
+            setLicenseResponse(result);
+            setIsLoading(false);
+            _context2.next = 13;
+            break;
+          case 9:
+            _context2.prev = 9;
+            _context2.t0 = _context2["catch"](0);
+            if (_context2.t0 instanceof Error) setError(_context2.t0);
+            setIsLoading(false);
+          case 13:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[0, 9]]);
+    }))();
+  }, [refresh]);
+  var onDissmiss = useCallback(function () {
+    setIsOpenRegisterDialog(false);
+  }, []);
+  //  renderMessagebar if the license is about to expire
+  var renderMessagebar = useCallback(function (licenseType, expiryDate, warningDays) {
+    var expirationDate = new Date(expiryDate);
+    var today = new Date();
+    var formatedExpiredDate = expirationDate.toLocaleDateString();
+    var dayDiff = differenceInDays(expirationDate, today);
+    var message = "";
+    if (dayDiff <= warningDays) {
+      message = formatString(strings.messageLicenseWarning, licenseType, dayDiff, formatedExpiredDate);
+      return createElement(InformationBar, {
+        message: message,
+        onAction: onMessageBarAction
+      });
+    }
+    return createElement(Fragment, null);
+  }, [expiryDate]);
+  // render the control based on the license status
+  var renderContent = useCallback(function () {
+    switch (status) {
+      case EStatus.valid:
+        return createElement(Fragment, null, renderMessagebar(licenseType, expiryDate, NUMBER_DAYS_WARNING), children);
+      case EStatus.genericError:
+      case EStatus.notFound:
+      case EStatus.blocked:
+      case EStatus.expired:
+      case EStatus.invalid:
+        return createElement(LicensePlaceHolder, {
+          licenseStatus: status,
+          licenseType: licenseType,
+          expiryDate: expiryDate
+        });
+    }
+    return createElement(Fragment, null);
+  }, [licensingResponse, refresh]);
+  if (isLoading) return null;
+  if (error) return createElement(ShowError, {
+    message: error.message
+  });
+  return createElement(Fragment, null, createElement(IdPrefixProvider, {
+    value: "news-feed-"
+  }, createElement(FluentProvider, {
+    theme: theme,
+    className: styles.root
+  }, createElement(ErrorBoundary, {
+    fallbackRender: fallbackRender
+  }, renderContent(), isOpenRegisterDialog && createElement(RegisterDialog, {
+    licenseStatus: status,
+    licenseType: licenseType,
+    expiryDate: expiryDate,
+    open: isOpenRegisterDialog,
+    onDismiss: onDissmiss
+  })))));
+};
+
+export { LicensePlaceHolder, LicenseProvider };
+//# sourceMappingURL=license-manager-react-components.esm.js.map