@strivacity/sdk-nuxt 3.0.2 → 4.0.0-beta.0

package/dist/runtime/composables/use-strivacity.js

@@ -0,0 +1,77 @@
+import { ref } from "vue";
+import { initFlow } from "@strivacity/sdk-core";
+import { useRuntimeConfig } from "#app";
+import { useSession } from "./use-session.js";
+import createLogging from "#strivacity-options-logging";
+import createHttpClient from "#strivacity-options-httpClient";
+let sdk;
+const loadingRef = ref(true);
+const languageRef = ref(globalThis.navigator?.language ?? "en-US");
+const isAuthenticatedRef = ref(false);
+const idTokenClaimsRef = ref(null);
+const accessTokenRef = ref(null);
+const refreshTokenRef = ref(null);
+const accessTokenExpiredRef = ref(true);
+const accessTokenExpirationDateRef = ref(null);
+const updateSession = async () => {
+  const authenticated = await sdk.isAuthenticated;
+  if (loadingRef.value) {
+    loadingRef.value = false;
+  }
+  if (sdk.language !== languageRef.value) {
+    languageRef.value = sdk.language;
+  }
+  if (authenticated !== isAuthenticatedRef.value) {
+    isAuthenticatedRef.value = authenticated;
+  }
+  if (sdk.idTokenClaims !== idTokenClaimsRef.value) {
+    idTokenClaimsRef.value = sdk.idTokenClaims || null;
+  }
+  if (sdk.accessToken !== accessTokenRef.value) {
+    accessTokenRef.value = sdk.accessToken || null;
+  }
+  if (sdk.refreshToken !== refreshTokenRef.value) {
+    refreshTokenRef.value = sdk.refreshToken || null;
+  }
+  if (sdk.accessTokenExpired !== accessTokenExpiredRef.value) {
+    accessTokenExpiredRef.value = sdk.accessTokenExpired;
+  }
+  if (sdk.accessTokenExpirationDate !== accessTokenExpirationDateRef.value) {
+    accessTokenExpirationDateRef.value = sdk.accessTokenExpirationDate || null;
+  }
+};
+export const useStrivacity = () => {
+  if (!sdk) {
+    sdk = initFlow({
+      ...useRuntimeConfig().public.strivacity,
+      logging: createLogging ? createLogging() : void 0,
+      httpClient: createHttpClient ? createHttpClient() : void 0
+    });
+    sdk.subscribeToAllEvents(updateSession);
+    sdk.session = useSession().value;
+    void updateSession();
+  }
+  return {
+    sdk,
+    loading: loadingRef,
+    language: languageRef,
+    isAuthenticated: isAuthenticatedRef,
+    idTokenClaims: idTokenClaimsRef,
+    accessToken: accessTokenRef,
+    refreshToken: refreshTokenRef,
+    accessTokenExpired: accessTokenExpiredRef,
+    accessTokenExpirationDate: accessTokenExpirationDateRef,
+    init: () => sdk.init(),
+    subscribeToEvent: ((...args) => sdk.subscribeToEvent(...args)),
+    subscribeToAllEvents: (...args) => sdk.subscribeToAllEvents(...args),
+    checkAuthentication: (...args) => sdk.checkAuthentication(...args),
+    tokenExchange: (...args) => sdk.tokenExchange(...args),
+    handleCallback: (...args) => sdk.handleCallback(...args),
+    refresh: () => sdk.refresh(),
+    revoke: () => sdk.revoke(),
+    logout: (...args) => sdk.logout(...args),
+    login: (...args) => sdk.login(...args),
+    register: (...args) => sdk.register(...args),
+    entry: (...args) => sdk.entry(...args)
+  };
+};

package/dist/runtime/middleware/auth.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").RouteMiddleware;
+export default _default;

package/dist/runtime/middleware/auth.server.js

