@htlkg/components 0.0.2 → 0.0.4

package/dist/useAdminPage-GhgXp0x8.js

@@ -0,0 +1,1070 @@
+import { ref, computed, inject, watch, onMounted } from "vue";
+import { routes } from "@htlkg/core";
+import { a as atom } from "./index-DGO_pNgG.js";
+import { u as useStore } from "./index-QK97OdqQ.js";
+function useModal(options = {}) {
+  const isOpen = ref(options.initialOpen ?? false);
+  function open() {
+    var _a;
+    isOpen.value = true;
+    (_a = options.onOpen) == null ? void 0 : _a.call(options);
+  }
+  function close() {
+    var _a;
+    isOpen.value = false;
+    (_a = options.onClose) == null ? void 0 : _a.call(options);
+  }
+  function toggle() {
+    if (isOpen.value) {
+      close();
+    } else {
+      open();
+    }
+  }
+  return {
+    isOpen,
+    open,
+    close,
+    toggle
+  };
+}
+function useTabs(options) {
+  const tabs = ref(options.tabs);
+  const activeTab = ref(
+    options.initialTab || (tabs.value.length > 0 ? tabs.value[0].id : "")
+  );
+  const currentTabIndex = computed(
+    () => tabs.value.findIndex((tab) => tab.id === activeTab.value)
+  );
+  const isFirstTab = computed(() => currentTabIndex.value === 0);
+  const isLastTab = computed(
+    () => currentTabIndex.value === tabs.value.length - 1
+  );
+  function setActiveTab(tabId) {
+    var _a;
+    const tab = tabs.value.find((t) => t.id === tabId);
+    if (tab && !tab.disabled) {
+      activeTab.value = tabId;
+      (_a = options.onChange) == null ? void 0 : _a.call(options, tabId);
+    }
+  }
+  function nextTab() {
+    if (!isLastTab.value) {
+      const nextIndex = currentTabIndex.value + 1;
+      const nextTab2 = tabs.value[nextIndex];
+      if (nextTab2 && !nextTab2.disabled) {
+        setActiveTab(nextTab2.id);
+      } else if (nextIndex < tabs.value.length - 1) {
+        activeTab.value = nextTab2.id;
+        nextTab2();
+      }
+    }
+  }
+  function previousTab() {
+    if (!isFirstTab.value) {
+      const prevIndex = currentTabIndex.value - 1;
+      const prevTab = tabs.value[prevIndex];
+      if (prevTab && !prevTab.disabled) {
+        setActiveTab(prevTab.id);
+      } else if (prevIndex > 0) {
+        activeTab.value = prevTab.id;
+        previousTab();
+      }
+    }
+  }
+  function isTabActive(tabId) {
+    return activeTab.value === tabId;
+  }
+  function isTabDisabled(tabId) {
+    const tab = tabs.value.find((t) => t.id === tabId);
+    return (tab == null ? void 0 : tab.disabled) ?? false;
+  }
+  return {
+    activeTab,
+    tabs,
+    currentTabIndex,
+    isFirstTab,
+    isLastTab,
+    setActiveTab,
+    nextTab,
+    previousTab,
+    isTabActive,
+    isTabDisabled
+  };
+}
+function useForm(options) {
+  const values = ref({ ...options.initialValues });
+  const errors = ref({});
+  const touched = ref({});
+  const isSubmitting = ref(false);
+  const isValid = computed(() => Object.keys(errors.value).length === 0);
+  function setFieldValue(field, value) {
+    values.value[field] = value;
+  }
+  function setFieldError(field, error) {
+    errors.value[field] = error;
+  }
+  function setFieldTouched(field, isTouched) {
+    touched.value[field] = isTouched;
+  }
+  async function validateField(field) {
+    var _a;
+    const rules = (_a = options.validationRules) == null ? void 0 : _a[field];
+    if (!rules || rules.length === 0) return true;
+    const value = values.value[field];
+    for (const rule of rules) {
+      const isValid2 = await rule.validate(value);
+      if (!isValid2) {
+        setFieldError(field, rule.message);
+        return false;
+      }
+    }
+    delete errors.value[field];
+    return true;
+  }
+  async function validateForm() {
+    const fields = Object.keys(values.value);
+    const validationResults = await Promise.all(
+      fields.map((field) => validateField(field))
+    );
+    return validationResults.every((result) => result);
+  }
+  async function handleSubmit(event) {
+    var _a;
+    if (event) {
+      event.preventDefault();
+    }
+    if (isSubmitting.value) return;
+    for (const field of Object.keys(values.value)) {
+      setFieldTouched(field, true);
+    }
+    const isFormValid = await validateForm();
+    if (!isFormValid) return;
+    isSubmitting.value = true;
+    try {
+      await ((_a = options.onSubmit) == null ? void 0 : _a.call(options, values.value));
+    } finally {
+      isSubmitting.value = false;
+    }
+  }
+  function resetForm() {
+    values.value = { ...options.initialValues };
+    errors.value = {};
+    touched.value = {};
+    isSubmitting.value = false;
+  }
+  return {
+    values,
+    errors,
+    touched,
+    isSubmitting,
+    isValid,
+    setFieldValue,
+    setFieldError,
+    setFieldTouched,
+    validateField,
+    validateForm,
+    handleSubmit,
+    resetForm
+  };
+}
+const required = (message = "This field is required") => ({
+  validate: (value) => {
+    if (value === null || value === void 0) return false;
+    if (typeof value === "string") return value.trim().length > 0;
+    if (Array.isArray(value)) return value.length > 0;
+    return true;
+  },
+  message
+});
+const minLength = (min2, message) => ({
+  validate: (value) => {
+    if (!value) return true;
+    return value.length >= min2;
+  },
+  message: message || `Must be at least ${min2} characters`
+});
+const maxLength = (max2, message) => ({
+  validate: (value) => {
+    if (!value) return true;
+    return value.length <= max2;
+  },
+  message: message || `Must be at most ${max2} characters`
+});
+const email = (message = "Invalid email address") => ({
+  validate: (value) => {
+    if (!value) return true;
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(value);
+  },
+  message
+});
+const pattern = (regex, message = "Invalid format") => ({
+  validate: (value) => {
+    if (!value) return true;
+    return regex.test(value);
+  },
+  message
+});
+const min = (minValue, message) => ({
+  validate: (value) => {
+    if (value === null || value === void 0) return true;
+    return value >= minValue;
+  },
+  message: message || `Must be at least ${minValue}`
+});
+const max = (maxValue, message) => ({
+  validate: (value) => {
+    if (value === null || value === void 0) return true;
+    return value <= maxValue;
+  },
+  message: message || `Must be at most ${maxValue}`
+});
+const custom = (validator, message) => ({
+  validate: validator,
+  message
+});
+function useFormValidation() {
+  return {
+    required,
+    minLength,
+    maxLength,
+    email,
+    pattern,
+    min,
+    max,
+    custom
+  };
+}
+const notifications = ref([]);
+function useNotifications() {
+  function addNotification(notification) {
+    const id = `notification-${Date.now()}-${Math.random()}`;
+    const newNotification = {
+      ...notification,
+      id
+    };
+    notifications.value.push(newNotification);
+    if (notification.duration) {
+      setTimeout(() => {
+        removeNotification(id);
+      }, notification.duration);
+    }
+    return id;
+  }
+  function removeNotification(id) {
+    const index = notifications.value.findIndex((n) => n.id === id);
+    if (index !== -1) {
+      notifications.value.splice(index, 1);
+    }
+  }
+  function clearAll() {
+    notifications.value = [];
+  }
+  function info(message, duration = 3e3) {
+    return addNotification({ message, type: "info", duration });
+  }
+  function success(message, duration = 3e3) {
+    return addNotification({ message, type: "success", duration });
+  }
+  function warning(message, duration = 3e3) {
+    return addNotification({ message, type: "warning", duration });
+  }
+  function error(message, duration = 5e3) {
+    return addNotification({ message, type: "error", duration });
+  }
+  return {
+    notifications,
+    addNotification,
+    removeNotification,
+    clearAll,
+    info,
+    success,
+    warning,
+    error
+  };
+}
+const PAGE_CONTEXT_KEY = Symbol("pageContext");
+const $user = atom(null);
+const $currentBrand = atom(null);
+function setUser(user) {
+  $user.set(user);
+}
+function setCurrentBrand(brand) {
+  $currentBrand.set(brand);
+}
+function usePageContext() {
+  const injected = inject(PAGE_CONTEXT_KEY, null);
+  if (injected) {
+    return computed(() => injected);
+  }
+  const user = useStore($user);
+  const brand = useStore($currentBrand);
+  return computed(() => {
+    var _a, _b, _c;
+    return {
+      user: user.value,
+      brand: brand.value ?? void 0,
+      brandId: (_a = brand.value) == null ? void 0 : _a.id,
+      isAdmin: ((_b = user.value) == null ? void 0 : _b.isAdmin) ?? false,
+      isSuperAdmin: ((_c = user.value) == null ? void 0 : _c.isSuperAdmin) ?? false,
+      routes
+    };
+  });
+}
+function useHasAccessToBrand(brandId) {
+  const context = usePageContext();
+  return computed(() => {
+    var _a;
+    const user = context.value.user;
+    if (!user) return false;
+    if (user.isAdmin || user.isSuperAdmin) return true;
+    return ((_a = user.brandIds) == null ? void 0 : _a.includes(brandId)) ?? false;
+  });
+}
+function useHasAccessToAccount(accountId) {
+  const context = usePageContext();
+  return computed(() => {
+    var _a;
+    const user = context.value.user;
+    if (!user) return false;
+    if (user.isAdmin || user.isSuperAdmin) return true;
+    return ((_a = user.accountIds) == null ? void 0 : _a.includes(accountId)) ?? false;
+  });
+}
+function useUserRoles() {
+  const context = usePageContext();
+  return computed(() => {
+    var _a;
+    return ((_a = context.value.user) == null ? void 0 : _a.roles) ?? [];
+  });
+}
+function useHasRole(role) {
+  const roles = useUserRoles();
+  return computed(() => roles.value.includes(role));
+}
+function useWizard(options) {
+  const {
+    steps,
+    initialData = {},
+    onComplete,
+    onStepChange,
+    validateOnNext = true,
+    allowBackWithoutValidation = true
+  } = options;
+  const currentStepIndex = ref(0);
+  const data = ref({ ...initialData });
+  const isCompleting = ref(false);
+  const stepValidation = ref({});
+  const stepErrors = ref({});
+  const currentStep = computed(() => steps[currentStepIndex.value]);
+  const isFirstStep = computed(() => currentStepIndex.value === 0);
+  const isLastStep = computed(() => currentStepIndex.value === steps.length - 1);
+  const progress = computed(
+    () => Math.round((currentStepIndex.value + 1) / steps.length * 100)
+  );
+  const currentStepValid = computed(() => {
+    const step = currentStep.value;
+    if (!step) return false;
+    if (step.optional) return true;
+    return stepValidation.value[step.id] !== false;
+  });
+  const allStepsValid = computed(() => {
+    return steps.every((step) => {
+      if (step.optional) return true;
+      return stepValidation.value[step.id] === true;
+    });
+  });
+  const stepperSteps = computed(
+    () => steps.map((step, index) => {
+      let status;
+      if (index < currentStepIndex.value) {
+        status = stepValidation.value[step.id] === false ? "error" : "complete";
+      } else if (index === currentStepIndex.value) {
+        status = "current";
+      } else {
+        status = "upcoming";
+      }
+      return {
+        id: step.id,
+        label: step.label,
+        status,
+        valid: stepValidation.value[step.id] ?? true
+      };
+    })
+  );
+  function getStepIndex(stepId) {
+    return steps.findIndex((s) => s.id === stepId);
+  }
+  function getStep(stepId) {
+    return steps.find((s) => s.id === stepId);
+  }
+  async function validateStep(stepIndex) {
+    const step = steps[stepIndex];
+    if (!step) return false;
+    if (step.optional) {
+      stepValidation.value[step.id] = true;
+      return true;
+    }
+    if (step.validate) {
+      try {
+        const result = await step.validate(data.value);
+        stepValidation.value[step.id] = result;
+        if (!result) {
+          stepErrors.value[step.id] = "Validation failed";
+        } else {
+          delete stepErrors.value[step.id];
+        }
+        return result;
+      } catch (error) {
+        stepValidation.value[step.id] = false;
+        stepErrors.value[step.id] = error instanceof Error ? error.message : "Validation error";
+        return false;
+      }
+    }
+    if (stepValidation.value[step.id] === void 0) {
+      stepValidation.value[step.id] = true;
+    }
+    return stepValidation.value[step.id] !== false;
+  }
+  function canGoToStep(targetIndex) {
+    if (targetIndex < 0 || targetIndex >= steps.length) return false;
+    if (targetIndex < currentStepIndex.value && allowBackWithoutValidation) {
+      return true;
+    }
+    if (targetIndex > currentStepIndex.value && validateOnNext) {
+      for (let i = 0; i < targetIndex; i++) {
+        const step = steps[i];
+        if (!step.optional && stepValidation.value[step.id] === false) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  async function goToNext() {
+    if (isLastStep.value) return false;
+    if (validateOnNext) {
+      const isValid = await validateStep(currentStepIndex.value);
+      if (!isValid) return false;
+    }
+    const fromIndex = currentStepIndex.value;
+    currentStepIndex.value++;
+    onStepChange == null ? void 0 : onStepChange(fromIndex, currentStepIndex.value, data.value);
+    return true;
+  }
+  function goToPrevious() {
+    if (isFirstStep.value) return false;
+    const fromIndex = currentStepIndex.value;
+    currentStepIndex.value--;
+    onStepChange == null ? void 0 : onStepChange(fromIndex, currentStepIndex.value, data.value);
+    return true;
+  }
+  async function goToStep(targetIndex) {
+    if (!canGoToStep(targetIndex)) return false;
+    if (targetIndex > currentStepIndex.value && validateOnNext) {
+      const isValid = await validateStep(currentStepIndex.value);
+      if (!isValid) return false;
+    }
+    const fromIndex = currentStepIndex.value;
+    currentStepIndex.value = targetIndex;
+    onStepChange == null ? void 0 : onStepChange(fromIndex, currentStepIndex.value, data.value);
+    return true;
+  }
+  function updateData(newData) {
+    data.value = { ...data.value, ...newData };
+  }
+  function updateStepData(stepId, stepData) {
+    updateData(stepData);
+    delete stepErrors.value[stepId];
+  }
+  function setStepValid(stepId, valid) {
+    stepValidation.value[stepId] = valid;
+    if (valid) {
+      delete stepErrors.value[stepId];
+    }
+  }
+  function setStepError(stepId, error) {
+    if (error) {
+      stepErrors.value[stepId] = error;
+      stepValidation.value[stepId] = false;
+    } else {
+      delete stepErrors.value[stepId];
+    }
+  }
+  function resetStep(stepId) {
+    delete stepValidation.value[stepId];
+    delete stepErrors.value[stepId];
+  }
+  function reset() {
+    currentStepIndex.value = 0;
+    data.value = { ...initialData };
+    stepValidation.value = {};
+    stepErrors.value = {};
+    isCompleting.value = false;
+  }
+  async function complete() {
+    if (isCompleting.value) return false;
+    isCompleting.value = true;
+    try {
+      for (let i = 0; i < steps.length; i++) {
+        const isValid = await validateStep(i);
+        if (!isValid && !steps[i].optional) {
+          currentStepIndex.value = i;
+          isCompleting.value = false;
+          return false;
+        }
+      }
+      if (onComplete) {
+        await onComplete(data.value);
+      }
+      return true;
+    } catch (error) {
+      console.error("[useWizard] Completion error:", error);
+      return false;
+    } finally {
+      isCompleting.value = false;
+    }
+  }
+  return {
+    // State
+    currentStepIndex,
+    currentStep,
+    data,
+    isFirstStep,
+    isLastStep,
+    isCompleting,
+    stepErrors,
+    // Stepper integration
+    stepperSteps,
+    // Validation
+    stepValidation,
+    currentStepValid,
+    allStepsValid,
+    // Navigation
+    goToNext,
+    goToPrevious,
+    goToStep,
+    canGoToStep,
+    // Data management
+    updateData,
+    updateStepData,
+    setStepValid,
+    setStepError,
+    resetStep,
+    reset,
+    // Completion
+    complete,
+    // Utilities
+    getStepIndex,
+    getStep,
+    progress
+  };
+}
+function useStats(options) {
+  const {
+    data,
+    loading,
+    definitions,
+    staggerDelay = 100,
+    initialDelay = 0,
+    previousData
+  } = options;
+  const loadingStates = ref(definitions.map(() => true));
+  let timers = [];
+  function clearTimers() {
+    timers.forEach((timer) => clearTimeout(timer));
+    timers = [];
+  }
+  function triggerStaggeredReveal() {
+    clearTimers();
+    loadingStates.value = definitions.map(() => true);
+    definitions.forEach((_, index) => {
+      const timer = setTimeout(() => {
+        loadingStates.value[index] = false;
+      }, initialDelay + staggerDelay * (index + 1));
+      timers.push(timer);
+    });
+  }
+  watch(
+    () => loading.value,
+    (isLoading, wasLoading) => {
+      if (wasLoading && !isLoading) {
+        triggerStaggeredReveal();
+      } else if (isLoading && !wasLoading) {
+        clearTimers();
+        loadingStates.value = definitions.map(() => true);
+      }
+    },
+    { immediate: true }
+  );
+  if (!loading.value) {
+    triggerStaggeredReveal();
+  }
+  const stats = computed(() => {
+    const items = data.value;
+    const prevItems = previousData == null ? void 0 : previousData.value;
+    return definitions.map((def) => {
+      const stat = {
+        id: def.id,
+        name: def.name,
+        stat: def.compute(items),
+        icon: def.icon,
+        color: def.color ?? "gray"
+      };
+      if (def.computeChange) {
+        stat.change = def.computeChange(items, prevItems);
+      }
+      if (def.computeChangeType) {
+        stat.changeType = def.computeChangeType(items, prevItems);
+      }
+      if (def.showFooter !== void 0) {
+        stat.showFooter = def.showFooter;
+      }
+      if (def.actionText) {
+        stat.actionText = def.actionText;
+      }
+      return stat;
+    });
+  });
+  const statsWithLoading = computed(
+    () => stats.value.map((stat, index) => ({
+      ...stat,
+      loading: loading.value || loadingStates.value[index]
+    }))
+  );
+  const allLoaded = computed(
+    () => !loading.value && loadingStates.value.every((s) => !s)
+  );
+  function getStat(id) {
+    return stats.value.find((s) => s.id === id);
+  }
+  function refreshAnimation() {
+    triggerStaggeredReveal();
+  }
+  return {
+    stats,
+    loadingStates,
+    statsWithLoading,
+    allLoaded,
+    refreshAnimation,
+    getStat
+  };
+}
+function countStat(id, name, icon, filter, options) {
+  return {
+    id,
+    name,
+    icon,
+    color: (options == null ? void 0 : options.color) ?? "gray",
+    compute: (items) => items.filter(filter).length
+  };
+}
+function sumStat(id, name, icon, getValue, options) {
+  return {
+    id,
+    name,
+    icon,
+    color: (options == null ? void 0 : options.color) ?? "gray",
+    compute: (items) => {
+      const sum = items.reduce((total, item) => total + getValue(item), 0);
+      return (options == null ? void 0 : options.format) ? options.format(sum) : sum.toLocaleString();
+    }
+  };
+}
+function averageStat(id, name, icon, getValue, options) {
+  return {
+    id,
+    name,
+    icon,
+    color: (options == null ? void 0 : options.color) ?? "gray",
+    compute: (items) => {
+      if (items.length === 0) return "0";
+      const sum = items.reduce((total, item) => total + getValue(item), 0);
+      const avg = sum / items.length;
+      const formatted = avg.toFixed((options == null ? void 0 : options.decimals) ?? 1);
+      return (options == null ? void 0 : options.suffix) ? `${formatted}${options.suffix}` : formatted;
+    }
+  };
+}
+function percentageStat(id, name, icon, filter, options) {
+  return {
+    id,
+    name,
+    icon,
+    color: (options == null ? void 0 : options.color) ?? "gray",
+    compute: (items) => {
+      if (items.length === 0) return "0%";
+      const count = items.filter(filter).length;
+      const percentage = count / items.length * 100;
+      return `${percentage.toFixed((options == null ? void 0 : options.decimals) ?? 1)}%`;
+    }
+  };
+}
+function useConfirmation(options = {}) {
+  const {
+    defaultConfirmText = "Confirm",
+    defaultCancelText = "Cancel",
+    defaultVariant = "default"
+  } = options;
+  const isOpen = ref(false);
+  const isLoading = ref(false);
+  const config = ref({
+    title: "",
+    message: "",
+    confirmText: defaultConfirmText,
+    cancelText: defaultCancelText,
+    variant: defaultVariant
+  });
+  let pending = null;
+  function confirm(confirmConfig) {
+    config.value = {
+      ...confirmConfig,
+      confirmText: confirmConfig.confirmText ?? defaultConfirmText,
+      cancelText: confirmConfig.cancelText ?? defaultCancelText,
+      variant: confirmConfig.variant ?? defaultVariant
+    };
+    isOpen.value = true;
+    isLoading.value = false;
+    return new Promise((resolve, reject) => {
+      pending = { resolve, reject };
+    });
+  }
+  function handleConfirm() {
+    if (pending) {
+      pending.resolve(true);
+      pending = null;
+    }
+    isOpen.value = false;
+    isLoading.value = false;
+  }
+  function handleCancel() {
+    if (pending) {
+      pending.resolve(false);
+      pending = null;
+    }
+    isOpen.value = false;
+    isLoading.value = false;
+  }
+  function close() {
+    if (pending) {
+      pending.resolve(false);
+      pending = null;
+    }
+    isOpen.value = false;
+    isLoading.value = false;
+  }
+  function confirmDelete(itemName, confirmConfig) {
+    return confirm({
+      title: "Delete Item",
+      message: `Are you sure you want to delete "${itemName}"? This action cannot be undone.`,
+      confirmText: "Delete",
+      cancelText: "Cancel",
+      variant: "danger",
+      ...confirmConfig
+    });
+  }
+  function confirmBulkDelete(count, itemType = "items", confirmConfig) {
+    return confirm({
+      title: `Delete ${count} ${itemType}`,
+      message: `Are you sure you want to delete ${count} ${itemType}? This action cannot be undone.`,
+      confirmText: "Delete All",
+      cancelText: "Cancel",
+      variant: "danger",
+      ...confirmConfig
+    });
+  }
+  function confirmDestructive(actionName, confirmConfig) {
+    return confirm({
+      title: `Confirm ${actionName}`,
+      message: `Are you sure you want to ${actionName.toLowerCase()}? This action cannot be undone.`,
+      confirmText: actionName,
+      cancelText: "Cancel",
+      variant: "danger",
+      ...confirmConfig
+    });
+  }
+  async function confirmWithAction(confirmConfig, action) {
+    const confirmed = await confirm(confirmConfig);
+    if (!confirmed) {
+      return { confirmed: false };
+    }
+    isLoading.value = true;
+    try {
+      const result = await action();
+      isOpen.value = false;
+      isLoading.value = false;
+      return { confirmed: true, result };
+    } catch (error) {
+      isLoading.value = false;
+      return {
+        confirmed: true,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  const modalProps = computed(() => ({
+    title: config.value.title,
+    open: isOpen.value,
+    modalName: "confirmation-dialog",
+    actions: [
+      {
+        name: config.value.cancelText ?? defaultCancelText,
+        value: "cancel"
+      },
+      {
+        name: config.value.confirmText ?? defaultConfirmText,
+        value: "confirm"
+      }
+    ]
+  }));
+  return {
+    // State
+    isOpen,
+    config,
+    isLoading,
+    // Core methods
+    confirm,
+    handleConfirm,
+    handleCancel,
+    close,
+    // Convenience methods
+    confirmDelete,
+    confirmBulkDelete,
+    confirmDestructive,
+    confirmWithAction,
+    // Modal props
+    modalProps
+  };
+}
+let globalConfirmation = null;
+function useGlobalConfirmation() {
+  if (!globalConfirmation) {
+    globalConfirmation = useConfirmation();
+  }
+  return globalConfirmation;
+}
+function resetGlobalConfirmation() {
+  globalConfirmation = null;
+}
+function useAdminPage(options) {
+  const {
+    title,
+    subtitle,
+    description,
+    breadcrumbs: initialBreadcrumbs = [],
+    sidebarActive,
+    actions: initialActions = [],
+    loading: initialLoading = true,
+    loadingDelay = 200
+  } = options;
+  const context = usePageContext();
+  const loadingHeader = ref(initialLoading);
+  const loadingContent = ref(initialLoading);
+  const actions = ref([...initialActions]);
+  onMounted(() => {
+    if (initialLoading) {
+      setTimeout(() => {
+        loadingHeader.value = false;
+      }, loadingDelay);
+      setTimeout(() => {
+        loadingContent.value = false;
+      }, loadingDelay * 2);
+    }
+  });
+  const user = computed(() => context.value.user);
+  const brand = computed(() => context.value.brand);
+  const isAdmin = computed(() => {
+    var _a;
+    return ((_a = user.value) == null ? void 0 : _a.isAdmin) ?? false;
+  });
+  const isSuperAdmin = computed(() => {
+    var _a;
+    return ((_a = user.value) == null ? void 0 : _a.isSuperAdmin) ?? false;
+  });
+  const breadcrumbs = computed(() => [
+    ...initialBreadcrumbs.map((b) => ({ ...b, current: false })),
+    { name: title, current: true }
+  ]);
+  const wrapperProps = computed(() => ({
+    currentPage: sidebarActive
+  }));
+  const headerProps = computed(() => ({
+    title,
+    subtitle,
+    description,
+    pages: breadcrumbs.value,
+    loading: loadingHeader.value
+  }));
+  function setLoading(loading) {
+    if (loading) {
+      loadingHeader.value = true;
+      loadingContent.value = true;
+    } else {
+      setTimeout(() => {
+        loadingHeader.value = false;
+      }, loadingDelay);
+      setTimeout(() => {
+        loadingContent.value = false;
+      }, loadingDelay * 2);
+    }
+  }
+  function updateAction(id, updates) {
+    const index = actions.value.findIndex((a) => a.id === id);
+    if (index !== -1) {
+      actions.value[index] = { ...actions.value[index], ...updates };
+    }
+  }
+  function setActionLoading(id, loading) {
+    updateAction(id, { loading });
+  }
+  return {
+    // Page info
+    title,
+    subtitle,
+    description,
+    // Breadcrumbs
+    breadcrumbs,
+    // Loading
+    loadingHeader,
+    loadingContent,
+    setLoading,
+    // Context
+    user,
+    brand,
+    isAdmin,
+    isSuperAdmin,
+    // Actions
+    actions,
+    updateAction,
+    setActionLoading,
+    // Props
+    wrapperProps,
+    headerProps
+  };
+}
+function useListPage(options) {
+  const {
+    entityName,
+    onCreateClick,
+    createIcon,
+    hideCreate = false,
+    ...pageOptions
+  } = options;
+  const actions = [];
+  if (!hideCreate && entityName) {
+    actions.push({
+      id: "create",
+      text: `Create ${entityName.charAt(0).toUpperCase() + entityName.slice(1)}`,
+      icon: createIcon,
+      color: "primary",
+      onClick: onCreateClick
+    });
+  }
+  return useAdminPage({
+    ...pageOptions,
+    actions
+  });
+}
+function useDetailPage(options) {
+  const {
+    entityName,
+    onEditClick,
+    onDeleteClick,
+    editIcon,
+    deleteIcon,
+    hideEdit = false,
+    hideDelete = false,
+    ...pageOptions
+  } = options;
+  const actions = [];
+  if (!hideEdit && onEditClick) {
+    actions.push({
+      id: "edit",
+      text: "Edit",
+      icon: editIcon,
+      color: "secondary",
+      onClick: onEditClick
+    });
+  }
+  if (!hideDelete && onDeleteClick) {
+    actions.push({
+      id: "delete",
+      text: "Delete",
+      icon: deleteIcon,
+      color: "danger",
+      onClick: onDeleteClick
+    });
+  }
+  return useAdminPage({
+    ...pageOptions,
+    actions
+  });
+}
+function useFormPage(options) {
+  const {
+    onSaveClick,
+    onCancelClick,
+    saveText = "Save",
+    cancelText = "Cancel",
+    saveIcon,
+    cancelIcon,
+    hideSave = false,
+    hideCancel = false,
+    ...pageOptions
+  } = options;
+  const actions = [];
+  if (!hideCancel && onCancelClick) {
+    actions.push({
+      id: "cancel",
+      text: cancelText,
+      icon: cancelIcon,
+      color: "secondary",
+      onClick: onCancelClick
+    });
+  }
+  if (!hideSave && onSaveClick) {
+    actions.push({
+      id: "save",
+      text: saveText,
+      icon: saveIcon,
+      color: "primary",
+      onClick: onSaveClick
+    });
+  }
+  return useAdminPage({
+    ...pageOptions,
+    actions
+  });
+}
+export {
+  $user as $,
+  PAGE_CONTEXT_KEY as P,
+  useTabs as a,
+  useForm as b,
+  useFormValidation as c,
+  useNotifications as d,
+  usePageContext as e,
+  useHasAccessToBrand as f,
+  useHasAccessToAccount as g,
+  useUserRoles as h,
+  useHasRole as i,
+  setCurrentBrand as j,
+  $currentBrand as k,
+  useWizard as l,
+  useStats as m,
+  countStat as n,
+  sumStat as o,
+  averageStat as p,
+  percentageStat as q,
+  useConfirmation as r,
+  setUser as s,
+  useGlobalConfirmation as t,
+  useModal as u,
+  resetGlobalConfirmation as v,
+  useAdminPage as w,
+  useListPage as x,
+  useDetailPage as y,
+  useFormPage as z
+};
+//# sourceMappingURL=useAdminPage-GhgXp0x8.js.map