@timardex/cluemart-shared 1.7.0 → 1.7.1

package/dist/auth/index.cjs

@@ -0,0 +1,1727 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/auth/index.ts
+var auth_exports = {};
+__export(auth_exports, {
+  ADMIN_APP_ROLES: () => ADMIN_APP_ROLES,
+  ADMIN_DASHBOARD_CONTEXTS: () => ADMIN_DASHBOARD_CONTEXTS,
+  DEFAULT_LIMITS: () => DEFAULT_LIMITS,
+  NO_LICENCE_FLAGS: () => NO_LICENCE_FLAGS,
+  PERMISSIONS: () => PERMISSIONS,
+  ROLE_PERMISSIONS: () => ROLE_PERMISSIONS,
+  UserProvider: () => UserProvider,
+  WILDCARD_PERMISSION: () => WILDCARD_PERMISSION,
+  canAccessAdminApp: () => canAccessAdminApp,
+  canAccessAdminPath: () => canAccessAdminPath,
+  createAuthManager: () => createAuthManager,
+  getDefaultAdminHome: () => getDefaultAdminHome,
+  getLicenceFlagsByRole: () => getLicenceFlagsByRole,
+  getPermissionsForRoles: () => getPermissionsForRoles,
+  getUsableAdminContexts: () => getUsableAdminContexts,
+  hasAllPermissions: () => hasAllPermissions,
+  hasAnyPermission: () => hasAnyPermission,
+  hasAnyRole: () => hasAnyRole,
+  hasLicence: () => hasLicence,
+  hasPermission: () => hasPermission,
+  hasRole: () => hasRole,
+  hasUserLicenceType: () => hasUserLicenceType,
+  isLicencedResourceType: () => isLicencedResourceType,
+  isProfileBadgeLicence: () => isProfileBadgeLicence,
+  permissionListIncludes: () => permissionListIncludes,
+  resolveAdminContextFromPath: () => resolveAdminContextFromPath,
+  useAuthCore: () => useAuthCore,
+  useAuthUser: () => useAuthUser
+});
+module.exports = __toCommonJS(auth_exports);
+
+// src/auth/createAuthManager.ts
+function createAuthManager() {
+  let logoutFn = null;
+  let userRefetchFn = null;
+  let logoutPromise = null;
+  return {
+    handleRefetchUser: async () => {
+      if (userRefetchFn) {
+        await userRefetchFn();
+      } else {
+        console.warn("\u274C User refetch function not set!");
+      }
+    },
+    logout() {
+      if (logoutPromise !== null) return logoutPromise;
+      if (logoutFn === null) {
+        console.warn("\u274C Logout function not set!");
+        return Promise.resolve();
+      }
+      logoutPromise = logoutFn().finally(() => {
+        logoutPromise = null;
+      });
+      return logoutPromise;
+    },
+    setLogout(fn) {
+      logoutFn = fn;
+    },
+    setUserRefetch(fn) {
+      userRefetchFn = fn;
+    }
+  };
+}
+
+// src/types/subscription.ts
+var TIERS_BY_PRIORITY = ["pro_plus", "pro", "standard"];
+var TIER_FROM_LICENCE = {
+  ["pro_event" /* PRO_EVENT */]: "pro",
+  ["pro_plus_event" /* PRO_PLUS_EVENT */]: "pro_plus",
+  ["pro_plus_vendor" /* PRO_PLUS_VENDOR */]: "pro_plus",
+  ["pro_vendor" /* PRO_VENDOR */]: "pro",
+  ["standard_event" /* STANDARD_EVENT */]: "standard",
+  ["standard_partner" /* STANDARD_PARTNER */]: "standard",
+  ["standard_vendor" /* STANDARD_VENDOR */]: "standard",
+  ["standard_affiliate" /* STANDARD_AFFILIATE */]: "standard",
+  ["standard_school" /* STANDARD_SCHOOL */]: "standard"
+};
+
+// src/auth/licenceUtils.ts
+function isLicencedResourceType(resourceType) {
+  return resourceType !== "affiliate" /* AFFILIATE */ && resourceType !== "school" /* SCHOOL */;
+}
+function isProfileBadgeLicence(licenceType) {
+  return licenceType !== "standard_affiliate" /* STANDARD_AFFILIATE */ && licenceType !== "standard_school" /* STANDARD_SCHOOL */;
+}
+var hasUserLicenceType = (authUser, licenceType) => authUser?.licences?.some((licence) => licence.licenceType === licenceType) ?? false;
+var hasLicence = (authUser, licenceType) => {
+  const directLicence = authUser?.licences?.some(
+    (licence) => licence.licenceType?.includes(licenceType)
+  ) ?? false;
+  return {
+    directLicence
+  };
+};
+var DEFAULT_LIMITS = {
+  // 1 means calendar/productMenu is enabled, 0 means disabled
+  availability: { pro: 1, pro_plus: 1, standard: 0 },
+  calendar: { pro: 1, pro_plus: 1, standard: 0 },
+  images: { pro: 12, pro_plus: 12, standard: 6 },
+  posters: { pro: 5, pro_plus: 5, standard: 5 },
+  productsList: { pro: 1, pro_plus: 1, standard: 0 },
+  relationShare: { pro: 1, pro_plus: 1, standard: 0 },
+  statistics: { pro: 1, pro_plus: 1, standard: 0 }
+};
+var NO_LICENCE_FLAGS = {
+  event: {
+    pro_plus: false,
+    // eslint-disable-next-line sort-keys
+    pro: false,
+    standard: false
+  },
+  partner: {
+    pro_plus: false,
+    // eslint-disable-next-line sort-keys
+    pro: false,
+    standard: false
+  },
+  vendor: {
+    pro_plus: false,
+    // eslint-disable-next-line sort-keys
+    pro: false,
+    standard: false
+  }
+};
+function getLicenceFlagsByRole(licences) {
+  const normalized = licences?.map((l) => l.toLowerCase()) ?? [];
+  const hasAnyLicence = normalized.length > 0;
+  function resolve(role) {
+    const result = {
+      pro_plus: false,
+      // eslint-disable-next-line sort-keys
+      pro: false,
+      standard: false
+    };
+    for (const tier of TIERS_BY_PRIORITY) {
+      if (normalized.some((l) => l.startsWith(`${tier}_${role}`))) {
+        result[tier] = true;
+        break;
+      }
+    }
+    if (!hasAnyLicence) {
+      result.pro = true;
+    }
+    return result;
+  }
+  return {
+    event: resolve("event" /* EVENT */),
+    partner: resolve("partner" /* PARTNER */),
+    vendor: resolve("vendor" /* VENDOR */)
+  };
+}
+
+// src/auth/permissions/permissions.ts
+var PERMISSIONS = [
+  "*",
+  // Dashboards
+  "dashboard.admin",
+  "dashboard.affiliate",
+  "dashboard.customer",
+  "dashboard.event",
+  "dashboard.partner",
+  "dashboard.school",
+  "dashboard.vendor",
+  // Admin: users
+  "users.delete",
+  "users.read",
+  "users.update",
+  // Admin: events
+  "events.create",
+  "events.delete",
+  "events.read",
+  "events.update",
+  // Admin: vendors
+  "vendors.create",
+  "vendors.delete",
+  "vendors.read",
+  "vendors.update",
+  // Admin: partners
+  "partners.create",
+  "partners.delete",
+  "partners.read",
+  "partners.update",
+  // Admin: schools
+  "schools.create",
+  "schools.delete",
+  "schools.read",
+  "schools.update",
+  // Admin: affiliates
+  "affiliates.create",
+  "affiliates.delete",
+  "affiliates.read",
+  "affiliates.update",
+  // Admin: ads / posts / settings
+  "ads.create",
+  "ads.delete",
+  "ads.read",
+  "ads.update",
+  "posts.create",
+  "posts.delete",
+  "posts.read",
+  "posts.update",
+  "settings.read",
+  "settings.update",
+  // Product: own-resource management
+  "affiliates.manage_own",
+  "events.manage_own",
+  "partners.manage_own",
+  "schools.manage_own",
+  "vendors.manage_own"
+];
+var WILDCARD_PERMISSION = "*";
+
+// src/auth/permissions/rolePermissions.ts
+var ADMIN_PERMISSIONS = [
+  "dashboard.admin",
+  "events.read",
+  "events.create",
+  "events.update",
+  "events.delete",
+  "vendors.read",
+  "vendors.create",
+  "vendors.update",
+  "vendors.delete",
+  "partners.read",
+  "partners.create",
+  "partners.update",
+  "partners.delete",
+  "schools.read",
+  "schools.create",
+  "schools.update",
+  "schools.delete",
+  "affiliates.read",
+  "affiliates.create",
+  "affiliates.update",
+  "affiliates.delete",
+  "ads.read",
+  "ads.create",
+  "ads.update",
+  "ads.delete",
+  "posts.read",
+  "posts.create",
+  "posts.update",
+  "posts.delete"
+];
+var ROLE_PERMISSIONS = {
+  ["super_admin" /* SUPER_ADMIN */]: ["*"],
+  ["admin" /* ADMIN */]: ADMIN_PERMISSIONS,
+  ["customer" /* CUSTOMER */]: ["dashboard.customer"],
+  ["event" /* EVENT */]: ["dashboard.event", "events.manage_own"],
+  ["vendor" /* VENDOR */]: ["dashboard.vendor", "vendors.manage_own"],
+  ["partner" /* PARTNER */]: ["dashboard.partner", "partners.manage_own"],
+  ["school" /* SCHOOL */]: ["dashboard.school", "schools.manage_own"],
+  ["affiliate" /* AFFILIATE */]: ["dashboard.affiliate", "affiliates.manage_own"]
+};
+
+// src/auth/permissions/helpers.ts
+function normalizeRoles(roles) {
+  if (!roles?.length) return [];
+  return roles;
+}
+function getPermissionsForRoles(roles) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const role of normalizeRoles(roles)) {
+    const perms = ROLE_PERMISSIONS[role] ?? [];
+    for (const perm of perms) {
+      if (!seen.has(perm)) {
+        seen.add(perm);
+        result.push(perm);
+      }
+    }
+  }
+  return result;
+}
+function permissionListIncludes(permissions, permission) {
+  if (!permissions?.length) return false;
+  const set = new Set(permissions);
+  if (set.has(WILDCARD_PERMISSION)) return true;
+  return set.has(permission);
+}
+function hasPermission(roles, permission) {
+  return permissionListIncludes(getPermissionsForRoles(roles), permission);
+}
+function hasAnyPermission(roles, permissions) {
+  if (permissions.length === 0) return false;
+  const granted = getPermissionsForRoles(roles);
+  return permissions.some((p) => permissionListIncludes(granted, p));
+}
+function hasAllPermissions(roles, permissions) {
+  if (permissions.length === 0) return true;
+  const granted = getPermissionsForRoles(roles);
+  return permissions.every((p) => permissionListIncludes(granted, p));
+}
+function hasRole(roles, role) {
+  return normalizeRoles(roles).includes(role);
+}
+function hasAnyRole(roles, checkRoles) {
+  if (checkRoles.length === 0) return false;
+  const set = new Set(normalizeRoles(roles));
+  return checkRoles.some((r) => set.has(r));
+}
+
+// src/auth/permissions/adminAppAccess.ts
+var ADMIN_APP_ROLES = [
+  "super_admin" /* SUPER_ADMIN */,
+  "admin" /* ADMIN */,
+  "event" /* EVENT */,
+  "vendor" /* VENDOR */,
+  "partner" /* PARTNER */,
+  "school" /* SCHOOL */,
+  "affiliate" /* AFFILIATE */
+];
+var ADMIN_DASHBOARD_CONTEXTS = [
+  {
+    context: "staff",
+    home: "/dashboard",
+    label: "Staff",
+    pathPrefixes: ["/dashboard"],
+    roles: ["super_admin" /* SUPER_ADMIN */, "admin" /* ADMIN */]
+  },
+  {
+    context: "event",
+    home: "/event/dashboard",
+    label: "Events",
+    pathPrefixes: ["/event"],
+    roles: ["event" /* EVENT */]
+  },
+  {
+    context: "vendor",
+    home: "/vendor/dashboard",
+    label: "Stallholders",
+    pathPrefixes: ["/vendor"],
+    roles: ["vendor" /* VENDOR */]
+  },
+  {
+    context: "partner",
+    home: "/partner/dashboard",
+    label: "Partners",
+    pathPrefixes: ["/partner"],
+    roles: ["partner" /* PARTNER */]
+  },
+  {
+    context: "school",
+    home: "/school/dashboard",
+    label: "Schools",
+    pathPrefixes: ["/school"],
+    roles: ["school" /* SCHOOL */]
+  },
+  {
+    context: "affiliate",
+    home: "/affiliate/dashboard",
+    label: "Affiliate",
+    pathPrefixes: ["/affiliate"],
+    roles: ["affiliate" /* AFFILIATE */]
+  }
+];
+function canAccessAdminApp(roles) {
+  return hasAnyRole(roles, ADMIN_APP_ROLES);
+}
+function getUsableAdminContexts(roles) {
+  return ADMIN_DASHBOARD_CONTEXTS.filter((ctx) => hasAnyRole(roles, ctx.roles));
+}
+function getDefaultAdminHome(roles, preferredContext) {
+  const usable = getUsableAdminContexts(roles);
+  if (usable.length === 0) {
+    return "/login";
+  }
+  if (preferredContext) {
+    const preferred = usable.find((ctx) => ctx.context === preferredContext);
+    if (preferred) return preferred.home;
+  }
+  return usable[0].home;
+}
+function resolveAdminContextFromPath(pathname) {
+  for (const ctx of ADMIN_DASHBOARD_CONTEXTS) {
+    if (ctx.pathPrefixes.some(
+      (prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`)
+    )) {
+      return ctx.context;
+    }
+  }
+  return null;
+}
+function canAccessAdminPath(roles, pathname) {
+  if (!canAccessAdminApp(roles)) return false;
+  const context = resolveAdminContextFromPath(pathname);
+  if (!context) {
+    return true;
+  }
+  const info = ADMIN_DASHBOARD_CONTEXTS.find((ctx) => ctx.context === context);
+  if (!info) return false;
+  return hasAnyRole(roles, info.roles);
+}
+
+// src/auth/useAuthCore.ts
+var import_react = require("react");
+
+// src/graphql/hooks/auth.ts
+var import_client3 = require("@apollo/client");
+
+// src/graphql/mutations/auth.ts
+var import_client2 = require("@apollo/client");
+
+// src/graphql/queries/global.ts
+var import_client = require("@apollo/client");
+var POSTER_USAGE_FIELDS_FRAGMENT = import_client.gql`
+  fragment PosterUsageFields on PosterUsageType {
+    month
+    count
+  }
+`;
+var SOCIAL_MEDIA_FIELDS_FRAGMENT = import_client.gql`
+  fragment SocialMediaFields on SocialMediaType {
+    name
+    link
+  }
+`;
+var RESOURCE_IMAGE_FIELDS_FRAGMENT = import_client.gql`
+  fragment ResourceImageFields on ResourceImageType {
+    active
+    source
+    title
+  }
+`;
+var OWNER_FIELDS_FRAGMENT = import_client.gql`
+  fragment OwnerFields on OwnerType {
+    email
+    userId
+  }
+`;
+var CATEGORY_FIELDS_FRAGMENT = import_client.gql`
+  fragment CategoryFields on CategoryType {
+    id
+    name
+    subcategories {
+      id
+      items {
+        id
+        name
+      }
+      name
+    }
+  }
+`;
+var LICENCE_FIELDS_FRAGMENT = import_client.gql`
+  fragment LicenceFields on UserLicenceType {
+    expiryDate
+    issuedDate
+    licenceType
+    prevLicenceType
+  }
+`;
+var TERMS_AGREEMENT_FIELDS_FRAGMENT = import_client.gql`
+  fragment TermsAgreementFields on TermsAgreementType {
+    appBuildNumber
+    appId
+    appVersion
+    brand
+    deviceName
+    installationId
+    manufacturer
+    modelName
+    osName
+    osVersion
+    termVersion
+    timestamp
+  }
+`;
+var DATETIME_FIELDS_FRAGMENT = import_client.gql`
+  fragment DateTimeFields on DateTimeType {
+    dateStatus
+    endDate
+    endTime
+    startDate
+    startTime
+  }
+`;
+var LOCATION_GEO_FIELDS_FRAGMENT = import_client.gql`
+  fragment LocationGeoFields on LocationGeoType {
+    coordinates
+    type
+  }
+`;
+var LOCATION_FIELDS_FRAGMENT = import_client.gql`
+  fragment LocationFields on LocationType {
+    city
+    country
+    fullAddress
+    geo {
+      ...LocationGeoFields
+    }
+    latitude
+    longitude
+    region
+  }
+  ${LOCATION_GEO_FIELDS_FRAGMENT}
+`;
+var USER_ACTIVITY_FIELDS_FRAGMENT = import_client.gql`
+  fragment UserActivityFields on UserActivityType {
+    favourites {
+      events
+      partners
+      vendors
+    }
+    going {
+      events {
+        resourceId
+        dateTime {
+          ...DateTimeFields
+        }
+      }
+    }
+    interested {
+      events {
+        resourceId
+        dateTime {
+          ...DateTimeFields
+        }
+      }
+    }
+    present {
+      events {
+        resourceId
+        dateTime {
+          ...DateTimeFields
+        }
+      }
+    }
+  }
+  ${DATETIME_FIELDS_FRAGMENT}
+`;
+var REDEEMED_REWARD_FIELDS_FRAGMENT = import_client.gql`
+  fragment RedeemedRewardFields on RedeemedRewardType {
+    name
+    pointsUsed
+    redeemedAt
+  }
+`;
+var STRIPE_FIELDS_FRAGMENT = import_client.gql`
+  fragment StripeSubscriptionFields on StripeSubscriptionType {
+    customerId
+    subscriptionId
+    status
+    currentPlan
+    startDate
+    endDate
+  }
+`;
+var USER_FIELDS_FRAGMENT = import_client.gql`
+  fragment UserFields on UserType {
+    _id
+    active
+    affiliate
+    avatar {
+      ...ResourceImageFields
+    }
+    createdAt
+    deletedAt
+    email
+    events
+    firstName
+    game
+    isTester
+    lastName
+    licences {
+      ...LicenceFields
+    }
+    location {
+      ...LocationFields
+    }
+    partner
+    overallPoints
+    platform
+    preferredRegion
+    permissions
+    promoCodes
+    roles
+    redeemedRewards {
+      ...RedeemedRewardFields
+    }
+    school
+    stripe {
+      ...StripeSubscriptionFields
+    }
+    termsAgreement {
+      ...TermsAgreementFields
+    }
+    userActivity {
+      ...UserActivityFields
+    }
+    vendor
+    updatedAt
+  }
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+  ${TERMS_AGREEMENT_FIELDS_FRAGMENT}
+  ${USER_ACTIVITY_FIELDS_FRAGMENT}
+  ${LICENCE_FIELDS_FRAGMENT}
+  ${LOCATION_FIELDS_FRAGMENT}
+  ${REDEEMED_REWARD_FIELDS_FRAGMENT}
+  ${STRIPE_FIELDS_FRAGMENT}
+`;
+var STALL_TYPE_FIELDS_FRAGMENT = import_client.gql`
+  fragment StallTypeFields on StallTypeType {
+    label
+    price
+    stallCapacity
+  }
+`;
+var RELATION_DATES_FRAGMENT = import_client.gql`
+  fragment RelationDates on RelationDateType {
+    dateTime {
+      dateStatus
+      endDate
+      endTime
+      startDate
+      startTime
+      stallType {
+        ...StallTypeFields
+      }
+    }
+    lastUpdateBy {
+      resourceId
+      userEmail
+    }
+    paymentReference
+    status
+  }
+  ${STALL_TYPE_FIELDS_FRAGMENT}
+`;
+var CONTACT_DETAILS_FIELDS_FRAGMENT = import_client.gql`
+  fragment ContactDetailsFields on ContactDetailsType {
+    email
+    landlinePhone
+    mobilePhone
+  }
+`;
+var EVENT_LIST_ITEM = import_client.gql`
+  fragment EventListItemFields on EventListItemType {
+    _id
+    active
+    approvedAt
+    claimed
+    cover {
+      ...ResourceImageFields
+    }
+    createdAt
+    dateTime {
+      ...DateTimeFields
+    }
+    deletedAt
+    description
+    eventType
+    googlePlaceId
+    images {
+      ...ResourceImageFields
+    }
+    location {
+      ...LocationFields
+    }
+    logo {
+      ...ResourceImageFields
+    }
+    name
+    rainOrShine
+    rating
+    region
+    relations {
+      relationId
+      relationDates {
+        ...RelationDates
+      }
+    }
+    reviewCount
+    slug
+    updatedAt
+  }
+  ${DATETIME_FIELDS_FRAGMENT}
+  ${LOCATION_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+  ${RELATION_DATES_FRAGMENT}
+`;
+var RELATED_POST_FIELDS_FRAGMENT = import_client.gql`
+  fragment RelatedPostFields on RelatedPostType {
+    postActive
+    postId
+    postSlug
+    postType
+  }
+`;
+var SOCIAL_SHARE_RESOURCE_FIELDS_FRAGMENT = import_client.gql`
+  fragment SocialShareResourceFields on SocialShareResourceType {
+    qrCode {
+      ...ResourceImageFields
+    }
+    socialImage {
+      ...ResourceImageFields
+    }
+  }
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/mutations/auth.ts
+var REGISTER_MUTATION = import_client2.gql`
+  mutation register($input: RegisterInputType!) {
+    register(input: $input) {
+      data {
+        refreshToken
+        token
+        user {
+          ...UserFields
+        }
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var LOGIN_MUTATION = import_client2.gql`
+  mutation login($input: LoginInputType!) {
+    login(input: $input) {
+      data {
+        refreshToken
+        token
+        user {
+          ...UserFields
+        }
+      }
+      message
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var LOGOUT_MUTATION = import_client2.gql`
+  mutation logout {
+    logout {
+      data
+      message
+    }
+  }
+`;
+var REFRESH_TOKEN_MUTATION = import_client2.gql`
+  mutation refreshToken($input: RefreshTokenInputType!) {
+    refreshToken(input: $input) {
+      data {
+        refreshToken
+        token
+      }
+      message
+    }
+  }
+`;
+var RESET_PASSWORD_MUTATION = import_client2.gql`
+  mutation resetPassword($input: ResetPasswordInputType!) {
+    resetPassword(input: $input) {
+      data
+      message
+    }
+  }
+`;
+var REQUEST_PASSWORD_RESET_MUTATION = import_client2.gql`
+  mutation requestPasswordReset($input: RequestPasswordResetInputType!) {
+    requestPasswordReset(input: $input) {
+      data
+      message
+    }
+  }
+`;
+var VALIDATE_VERIFICATION_TOKEN_MUTATION = import_client2.gql`
+  mutation validateVerificationToken(
+    $input: ValidateVerificationTokenInputType!
+  ) {
+    validateVerificationToken(input: $input) {
+      data
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/auth.ts
+var useLogout = () => {
+  const [logout, { loading, error }] = (0, import_client3.useMutation)(LOGOUT_MUTATION);
+  return { error, loading, logout };
+};
+
+// src/graphql/hooks/user/hooksQuery.ts
+var import_client8 = require("@apollo/client");
+
+// src/graphql/queries/user.ts
+var import_client7 = require("@apollo/client");
+
+// src/graphql/queries/event.ts
+var import_client4 = require("@apollo/client");
+var EVENT_INFO = import_client4.gql`
+  fragment EventInfoFields on EventInfoType {
+    _id
+    applicationDeadlineHours
+    dateTime {
+      dateStatus
+      endDate
+      endTime
+      stallTypes {
+        ...StallTypeFields
+      }
+      startDate
+      startTime
+    }
+    eventId
+    packInTime
+    paymentDueHours
+    paymentInfo {
+      accountHolderName
+      accountNumber
+      link
+      paymentMethod
+    }
+    refundPolicy {
+      category
+      label
+      value
+    }
+    requirements {
+      category
+      label
+      value
+    }
+  }
+  ${STALL_TYPE_FIELDS_FRAGMENT}
+`;
+var EVENT = import_client4.gql`
+  fragment EventFields on EventType {
+    _id
+    active
+    adIds
+    approvedAt
+    cover {
+      ...ResourceImageFields
+    }
+    claimed
+    createdAt
+    contactDetails {
+      ...ContactDetailsFields
+    }
+    dateTime {
+      ...DateTimeFields
+    }
+    description
+    deletedAt
+    googlePlaceId
+    images {
+      ...ResourceImageFields
+    }
+    eventType
+    location {
+      ...LocationFields
+    }
+    logo {
+      ...ResourceImageFields
+    }
+    eventInfoId
+    name
+    nzbn
+    owner {
+      ...OwnerFields
+    }
+    promoCodes
+    provider
+    posterUsage {
+      ...PosterUsageFields
+    }
+    region
+    relations {
+      relationId
+      relationDates {
+        ...RelationDates
+      }
+    }
+    rating
+    reviewCount
+    rainOrShine
+    relatedPost {
+      ...RelatedPostFields
+    }
+    socialMedia {
+      ...SocialMediaFields
+    }
+    sharePublic {
+      ...SocialShareResourceFields
+    }
+    shareRelation {
+      ...SocialShareResourceFields
+    }
+    slug
+    tags
+    termsAgreement {
+      ...TermsAgreementFields
+    }
+    updatedAt
+  }
+  ${DATETIME_FIELDS_FRAGMENT}
+  ${LOCATION_FIELDS_FRAGMENT}
+  ${OWNER_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+  ${SOCIAL_MEDIA_FIELDS_FRAGMENT}
+  ${POSTER_USAGE_FIELDS_FRAGMENT}
+  ${CONTACT_DETAILS_FIELDS_FRAGMENT}
+  ${TERMS_AGREEMENT_FIELDS_FRAGMENT}
+  ${RELATION_DATES_FRAGMENT}
+  ${RELATED_POST_FIELDS_FRAGMENT}
+  ${SOCIAL_SHARE_RESOURCE_FIELDS_FRAGMENT}
+`;
+var GET_EVENTS = import_client4.gql`
+  query getEvents($dateStatus: EventDateStatusEnumType) {
+    events(dateStatus: $dateStatus) {
+      ...EventListItemFields
+    }
+  }
+  ${EVENT_LIST_ITEM}
+`;
+var GET_EVENT = import_client4.gql`
+  query getEvent($_id: ID!) {
+    event(_id: $_id) {
+      ...EventFields
+    }
+  }
+  ${EVENT}
+`;
+var GET_EVENT_BY_PLACE_ID = import_client4.gql`
+  query getEventByPlaceId($googlePlaceId: String!) {
+    eventByPlaceId(googlePlaceId: $googlePlaceId) {
+      ...EventListItemFields
+    }
+  }
+  ${EVENT_LIST_ITEM}
+`;
+var GET_EVENTS_BY_REGION = import_client4.gql`
+  query getEventsByRegion(
+    $region: String!
+    $options: ResourcesByRegionOptions
+    $dateStatus: EventDateStatusEnumType
+  ) {
+    eventsByRegion(
+      region: $region
+      options: $options
+      dateStatus: $dateStatus
+    ) {
+      ...EventListItemFields
+    }
+  }
+  ${EVENT_LIST_ITEM}
+`;
+var SEARCH_EVENTS = import_client4.gql`
+  query searchEvents(
+    $region: String!
+    $search: String
+    $tags: [String]
+    $dateStatus: EventDateStatusEnumType
+  ) {
+    eventsSearch(
+      region: $region
+      search: $search
+      tags: $tags
+      dateStatus: $dateStatus
+    ) {
+      ...EventListItemFields
+    }
+  }
+  ${EVENT_LIST_ITEM}
+`;
+var GET_EVENTS_NEAR_ME = import_client4.gql`
+  query getEventsNearMe(
+    $latitude: Float!
+    $longitude: Float!
+    $radius: Int
+    $dateStatus: EventDateStatusEnumType
+  ) {
+    eventsNearMe(
+      latitude: $latitude
+      longitude: $longitude
+      radius: $radius
+      dateStatus: $dateStatus
+    ) {
+      ...EventListItemFields
+    }
+  }
+  ${EVENT_LIST_ITEM}
+`;
+var GET_EVENT_INFO = import_client4.gql`
+  query getEventInfo($eventId: ID!) {
+    eventInfo(eventId: $eventId) {
+      ...EventInfoFields
+    }
+  }
+  ${EVENT_INFO}
+`;
+
+// src/graphql/queries/partner.ts
+var import_client5 = require("@apollo/client");
+var PARTNER = import_client5.gql`
+  fragment PartnerFields on PartnerType {
+    _id
+    active
+    adIds
+    approvedAt
+    cover {
+      ...ResourceImageFields
+    }
+    createdAt
+    contactDetails {
+      ...ContactDetailsFields
+    }
+    description
+    deletedAt
+    images {
+      ...ResourceImageFields
+    }
+    location {
+      ...LocationFields
+    }
+    logo {
+      ...ResourceImageFields
+    }
+    name
+    nzbn
+    owner {
+      ...OwnerFields
+    }
+    partnerType
+    posterUsage {
+      ...PosterUsageFields
+    }
+    rating
+    region
+    reviewCount
+    relatedPost {
+      ...RelatedPostFields
+    }
+    socialMedia {
+      ...SocialMediaFields
+    }
+    slug
+    sharePublic {
+      ...SocialShareResourceFields
+    }
+    termsAgreement {
+      ...TermsAgreementFields
+    }
+    updatedAt
+  }
+  ${TERMS_AGREEMENT_FIELDS_FRAGMENT}
+  ${LOCATION_FIELDS_FRAGMENT}
+  ${OWNER_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+  ${POSTER_USAGE_FIELDS_FRAGMENT}
+  ${SOCIAL_MEDIA_FIELDS_FRAGMENT}
+  ${CONTACT_DETAILS_FIELDS_FRAGMENT}
+  ${RELATED_POST_FIELDS_FRAGMENT}
+  ${SOCIAL_SHARE_RESOURCE_FIELDS_FRAGMENT}
+`;
+var GET_PARTNERS = import_client5.gql`
+  query getPartners {
+    partners {
+      ...PartnerFields
+    }
+  }
+  ${PARTNER}
+`;
+var GET_PARTNER = import_client5.gql`
+  query getPartner($_id: ID!) {
+    partner(_id: $_id) {
+      ...PartnerFields
+    }
+  }
+  ${PARTNER}
+`;
+var GET_PARTNERS_BY_REGION = import_client5.gql`
+  query getPartnersByRegion(
+    $region: String!
+    $options: ResourcesByRegionOptions
+  ) {
+    partnersByRegion(region: $region, options: $options) {
+      ...PartnerFields
+    }
+  }
+  ${PARTNER}
+`;
+var SEARCH_PARTNERS = import_client5.gql`
+  query searchPartners($search: String!, $region: String!) {
+    partnersSearch(search: $search, region: $region) {
+      ...PartnerFields
+    }
+  }
+  ${PARTNER}
+`;
+
+// src/graphql/queries/vendor.ts
+var import_client6 = require("@apollo/client");
+var VENDOR_DATETIME_FIELDS_FRAGMENT = import_client6.gql`
+  fragment VendorDateTimeFields on VendorDateTimeType {
+    dateStatus
+    endDate
+    endTime
+    startDate
+    startTime
+  }
+`;
+var VENDOR_PRODUCT_LIST_FIELDS_FRAGMENT = import_client6.gql`
+  fragment VendorProductListFields on VendorProductListType {
+    description
+    name
+    price
+    priceUnit
+    productGroups
+  }
+`;
+var VENDOR = import_client6.gql`
+  fragment VendorFields on VendorType {
+    _id
+    active
+    adIds
+    approvedAt
+    availability {
+      corporate
+      private
+      school
+    }
+    vendorInfoId
+    categories {
+      ...CategoryFields
+    }
+    calendar {
+      active
+      calendarData {
+        dateTime {
+          ...VendorDateTimeFields
+        }
+        description
+        location {
+          ...LocationFields
+        }
+      }
+    }
+    contactDetails {
+      ...ContactDetailsFields
+    }
+    cover {
+      ...ResourceImageFields
+    }
+    createdAt
+    claimed
+    description
+    deletedAt
+    foodTruck
+    images {
+      ...ResourceImageFields
+    }
+    logo {
+      ...ResourceImageFields
+    }
+    name
+    owner {
+      ...OwnerFields
+    }
+    products {
+      active
+      productsList {
+        ...VendorProductListFields
+      }
+    }
+    promoCodes
+    posterUsage {
+      ...PosterUsageFields
+    }
+    rating
+    region
+    reviewCount
+    relatedPost {
+      ...RelatedPostFields
+    }
+    relations {
+      relationId
+      relationDates {
+        ...RelationDates
+      }
+    }
+    slug
+    socialMedia {
+      ...SocialMediaFields
+    }
+    sharePublic {
+      ...SocialShareResourceFields
+    }
+    shareRelation {
+      ...SocialShareResourceFields
+    }
+    termsAgreement {
+      ...TermsAgreementFields
+    }
+    updatedAt
+    vendorType
+    unregisteredVendorId
+  }
+  ${CATEGORY_FIELDS_FRAGMENT}
+  ${VENDOR_DATETIME_FIELDS_FRAGMENT}
+  ${LOCATION_FIELDS_FRAGMENT}
+  ${OWNER_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+  ${SOCIAL_MEDIA_FIELDS_FRAGMENT}
+  ${POSTER_USAGE_FIELDS_FRAGMENT}
+  ${VENDOR_PRODUCT_LIST_FIELDS_FRAGMENT}
+  ${CONTACT_DETAILS_FIELDS_FRAGMENT}
+  ${TERMS_AGREEMENT_FIELDS_FRAGMENT}
+  ${RELATION_DATES_FRAGMENT}
+  ${RELATED_POST_FIELDS_FRAGMENT}
+  ${SOCIAL_SHARE_RESOURCE_FIELDS_FRAGMENT}
+`;
+var VENDOR_ATTRIBUTES_FRAGMENT = import_client6.gql`
+  fragment VendorAttributesFields on VendorAttributesType {
+    details
+    isRequired
+  }
+`;
+var VENDOR_INFO = import_client6.gql`
+  fragment VendorInfoFields on VendorInfoType {
+    _id
+    compliance {
+      foodBeverageLicense
+      liabilityInsurance
+    }
+    documents {
+      ...ResourceImageFields
+    }
+    requirements {
+      electricity {
+        ...VendorAttributesFields
+      }
+      gazebo {
+        ...VendorAttributesFields
+      }
+      table {
+        ...VendorAttributesFields
+      }
+    }
+    product {
+      foodFlavors
+      packaging
+      priceRange {
+        max
+        min
+      }
+      producedIn
+    }
+    stallInfo {
+      size {
+        depth
+        width
+      }
+    }
+    vendorId
+  }
+  ${VENDOR_ATTRIBUTES_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+`;
+var UNREGISTERED_VENDOR_INVITATION_FRAGMENT = import_client6.gql`
+  fragment UnregisteredVendorInvitationFields on UnregisteredVendorInvitationType {
+    dateTime {
+      ...DateTimeFields
+    }
+    inviterId
+  }
+  ${DATETIME_FIELDS_FRAGMENT}
+`;
+var UNREGISTERED_VENDOR = import_client6.gql`
+  fragment UnregisteredVendorFields on UnregisteredVendorType {
+    _id
+    active
+    categoryIds
+    claimed
+    createdAt
+    deletedAt
+    email
+    invitations {
+      ...UnregisteredVendorInvitationFields
+    }
+    name
+    region
+    updatedAt
+  }
+  ${UNREGISTERED_VENDOR_INVITATION_FRAGMENT}
+`;
+var GET_VENDORS = import_client6.gql`
+  query getVendors {
+    vendors {
+      ...VendorFields
+    }
+  }
+  ${VENDOR}
+`;
+var GET_VENDOR = import_client6.gql`
+  query getVendor($_id: ID!) {
+    vendor(_id: $_id) {
+      ...VendorFields
+    }
+  }
+  ${VENDOR}
+`;
+var GET_VENDORS_BY_REGION = import_client6.gql`
+  query getVendorsByRegion(
+    $region: String!
+    $options: ResourcesByRegionOptions
+  ) {
+    vendorsByRegion(region: $region, options: $options) {
+      ...VendorFields
+    }
+  }
+  ${VENDOR}
+`;
+var SEARCH_VENDORS = import_client6.gql`
+  query searchVendors($search: String!, $region: String!) {
+    vendorSearch(search: $search, region: $region) {
+      ...VendorFields
+    }
+  }
+  ${VENDOR}
+`;
+var GET_VENDOR_INFO = import_client6.gql`
+  query getVendorInfo($vendorId: ID!) {
+    vendorInfo(vendorId: $vendorId) {
+      ...VendorInfoFields
+    }
+  }
+  ${VENDOR_INFO}
+`;
+var GET_UNREGISTERED_VENDORS = import_client6.gql`
+  query getUnregisteredVendors {
+    unregisteredVendors {
+      ...UnregisteredVendorFields
+    }
+  }
+  ${UNREGISTERED_VENDOR}
+`;
+var GET_UNREGISTERED_VENDORS_BY_INVITER_ID = import_client6.gql`
+  query getUnregisteredVendorsByInviterId($inviterId: ID!) {
+    unregisteredVendorsByInviterId(inviterId: $inviterId) {
+      ...UnregisteredVendorFields
+    }
+  }
+  ${UNREGISTERED_VENDOR}
+`;
+var GET_UNREGISTERED_VENDOR = import_client6.gql`
+  query getUnregisteredVendor($_id: ID!) {
+    unregisteredVendor(_id: $_id) {
+      ...UnregisteredVendorFields
+    }
+  }
+  ${UNREGISTERED_VENDOR}
+`;
+
+// src/graphql/queries/user.ts
+var GET_USERS = import_client7.gql`
+  query getUsers {
+    users {
+      ...UserFields
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var GET_USER = import_client7.gql`
+  query getUser($_id: ID!) {
+    user(_id: $_id) {
+      ...UserFields
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var GET_USER_EVENTS = import_client7.gql`
+  query getUserEvents {
+    userEvents {
+      ...EventFields
+    }
+  }
+  ${EVENT}
+`;
+var GET_USER_VENDORS = import_client7.gql`
+  query getUserVendors {
+    userVendors {
+      ...VendorFields
+    }
+  }
+  ${VENDOR}
+`;
+var GET_USER_PARTNERS = import_client7.gql`
+  query getUserPartners {
+    userPartners {
+      ...PartnerFields
+    }
+  }
+  ${PARTNER}
+`;
+var GET_USER_ACTIVITIES = import_client7.gql`
+  query getUserActivities {
+    userActivities {
+      favourites {
+        events {
+          ...EventListItemFields
+        }
+        partners {
+          ...PartnerFields
+        }
+        vendors {
+          ...VendorFields
+        }
+      }
+      going {
+        events {
+          ...EventListItemFields
+        }
+      }
+      interested {
+        events {
+          ...EventListItemFields
+        }
+      }
+      present {
+        events {
+          ...EventListItemFields
+        }
+      }
+    }
+  }
+  ${EVENT_LIST_ITEM}
+  ${VENDOR}
+  ${PARTNER}
+`;
+var GET_USER_RESOURCES = import_client7.gql`
+  query getUserResources($userId: ID!) {
+    userResources(userId: $userId) {
+      resources {
+        _id
+        logo
+        name
+        resourceType
+      }
+    }
+  }
+`;
+
+// src/graphql/hooks/user/hooksQuery.ts
+var useGetUser = (_id) => {
+  const { loading, error, data, refetch } = (0, import_client8.useQuery)(
+    GET_USER,
+    {
+      fetchPolicy: "network-only",
+      skip: !_id || _id === "",
+      variables: { _id }
+    }
+  );
+  const user = data?.user;
+  return { error, loading, refetch, user };
+};
+
+// src/storage/index.ts
+var USER_STORAGE_KEY = "authUser";
+
+// src/auth/useAuthCore.ts
+function useAuthCore(adapters) {
+  const {
+    storage,
+    authManager,
+    afterLogout,
+    shouldCallLogoutMutation = () => true,
+    notifyLogoutSuccess,
+    notifySessionExpired,
+    onError
+  } = adapters;
+  const [authUser, setAuthUser] = (0, import_react.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  const userId = (0, import_react.useMemo)(() => authUser?._id ?? "", [authUser?._id]);
+  const { refetch } = useGetUser(userId);
+  const { logout, loading } = useLogout();
+  const handleSetAuthUser = (0, import_react.useCallback)(
+    async (user) => {
+      setAuthUser(user);
+      if (user) {
+        await storage.setItem(USER_STORAGE_KEY, JSON.stringify(user));
+      } else {
+        await storage.removeItem(USER_STORAGE_KEY);
+      }
+    },
+    [storage]
+  );
+  const handleRefetchUser = (0, import_react.useCallback)(async () => {
+    if (!authUser) return;
+    try {
+      const result = await refetch();
+      if (!result) return;
+      const { data } = result;
+      if (data?.user) await handleSetAuthUser(data.user);
+    } catch (error) {
+      onError?.(error, { action: "refetchUser" });
+      console.warn(
+        "Failed to refetch user:",
+        error instanceof Error ? error.message : error
+      );
+    }
+  }, [authUser, handleSetAuthUser, onError, refetch]);
+  const licences = (0, import_react.useCallback)(
+    (resourceId) => {
+      const myLicences = authUser?.licences?.map((licence) => licence.licenceType) ?? [];
+      const myResourceIds = [
+        authUser?.vendor ?? null,
+        authUser?.partner ?? null,
+        ...authUser?.events ?? []
+      ].filter((id) => id !== null);
+      return myResourceIds.includes(resourceId) ? getLicenceFlagsByRole(myLicences) : NO_LICENCE_FLAGS;
+    },
+    [authUser]
+  );
+  const getLicenseAccessLevel = (0, import_react.useCallback)(
+    (limitType, resourceId, resourceType) => {
+      if (!isLicencedResourceType(resourceType)) {
+        return 0;
+      }
+      if (resourceId === "") {
+        return DEFAULT_LIMITS[limitType].pro;
+      }
+      const roleLicences = licences(resourceId)[resourceType];
+      if (roleLicences.pro_plus) return DEFAULT_LIMITS[limitType].pro_plus;
+      if (roleLicences.pro) return DEFAULT_LIMITS[limitType].pro;
+      if (roleLicences.standard) return DEFAULT_LIMITS[limitType].standard;
+      return 0;
+    },
+    [licences]
+  );
+  const hasVendorLicence = (0, import_react.useMemo)(
+    () => hasLicence(authUser, "vendor"),
+    [authUser]
+  );
+  const hasPartnerLicence = (0, import_react.useMemo)(
+    () => hasLicence(authUser, "partner"),
+    [authUser]
+  );
+  const hasEventLicence = (0, import_react.useMemo)(
+    () => hasLicence(authUser, "event"),
+    [authUser]
+  );
+  const hasUserLicence = (0, import_react.useCallback)(
+    (licenceType) => hasUserLicenceType(authUser, licenceType),
+    [authUser]
+  );
+  const permissions = (0, import_react.useMemo)(() => {
+    if (authUser?.permissions != null) {
+      return authUser.permissions;
+    }
+    return getPermissionsForRoles(authUser?.roles);
+  }, [authUser?.permissions, authUser?.roles]);
+  const hasPermissionFn = (0, import_react.useCallback)(
+    (permission) => permissionListIncludes(permissions, permission),
+    [permissions]
+  );
+  const hasRoleFn = (0, import_react.useCallback)(
+    (role) => hasRole(authUser?.roles, role),
+    [authUser?.roles]
+  );
+  const isAdmin = (0, import_react.useMemo)(
+    () => hasRole(authUser?.roles, "admin" /* ADMIN */) || permissionListIncludes(permissions, "dashboard.admin") || permissionListIncludes(permissions, "*"),
+    [authUser?.roles, permissions]
+  );
+  const isSuperAdmin = (0, import_react.useMemo)(
+    () => hasRole(authUser?.roles, "super_admin" /* SUPER_ADMIN */),
+    [authUser?.roles]
+  );
+  const isAffiliate = (0, import_react.useMemo)(
+    () => hasRole(authUser?.roles, "affiliate" /* AFFILIATE */) && authUser?.affiliate !== null && authUser?.affiliate !== void 0,
+    [authUser?.roles, authUser?.affiliate]
+  );
+  const isSchool = (0, import_react.useMemo)(
+    () => hasRole(authUser?.roles, "school" /* SCHOOL */) && authUser?.school !== null && authUser?.school !== void 0,
+    [authUser?.roles, authUser?.school]
+  );
+  (0, import_react.useEffect)(() => {
+    const loadUser = async () => {
+      try {
+        const userJson = await storage.getItem(USER_STORAGE_KEY);
+        await handleSetAuthUser(userJson ? JSON.parse(userJson) : null);
+      } catch (error) {
+        onError?.(error, { action: "loadUserFromStorage" });
+        console.error("Failed to load user from storage:", error);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    void loadUser();
+  }, []);
+  const logoutWithReason = (0, import_react.useCallback)(
+    async (reason) => {
+      try {
+        if (shouldCallLogoutMutation(reason)) {
+          try {
+            const result = await logout();
+            const message = result?.data?.logout?.message;
+            if (message) {
+              notifyLogoutSuccess?.(message);
+            }
+          } catch (err) {
+            onError?.(err, { action: "logout" });
+            console.warn("Logout request failed (ignored):", err);
+          }
+        }
+      } finally {
+        await afterLogout(reason);
+        setAuthUser(null);
+        await storage.removeItem(USER_STORAGE_KEY);
+      }
+    },
+    [
+      afterLogout,
+      logout,
+      notifyLogoutSuccess,
+      onError,
+      shouldCallLogoutMutation,
+      storage
+    ]
+  );
+  const handleLogoutExplicit = (0, import_react.useCallback)(
+    () => logoutWithReason("manual"),
+    [logoutWithReason]
+  );
+  const handleLogoutExpired = (0, import_react.useCallback)(async () => {
+    const hadSession = authUser != null;
+    if (!hadSession) return;
+    await logoutWithReason("expired");
+    notifySessionExpired?.();
+  }, [authUser, logoutWithReason, notifySessionExpired]);
+  (0, import_react.useEffect)(() => {
+    authManager.setLogout(() => handleLogoutExpired());
+    authManager.setUserRefetch(() => handleRefetchUser());
+  }, [authManager, handleLogoutExpired, handleRefetchUser]);
+  return {
+    authUser,
+    getLicenseAccessLevel,
+    handleLogoutExplicit,
+    hasEventLicence,
+    hasPartnerLicence,
+    hasPermission: hasPermissionFn,
+    hasRole: hasRoleFn,
+    hasUserLicence,
+    hasVendorLicence,
+    isAdmin,
+    isAffiliate,
+    isLoading: loading || isLoading,
+    isSchool,
+    isSuperAdmin,
+    permissions,
+    refetchUser: handleRefetchUser,
+    setUser: handleSetAuthUser
+  };
+}
+
+// src/auth/UserProvider.tsx
+var import_react2 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var UserContext = (0, import_react2.createContext)(void 0);
+var UserProvider = ({ children, value }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(UserContext.Provider, { value, children });
+};
+var useAuthUser = () => {
+  const context = (0, import_react2.useContext)(UserContext);
+  if (!context) {
+    throw new Error("useAuthUser must be used within a UserProvider");
+  }
+  return context;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADMIN_APP_ROLES,
+  ADMIN_DASHBOARD_CONTEXTS,
+  DEFAULT_LIMITS,
+  NO_LICENCE_FLAGS,
+  PERMISSIONS,
+  ROLE_PERMISSIONS,
+  UserProvider,
+  WILDCARD_PERMISSION,
+  canAccessAdminApp,
+  canAccessAdminPath,
+  createAuthManager,
+  getDefaultAdminHome,
+  getLicenceFlagsByRole,
+  getPermissionsForRoles,
+  getUsableAdminContexts,
+  hasAllPermissions,
+  hasAnyPermission,
+  hasAnyRole,
+  hasLicence,
+  hasPermission,
+  hasRole,
+  hasUserLicenceType,
+  isLicencedResourceType,
+  isProfileBadgeLicence,
+  permissionListIncludes,
+  resolveAdminContextFromPath,
+  useAuthCore,
+  useAuthUser
+});
+//# sourceMappingURL=index.cjs.map