@@ -0,0 +1,12 @@
+import { defineNuxtRouteMiddleware, useNuxtApp } from "#imports";
+import { useSession } from "../composables/use-session.js";
+export default defineNuxtRouteMiddleware(async () => {
+  if (!import.meta.server) {
+    return;
+  }
+  const app = useNuxtApp();
+  const h3Event = app.ssrContext.event;
+  const { useStrivacity } = await import("../server/composables/use-strivacity.js");
+  const sdk = useStrivacity(h3Event);
+  useSession().value = await sdk.getSession() ?? void 0;
+});

package/dist/runtime/server/api/auth/backchannel-logout.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/api/auth/backchannel-logout.get.js

@@ -0,0 +1,2 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleBackChannelLogout(event));

package/dist/runtime/server/api/auth/callback.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/api/auth/callback.get.js

@@ -0,0 +1,2 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleCallback(event));

package/dist/runtime/server/api/auth/entry.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/api/auth/entry.get.js

@@ -0,0 +1,2 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleEntry(event));

package/dist/runtime/server/api/auth/login.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/api/auth/login.get.js

@@ -0,0 +1,2 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleLogin(event));

package/dist/runtime/server/api/auth/logout.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/api/auth/logout.get.js

@@ -0,0 +1,2 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleLogout(event));

package/dist/runtime/server/api/auth/refresh.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/api/auth/refresh.get.js

@@ -0,0 +1,2 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleRefresh(event));

package/dist/runtime/server/api/auth/register.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/api/auth/register.get.js

@@ -0,0 +1,2 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleRegister(event));

package/dist/runtime/server/api/auth/revoke.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/api/auth/revoke.get.js

@@ -0,0 +1,2 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleRevoke(event));

package/dist/runtime/server/composables/use-strivacity.d.ts

@@ -0,0 +1,2 @@
+import type { H3Event } from 'h3';
+export declare const useStrivacity: (event: H3Event) => import("../../types.js").NuxtServerSDK;

package/dist/runtime/server/composables/use-strivacity.js

@@ -0,0 +1,9 @@
+export const useStrivacity = (event) => {
+  if (import.meta.client) {
+    throw new Error('The "useStrivacity" composable should only be used on the server.');
+  }
+  if (!event) {
+    throw new Error("useStrivacity() can not be called without passing an H3Event instance.");
+  }
+  return event.context.strivacity.sdk;
+};

package/dist/runtime/server/plugins/auth.server.d.ts

@@ -0,0 +1,10 @@
+import type { NuxtServerSDK } from '../../types.js';
+declare module 'h3' {
+    interface H3EventContext {
+        strivacity: {
+            sdk: NuxtServerSDK;
+        };
+    }
+}
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/auth.server.js

@@ -0,0 +1,66 @@
+import { toWebRequest } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
+import { createBaseServerSDK } from "@strivacity/sdk-core/server";
+import { ConfigurationError } from "@strivacity/sdk-core/utils";
+import { createEncryptedCookieStorage } from "../../storages/default.js";
+export default defineNitroPlugin((nitroApp) => {
+  void setupAuthPlugin(nitroApp);
+});
+async function setupAuthPlugin(nitroApp) {
+  const config = useRuntimeConfig();
+  const initConfig = { ...config.strivacity };
+  const customStorage = (await import("#strivacity-options-storage")).default();
+  const customStateStorage = (await import("#strivacity-options-stateStorage")).default();
+  const customLogging = (await import("#strivacity-options-logging")).default();
+  const customHttpClient = (await import("#strivacity-options-httpClient")).default();
+  if (customStorage) {
+    initConfig.storage = customStorage;
+  }
+  if (customStateStorage) {
+    initConfig.stateStorage = customStateStorage;
+  }
+  if (customLogging) {
+    initConfig.logging = customLogging;
+  }
+  if (customHttpClient) {
+    initConfig.httpClient = customHttpClient;
+  }
+  if (!initConfig.storage) {
+    if (!initConfig.secret) {
+      throw new ConfigurationError("Secret is required for encrypted cookie storage");
+    }
+    initConfig.cookieMaxAge ??= 30 * 24 * 60 * 60;
+    initConfig.storage = createEncryptedCookieStorage(initConfig.secret, { defaultCookieOptions: { maxAge: initConfig.cookieMaxAge } });
+  }
+  const base = createBaseServerSDK(
+    {
+      toRequest: (event) => toWebRequest(event)
+    },
+    initConfig
+  );
+  nitroApp.hooks.hook("request", (event) => {
+    event.context.strivacity ??= {};
+    event.context.strivacity.sdk ??= {
+      get options() {
+        return base.options;
+      },
+      getSession: () => base.getSession(event),
+      updateSession: (session) => base.updateSession(session, event),
+      refreshSession: () => base.refreshSession(event),
+      revokeSession: () => base.revokeSession(event),
+      getEntrySession: (entryUrl) => base.getEntrySession(entryUrl),
+      completeLogin: (params) => base.completeLogin(params, event),
+      logout: (postLogoutRedirectUri) => base.logout(postLogoutRedirectUri, event),
+      handleLogin: (evt) => base.handleLogin(evt),
+      handleRegister: (evt) => base.handleRegister(evt),
+      handleCallback: (evt) => base.handleCallback(evt),
+      handleRefresh: (evt) => base.handleRefresh(evt),
+      handleRevoke: (evt) => base.handleRevoke(evt),
+      handleEntry: (evt) => base.handleEntry(evt),
+      handleLogout: (evt) => base.handleLogout(evt),
+      handleBackChannelLogout: (evt) => base.handleBackChannelLogout(evt),
+      handler: (evt) => base.handler(evt)
+    };
+  });
+}

