@thunderid/nuxt 0.0.1

package/dist/runtime/components/ThunderIDRoot.js

@@ -0,0 +1,160 @@
+import { generateFlattenedUserProfile } from "@thunderid/browser";
+import {
+  BrandingProvider,
+  FlowMetaProvider,
+  FlowProvider,
+  I18nProvider,
+  OrganizationProvider,
+  ThemeProvider,
+  UserProvider
+} from "@thunderid/vue";
+import { defineComponent, h } from "vue";
+import { useState, useRuntimeConfig } from "#imports";
+const ThunderIDRoot = defineComponent({
+  name: "ThunderIDRoot",
+  setup(_props, { slots }) {
+    const userProfileState = useState("thunderid:user-profile");
+    const currentOrgState = useState("thunderid:current-org");
+    const myOrgsState = useState("thunderid:my-orgs");
+    const brandingState = useState("thunderid:branding");
+    const authState = useState("thunderid:auth");
+    const prefs = useRuntimeConfig().public.thunderid?.preferences;
+    const shouldFetchProfile = prefs?.user?.fetchUserProfile !== false;
+    const shouldFetchOrgs = prefs?.user?.fetchOrganizations !== false;
+    const shouldFetchBranding = prefs?.theme?.inheritFromBranding !== false;
+    const themeMode = prefs?.theme?.mode ?? "light";
+    const onUpdateProfile = (payload) => {
+      const prev = userProfileState.value;
+      userProfileState.value = prev ? {
+        ...prev,
+        flattenedProfile: generateFlattenedUserProfile(payload, prev.schemas),
+        profile: payload
+      } : {
+        flattenedProfile: generateFlattenedUserProfile(payload, []),
+        profile: payload,
+        schemas: []
+      };
+      authState.value = { ...authState.value, user: payload };
+    };
+    const updateProfile = async (requestConfig, _sessionId) => {
+      if (_sessionId) {
+      }
+      try {
+        const result = await $fetch("/api/auth/user/profile", {
+          body: requestConfig,
+          method: "PATCH"
+        });
+        if (result?.success && result.data?.user) {
+          onUpdateProfile(result.data.user);
+        }
+        return result;
+      } catch (err) {
+        return { data: { user: {} }, error: String(err), success: false };
+      }
+    };
+    const revalidateProfile = async () => {
+      try {
+        const res = await $fetch("/api/auth/user/profile");
+        if (res) userProfileState.value = res;
+      } catch {
+      }
+    };
+    const onOrganizationSwitch = async (organization) => $fetch("/api/auth/organizations/switch", { body: { organization }, method: "POST" });
+    const getAllOrganizations = async () => $fetch("/api/auth/organizations");
+    const revalidateMyOrganizations = async () => {
+      try {
+        const res = await $fetch("/api/auth/organizations/me");
+        myOrgsState.value = res ?? [];
+        return myOrgsState.value;
+      } catch {
+        return myOrgsState.value;
+      }
+    };
+    const createOrganization = async (payload) => $fetch("/api/auth/organizations", { body: payload, method: "POST" });
+    const revalidateCurrentOrganization = async () => {
+      try {
+        const res = await $fetch("/api/auth/organizations/current");
+        currentOrgState.value = res ?? null;
+        return currentOrgState.value;
+      } catch {
+        return currentOrgState.value;
+      }
+    };
+    const revalidateBranding = async () => {
+      try {
+        const res = await $fetch("/api/auth/branding");
+        if (res) brandingState.value = res;
+      } catch {
+      }
+    };
+    return () => h(
+      I18nProvider,
+      { preferences: prefs?.i18n },
+      {
+        default: () => h(
+          FlowMetaProvider,
+          { enabled: false },
+          {
+            default: () => h(
+              BrandingProvider,
+              {
+                // When inheritFromBranding is disabled, pass null so the provider
+                // falls back to its own default theme without using SSR-fetched data.
+                brandingPreference: shouldFetchBranding ? brandingState.value : null,
+                revalidateBranding: shouldFetchBranding ? revalidateBranding : void 0
+              },
+              {
+                default: () => h(
+                  ThemeProvider,
+                  {
+                    // Mirror the same flag used in the Nitro plugin gate.
+                    inheritFromBranding: shouldFetchBranding,
+                    mode: themeMode
+                  },
+                  {
+                    default: () => h(FlowProvider, null, {
+                      default: () => h(
+                        UserProvider,
+                        {
+                          // When fetchUserProfile is false the Nitro plugin
+                          // skips SCIM calls, so we must also pass empty values
+                          // here to keep SSR and client in sync.
+                          flattenedProfile: shouldFetchProfile ? userProfileState.value?.flattenedProfile ?? null : null,
+                          onUpdateProfile: shouldFetchProfile ? onUpdateProfile : void 0,
+                          profile: shouldFetchProfile ? userProfileState.value : null,
+                          revalidateProfile: shouldFetchProfile ? revalidateProfile : void 0,
+                          schemas: shouldFetchProfile ? userProfileState.value?.schemas ?? null : null,
+                          updateProfile: shouldFetchProfile ? updateProfile : void 0
+                        },
+                        {
+                          default: () => h(
+                            OrganizationProvider,
+                            {
+                              // When fetchOrganizations is false pass empty
+                              // values so the provider renders without org data.
+                              createOrganization: shouldFetchOrgs ? createOrganization : void 0,
+                              currentOrganization: shouldFetchOrgs ? currentOrgState.value : null,
+                              getAllOrganizations: shouldFetchOrgs ? getAllOrganizations : void 0,
+                              myOrganizations: shouldFetchOrgs ? myOrgsState.value : [],
+                              onOrganizationSwitch: shouldFetchOrgs ? onOrganizationSwitch : void 0,
+                              revalidateCurrentOrganization: shouldFetchOrgs ? revalidateCurrentOrganization : void 0,
+                              revalidateMyOrganizations: shouldFetchOrgs ? revalidateMyOrganizations : void 0
+                            },
+                            {
+                              default: () => slots["default"]?.()
+                            }
+                          )
+                        }
+                      )
+                    })
+                  }
+                )
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+});
+export default ThunderIDRoot;

package/dist/runtime/components/actions/SignInButton.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { type Component } from 'vue';
+/**
+ * Nuxt-specific SignInButton container.
+ *
+ * Mirrors the Next.js SDK's SignInButton: imports {@link BaseSignInButton} from
+ * `@thunderid/vue` and wires navigation through Nuxt's `navigateTo` so
+ * server-side redirects work correctly (no `window.location` access).
+ *
+ * The `signIn` action and `signInUrl` come from the Nuxt-specific
+ * {@link useThunderID} composable which is provided via the Nuxt auto-import
+ * layer — not directly from `@thunderid/vue`.
+ *
+ * @example
+ * ```vue
+ * <ThunderIDSignInButton />
+ * <ThunderIDSignInButton class="btn-primary">Log in</ThunderIDSignInButton>
+ * ```
+ */
+declare const SignInButton: Component;
+export default SignInButton;

package/dist/runtime/components/actions/SignInButton.js

@@ -0,0 +1,51 @@
+import { ThunderIDRuntimeError } from "@thunderid/browser";
+import { BaseSignInButton } from "@thunderid/vue";
+import { defineComponent, h, ref } from "vue";
+import { navigateTo } from "#app";
+import { useThunderID } from "#imports";
+const SignInButton = defineComponent({
+  emits: ["click", "error"],
+  name: "SignInButton",
+  props: {
+    signInOptions: { default: void 0, type: Object }
+  },
+  setup(props, { slots, emit, attrs }) {
+    const { signIn, signInUrl, signInOptions: contextSignInOptions } = useThunderID();
+    const isLoading = ref(false);
+    const handleSignIn = async (e) => {
+      try {
+        isLoading.value = true;
+        if (signInUrl) {
+          await navigateTo(signInUrl, { external: true });
+        } else {
+          await signIn(props.signInOptions ?? contextSignInOptions);
+        }
+        if (e) emit("click", e);
+      } catch (error) {
+        emit("error", error);
+        throw new ThunderIDRuntimeError(
+          `Sign in failed: ${error instanceof Error ? error.message : String(error)}`,
+          "SignInButton-handleSignIn-RuntimeError-001",
+          "nuxt",
+          "Something went wrong while trying to sign in. Please try again later."
+        );
+      } finally {
+        isLoading.value = false;
+      }
+    };
+    return () => {
+      const slotContent = slots["default"] ? () => slots["default"]({ isLoading: isLoading.value }) : void 0;
+      return h(
+        BaseSignInButton,
+        {
+          class: attrs["class"],
+          isLoading: isLoading.value,
+          onClick: handleSignIn,
+          style: attrs["style"]
+        },
+        slotContent
+      );
+    };
+  }
+});
+export default SignInButton;

package/dist/runtime/components/actions/SignOutButton.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { type Component } from 'vue';
+/**
+ * Nuxt-specific SignOutButton container.
+ *
+ * Imports {@link BaseSignOutButton} from `@thunderid/vue` and wires the
+ * `signOut` action through the Nuxt-specific {@link useThunderID} composable
+ * (auto-import layer), which uses Nuxt's `navigateTo` instead of
+ * `window.location`.
+ *
+ * @example
+ * ```vue
+ * <ThunderIDSignOutButton />
+ * <ThunderIDSignOutButton class="btn-secondary">Sign out</ThunderIDSignOutButton>
+ * ```
+ */
+declare const SignOutButton: Component;
+export default SignOutButton;

package/dist/runtime/components/actions/SignOutButton.js

@@ -0,0 +1,43 @@
+import { ThunderIDRuntimeError } from "@thunderid/browser";
+import { BaseSignOutButton } from "@thunderid/vue";
+import { defineComponent, h, ref } from "vue";
+import { useThunderID } from "#imports";
+const SignOutButton = defineComponent({
+  emits: ["click", "error"],
+  name: "SignOutButton",
+  setup(_, { slots, emit, attrs }) {
+    const { signOut } = useThunderID();
+    const isLoading = ref(false);
+    const handleSignOut = async (e) => {
+      try {
+        isLoading.value = true;
+        await signOut();
+        if (e) emit("click", e);
+      } catch (error) {
+        emit("error", error);
+        throw new ThunderIDRuntimeError(
+          `Sign out failed: ${error instanceof Error ? error.message : String(error)}`,
+          "SignOutButton-handleSignOut-RuntimeError-001",
+          "nuxt",
+          "Something went wrong while trying to sign out. Please try again later."
+        );
+      } finally {
+        isLoading.value = false;
+      }
+    };
+    return () => {
+      const slotContent = slots["default"] ? () => slots["default"]({ isLoading: isLoading.value }) : void 0;
+      return h(
+        BaseSignOutButton,
+        {
+          class: attrs["class"],
+          isLoading: isLoading.value,
+          onClick: handleSignOut,
+          style: attrs["style"]
+        },
+        slotContent
+      );
+    };
+  }
+});
+export default SignOutButton;

package/dist/runtime/components/actions/SignUpButton.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { type Component } from 'vue';
+/**
+ * Nuxt-specific SignUpButton container.
+ *
+ * Imports {@link BaseSignUpButton} from `@thunderid/vue` and wires navigation
+ * through Nuxt's `navigateTo` so a configured `signUpUrl` is followed
+ * SSR-safely instead of via `window.location`.
+ *
+ * @example
+ * ```vue
+ * <ThunderIDSignUpButton />
+ * <ThunderIDSignUpButton class="btn-primary">Create account</ThunderIDSignUpButton>
+ * ```
+ */
+declare const SignUpButton: Component;
+export default SignUpButton;

package/dist/runtime/components/actions/SignUpButton.js

@@ -0,0 +1,48 @@
+import { ThunderIDRuntimeError } from "@thunderid/browser";
+import { BaseSignUpButton } from "@thunderid/vue";
+import { defineComponent, h, ref } from "vue";
+import { navigateTo } from "#app";
+import { useThunderID } from "#imports";
+const SignUpButton = defineComponent({
+  emits: ["click", "error"],
+  name: "SignUpButton",
+  setup(_, { slots, emit, attrs }) {
+    const { signUp, signUpUrl } = useThunderID();
+    const isLoading = ref(false);
+    const handleSignUp = async (e) => {
+      try {
+        isLoading.value = true;
+        if (signUpUrl) {
+          await navigateTo(signUpUrl, { external: true });
+        } else {
+          await signUp();
+        }
+        if (e) emit("click", e);
+      } catch (error) {
+        emit("error", error);
+        throw new ThunderIDRuntimeError(
+          `Sign up failed: ${error instanceof Error ? error.message : String(error)}`,
+          "SignUpButton-handleSignUp-RuntimeError-001",
+          "nuxt",
+          "Something went wrong while trying to sign up. Please try again later."
+        );
+      } finally {
+        isLoading.value = false;
+      }
+    };
+    return () => {
+      const slotContent = slots["default"] ? () => slots["default"]({ isLoading: isLoading.value }) : void 0;
+      return h(
+        BaseSignUpButton,
+        {
+          class: attrs["class"],
+          isLoading: isLoading.value,
+          onClick: handleSignUp,
+          style: attrs["style"]
+        },
+        slotContent
+      );
+    };
+  }
+});
+export default SignUpButton;

package/dist/runtime/components/auth/Callback.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { type Component } from 'vue';
+/**
+ * Nuxt-specific Callback component.
+ *
+ * Handles OAuth callback parameter forwarding — extracts `code`, `state`, and
+ * `error` from the URL, validates the state stored in `sessionStorage`, and
+ * forwards the OAuth parameters to the originating route.
+ *
+ * **SSR-safe**: all `window` / `sessionStorage` access is gated inside
+ * `onMounted`, which only runs on the client. Navigation uses Nuxt's
+ * `navigateTo` instead of `window.location` so the redirect is handled
+ * correctly in both SSR and CSR contexts.
+ *
+ * Pass `onNavigate` to override the navigation handler (e.g. for testing or
+ * custom routing logic).
+ *
+ * @example
+ * ```vue
+ * <!-- pages/callback.vue -->
+ * <template>
+ *   <ThunderIDCallback :on-error="handleError" />
+ * </template>
+ * ```
+ */
+declare const Callback: Component;
+export default Callback;

package/dist/runtime/components/auth/Callback.js

@@ -0,0 +1,93 @@
+import { defineComponent, onMounted } from "vue";
+import { navigateTo } from "#app";
+const error = (msg, ...args) => {
+  console.error(`[@thunderid/nuxt] Callback: ${msg}`, ...args);
+};
+const Callback = defineComponent({
+  name: "Callback",
+  props: {
+    onError: { default: void 0, type: Function },
+    onNavigate: { default: void 0, type: Function }
+  },
+  setup(props) {
+    const navigate = (path) => {
+      if (props.onNavigate) {
+        props.onNavigate(path);
+      } else {
+        navigateTo(path);
+      }
+    };
+    onMounted(() => {
+      let returnPath = "/";
+      try {
+        const urlParams = new URLSearchParams(window.location.search);
+        const code = urlParams.get("code");
+        const state = urlParams.get("state");
+        const nonce = urlParams.get("nonce");
+        const oauthError = urlParams.get("error");
+        const errorDescription = urlParams.get("error_description");
+        if (!code && !state && !oauthError) {
+          return;
+        }
+        if (!state) {
+          throw new Error("Missing OAuth state parameter - possible security issue");
+        }
+        const storedData = sessionStorage.getItem(`thunderid_oauth_${state}`);
+        if (!storedData) {
+          if (oauthError) {
+            const errorMsg = errorDescription || oauthError || "OAuth authentication failed";
+            const err = new Error(errorMsg);
+            props.onError?.(err);
+            const params2 = new URLSearchParams();
+            params2.set("error", oauthError);
+            if (errorDescription) {
+              params2.set("error_description", errorDescription);
+            }
+            navigate(`/?${params2.toString()}`);
+            return;
+          }
+          throw new Error("Invalid OAuth state - possible CSRF attack");
+        }
+        const { path, timestamp } = JSON.parse(storedData);
+        returnPath = path || "/";
+        const MAX_STATE_AGE = 3e5;
+        if (Date.now() - timestamp > MAX_STATE_AGE) {
+          sessionStorage.removeItem(`thunderid_oauth_${state}`);
+          throw new Error("OAuth state expired - please try again");
+        }
+        sessionStorage.removeItem(`thunderid_oauth_${state}`);
+        if (oauthError) {
+          const errorMsg = errorDescription || oauthError || "OAuth authentication failed";
+          const err = new Error(errorMsg);
+          props.onError?.(err);
+          const params2 = new URLSearchParams();
+          params2.set("error", oauthError);
+          if (errorDescription) {
+            params2.set("error_description", errorDescription);
+          }
+          navigate(`${returnPath}?${params2.toString()}`);
+          return;
+        }
+        if (!code) {
+          throw new Error("Missing OAuth authorization code");
+        }
+        const params = new URLSearchParams();
+        params.set("code", code);
+        if (nonce) {
+          params.set("nonce", nonce);
+        }
+        navigate(`${returnPath}?${params.toString()}`);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "OAuth callback processing failed";
+        error("OAuth callback error:", err);
+        props.onError?.(err instanceof Error ? err : new Error(errorMessage));
+        const params = new URLSearchParams();
+        params.set("error", "callback_error");
+        params.set("error_description", errorMessage);
+        navigate(`${returnPath}?${params.toString()}`);
+      }
+    });
+    return () => null;
+  }
+});
+export default Callback;

package/dist/runtime/components/auth/SignIn.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { type Component } from 'vue';
+/**
+ * Nuxt-specific SignIn container for the embedded (app-native) sign-in flow.
+ *
+ * Mirrors the Vue SDK's `SignIn` container but replaces all `window.location`
+ * navigation with Nuxt's `navigateTo` so redirects after a successful embedded
+ * sign-in are SSR-safe.
+ *
+ * Uses `useThunderID()` from the Nuxt auto-import layer — the Nuxt-specific
+ * wrapper that provides Nitro-route-aware `signIn`, `signOut`, `signUp`.
+ *
+ * Delegates all UI rendering to {@link BaseSignIn} from `@thunderid/vue`, which
+ * itself is platform-aware (routes to V1 authenticator or V2 component flow).
+ *
+ * @example
+ * ```vue
+ * <ThunderIDSignIn @success="onSignIn" @error="onError" />
+ * ```
+ */
+declare const SignIn: Component;
+export default SignIn;

package/dist/runtime/components/auth/SignIn.js

@@ -0,0 +1,60 @@
+import { BaseSignIn } from "@thunderid/vue";
+import { defineComponent, h } from "vue";
+import { navigateTo } from "#app";
+import { useThunderID } from "#imports";
+const SignIn = defineComponent({
+  emits: ["error", "success"],
+  name: "SignIn",
+  props: {
+    className: { default: "", type: String },
+    size: {
+      default: "medium",
+      type: String
+    },
+    variant: {
+      default: "outlined",
+      type: String
+    }
+  },
+  setup(props, { emit, attrs }) {
+    const { signIn, afterSignInUrl, isInitialized, isLoading } = useThunderID();
+    const handleInitialize = async () => (
+      // Pass flowId='' to trigger the embedded-flow initiation path in useThunderID.
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await signIn({ flowId: "" }, {})
+    );
+    const handleOnSubmit = async (payload, request) => await signIn(payload, request);
+    const handleSuccess = async (authData) => {
+      emit("success", authData);
+      if (authData && afterSignInUrl) {
+        if (import.meta.client) {
+          const url = new URL(afterSignInUrl, window.location.origin);
+          Object.entries(authData).forEach(([key, value]) => {
+            if (value !== void 0 && value !== null) {
+              url.searchParams.append(key, String(value));
+            }
+          });
+          await navigateTo(url.pathname + url.search + url.hash);
+        } else {
+          await navigateTo(afterSignInUrl);
+        }
+      }
+    };
+    return () => h(BaseSignIn, {
+      ...attrs,
+      afterSignInUrl,
+      class: props.className,
+      isLoading: (isLoading?.value ?? false) || !(isInitialized?.value ?? true),
+      onError: (err) => emit("error", err),
+      onInitialize: handleInitialize,
+      onSubmit: handleOnSubmit,
+      onSuccess: handleSuccess,
+      showLogo: true,
+      showSubtitle: true,
+      showTitle: true,
+      size: props.size,
+      variant: props.variant
+    });
+  }
+});
+export default SignIn;