@abyss-project/commons-front-core 3.3.2 → 4.0.0

package/dist/auth/components/SecuritySettings/sections/EmailSection.component.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The account's e-mail address (5.3): a new address, a 6-digit code sent to it, then the switch —
+ * all behind a recent proof of identity (the re-authentication dialog opens past 5 minutes).
+ * Confirming signs out every other session, as a password change does.
+ */
+export declare const EmailSection: () => import("react/jsx-runtime").JSX.Element;

package/dist/auth/components/SecuritySettings/sections/PasskeysSection.component.d.ts

@@ -0,0 +1,10 @@
+type Props = {
+    /** Whether this device can create a passkey (the list is shown either way). */
+    passkeySupported: boolean;
+};
+/**
+ * The account's passkeys: add one from this device, rename, remove. Adding and removing need a
+ * proof of less than 5 minutes: the re-authentication dialog opens when it is older.
+ */
+export declare const PasskeysSection: ({ passkeySupported }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/auth/components/SecuritySettings/sections/PasswordSection.component.d.ts

@@ -0,0 +1,9 @@
+/** The policy as a password manager reads it when it generates one (ADR-0059). */
+export declare const PASSWORD_RULES: string;
+/**
+ * Changing the password asks for the current one (ADR-0059) and a recent proof of identity (the
+ * re-authentication dialog opens past 5 minutes). An account without password (signed up by code,
+ * passkey, Google or Apple) gets one through the reset e-mail: the change needs a current password
+ * to compare.
+ */
+export declare const PasswordSection: () => import("react/jsx-runtime").JSX.Element;

package/dist/auth/components/SecuritySettings/sections/RecoveryCodesSection.component.d.ts

@@ -0,0 +1,10 @@
+import { IMfaStatus } from '@abyss-project/main';
+type Props = {
+    status: IMfaStatus;
+};
+/**
+ * The recovery codes (5.3): how many are left, and a new set of ten — replacing every previous
+ * code — shown once. They stand in for a factor, so they exist only once one is enrolled.
+ */
+export declare const RecoveryCodesSection: ({ status }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/auth/components/SecuritySettings/sections/SecuritySection.component.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { AuthErrorKind } from '../../shared/auth-errors';
+type SecuritySectionProps = {
+    id: string;
+    title: string;
+    lede?: ReactNode;
+    /** The section's main action, at the right of the title (under it on a phone). */
+    action?: ReactNode;
+    children: ReactNode;
+};
+/** One block of the Security page: a titled card. */
+export declare const SecuritySection: ({ id, title, lede, action, children, }: SecuritySectionProps) => import("react/jsx-runtime").JSX.Element;
+/** Placeholder lines while a section loads: the card keeps its height. */
+export declare const SectionSkeleton: ({ lines }: {
+    lines?: number;
+}) => import("react/jsx-runtime").JSX.Element;
+/** A section that could not load: the cause and a retry. */
+export declare const SectionError: ({ error, onRetry, }: {
+    error?: AuthErrorKind;
+    onRetry: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+/** A failed action inside a loaded section, announced politely. */
+export declare const ActionError: ({ error }: {
+    error: AuthErrorKind | null;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/auth/components/SecuritySettings/sections/SessionsSection.component.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The open sessions of the account (5.2): device, platform and opening date, how it signed in,
+ * last activity, last IP address (masked by abyss-main) — enough to tell two "Chrome · Windows"
+ * apart.
+ * Revoking one ends it on the server; its device is signed out at the latest when its access
+ * token expires (15 min, CA12). The current session is ended by signing out, not from here.
+ */
+export declare const SessionsSection: () => import("react/jsx-runtime").JSX.Element;

package/dist/auth/components/SecuritySettings/sections/TotpSection.component.d.ts

@@ -0,0 +1,11 @@
+import { IMfaStatus } from '@abyss-project/main';
+type Props = {
+    status: IMfaStatus;
+};
+/**
+ * The authenticator app (TOTP, 5.3): set up with a QR code, the key or the `otpauth://` link, then
+ * confirmed by a first code; turned off after confirmation. The last factor of an account that
+ * requires MFA cannot be turned off (the server says so, the message explains).
+ */
+export declare const TotpSection: ({ status }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/auth/components/SecuritySettings/sections/use-section-action.hook.d.ts

@@ -0,0 +1,9 @@
+import { AuthErrorKind } from '../../shared/auth-errors';
+export interface SectionAction {
+    busy: boolean;
+    error: AuthErrorKind | null;
+    /** Runs one action of the section; its failure lands in `error`. Resolves `true` on success. */
+    run: (action: () => Promise<void>) => Promise<boolean>;
+    clearError: () => void;
+}
+export declare const useSectionAction: () => SectionAction;

package/dist/auth/components/index.d.ts

@@ -0,0 +1,11 @@
+export { AuthFlow } from './AuthFlow/AuthFlow.component';
+export type { AuthFlowProps } from './AuthFlow/AuthFlow.component';
+export type { AuthFlowContext, AuthFlowLegal, AuthFlowResult, } from './AuthFlow/auth-flow.types';
+export { AuthProviderButtons, AuthProviderKind, } from './AuthProviderButtons/AuthProviderButtons.component';
+export type { AuthFlowProviders, AuthProviderButtonsProps, } from './AuthProviderButtons/AuthProviderButtons.component';
+export { SecuritySettings } from './SecuritySettings/SecuritySettings.component';
+export { ReauthDialog } from './ReauthDialog/ReauthDialog.component';
+export type { ReauthDialogProps } from './ReauthDialog/ReauthDialog.component';
+export { AuthReauthHost } from './ReauthDialog/AuthReauthHost.component';
+export { MfaRequirementBanner } from './MfaRequirementBanner/MfaRequirementBanner.component';
+export type { MfaRequirementBannerProps } from './MfaRequirementBanner/MfaRequirementBanner.component';

package/dist/auth/components/shared/AuthStepFrame.component.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { AuthErrorKind } from './auth-errors';
+type Props = {
+    title: string;
+    lede?: ReactNode;
+    /** The step's failure, announced politely to assistive technologies. */
+    error?: AuthErrorKind | null;
+    /** A neutral confirmation (code sent again, e-mail sent…). */
+    notice?: ReactNode;
+    /** Shown under the error: the way out it calls for (retry, new code…). */
+    errorAction?: ReactNode;
+    children: ReactNode;
+};
+/**
+ * The frame every authentication step shares: one title, an optional lede, the step's error or
+ * notice in a polite live region, then the step's form.
+ */
+export declare const AuthStepFrame: ({ title, lede, error, notice, errorAction, children, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/auth/components/shared/OneTimeCodeField.component.d.ts

@@ -0,0 +1,17 @@
+/** Length of an e-mail code and of a TOTP code. */
+export declare const ONE_TIME_CODE_LENGTH = 6;
+type Props = {
+    id: string;
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    error?: boolean;
+    autoFocus?: boolean;
+};
+/**
+ * Six-digit code field (e-mail code, TOTP). `one-time-code` lets the platform offer the code it
+ * just received; a pasted code keeps working whatever its spacing, since only the digits are kept.
+ */
+export declare const OneTimeCodeField: ({ id, label, value, onChange, disabled, error, autoFocus, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/auth/components/shared/RecoveryCodesPanel.component.d.ts

@@ -0,0 +1,12 @@
+type Props = {
+    codes: string[];
+    /** The browser can save a file; a native webview cannot, copying is offered alone there. */
+    canDownload: boolean;
+    onAcknowledge: () => void;
+};
+/**
+ * The ten recovery codes, shown once: abyss-main keeps only their hashes. The user leaves this
+ * panel only by confirming they stored them.
+ */
+export declare const RecoveryCodesPanel: ({ codes, canDownload, onAcknowledge, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/auth/components/shared/TotpSetupPanel.component.d.ts

@@ -0,0 +1,14 @@
+import { AuthClient } from '../../client/auth-client';
+type Props = {
+    client: AuthClient;
+    /** The TOTP is on; `recoveryCodes` when this confirmation generated them (shown once). */
+    onEnabled: (recoveryCodes?: string[]) => void;
+    onCancel?: () => void;
+};
+/**
+ * Sets up an authenticator app: a new pending secret, shown as a QR code (painted inline, not
+ * through `QRCodeModal`), as a key to type, and — on a phone — as an `otpauth://` link that opens
+ * the app; the first code the app shows turns it on.
+ */
+export declare const TotpSetupPanel: ({ client, onEnabled, onCancel }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/auth/components/shared/auth-errors.d.ts

@@ -0,0 +1,42 @@
+import { IApiError, IResponse } from '@abyss-project/main';
+import { ExistingTranslationKey } from '../../../hooks/use-rich-intl.hook';
+/** Every failure an authentication screen tells apart, each with its own message. */
+export declare enum AuthErrorKind {
+    OFFLINE = "offline",
+    NETWORK = "network",
+    SERVER = "server",
+    CODE_INVALID = "code-invalid",
+    CODE_EXPIRED = "code-expired",
+    CODE_TOO_MANY = "code-too-many",
+    MFA_INVALID = "mfa-invalid",
+    TOKEN_EXPIRED = "token-expired",
+    CREDENTIALS_INVALID = "credentials-invalid",
+    EMAIL_NOT_VERIFIED = "email-not-verified",
+    RATE_LIMITED = "rate-limited",
+    SIGNUP_EXPIRED = "signup-expired",
+    PASSKEY_FAILED = "passkey-failed",
+    ID_TOKEN_INVALID = "id-token-invalid",
+    LAST_FACTOR = "last-factor",
+    CURRENT_PASSWORD = "current-password",
+    PASSWORD_POLICY = "password-policy",
+    EMAIL_CHANGE_UNAVAILABLE = "email-change-unavailable",
+    REAUTH_CANCELLED = "reauth-cancelled",
+    SESSION_REVOKED = "session-revoked",
+    CEREMONY_CANCELLED = "ceremony-cancelled",
+    CEREMONY_UNSUPPORTED = "ceremony-unsupported",
+    CEREMONY_NO_CREDENTIAL = "ceremony-no-credential",
+    CEREMONY_FAILED = "ceremony-failed",
+    UNKNOWN = "unknown"
+}
+/** An SDK answer that carried an `error` instead of throwing. */
+export declare class AuthApiError extends Error {
+    readonly apiError: IApiError;
+    constructor(apiError: IApiError);
+}
+/** The `data` of an SDK answer; its `error`, if any, thrown as an `AuthApiError`. */
+export declare const unwrap: <T>(response: IResponse<T>) => T;
+export declare const isOffline: () => boolean;
+/** Sorts any failure of an authentication call or ceremony into the kind its screen shows. */
+export declare const readAuthError: (error: unknown) => AuthErrorKind;
+/** The message of an error kind, under `auth.errors`. */
+export declare const authErrorMessageId: (kind: AuthErrorKind) => ExistingTranslationKey;

package/dist/auth/components/shared/mfa-status-events.d.ts

@@ -0,0 +1,2 @@
+export declare const notifyMfaChanged: () => void;
+export declare const subscribeMfaChanged: (listener: () => void) => (() => void);

package/dist/auth/components/shared/passkey-ceremonies.d.ts

@@ -0,0 +1,17 @@
+import { IRegistrationVerifyPasskeyUserData } from '@abyss-project/main';
+import { AuthClient } from '../../client/auth-client';
+/**
+ * Creates a passkey for the signed-in user: options from abyss-main, the platform ceremony, then
+ * the verification. Both calls need a proof of less than 5 minutes: `withAuthRetry` opens the
+ * re-authentication dialog when it is older. `recoveryCodes` comes back when this passkey is the
+ * account's first second factor, to be shown once.
+ */
+export declare const registerPasskey: (client: AuthClient, name: string) => Promise<IRegistrationVerifyPasskeyUserData>;
+/**
+ * Re-proves the current session with one of the user's passkeys. The new session (fresh proof,
+ * `mfa` from then on, rotated refresh token) goes through `handleResult`.
+ */
+export declare const reauthenticateWithPasskey: (client: AuthClient) => Promise<void>;
+/** Whether this user declined the passkey proposal on this device. */
+export declare const isPasskeyNudgeDismissed: (userId: string) => boolean;
+export declare const dismissPasskeyNudge: (userId: string) => void;

package/dist/auth/components/shared/use-async-resource.hook.d.ts

@@ -0,0 +1,18 @@
+import { AuthErrorKind } from './auth-errors';
+export declare enum ResourceStatus {
+    LOADING = "loading",
+    READY = "ready",
+    ERROR = "error"
+}
+export interface AsyncResource<T> {
+    status: ResourceStatus;
+    data?: T;
+    error?: AuthErrorKind;
+    /** Loads again; the data already shown stays until the new answer lands. */
+    reload: () => void;
+}
+/**
+ * Loads `load()` on mount and on every `reload()`. An answer that a later load overtook is
+ * dropped, so a slow first answer never overwrites a fresh one.
+ */
+export declare const useAsyncResource: <T>(load: () => Promise<T>) => AsyncResource<T>;

package/dist/auth/components/shared/use-offline.hook.d.ts

@@ -0,0 +1,2 @@
+/** `true` while the browser (or the native webview) reports the network as down. */
+export declare const useOffline: () => boolean;

package/dist/auth/components/shared/use-passkey-name.hook.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The name a new passkey gets ("Passkey du 1 oct. 2026"), renamable on the Security page: the
+ * device that holds it is not known to the page.
+ */
+export declare const usePasskeyDefaultName: () => (() => string);

package/dist/auth/components/test-support/auth-sdk.mock.d.ts

@@ -0,0 +1,57 @@
+import { Mock } from 'vitest';
+/**
+ * Spec-only stand-in for `AbyssCore.sdk`, the surface the auth screens call. Specs install it with
+ * `vi.mock('@abyss-project/main', …)` and drive each call from the test. Imports nothing from
+ * `@abyss-project/main` on purpose: the mock factory loads this file while that module is mocked.
+ */
+export declare const sdkMock: {
+    auth: {
+        refresh: Mock<(...args: any[]) => any>;
+        login: Mock<(...args: any[]) => any>;
+        logout: Mock<(...args: any[]) => any>;
+        completeSignup: Mock<(...args: any[]) => any>;
+        reauthPassword: Mock<(...args: any[]) => any>;
+        createIdTokenNonce: Mock<(...args: any[]) => any>;
+        signInWithIdToken: Mock<(...args: any[]) => any>;
+        getConnectUrlDiscordAuth: Mock<(...args: any[]) => any>;
+        getConnectUrlSlackAuth: Mock<(...args: any[]) => any>;
+        sendEmailResetPassword: Mock<(...args: any[]) => any>;
+        emailCode: {
+            request: Mock<(...args: any[]) => any>;
+            verify: Mock<(...args: any[]) => any>;
+            reauthRequest: Mock<(...args: any[]) => any>;
+            reauthVerify: Mock<(...args: any[]) => any>;
+        };
+    };
+    passkey: {
+        authenticationOptions: Mock<(...args: any[]) => any>;
+        authenticationVerify: Mock<(...args: any[]) => any>;
+        reauthVerify: Mock<(...args: any[]) => any>;
+        registrationOptions: Mock<(...args: any[]) => any>;
+        registrationVerify: Mock<(...args: any[]) => any>;
+        list: Mock<(...args: any[]) => any>;
+        update: Mock<(...args: any[]) => any>;
+        remove: Mock<(...args: any[]) => any>;
+    };
+    mfa: {
+        verify: Mock<(...args: any[]) => any>;
+        reauth: Mock<(...args: any[]) => any>;
+        getStatus: Mock<(...args: any[]) => any>;
+        setupTotp: Mock<(...args: any[]) => any>;
+        confirmTotp: Mock<(...args: any[]) => any>;
+        disableTotp: Mock<(...args: any[]) => any>;
+        regenerateRecoveryCodes: Mock<(...args: any[]) => any>;
+    };
+    session: {
+        list: Mock<(...args: any[]) => any>;
+        revoke: Mock<(...args: any[]) => any>;
+        revokeOthers: Mock<(...args: any[]) => any>;
+    };
+    user: {
+        me: Mock<(...args: any[]) => any>;
+        updatePassword: Mock<(...args: any[]) => any>;
+        requestEmailChange: Mock<(...args: any[]) => any>;
+        confirmEmailChange: Mock<(...args: any[]) => any>;
+    };
+};
+export declare const resetSdkMock: () => void;

package/dist/auth/components/test-support/auth-test-harness.d.ts

@@ -0,0 +1,48 @@
+import { ReactElement } from 'react';
+import { vi } from 'vitest';
+import { ISessionAuthData, IUser, SessionPlatform, UserLanguage } from '@abyss-project/main';
+import { AuthBridge } from '../../client/auth-bridge';
+import { AuthClient } from '../../client/auth-client';
+export declare const testUser: IUser;
+export declare const sessionOf: (user?: IUser, overrides?: Partial<ISessionAuthData>) => ISessionAuthData;
+/** The rejection axios produces for an HTTP answer carrying an API error. */
+export declare const apiError: (status: number, code: string) => {
+    isAxiosError: boolean;
+    response: {
+        status: number;
+        data: {
+            error: {
+                code: string;
+                message: string;
+            };
+        };
+    };
+};
+/** The rejection axios produces when nothing answered. */
+export declare const networkError: () => {
+    isAxiosError: boolean;
+};
+export type MockBridge = AuthBridge & {
+    passkeySupported: ReturnType<typeof vi.fn>;
+    getPasskey: ReturnType<typeof vi.fn>;
+    createPasskey: ReturnType<typeof vi.fn>;
+    google: ReturnType<typeof vi.fn>;
+    apple: ReturnType<typeof vi.fn>;
+};
+export declare const createBridgeMock: (platform?: SessionPlatform, passkeySupported?: boolean) => MockBridge;
+export interface RenderWithAuthOptions {
+    bridge?: MockBridge;
+    /** Signed in at launch with this session; signed out (refresh refused) when absent. */
+    session?: ISessionAuthData;
+    language?: UserLanguage;
+}
+export interface RenderedWithAuth {
+    client: AuthClient;
+    bridge: MockBridge;
+    container: HTMLElement;
+}
+/**
+ * Renders inside the providers every host gives the auth screens: intl (commons messages), the
+ * Abyss dark theme, and an `AuthProvider` over a real auth client with a mocked bridge.
+ */
+export declare const renderWithAuth: (ui: ReactElement, options?: RenderWithAuthOptions) => RenderedWithAuth;

package/dist/auth/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './components';

package/dist/auth/react/AuthProvider.component.d.ts

@@ -0,0 +1,15 @@
+import { PropsWithChildren, Context } from 'react';
+import { AuthClient, AuthState } from '../client/auth-client';
+export interface AuthContextValue {
+    state: AuthState;
+    client: AuthClient;
+}
+export declare const AuthContext: Context<AuthContextValue | null>;
+export type AuthProviderProps = PropsWithChildren<{
+    client: AuthClient;
+}>;
+/**
+ * Exposes the client and its state to `useAuth()`, and starts `client.bootstrap()` on mount
+ * (idempotent: a StrictMode double mount restores the session once).
+ */
+export declare const AuthProvider: ({ client, children }: AuthProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/auth/react/AuthProvider.component.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/react/use-auth.hook.d.ts

@@ -0,0 +1,3 @@
+import { AuthContextValue } from './AuthProvider.component';
+/** The authentication state and client of the closest `<AuthProvider>`. */
+export declare const useAuth: () => AuthContextValue;

package/dist/auth-client.d.ts

@@ -0,0 +1,2 @@
+export * from './auth/client/index'
+export {}

package/dist/auth-client.js

@@ -0,0 +1,26 @@
+import { a as e, A as R, R as _, b as s, c as S, s as r } from "./token-storage-D3e11ePD.js";
+import { g as A, i as T, j as o, A as u, G as L, c as h, L as M, d as O, e as P, a as C, b as I, R as c, U as d, f as H, h as N, u as g } from "./use-auth.hook-B_TU5W3g.js";
+export {
+  A as APPLE_ID_SCRIPT_URL,
+  e as AuthBridgeError,
+  R as AuthBridgeErrorCode,
+  T as AuthContext,
+  o as AuthProvider,
+  u as AuthStatus,
+  L as GOOGLE_IDENTITY_SCRIPT_URL,
+  h as LOST_RESPONSE_LATE_RETRIES_AT_MS,
+  M as LOST_RESPONSE_RETRY_DELAYS_MS,
+  O as REFRESH_ATTEMPT_TIMEOUT_MS,
+  P as REFRESH_LOCK_NAME,
+  C as REFRESH_MARGIN_MS,
+  I as REFRESH_REPLAY_GRACE_MS,
+  _ as REFRESH_TOKEN_STORAGE_KEY,
+  c as ReauthMethod,
+  d as UNREACHABLE_RETRY_MS,
+  H as createAuthClient,
+  s as createSecureTokenStorage,
+  N as createWebBridge,
+  S as createWebTokenStorage,
+  r as sha256Hex,
+  g as useAuth
+};

package/dist/auth-native.d.ts

@@ -0,0 +1,2 @@
+export * from './auth/client/capacitor-bridge'
+export {}

package/dist/auth-native.js

@@ -0,0 +1,84 @@
+import { C as d } from "./index-D7cgykJH.js";
+import { SessionPlatform as l } from "@abyss-project/main";
+import { A as r, a as i, b as g } from "./token-storage-D3e11ePD.js";
+const p = () => new i(
+  r.UNSUPPORTED,
+  "Passkeys are not enabled in this app"
+), y = Object.values(r), m = (e) => {
+  if (e instanceof i)
+    return e;
+  const t = e == null ? void 0 : e.code, a = e instanceof Error ? e.message : "Native authentication failed";
+  return typeof t == "string" && y.includes(t) ? new i(t, a, e) : new i(r.FAILED, a, e);
+}, n = async (e) => {
+  try {
+    return await e();
+  } catch (t) {
+    throw m(t);
+  }
+}, f = (e) => ({
+  platform: e.platform,
+  passkeySupported: () => n(async () => {
+    if (!e.passkeys)
+      return !1;
+    const t = await e.loadPlugin(), { supported: a } = await t.isPasskeySupported();
+    return a;
+  }),
+  getPasskey: (t, a = !1) => n(async () => {
+    if (!e.passkeys)
+      throw p();
+    const s = await e.loadPlugin(), { responseJson: c } = await s.getPasskey({
+      optionsJson: JSON.stringify(t),
+      preferImmediatelyAvailable: a
+    });
+    return JSON.parse(c);
+  }),
+  createPasskey: (t) => n(async () => {
+    if (!e.passkeys)
+      throw p();
+    const a = await e.loadPlugin(), { responseJson: s } = await a.createPasskey({
+      optionsJson: JSON.stringify(t)
+    });
+    return JSON.parse(s);
+  }),
+  google: (t) => n(async () => {
+    const a = await e.loadPlugin(), { idToken: s } = await a.signInWithGoogle({
+      serverClientId: e.googleServerClientId,
+      nonce: t
+    });
+    return { idToken: s };
+  }),
+  // The plugin hands Apple the SHA-256 of the raw nonce itself (README of the plugin).
+  apple: (t) => n(async () => {
+    const s = await (await e.loadPlugin()).signInWithApple({ nonce: t });
+    return {
+      idToken: s.idToken,
+      ...s.givenName ? { givenName: s.givenName } : {},
+      ...s.familyName ? { familyName: s.familyName } : {}
+    };
+  })
+}), w = (e) => e;
+let o = null;
+const u = () => (o || (o = import("@abyss-project/capacitor-auth").then(
+  (e) => w(e.AbyssAuth),
+  (e) => {
+    throw o = null, e;
+  }
+)), o), k = () => {
+  const e = d.getPlatform();
+  if (e === "ios")
+    return l.IOS;
+  if (e === "android")
+    return l.ANDROID;
+  throw new Error(
+    `The Capacitor auth bridge needs iOS or Android, not "${e}"`
+  );
+}, N = (e) => f({
+  platform: k(),
+  googleServerClientId: e.googleServerClientId,
+  passkeys: e.nativePasskeys ?? !1,
+  loadPlugin: u
+}), v = () => g(u);
+export {
+  N as createCapacitorBridge,
+  v as createCapacitorTokenStorage
+};

package/dist/components/Layouts/AbyssLayoutProvider/AbyssLayoutProvider.component.d.ts

@@ -1,7 +1,6 @@
 import { default as React } from 'react';
 import { AbyssLayoutStore, AbyssLayoutState } from './abyss-layout.store';
-import { UseBoundStore } from 'zustand/react';
-import { StoreApi } from 'zustand';
+import { UseBoundStore, StoreApi } from 'zustand';
 import { PersistOptions } from 'zustand/middleware';
 type Props = {
     store: AbyssLayoutStore;
@@ -14,7 +13,7 @@ export declare const useAbyssLayoutStore: () => UseBoundStore<Omit< StoreApi<Aby
             sidebarCollapsed: boolean;
         }>>) => void;
         clearStorage: () => void;
-        rehydrate: () => void | Promise<void>;
+        rehydrate: () => Promise<void> | void;
         hasHydrated: () => boolean;
         onHydrate: (fn: (state: AbyssLayoutState) => void) => () => void;
         onFinishHydration: (fn: (state: AbyssLayoutState) => void) => () => void;

package/dist/components/Layouts/AbyssLayoutProvider/abyss-layout.store.d.ts

@@ -16,7 +16,7 @@ export declare const createAbyssLayoutStore: (persistKey: string) => UseBoundSto
             sidebarCollapsed: boolean;
         }>>) => void;
         clearStorage: () => void;
-        rehydrate: () => void | Promise<void>;
+        rehydrate: () => Promise<void> | void;
         hasHydrated: () => boolean;
         onHydrate: (fn: (state: AbyssLayoutState) => void) => () => void;
         onFinishHydration: (fn: (state: AbyssLayoutState) => void) => () => void;

package/dist/components/Support/SupportTicketDetail.mobile-layout.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cookie-consent.js

@@ -1,4 +1,4 @@
-import { A as s, c as a, C as n, a as C, D as i, R as t, V as r, d as A, f as k, r as c, e as l, u as D, b as E, w as I } from "./CookieConsentSettings.component-tRVw_4zH.js";
+import { A as s, c as a, C as n, a as C, D as i, R as t, V as r, d as A, f as k, r as c, e as l, u as D, b as E, w as I } from "./CookieConsentSettings.component-B06_BnQP.js";
 export {
   s as AbyssCookieConsentProvider,
   a as COOKIE_NAME,