package/dist/runtime/server/utils/helpers.d.ts

@@ -0,0 +1,18 @@
+import type { H3Event } from 'h3';
+import type { HttpClientResponse } from '@strivacity/sdk-core/types';
+/**
+ * Proxies an HttpClientResponse to a Web Response, preserving headers and status code.
+ */
+export declare function proxyResponse<T = unknown>(response: HttpClientResponse<T>): Response;
+/**
+ * Extracts the accept-language locale from the event's request headers.
+ */
+export declare function getLocaleFromEvent(event: H3Event): string | undefined;
+/**
+ * Returns a safe absolute redirect URL only if it shares the same origin as safeBaseUrl, preventing open redirects.
+ *
+ * @param dangerousRedirect - The untrusted redirect path or URL.
+ * @param safeBaseUrl - The trusted base URL whose origin is used as the allowed origin.
+ * @returns The resolved URL string if safe, or undefined.
+ */
+export declare function toSafeRedirect(dangerousRedirect: string | undefined | null, safeBaseUrl: string): string | null;

package/dist/runtime/server/utils/helpers.js

@@ -0,0 +1,39 @@
+import { DISALLOWED_PROXY_HEADERS } from "@strivacity/sdk-core/utils";
+export function proxyResponse(response) {
+  const proxyHeaders = new Headers();
+  for (const [key, value] of response.headers.entries()) {
+    if (key.toLowerCase() === "set-cookie") continue;
+    if (!DISALLOWED_PROXY_HEADERS.has(key.toLowerCase())) {
+      proxyHeaders.set(key, value);
+    }
+  }
+  const setCookie = response.headers.get("set-cookie");
+  if (setCookie) {
+    proxyHeaders.set("set-cookie", setCookie);
+  }
+  return new Response(response.body ?? null, {
+    status: response.status,
+    headers: proxyHeaders
+  });
+}
+export function getLocaleFromEvent(event) {
+  const acceptLanguage = event.headers.get("accept-language");
+  if (!acceptLanguage) return void 0;
+  return acceptLanguage.split(",")[0]?.split(";")[0]?.trim();
+}
+export function toSafeRedirect(dangerousRedirect, safeBaseUrl) {
+  let url;
+  if (!dangerousRedirect) {
+    return null;
+  }
+  try {
+    safeBaseUrl = new URL(safeBaseUrl).origin;
+    url = new URL(dangerousRedirect?.startsWith("/") ? dangerousRedirect.slice(1) : dangerousRedirect, safeBaseUrl);
+  } catch {
+    return null;
+  }
+  if (url.origin === new URL(safeBaseUrl).origin) {
+    return url.toString();
+  }
+  return null;
+}

