@feedmepos/mf-common 1.8.40 → 1.9.0

package/dist/app.js

@@ -485,6 +485,9 @@ FeedMeAuth._token = null;
 FeedMeAuth.authStateChangeCallBackId = 1;
 window.FeedMeAuthGlobal = FeedMeAuth;
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
 function getAugmentedNamespace(n) {
   if (n.__esModule)
     return n;
@@ -44878,14 +44881,14 @@ var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || functi
   return mod && mod.__esModule ? mod : { "default": mod };
 };
 Object.defineProperty(utils$3, "__esModule", { value: true });
-utils$3.clone = clone;
+utils$3.clone = clone$1;
 utils$3.randomString = randomString;
 utils$3.encode = encode$2;
 utils$3.decode = decode;
 utils$3.hexStringToBase64 = hexStringToBase64;
 utils$3.base64ToHexString = base64ToHexString;
 const fn_1 = __importDefault(fn$1);
-function clone(param) {
+function clone$1(param) {
   return JSON.parse(JSON.stringify(param));
 }
 function randomString(length = 10) {
@@ -47561,6 +47564,7 @@ class FmpUser {
     __publicField(this, "photoURL");
     __publicField(this, "displayName");
     __publicField(this, "phoneNumber");
+    __publicField(this, "_role");
     __publicField(this, "role");
     __publicField(this, "_adminPermissions", []);
     __publicField(this, "_permissions", []);
@@ -47569,6 +47573,7 @@ class FmpUser {
     this.photoURL = user2.photoURL;
     this.displayName = user2.displayName;
     this.phoneNumber = user2.phoneNumber;
+    this._role = role;
     this.role = {
       isAdmin: role === "admin",
       isStaff: role === "staff",
@@ -47611,12 +47616,15 @@ const coreStore = defineStore("portal-core", () => {
       throw new Error("User already logged in");
     }
     await new Promise((resolve) => {
-      const unsubscribe = FeedMeAuth.onAuthStateChanged(async (user2) => {
-        if (!user2)
-          return;
-        unsubscribe();
-        await setUser(user2);
-        resolve(user2);
+      FeedMeAuth.onAuthStateChanged(async (user2) => {
+        if (sessionUser.value && !user2) {
+          window.location.reload();
+        } else if (!sessionUser.value && user2) {
+          await setUser(user2);
+          resolve(user2);
+        } else if (user2) {
+          await setUser(user2);
+        }
       });
       FeedMeAuth.signIn({ waitForInitialAuthState: true });
     });
@@ -47627,7 +47635,6 @@ const coreStore = defineStore("portal-core", () => {
   }
   async function signOut() {
     FeedMeAuth.signOut();
-    await setUser(null);
   }
   async function setUser(user2) {
     if (user2) {
@@ -47636,31 +47643,29 @@ const coreStore = defineStore("portal-core", () => {
       }
       const { customClaims } = await FeedMeAuth.getUserClaims();
       const agents = await readAvailableAgents();
-      sessionUser.value = new FmpUser(user2, customClaims ?? {}, agents);
+      const _sessionUser = new FmpUser(user2, customClaims ?? {}, agents);
       await readBusinesses();
-      await fetchUserAdminPermissions();
-      await fetchUserPermissions();
+      await Promise.all([fetchUserAdminPermissions(_sessionUser), fetchUserPermissions(_sessionUser)]);
+      sessionUser.value = _sessionUser;
     } else {
       sessionUser.value = null;
       businesses.value = [];
       changeBusiness(void 0);
     }
   }
-  async function fetchUserAdminPermissions() {
-    const user2 = sessionUser.value;
+  async function fetchUserAdminPermissions(_sessionUser) {
+    const user2 = _sessionUser || sessionUser.value;
     if (!user2)
       return;
     const adminPermissions = await readUserAdminPermission();
     user2.setAdminPermisssions(adminPermissions);
-    sessionUser.value = user2;
   }
-  async function fetchUserPermissions() {
-    const user2 = sessionUser.value;
+  async function fetchUserPermissions(_sessionUser) {
+    const user2 = _sessionUser || sessionUser.value;
     if (!user2 || !currentBusiness.value)
       return;
     const businessPermissions = await readUserBusinessPermission(currentBusiness.value._id);
     user2.setPermissions(businessPermissions);
-    sessionUser.value = user2;
   }
   const namespace = ref("dev");
   function setNamespace(ns) {
@@ -50850,9 +50855,6 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     }
     async function logout() {
       await coreStore2.signOut();
-      window.location.replace(
-        `${FeedMeAuth.baseUrl}/login?fm_redirect=${encodeURIComponent(window.location.href)}`
-      );
     }
     async function gotoPortalV2() {
       const isDev = coreStore2.namespace.value === "dev";
@@ -50860,16 +50862,6 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     }
     const dropdownOpened = ref(false);
     const router = useRouter();
-    onMounted(async () => {
-      FeedMeAuth.onAuthStateChanged(async (user22) => {
-        var _a;
-        if (((_a = coreStore2.sessionUser.value) == null ? void 0 : _a.id) === (user22 == null ? void 0 : user22.id))
-          return;
-        await coreStore2.setUser(user22);
-      });
-      if (!coreStore2.sessionUser.value)
-        signIn();
-    });
     function onSelectApp(app) {
       if (app.external) {
         window.location.href = app.path;
@@ -50911,6 +50903,964 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
+var sift_csp_min = { exports: {} };
+(function(module, exports) {
+  !function(n, t) {
+    module.exports = t();
+  }(commonjsGlobal, function() {
+    return function(n) {
+      var t = {};
+      function r(e) {
+        if (t[e])
+          return t[e].exports;
+        var o = t[e] = { i: e, l: false, exports: {} };
+        return n[e].call(o.exports, o, o.exports, r), o.l = true, o.exports;
+      }
+      return r.m = n, r.c = t, r.d = function(n2, t2, e) {
+        r.o(n2, t2) || Object.defineProperty(n2, t2, { enumerable: true, get: e });
+      }, r.r = function(n2) {
+        "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(n2, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(n2, "__esModule", { value: true });
+      }, r.t = function(n2, t2) {
+        if (1 & t2 && (n2 = r(n2)), 8 & t2)
+          return n2;
+        if (4 & t2 && "object" == typeof n2 && n2 && n2.__esModule)
+          return n2;
+        var e = /* @__PURE__ */ Object.create(null);
+        if (r.r(e), Object.defineProperty(e, "default", { enumerable: true, value: n2 }), 2 & t2 && "string" != typeof n2)
+          for (var o in n2)
+            r.d(
+              e,
+              o,
+              (function(t3) {
+                return n2[t3];
+              }).bind(null, o)
+            );
+        return e;
+      }, r.n = function(n2) {
+        var t2 = n2 && n2.__esModule ? function() {
+          return n2.default;
+        } : function() {
+          return n2;
+        };
+        return r.d(t2, "a", t2), t2;
+      }, r.o = function(n2, t2) {
+        return Object.prototype.hasOwnProperty.call(n2, t2);
+      }, r.p = "", r(r.s = 0);
+    }([
+      function(n, t, r) {
+        n.exports = r(1);
+      },
+      function(n, t, r) {
+        function e(n2) {
+          return (e = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(n3) {
+            return typeof n3;
+          } : function(n3) {
+            return n3 && "function" == typeof Symbol && n3.constructor === Symbol && n3 !== Symbol.prototype ? "symbol" : typeof n3;
+          })(n2);
+        }
+        function o(n2) {
+          var t2 = "[object " + n2 + "]";
+          return function(n3) {
+            return Object.prototype.toString.call(n3) === t2;
+          };
+        }
+        r.r(t), r.d(t, "default", function() {
+          return m;
+        }), r.d(t, "compare", function() {
+          return j;
+        }), r.d(t, "comparable", function() {
+          return O;
+        });
+        var u = o("Array"), i = o("Object"), f = o("Function");
+        function c(n2, t2) {
+          return f(n2.get) ? n2.get(t2) : n2[t2];
+        }
+        function a(n2) {
+          return function(t2, r2) {
+            if (!u(r2) || !r2.length)
+              return n2(t2, r2);
+            for (var e2 = 0, o2 = r2.length; e2 < o2; e2++)
+              if (n2(t2, c(r2, e2)))
+                return true;
+            return false;
+          };
+        }
+        function l(n2) {
+          return function(t2, r2) {
+            if (!u(r2) || !r2.length)
+              return n2(t2, r2);
+            for (var e2 = 0, o2 = r2.length; e2 < o2; e2++)
+              if (!n2(t2, c(r2, e2)))
+                return false;
+            return true;
+          };
+        }
+        function p(n2, t2, r2, e2) {
+          return n2.validate(n2.options, t2, r2, e2);
+        }
+        var s = {
+          $eq: a(function(n2, t2) {
+            return n2(t2);
+          }),
+          $ne: l(function(n2, t2) {
+            return n2(t2);
+          }),
+          $gt: a(function(n2, t2) {
+            return n2(t2);
+          }),
+          $gte: a(function(n2, t2) {
+            return n2(t2);
+          }),
+          $lt: a(function(n2, t2) {
+            return n2(t2);
+          }),
+          $lte: a(function(n2, t2) {
+            return n2(t2);
+          }),
+          $mod: a(function(n2, t2) {
+            return n2(t2);
+          }),
+          $in: function(n2, t2) {
+            return n2(t2);
+          },
+          $nin: function(n2, t2) {
+            return n2(t2);
+          },
+          $not: function(n2, t2, r2, e2) {
+            return n2(t2, r2, e2);
+          },
+          $type: function(n2, t2) {
+            return n2(t2);
+          },
+          $all: function(n2, t2, r2, e2) {
+            return s.$and(n2, t2, r2, e2);
+          },
+          $size: function(n2, t2) {
+            return !!t2 && n2 === t2.length;
+          },
+          $or: function(n2, t2, r2, e2) {
+            for (var o2 = 0, u2 = n2.length; o2 < u2; o2++)
+              if (p(c(n2, o2), t2, r2, e2))
+                return true;
+            return false;
+          },
+          $nor: function(n2, t2, r2, e2) {
+            return !s.$or(n2, t2, r2, e2);
+          },
+          $and: function(n2, t2, r2, e2) {
+            for (var o2 = 0, u2 = n2.length; o2 < u2; o2++)
+              if (!p(c(n2, o2), t2, r2, e2))
+                return false;
+            return true;
+          },
+          $regex: a(function(n2, t2) {
+            return "string" == typeof t2 && n2.test(t2);
+          }),
+          $where: function(n2, t2, r2, e2) {
+            return n2.call(t2, t2, r2, e2);
+          },
+          $elemMatch: function(n2, t2, r2, e2) {
+            return u(t2) ? !!~function(n3, t3) {
+              for (var r3 = 0; r3 < n3.length; r3++) {
+                c(n3, r3);
+                if (p(t3, c(n3, r3)))
+                  return r3;
+              }
+              return -1;
+            }(t2, n2) : p(n2, t2, r2, e2);
+          },
+          $exists: function(n2, t2, r2, e2) {
+            return e2.hasOwnProperty(r2) === n2;
+          }
+        }, g = {
+          $eq: function(n2, t2, r2) {
+            var e2 = r2.comparable, o2 = r2.compare;
+            return n2 instanceof RegExp ? a(function(t3) {
+              return "string" == typeof t3 && n2.test(t3);
+            }) : n2 instanceof Function ? a(n2) : u(n2) && !n2.length ? a(function(n3) {
+              return u(n3) && !n3.length;
+            }) : a(
+              null === n2 ? function(n3) {
+                return null == n3;
+              } : function(t3) {
+                return 0 === o2(e2(t3), e2(n2));
+              }
+            );
+          },
+          $gt: function(n2, t2, r2) {
+            var e2 = r2.comparable, o2 = r2.compare;
+            return function(t3) {
+              return o2(e2(t3), e2(n2)) > 0;
+            };
+          },
+          $gte: function(n2, t2, r2) {
+            var e2 = r2.comparable, o2 = r2.compare;
+            return function(t3) {
+              return o2(e2(t3), e2(n2)) >= 0;
+            };
+          },
+          $lt: function(n2, t2, r2) {
+            var e2 = r2.comparable, o2 = r2.compare;
+            return function(t3) {
+              return o2(e2(t3), e2(n2)) < 0;
+            };
+          },
+          $lte: function(n2, t2, r2) {
+            var e2 = r2.comparable, o2 = r2.compare;
+            return function(t3) {
+              return o2(e2(t3), e2(n2)) <= 0;
+            };
+          },
+          $in: function(n2, t2, r2) {
+            var o2 = r2.comparable;
+            return function(t3) {
+              if (!(t3 instanceof Array)) {
+                var u2 = o2(t3);
+                if (u2 === t3 && "object" === e(t3)) {
+                  for (f2 = n2.length; f2--; )
+                    if (String(n2[f2]) === String(t3) && "[object Object]" !== String(t3))
+                      return true;
+                }
+                if (void 0 === u2) {
+                  for (f2 = n2.length; f2--; )
+                    if (null == n2[f2])
+                      return true;
+                }
+                for (f2 = n2.length; f2--; ) {
+                  var i2 = p(h(c(n2, f2), r2), u2, f2, n2);
+                  if (i2 && "[object Object]" !== String(i2) && "[object Object]" !== String(u2))
+                    return true;
+                }
+                return !!~n2.indexOf(u2);
+              }
+              for (var f2 = t3.length; f2--; )
+                if (~n2.indexOf(o2(c(t3, f2))))
+                  return true;
+              return false;
+            };
+          },
+          $nin: function(n2, t2, r2) {
+            var e2 = g.$in(n2, t2, r2);
+            return function(n3, t3, r3, o2) {
+              return !e2(n3, t3, r3, o2);
+            };
+          },
+          $mod: function(n2) {
+            return function(t2) {
+              return t2 % n2[0] == n2[1];
+            };
+          },
+          $ne: function(n2, t2, r2) {
+            var e2 = g.$eq(n2, t2, r2);
+            return l(function(n3, t3, r3, o2) {
+              return !e2(n3, t3, r3, o2);
+            });
+          },
+          $and: function(n2, t2, r2) {
+            return n2.map(d(r2));
+          },
+          $all: function(n2, t2, r2) {
+            return g.$and(n2, t2, r2);
+          },
+          $or: function(n2, t2, r2) {
+            return n2.map(d(r2));
+          },
+          $nor: function(n2, t2, r2) {
+            return n2.map(d(r2));
+          },
+          $not: function(n2, t2, r2) {
+            var e2 = d(r2)(n2);
+            return function(n3, t3, r3) {
+              return !p(e2, n3, t3, r3);
+            };
+          },
+          $type: function(n2) {
+            return function(t2, r2, e2) {
+              return null != t2 && (t2 instanceof n2 || t2.constructor == n2);
+            };
+          },
+          $regex: function(n2, t2) {
+            return new RegExp(n2, t2.$options);
+          },
+          $where: function(n2) {
+            if ("function" == typeof n2)
+              return n2;
+            throw new Error(
+              'In CSP mode, sift does not support strings in "$where" condition'
+            );
+          },
+          $elemMatch: function(n2, t2, r2) {
+            return d(r2)(n2);
+          },
+          $exists: function(n2) {
+            return !!n2;
+          }
+        };
+        function v(n2, t2) {
+          return { options: n2, validate: t2 };
+        }
+        function $(n2, t2) {
+          var r2 = n2.keyPath, e2 = n2.child, o2 = n2.query, i2 = [];
+          if (function n3(t3, r3, e3, o3, i3) {
+            if (e3 === r3.length || null == t3)
+              return void i3.push([t3, r3[e3 - 1], o3]);
+            var f3 = c(r3, e3);
+            if (u(t3) && isNaN(Number(f3)))
+              for (var a3 = 0, l3 = t3.length; a3 < l3; a3++)
+                n3(c(t3, a3), r3, e3, t3, i3);
+            else
+              n3(c(t3, f3), r3, e3 + 1, t3, i3);
+          }(t2, r2, 0, t2, i2), 1 === i2.length) {
+            var f2 = i2[0];
+            return p(e2, f2[0], f2[1], f2[2]);
+          }
+          for (var a2 = o2 && void 0 !== o2.$ne, l2 = a2, s2 = 0; s2 < i2.length; s2++) {
+            var g2 = i2[s2], v2 = p(e2, g2[0], g2[1], g2[2]);
+            a2 ? l2 &= v2 : l2 |= v2;
+          }
+          return l2;
+        }
+        function b(n2, t2, r2) {
+          return v({ keyPath: n2, child: t2, query: r2 }, $);
+        }
+        function d(n2) {
+          var t2 = n2.comparable, r2 = n2.expressions, e2 = function(n3) {
+            var t3;
+            return (!n3 || (!(t3 = n3) || t3.constructor !== Object && t3.constructor !== Array && "function Object() { [native code] }" !== t3.constructor.toString() && "function Array() { [native code] }" !== t3.constructor.toString() || t3.toJSON)) && (n3 = { $eq: n3 }), n3;
+          }, o2 = function(e3) {
+            e3 = t2(e3);
+            var o3 = [];
+            for (var i2 in e3) {
+              var f2 = e3[i2];
+              if ("$options" !== i2) {
+                var c2 = s[i2] || n2 && r2 && r2[i2];
+                if (c2)
+                  g[i2] && (f2 = g[i2](f2, e3, n2)), o3.push(v(t2(f2), c2));
+                else {
+                  if (36 === i2.charCodeAt(0))
+                    throw new Error("Unknown operation " + i2);
+                  var a2 = i2.split(".");
+                  o3.push(b(a2, u2(f2), f2));
+                }
+              }
+            }
+            return 1 === o3.length ? o3[0] : v(o3, s.$and);
+          }, u2 = function(n3) {
+            return n3 = e2(n3), -1 === function n4(t3, r3) {
+              if (!i(t3))
+                return r3;
+              for (var e3 in t3)
+                r3.push(e3), n4(t3[e3], r3);
+              return r3;
+            }(n3, []).join(",").search(/[$.]/) ? v(n3, y) : o2(n3);
+          };
+          return function(n3) {
+            return o2(e2(n3));
+          };
+        }
+        function y(n2, t2) {
+          if (Object.prototype.toString.call(n2) !== Object.prototype.toString.call(t2))
+            return false;
+          if (i(n2)) {
+            if (Object.keys(n2).length !== Object.keys(t2).length)
+              return false;
+            for (var r2 in n2)
+              if (!y(n2[r2], t2[r2]))
+                return false;
+            return true;
+          }
+          if (u(n2)) {
+            if (n2.length !== t2.length)
+              return false;
+            for (var e2 = 0, o2 = n2.length; e2 < o2; e2++)
+              if (!y(n2[e2], t2[e2]))
+                return false;
+            return true;
+          }
+          return n2 === t2;
+        }
+        function h(n2, t2) {
+          var r2 = d(t2)(n2);
+          return t2 && t2.select && (r2 = {
+            options: r2,
+            validate: function(n3, r3, e2, o2) {
+              return p(n3, r3 && t2.select(r3), e2, o2);
+            }
+          }), r2;
+        }
+        function m(n2, t2) {
+          var r2 = h(n2, t2 = Object.assign({ compare: j, comparable: O }, t2));
+          return function(n3, t3, e2) {
+            return p(r2, n3, t3, e2);
+          };
+        }
+        function j(n2, t2) {
+          if (y(n2, t2))
+            return 0;
+          if (e(n2) === e(t2)) {
+            if (n2 > t2)
+              return 1;
+            if (n2 < t2)
+              return -1;
+          }
+        }
+        function O(n2) {
+          return n2 instanceof Date ? n2.getTime() : u(n2) ? n2.map(O) : n2 && "function" == typeof n2.toJSON ? n2.toJSON() : n2;
+        }
+      }
+    ]);
+  });
+})(sift_csp_min);
+var sift_csp_minExports = sift_csp_min.exports;
+const sift = /* @__PURE__ */ getDefaultExportFromCjs(sift_csp_minExports);
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  subClass.__proto__ = superClass;
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf(o, p);
+}
+function isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct)
+    return false;
+  if (Reflect.construct.sham)
+    return false;
+  if (typeof Proxy === "function")
+    return true;
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct2(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2)
+        _setPrototypeOf(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn2) {
+  return Function.toString.call(fn2).indexOf("[native code]") !== -1;
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+  _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+    if (Class2 === null || !_isNativeFunction(Class2))
+      return Class2;
+    if (typeof Class2 !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class2))
+        return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class2);
+  };
+  return _wrapNativeSuper(Class);
+}
+function _assertThisInitialized(self2) {
+  if (self2 === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self2;
+}
+var getDefaultMessage = function getDefaultMessage2(error) {
+  return 'Cannot execute "' + error.action + '" on "' + error.subjectName + '"';
+};
+var defaultErrorMessage = getDefaultMessage;
+var ForbiddenError = /* @__PURE__ */ function(_Error) {
+  _inheritsLoose(ForbiddenError2, _Error);
+  ForbiddenError2.setDefaultMessage = function setDefaultMessage(messageOrFn) {
+    if (messageOrFn === null) {
+      defaultErrorMessage = getDefaultMessage;
+    } else {
+      defaultErrorMessage = typeof messageOrFn === "string" ? function() {
+        return messageOrFn;
+      } : messageOrFn;
+    }
+  };
+  ForbiddenError2.from = function from(ability) {
+    var error = new this("");
+    Object.defineProperty(error, "ability", {
+      value: ability
+    });
+    return error;
+  };
+  function ForbiddenError2(message, options) {
+    var _this;
+    if (options === void 0) {
+      options = {};
+    }
+    _this = _Error.call(this, message) || this;
+    _this._setMetadata(options);
+    _this.message = message || defaultErrorMessage(_assertThisInitialized(_this));
+    _this._customMessage = null;
+    if (typeof Error.captureStackTrace === "function") {
+      _this.name = _this.constructor.name;
+      Error.captureStackTrace(_assertThisInitialized(_this), _this.constructor);
+    }
+    return _this;
+  }
+  var _proto = ForbiddenError2.prototype;
+  _proto.setMessage = function setMessage(message) {
+    this._customMessage = message;
+    return this;
+  };
+  _proto.throwUnlessCan = function throwUnlessCan(action, subject, field) {
+    if (!this.ability) {
+      throw new ReferenceError("Cannot throw FordiddenError without respective ability instance");
+    }
+    var rule = this.ability.relevantRuleFor(action, subject, field);
+    if (rule && !rule.inverted) {
+      return;
+    }
+    this._setMetadata({
+      action,
+      subject,
+      field,
+      subjectName: this.ability.subjectName(subject)
+    });
+    var reason = rule ? rule.reason : "";
+    this.message = this._customMessage || reason || defaultErrorMessage(this);
+    throw this;
+  };
+  _proto._setMetadata = function _setMetadata(options) {
+    this.subject = options.subject;
+    this.subjectName = options.subjectName;
+    this.action = options.action;
+    this.field = options.field;
+  };
+  return ForbiddenError2;
+}(_wrapNativeSuper(Error));
+function wrapArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function getSubjectName(subject) {
+  if (!subject || typeof subject === "string") {
+    return subject;
+  }
+  var Type = typeof subject === "object" ? subject.constructor : subject;
+  return Type.modelName || Type.name;
+}
+function clone(object) {
+  return JSON.parse(JSON.stringify(object));
+}
+var REGEXP_SPECIAL_CHARS = /[-/\\^$+?.()|[\]{}]/g;
+var REGEXP_ANY = /\.?\*+\.?/g;
+var REGEXP_STARS = /\*+/;
+var REGEXP_DOT = /\./g;
+function detectRegexpPattern(match, index, string) {
+  var quantifier = string[0] === "*" || match[0] === "." && match[match.length - 1] === "." ? "+" : "*";
+  var matcher = match.indexOf("**") === -1 ? "[^.]" : ".";
+  var pattern = match.replace(REGEXP_DOT, "\\$&").replace(REGEXP_STARS, matcher + quantifier);
+  return index + match.length === string.length ? "(?:" + pattern + ")?" : pattern;
+}
+function escapeRegexp(match, index, string) {
+  if (match === "." && (string[index - 1] === "*" || string[index + 1] === "*")) {
+    return match;
+  }
+  return "\\" + match;
+}
+function createPattern(fields) {
+  var patterns = fields.map(function(field) {
+    return field.replace(REGEXP_SPECIAL_CHARS, escapeRegexp).replace(REGEXP_ANY, detectRegexpPattern);
+  });
+  var pattern = patterns.length > 1 ? "(?:" + patterns.join("|") + ")" : patterns[0];
+  return new RegExp("^" + pattern + "$");
+}
+var Rule = /* @__PURE__ */ function() {
+  function Rule2(params) {
+    this.actions = params.actions || params.action;
+    this.subject = params.subject;
+    this.fields = !params.fields || params.fields.length === 0 ? void 0 : wrapArray(params.fields);
+    Object.defineProperty(this, "_fieldsPattern", {
+      writable: true
+    });
+    this.inverted = !!params.inverted;
+    this.conditions = params.conditions;
+    Object.defineProperty(this, "_matches", {
+      writable: true,
+      value: this.conditions ? sift(this.conditions) : void 0
+    });
+    this.reason = params.reason;
+  }
+  var _proto = Rule2.prototype;
+  _proto.matches = function matches(object) {
+    if (!this._matches) {
+      return true;
+    }
+    if (typeof object === "string") {
+      return !this.inverted;
+    }
+    return this._matches(object);
+  };
+  _proto.isRelevantFor = function isRelevantFor(object, field) {
+    if (!this.fields) {
+      return true;
+    }
+    if (!field) {
+      return !this.inverted;
+    }
+    return this.matchesField(field);
+  };
+  _proto.matchesField = function matchesField(field) {
+    if (typeof this._fieldsPattern === "undefined") {
+      this._fieldsPattern = this.fields.join("").indexOf("*") === -1 ? null : createPattern(this.fields);
+    }
+    if (this._fieldsPattern === null || field.indexOf("*") !== -1) {
+      return this.fields.indexOf(field) !== -1;
+    }
+    return this._fieldsPattern.test(field);
+  };
+  return Rule2;
+}();
+var PRIVATE_FIELD = typeof Symbol !== "undefined" ? Symbol("private") : "__" + Date.now();
+var DEFAULT_ALIASES = {
+  crud: ["create", "read", "update", "delete"]
+};
+function hasAction(action, actions) {
+  return action === actions || Array.isArray(actions) && actions.indexOf(action) !== -1;
+}
+var Ability = /* @__PURE__ */ function() {
+  Ability2.addAlias = function addAlias(alias, actions) {
+    if (alias === "manage" || hasAction("manage", actions)) {
+      throw new Error('Cannot add alias for "manage" action because it represents any action');
+    }
+    if (hasAction(alias, actions)) {
+      throw new Error("Attempt to alias action to itself: " + alias + " -> " + actions.toString());
+    }
+    DEFAULT_ALIASES[alias] = actions;
+    return this;
+  };
+  function Ability2(rules, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    Object.defineProperty(this, "subjectName", {
+      value: options.subjectName || getSubjectName
+    });
+    this[PRIVATE_FIELD] = {
+      RuleType: options.RuleType || Rule,
+      originalRules: rules || [],
+      hasPerFieldRules: false,
+      indexedRules: /* @__PURE__ */ Object.create(null),
+      mergedRules: /* @__PURE__ */ Object.create(null),
+      events: {},
+      aliases: clone(DEFAULT_ALIASES)
+    };
+    this.update(rules);
+  }
+  var _proto = Ability2.prototype;
+  _proto.update = function update(rules) {
+    if (!Array.isArray(rules)) {
+      return this;
+    }
+    var payload = {
+      rules,
+      ability: this
+    };
+    this.emit("update", payload);
+    this[PRIVATE_FIELD].originalRules = rules.slice(0);
+    this[PRIVATE_FIELD].mergedRules = /* @__PURE__ */ Object.create(null);
+    var index = this.buildIndexFor(rules);
+    if (process.env.NODE_ENV !== "production" && index.isAllInverted && rules.length) {
+      console.warn("[casl]: Ability contains only inverted rules. That means user will not be able to do any actions. This will be changed to Error throw in the next major version");
+    }
+    this[PRIVATE_FIELD].indexedRules = index.rules;
+    this[PRIVATE_FIELD].hasPerFieldRules = index.hasPerFieldRules;
+    this.emit("updated", payload);
+    return this;
+  };
+  _proto.buildIndexFor = function buildIndexFor(rules) {
+    var indexedRules = /* @__PURE__ */ Object.create(null);
+    var RuleType = this[PRIVATE_FIELD].RuleType;
+    var isAllInverted = true;
+    var hasPerFieldRules = false;
+    for (var i = 0; i < rules.length; i++) {
+      var rule = new RuleType(rules[i]);
+      var actions = this.expandActions(rule.actions);
+      var subjects = wrapArray(rule.subject);
+      var priority = rules.length - i - 1;
+      isAllInverted = !!(isAllInverted && rule.inverted);
+      if (!hasPerFieldRules && rule.fields) {
+        hasPerFieldRules = true;
+      }
+      for (var k = 0; k < subjects.length; k++) {
+        var subject = subjects[k];
+        indexedRules[subject] = indexedRules[subject] || /* @__PURE__ */ Object.create(null);
+        for (var j = 0; j < actions.length; j++) {
+          var action = actions[j];
+          indexedRules[subject][action] = indexedRules[subject][action] || /* @__PURE__ */ Object.create(null);
+          indexedRules[subject][action][priority] = rule;
+        }
+      }
+    }
+    return {
+      isAllInverted,
+      hasPerFieldRules,
+      rules: indexedRules
+    };
+  };
+  _proto.expandActions = function expandActions(rawActions) {
+    var aliases = this[PRIVATE_FIELD].aliases;
+    var actions = wrapArray(rawActions);
+    var i = 0;
+    while (i < actions.length) {
+      var action = actions[i++];
+      if (aliases.hasOwnProperty(action)) {
+        actions = actions.concat(aliases[action]);
+      }
+    }
+    return actions;
+  };
+  _proto.can = function can(action, subject, field) {
+    if (field && typeof field !== "string") {
+      throw new Error("Ability.can expects 3rd parameter to be a string. See https://stalniy.github.io/casl/abilities/2017/07/21/check-abilities.html#checking-fields for details");
+    }
+    var rule = this.relevantRuleFor(action, subject, field);
+    return !!rule && !rule.inverted;
+  };
+  _proto.relevantRuleFor = function relevantRuleFor(action, subject, field) {
+    var rules = this.rulesFor(action, subject, field);
+    for (var i = 0; i < rules.length; i++) {
+      if (rules[i].matches(subject)) {
+        return rules[i];
+      }
+    }
+    return null;
+  };
+  _proto.possibleRulesFor = function possibleRulesFor(action, subject) {
+    var subjectName = this.subjectName(subject);
+    var mergedRules = this[PRIVATE_FIELD].mergedRules;
+    var key = subjectName + "_" + action;
+    if (!mergedRules[key]) {
+      mergedRules[key] = this.mergeRulesFor(action, subjectName);
+    }
+    return mergedRules[key];
+  };
+  _proto.mergeRulesFor = function mergeRulesFor(action, subjectName) {
+    var indexedRules = this[PRIVATE_FIELD].indexedRules;
+    var mergedRules = [subjectName, "all"].reduce(function(rules, subjectType) {
+      var subjectRules = indexedRules[subjectType];
+      if (!subjectRules) {
+        return rules;
+      }
+      return Object.assign(rules, subjectRules[action], subjectRules.manage);
+    }, []);
+    return mergedRules.filter(Boolean);
+  };
+  _proto.rulesFor = function rulesFor(action, subject, field) {
+    var rules = this.possibleRulesFor(action, subject);
+    if (!this[PRIVATE_FIELD].hasPerFieldRules) {
+      return rules;
+    }
+    return rules.filter(function(rule) {
+      return rule.isRelevantFor(subject, field);
+    });
+  };
+  _proto.cannot = function cannot() {
+    return !this.can.apply(this, arguments);
+  };
+  _proto.throwUnlessCan = function throwUnlessCan() {
+    var _ForbiddenError$from;
+    console.warn('\n      Ability.throwUnlessCan is deprecated and will be removed in 4.x version.\n      Please use "ForbiddenError.from(ability).throwUnlessCan(...)" instead.\n    '.trim());
+    (_ForbiddenError$from = ForbiddenError.from(this)).throwUnlessCan.apply(_ForbiddenError$from, arguments);
+  };
+  _proto.on = function on(event, handler) {
+    var events = this[PRIVATE_FIELD].events;
+    var isAttached = true;
+    if (!events[event]) {
+      events[event] = [];
+    }
+    events[event].push(handler);
+    return function() {
+      if (isAttached) {
+        var index = events[event].indexOf(handler);
+        events[event].splice(index, 1);
+        isAttached = false;
+      }
+    };
+  };
+  _proto.emit = function emit(event, payload) {
+    var handlers = this[PRIVATE_FIELD].events[event];
+    if (handlers) {
+      handlers.slice(0).forEach(function(handler) {
+        return handler(payload);
+      });
+    }
+  };
+  _createClass(Ability2, [{
+    key: "rules",
+    get: function get() {
+      return this[PRIVATE_FIELD].originalRules;
+    }
+  }]);
+  return Ability2;
+}();
+var Permission;
+((Permission2) => {
+  ((Level2) => {
+    Level2[Level2["feedMe"] = 0] = "feedMe";
+    Level2[Level2["business"] = 1] = "business";
+    Level2[Level2["restaurant"] = 2] = "restaurant";
+  })(Permission2.Level || (Permission2.Level = {}));
+  ((Action2) => {
+    Action2["manage"] = "manage";
+    Action2["create"] = "create";
+    Action2["read"] = "read";
+    Action2["update"] = "update";
+    Action2["delete"] = "delete";
+  })(Permission2.Action || (Permission2.Action = {}));
+})(Permission || (Permission = {}));
+((Permission2) => {
+  ((Subject2) => {
+    ((Feedme2) => {
+      Feedme2["all"] = "all";
+      Feedme2["restaurant"] = "restaurant";
+      Feedme2["business"] = "business";
+      Feedme2["delivery"] = "delivery";
+      Feedme2["agent"] = "agent";
+    })(Subject2.Feedme || (Subject2.Feedme = {}));
+    ((FeedmeBusinessField2) => {
+      FeedmeBusinessField2["quota"] = "quota";
+      FeedmeBusinessField2["owner"] = "owner";
+    })(Subject2.FeedmeBusinessField || (Subject2.FeedmeBusinessField = {}));
+    ((Business2) => {
+      Business2["profile"] = "business::profile";
+      Business2["restaurant"] = "business::restaurant";
+      Business2["menu"] = "business::menu";
+      Business2["promotion"] = "business::promotion";
+      Business2["voucher"] = "business::voucher";
+      Business2["membership"] = "business::membership";
+      Business2["stock"] = "business::stock";
+      Business2["permission"] = "business::permission";
+      Business2["role"] = "business::role";
+    })(Subject2.Business || (Subject2.Business = {}));
+    ((Restaurant2) => {
+      Restaurant2["restaurant"] = "restaurant";
+    })(Subject2.Restaurant || (Subject2.Restaurant = {}));
+  })(Permission2.Subject || (Permission2.Subject = {}));
+})(Permission || (Permission = {}));
+async function validate(params) {
+  const { sessionUser, validationManifest } = params;
+  const { requiredRoles, requiredCaslPermissions, customValidationFunction } = validationManifest;
+  if (!sessionUser) {
+    return { canAccess: false };
+  }
+  if (requiredRoles && requiredRoles.length > 0) {
+    if (!requiredRoles.includes(sessionUser._role || "")) {
+      return Promise.resolve({
+        canAccess: false,
+        message: "User does not have permission to access"
+      });
+    }
+  }
+  if (requiredCaslPermissions && requiredCaslPermissions.length > 0) {
+    const ability = new Ability(sessionUser.permissions);
+    if (requiredCaslPermissions.every(
+      (permission) => !ability.can(permission.action, permission.subject, permission.field)
+    )) {
+      return Promise.resolve({
+        canAccess: false,
+        message: "User does not have permission to access"
+      });
+    }
+  }
+  if (customValidationFunction) {
+    const customValidationResult = await customValidationFunction();
+    if (!customValidationResult.canAccess) {
+      return customValidationResult;
+    }
+  }
+  return Promise.resolve({ canAccess: true });
+}
+const ACCESS_DENIED_ROUTE = "access-denied";
+async function validateRoute(route) {
+  for (const matched of route.matched) {
+    if (matched.meta.validationManifest) {
+      const validationResult = await validate({
+        sessionUser: useCoreStore().sessionUser.value,
+        validationManifest: matched.meta.validationManifest
+      });
+      if (!validationResult.canAccess) {
+        return {
+          canAccess: false,
+          message: validationResult.message,
+          redirectTo: ACCESS_DENIED_ROUTE
+        };
+      }
+    }
+  }
+  return {
+    canAccess: true
+  };
+}
+function installRouteValidation(router) {
+  router.beforeEach(async (to, _, next) => {
+    const validationResult = await validateRoute(to);
+    if (!validationResult.canAccess) {
+      if (validationResult.redirectTo) {
+        next({ name: validationResult.redirectTo });
+      } else {
+        next({ name: ACCESS_DENIED_ROUTE });
+      }
+    } else {
+      next();
+    }
+  });
+}
 function initialize(clientId, namespace) {
   namespace && useCoreStore().setNamespace(namespace);
   const DEBUG_ACCOUNT_URL = "DEBUG_ACCOUNT_URL";
@@ -50919,14 +51869,21 @@ function initialize(clientId, namespace) {
     FeedMeAuth.setBaseUrl(debugAccountUrl);
   }
   FeedMeAuth.initialize({ clientId, loginMode: "iframe", oneTapMode: "full_screen" });
+  const coreStore2 = useCoreStore();
+  if (!coreStore2.sessionUser.value) {
+    coreStore2.signIn();
+  }
 }
 const onAuthStateChanged = FeedMeAuth.onAuthStateChanged;
 export {
   CountryOptions,
   FeedMeAuth,
   _sfc_main as FmNavBar,
+  FmpUser,
+  Permission,
   baseClientInstance,
   initialize,
+  installRouteValidation,
   onAuthStateChanged,
   useCoreStore
 };