package/dist/runtime/storages/core.d.ts

@@ -0,0 +1 @@
+export { COOKIE_CONTEXT, COOKIE_CHUNK_SIZE, createCacheAPIStorage, createIndexedDBStorage, createLocalStorage, createMemoryStorage, createServerMemoryStorage, createSessionStorage, createWorkerStorage, handleWorkerStorageRequests, createServerStateStorage, } from '@strivacity/sdk-core/storages';

package/dist/runtime/storages/core.js

@@ -0,0 +1,13 @@
+export {
+  COOKIE_CONTEXT,
+  COOKIE_CHUNK_SIZE,
+  createCacheAPIStorage,
+  createIndexedDBStorage,
+  createLocalStorage,
+  createMemoryStorage,
+  createServerMemoryStorage,
+  createSessionStorage,
+  createWorkerStorage,
+  handleWorkerStorageRequests,
+  createServerStateStorage
+} from "@strivacity/sdk-core/storages";

package/dist/runtime/storages/default.d.ts

@@ -0,0 +1,21 @@
+import type { H3Event } from 'h3';
+import type { EncryptedCookieStorageOptions, ServerStorage, SessionIdCookieStorageOptions } from '@strivacity/sdk-core/types';
+import type { NuxtServerStorage } from '../types.js';
+/**
+ * Creates a session storage that puts a random unique id value cookie on the client and keeping the actual session data in the given `storage`.
+ *
+ * @param {SDKStorage} storage - The storage used to persist session data, keyed by a randomly generated session id.
+ * @param {SessionIdCookieStorageOptions} [options] - Options for configuring the session-id cookie storage.
+ * @returns {ServerStorage} An object implementing the ServerStorage interface for managing sessions indexed by a session-id cookie.
+ */
+export declare function createSessionIdCookieStorage(storage: ServerStorage, options?: SessionIdCookieStorageOptions): ServerStorage<H3Event<import("h3").EventHandlerRequest>>;
+/**
+ * Creates an encrypted cookie session storage.
+ * Only callable in server-side contexts.
+ *
+ * @param secret - The secret key used for encryption and decryption.
+ * @param {EncryptedCookieStorageOptions} [options] - Options for configuring the encrypted cookie storage.
+ * @param {Partial<ServerCookieOptions>} [options.defaultCookieOptions] - Default cookie attributes for the encrypted cookie.
+ * @returns An object implementing the NuxtServerStorage interface for managing encrypted cookies in Nuxt.
+ */
+export declare function createEncryptedCookieStorage(secret: string, options?: EncryptedCookieStorageOptions): NuxtServerStorage;

package/dist/runtime/storages/default.js

@@ -0,0 +1,71 @@
+import { getCookie, setCookie, deleteCookie, toWebRequest } from "h3";
+import { encryptString, decryptString } from "@strivacity/sdk-core/utils/crypto";
+import { COOKIE_CONTEXT, COOKIE_CHUNK_SIZE } from "@strivacity/sdk-core/server";
+import { createSessionIdCookieStorage as createSessionIdCookieStorageBase } from "@strivacity/sdk-core/storages/server";
+export function createSessionIdCookieStorage(storage, options) {
+  return createSessionIdCookieStorageBase(
+    {
+      toRequest: (event) => toWebRequest(event)
+    },
+    storage,
+    options
+  );
+}
+export function createEncryptedCookieStorage(secret, options) {
+  const defaultCookieOptions = {
+    httpOnly: true,
+    secure: true,
+    path: "/",
+    sameSite: "lax",
+    ...options?.defaultCookieOptions
+  };
+  const storage = {
+    async get(key, event) {
+      if (!event) {
+        return null;
+      }
+      const cookie = getCookie(event, key) ?? null;
+      if (cookie) {
+        return await decryptString(cookie, secret, COOKIE_CONTEXT);
+      }
+      const cookieChunks = [];
+      for (let i = 0; ; i++) {
+        const chunk = getCookie(event, `${key}.${i}`);
+        if (!chunk) {
+          break;
+        }
+        cookieChunks.push(chunk);
+      }
+      if (cookieChunks.length === 0) {
+        return null;
+      }
+      return await decryptString(cookieChunks.join(""), secret, COOKIE_CONTEXT);
+    },
+    async set(key, value, event, cookieOptions = {}) {
+      if (!event) {
+        return;
+      }
+      cookieOptions = { ...defaultCookieOptions, ...cookieOptions };
+      await storage.delete(key, event, cookieOptions);
+      const encrypted = await encryptString(value, secret, COOKIE_CONTEXT);
+      if (encrypted.length <= COOKIE_CHUNK_SIZE) {
+        setCookie(event, key, encrypted, cookieOptions);
+      } else {
+        for (let i = 0; i * COOKIE_CHUNK_SIZE < encrypted.length; i++) {
+          setCookie(event, `${key}.${i}`, encrypted.slice(i * COOKIE_CHUNK_SIZE, (i + 1) * COOKIE_CHUNK_SIZE), cookieOptions);
+        }
+      }
+    },
+    async delete(key, event, cookieOptions = {}) {
+      if (!event) {
+        return;
+      }
+      deleteCookie(event, key, cookieOptions);
+      for (let i = 0; getCookie(event, `${key}.${i}`); i++) {
+        deleteCookie(event, `${key}.${i}`, cookieOptions);
+      }
+      return Promise.resolve();
+    }
+  };
+  return storage;
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,219 @@
+import type { H3Event } from 'h3';
+import type { Ref } from 'vue';
+import type { ServerSDKOptions, ServerSDKInitConfig, SDKStorage, CookieOptions, IdTokenClaims, RedirectFlow, PopupFlow, NativeFlow, EmbeddedFlow, NativeFlowMessage, initFlow, FallbackError, NativeParams, NativeFlowState, SessionData, LogoutTokenClaims, BaseServerSDK } from '@strivacity/sdk-core';
+declare module '@nuxt/schema' {
+    interface RuntimeConfig {
+        strivacity: StrivacityRuntimeConfig;
+    }
+    interface PublicRuntimeConfig {
+        strivacity: StrivacityPublicRuntimeConfig;
+    }
+}
+export * from '@strivacity/sdk-core/types';
+export type StrivacityRuntimeConfig = NuxtServerSDKInitConfig;
+export type StrivacityPublicRuntimeConfig = Omit<NuxtServerSDKInitConfig, 'secret' | 'storageFactoryPath' | 'stateStorageFactoryPath' | 'loggingFactoryPath' | 'httpClientFactoryPath'>;
+export type SDKContext<Flow extends RedirectFlow | PopupFlow | NativeFlow | EmbeddedFlow> = {
+    /**
+     * The underlying Strivacity SDK flow instance.
+     */
+    readonly sdk: Flow;
+    /**
+     * A boolean indicating whether the SDK is still loading.
+     */
+    readonly loading: Ref<boolean>;
+    /**
+     * BCP 47 language code representing the current language of the SDK.
+     */
+    readonly language: Ref<string>;
+    /**
+     * A boolean ref indicating whether the user is authenticated.
+     */
+    readonly isAuthenticated: Ref<boolean>;
+    /**
+     * The claims from the ID token, if available.
+     */
+    readonly idTokenClaims: Ref<IdTokenClaims | null>;
+    /**
+     * The access token, if available.
+     */
+    readonly accessToken: Ref<string | null>;
+    /**
+     * The refresh token, if available.
+     */
+    readonly refreshToken: Ref<string | null>;
+    /**
+     * A boolean ref indicating whether the access token has expired.
+     */
+    readonly accessTokenExpired: Ref<boolean>;
+    /**
+     * The expiration date of the access token, if available.
+     */
+    readonly accessTokenExpirationDate: Ref<number | null>;
+    /**
+     * Subscribes to a specific SDK event.
+     */
+    subscribeToEvent: Flow['subscribeToEvent'];
+    /**
+     * Subscribes to all SDK events.
+     */
+    subscribeToAllEvents: Flow['subscribeToAllEvents'];
+    /**
+     * Checks whether the user is currently authenticated, optionally triggering a token refresh.
+     */
+    checkAuthentication: Flow['checkAuthentication'];
+    /**
+     * Initializes the SDK, loading metadata and restoring any persisted session.
+     */
+    init: Flow['init'];
+    /**
+     * Performs a token exchange using the provided parameters.
+     */
+    tokenExchange: Flow['tokenExchange'];
+    /**
+     * Handles the authentication callback by parsing the response from the given URL.
+     */
+    handleCallback: Flow['handleCallback'];
+    /**
+     * Refreshes the current access token using the refresh token.
+     */
+    refresh: Flow['refresh'];
+    /**
+     * Revokes the current tokens.
+     */
+    revoke: Flow['revoke'];
+    /**
+     * Logs the user out and optionally redirects to a post-logout URI.
+     */
+    logout: Flow['logout'];
+    /**
+     * Initiates the login flow.
+     */
+    login: Flow['login'];
+    /**
+     * Initiates the registration flow.
+     */
+    register: Flow['register'];
+    /**
+     * Handles the entry point URL of the authentication flow, typically used for embedded or native modes.
+     */
+    entry: Flow['entry'];
+};
+export type SDKInstance = ReturnType<typeof initFlow>;
+export type LoginContext = {
+    /**
+     * Whether a form submission or session initialization is in progress.
+     */
+    loading: Ref<boolean>;
+    /**
+     * Current form field values, keyed by form ID then widget ID.
+     */
+    forms: Ref<Record<string, Record<string, unknown>>>;
+    /**
+     * Current validation and info messages, keyed by form ID then widget ID.
+     */
+    messages: Ref<Record<string, Record<string, NativeFlowMessage>>>;
+    /**
+     * The current login flow state returned by the backend.
+     */
+    state: Ref<Partial<NativeFlowState>>;
+    /**
+     * Submits the form with the given ID and advances the login flow.
+     *
+     * @param formId - The ID of the form to submit.
+     * @param customBody - Optional custom body to send with the form submission. If not provided, the current form values will be used.
+     * @returns A promise that resolves when the form submission is complete.
+     */
+    submitForm: (formId: string, customBody?: Record<string, unknown>) => Promise<void>;
+    /**
+     * Redirects to the hosted login UI.
+     *
+     * @param message - Optional message to log before redirecting.
+     * @returns A promise that resolves when the redirect is initiated.
+     */
+    triggerFallback: (message?: string) => void;
+    /**
+     * Signals that the login flow was closed by the user.
+     */
+    triggerClose: () => void;
+    /**
+     * Updates a single field value within a form before submission.
+     *
+     * @param formId - The ID of the form containing the field.
+     * @param widgetId - The ID of the widget (field) to update.
+     * @param value - The new value to set for the field.
+     */
+    setFormValue: (formId: string, widgetId: string, value: unknown) => void;
+    /**
+     * Sets a validation or info message on a specific widget.
+     *
+     * @param formId - The ID of the form containing the widget.
+     * @param widgetId - The ID of the widget to set the message for.
+     * @param value - The message to set, which can be a string or a structured NativeFlowMessage.
+     */
+    setMessage: (formId: string, widgetId: string, value: NativeFlowMessage) => void;
+};
+export type UseNativeLoginOptions = {
+    /**
+     * Optional parameters to be passed to the login session request. These parameters will be sent to the `authorizationUri` endpoint.
+     */
+    params?: NativeParams;
+    /**
+     * A render function called when the user successfully completes the login flow.
+     * This can be used to perform any necessary actions after a successful login, such as redirecting the user or updating the application state. Defaults to `null`.
+     */
+    onLogin?: (session: SessionData) => void | Promise<void>;
+    /**
+     * Called when the fallback flow is triggered, typically due to an error or unsupported environment. Receives a `FallbackError` object containing the hosted URL to redirect to.
+     */
+    onFallback?: (error: FallbackError) => void | Promise<void>;
+    /**
+     * Called when the login flow is closed by the user. This can be used to perform any necessary cleanup or state updates in the application. Defaults to `null`.
+     */
+    onClose?: () => void | Promise<void>;
+    /**
+     * Called when an error occurs during the login session initialization or flow. Receives an `Error` object describing the issue.
+     */
+    onError?: (error: Error) => void | Promise<void>;
+    /**
+     * Called when a global message is received during the login flow. This can be used to display messages to the user or log them for debugging purposes.
+     */
+    onGlobalMessage?: (message: NativeFlowMessage) => void | Promise<void>;
+};
+/**
+ * Extends the base SDKStorage interface with optional back-channel logout support.
+ */
+export type NuxtServerStorage = SDKStorage<[
+    event?: H3Event
+], [
+    event?: H3Event,
+    cookieOptions?: CookieOptions
+], [
+    event?: H3Event,
+    cookieOptions?: CookieOptions
+]> & {
+    deleteByLogoutToken?(token: LogoutTokenClaims): Promise<void>;
+};
+export type NuxtServerSDKOptions<Storage extends NuxtServerStorage = NuxtServerStorage, StateStorage extends SDKStorage = SDKStorage> = ServerSDKOptions<Storage, StateStorage>;
+export type NuxtServerSDKInitConfig = ServerSDKInitConfig & Partial<Omit<NuxtServerSDKOptions, 'storage' | 'stateStorage' | 'logging' | 'httpClient'>> & {
+    /**
+     * Optional path to a custom storage factory module.
+     * The factory should export a function that returns an object implementing the SDKStorage interface.
+     */
+    storageFactoryPath?: string;
+    /**
+     * Optional path to a custom state storage factory module.
+     * The factory should export a function that returns an object implementing the SDKStorage interface.
+     */
+    stateStorageFactoryPath?: string;
+    /**
+     * Optional path to a custom logging factory module.
+     * The factory should export a function that returns an object implementing the SDKLogging interface.
+     */
+    loggingFactoryPath?: string;
+    /**
+     * Optional path to a custom HTTP client factory module.
+     * The factory should export a function that returns an object implementing the SDKHttpClient interface.
+     */
+    httpClientFactoryPath?: string;
+};
+export type NuxtServerSDK<TEvent extends H3Event = H3Event> = BaseServerSDK<TEvent>;

package/dist/runtime/types.js

@@ -0,0 +1 @@
+export * from "@strivacity/sdk-core/types";

package/dist/runtime/utils/core.d.ts

@@ -0,0 +1 @@
+export { FallbackError, PopupBlockedError, PopupClosedError, UnsupportedFlowError, SessionExpiredError, NetworkError, ServerError, OidcError, ProtocolError, ConfigurationError, InternalError, throwTokenEndpointError, throwHttpError, assertWebAuthnCredential, buildAuthorizationUrl, buildCookieString, buildEndSessionUrl, createDefaultLogging, createHttpClient, createSession, createState, createWebAuthnCredential, decodeBase64URL, decodeJwt, decryptString, defaultOptions, encodeBase64URL, encryptString, exchangeCode, fetchFlowEntry, finalizeLoginSession, generateCodeChallenge, generateCodeVerifier, generateJwt, generateRandomHex, getDefaultFlowState, getDiscoveryDocument, getSDKOptions, getServerSDKOptions, injectScript, isSessionExpired, loadSession, parseCookieHeader, parseState, proxyResponse, pushSetCookie, flushSetCookies, refreshToken, revokeToken, serializeCookie, serializeSession, serializeState, submitLoginForm, timestamp, toSafeRedirect, unflattenObject, verifyIdToken, verifyJwt, DISALLOWED_PROXY_HEADERS, RETURN_TO_COOKIE, BACKCHANNEL_LOGOUT_EVENT, DEFAULT_COOKIE_MAX_AGE, } from '@strivacity/sdk-core/utils';