@strands.gg/accui 2.17.58 → 2.17.60

package/dist/nuxt/runtime/plugin.client.es.js

@@ -0,0 +1,21 @@
+import { defineNuxtPlugin as s, useRuntimeConfig as a } from "nuxt/app";
+import { s as d, S as c } from "../../useStrandsConfig-B2UXxIbT.es.js";
+import { u as r } from "../../useDarkMode-BdG1G2mj.es.js";
+const g = s({
+  name: "strands-auth-client",
+  async setup() {
+    const e = a().public.strandsAuth, t = {
+      ...c,
+      ...e
+    };
+    if (d(t), typeof window < "u" && (window.__STRANDS_CONFIG__ = t), t?.accentColor && typeof window < "u" && document.documentElement.style.setProperty("--strands-accent", t.accentColor), typeof window < "u") {
+      const i = t?.theme || "system";
+      r().setTheme(i);
+    }
+    const { useStrandsAuth: n } = await import("./composables/useStrandsAuth.es.js"), { initialize: o } = n();
+    await o();
+  }
+});
+export {
+  g as default
+};

package/dist/nuxt/runtime/plugin.server.cjs.js

@@ -0,0 +1 @@
+"use strict";const n=require("nuxt/app"),s=require("../../useStrandsConfig-BYOAEt9d.cjs.js"),r=n.defineNuxtPlugin({name:"strands-auth-server",setup(){const e=n.useRuntimeConfig().public.strandsAuth,t={...s.STRANDS_AUTH_DEFAULTS,...e};s.setStrandsConfig(t)}});module.exports=r;

package/dist/nuxt/runtime/plugin.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('nuxt/app').Plugin<Record<string, unknown>> & import('nuxt/app').ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/nuxt/runtime/plugin.server.es.js

@@ -0,0 +1,15 @@
+import { defineNuxtPlugin as t, useRuntimeConfig as e } from "nuxt/app";
+import { s as o, S as r } from "../../useStrandsConfig-B2UXxIbT.es.js";
+const u = t({
+  name: "strands-auth-server",
+  setup() {
+    const s = e().public.strandsAuth, n = {
+      ...r,
+      ...s
+    };
+    o(n);
+  }
+});
+export {
+  u as default
+};

package/dist/nuxt/runtime/plugins/auth-interceptor.client.cjs.js

@@ -0,0 +1 @@
+"use strict";const a=require("nuxt/app"),l=a.defineNuxtPlugin({name:"strands-auth-interceptor",setup(){if(process.server)return;const t=globalThis.fetch;globalThis.fetch=async(e,o)=>{try{let s;if(typeof e=="string"?s=e:e instanceof URL?s=e.toString():s=e.url,p(s)){const c={...o,credentials:"include"};return t(e,c)}return t(e,o)}catch(s){return console.error("[Strands Auth] Error in fetch interceptor:",s),t(e,o)}}}});function p(t){if(!t.startsWith("http")||["googleapis.com","github.com/api","api.github.com","discord.com/api","graph.microsoft.com","api.stripe.com","api.twilio.com"].some(r=>t.includes(r)))return!1;const i=["/api/","/v1/","/v2/","/graphql","/trpc"].some(r=>t.includes(r)),n=[":3001",":8000",":8080",":5000",":4000"].some(r=>t.includes(r));return i||n}module.exports=l;

package/dist/nuxt/runtime/plugins/auth-interceptor.client.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Auth interceptor plugin for Nuxt
+ *
+ * With HTTP-only cookies, we no longer need to inject Authorization headers.
+ * This interceptor now only adds `credentials: 'include'` to API requests
+ * so that cookies are sent automatically.
+ */
+declare const _default: import('nuxt/app').Plugin<Record<string, unknown>> & import('nuxt/app').ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/nuxt/runtime/plugins/auth-interceptor.client.es.js

@@ -0,0 +1,46 @@
+import { defineNuxtPlugin as a } from "nuxt/app";
+const h = a({
+  name: "strands-auth-interceptor",
+  setup() {
+    if (process.server) return;
+    const t = globalThis.fetch;
+    globalThis.fetch = async (e, o) => {
+      try {
+        let s;
+        if (typeof e == "string" ? s = e : e instanceof URL ? s = e.toString() : s = e.url, l(s)) {
+          const n = {
+            ...o,
+            credentials: "include"
+          };
+          return t(e, n);
+        }
+        return t(e, o);
+      } catch (s) {
+        return console.error("[Strands Auth] Error in fetch interceptor:", s), t(e, o);
+      }
+    };
+  }
+});
+function l(t) {
+  if (!t.startsWith("http") || [
+    "googleapis.com",
+    "github.com/api",
+    "api.github.com",
+    "discord.com/api",
+    "graph.microsoft.com",
+    "api.stripe.com",
+    "api.twilio.com"
+  ].some((r) => t.includes(r)))
+    return !1;
+  const i = [
+    "/api/",
+    "/v1/",
+    "/v2/",
+    "/graphql",
+    "/trpc"
+  ].some((r) => t.includes(r)), c = [":3001", ":8000", ":8080", ":5000", ":4000"].some((r) => t.includes(r));
+  return i || c;
+}
+export {
+  h as default
+};

package/dist/nuxt/types.d.ts

@@ -0,0 +1,51 @@
+export interface StrandsUser {
+    id: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    avatar?: string;
+    mfaEnabled: boolean;
+    emailVerified: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface StrandsSession {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: Date;
+    user: StrandsUser;
+}
+declare module '@nuxt/schema' {
+    interface PublicRuntimeConfig {
+        strandsAuth?: {
+            baseUrl?: string;
+            applicationId?: string;
+            publicKey?: string;
+            accentColor?: string;
+            redirectUrl?: string;
+            onSignInUrl?: string;
+            onSignOutUrl?: string;
+            authUrl?: string;
+            /** @deprecated OAuth providers are now dynamically fetched from API */
+            oauthProviders?: string[];
+            autoRefresh?: boolean;
+            refreshInterval?: number;
+            protectedRoutes?: string[];
+            guestOnlyRoutes?: string[];
+            devMode?: boolean;
+            /**
+             * Theme mode for the UI components
+             * @default 'system'
+             */
+            theme?: 'light' | 'dark' | 'system';
+        };
+    }
+}
+declare module 'nuxt/app' {
+    interface NuxtApp {
+        $strandsAuth: {
+            accentColor: string;
+        };
+    }
+}
+export {};

package/dist/nuxt.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const u=require("./nuxt/module.cjs.js"),e=require("./nuxt/runtime/composables/useStrandsAuth.cjs.js"),t=require("./nuxt/runtime/composables/useAuthenticatedFetch.cjs.js");exports.default=u;exports.useAuthState=e.useAuthState;exports.useAuthUser=e.useAuthUser;exports.useStrandsAuth=e.useStrandsAuth;exports.$authFetch=t.$authFetch;exports.useAuthenticatedFetch=t.useAuthenticatedFetch;

package/dist/nuxt.d.ts

@@ -0,0 +1,4 @@
+export { default } from './nuxt/module';
+export type { StrandsAuthConfig, StrandsAuthEndpoints } from './types';
+export { useStrandsAuth, useAuthUser, useAuthState } from './nuxt/runtime/composables/useStrandsAuth';
+export { useAuthenticatedFetch, $authFetch } from './nuxt/runtime/composables/useAuthenticatedFetch';

package/dist/nuxt.es.js

@@ -0,0 +1,11 @@
+import { default as u } from "./nuxt/module.es.js";
+import { useAuthState as h, useAuthUser as o, useStrandsAuth as s } from "./nuxt/runtime/composables/useStrandsAuth.es.js";
+import { $authFetch as f, useAuthenticatedFetch as A } from "./nuxt/runtime/composables/useAuthenticatedFetch.es.js";
+export {
+  f as $authFetch,
+  u as default,
+  h as useAuthState,
+  o as useAuthUser,
+  A as useAuthenticatedFetch,
+  s as useStrandsAuth
+};

package/dist/robots.txt

@@ -0,0 +1,4 @@
+User-agent: *
+Allow: /
+
+Sitemap: https://strandsui.com/sitemap.xml

package/dist/shared/defaults.d.ts

@@ -0,0 +1,2 @@
+import { StrandsAuthConfig } from '../types';
+export declare const STRANDS_AUTH_DEFAULTS: Required<Omit<StrandsAuthConfig, 'clientId' | 'supportEmail' | 'oauth2RedirectUrl' | 'onSignOutUrl' | 'onSignInUrl' | 'redirectUrl' | 'authUrl'>>;

package/dist/sitemap.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://strandsui.com/</loc>
+    <lastmod>2025-01-15</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>1.0</priority>
+  </url>
+</urlset>

package/dist/types/composables.d.ts

@@ -0,0 +1,97 @@
+import { ComputedRef, Ref } from 'vue';
+import { User, Session, SignInCredentials, SignUpData, SessionInfo, SessionStats, MfaDevice, StrandsAuthConfig, StrandsAuthEndpoints, AuthenticatedFetchOptions } from './index';
+export interface UseStrandsAuthReturn {
+    user: ComputedRef<User | null>;
+    currentUser: ComputedRef<User | null>;
+    currentSession: ComputedRef<Session | null>;
+    isAuthenticated: ComputedRef<boolean>;
+    isLoading: ComputedRef<boolean>;
+    loading: ComputedRef<boolean>;
+    loadingMessage: ComputedRef<string>;
+    isInitializing: ComputedRef<boolean>;
+    isInitialized: ComputedRef<boolean>;
+    isSigningIn: ComputedRef<boolean>;
+    isSigningUp: ComputedRef<boolean>;
+    isSigningOut: ComputedRef<boolean>;
+    isRefreshingToken: ComputedRef<boolean>;
+    isSendingMfaEmail: ComputedRef<boolean>;
+    isVerifyingMfa: ComputedRef<boolean>;
+    mfaRequired: ComputedRef<boolean>;
+    mfaSessionId: ComputedRef<string | null>;
+    availableMfaMethods: ComputedRef<MfaDevice[]>;
+    signIn: (credentials: SignInCredentials) => Promise<any>;
+    signUp: (userData: SignUpData) => Promise<void>;
+    signOut: () => Promise<void>;
+    refreshToken: () => Promise<boolean>;
+    fetchProfile: () => Promise<User>;
+    updateProfile: (updates: Partial<User>) => Promise<User>;
+    updateUserSettings: (settings: any) => Promise<User>;
+    changeEmail: (newEmail: string, password: string) => Promise<void>;
+    changeUsername: (newUsername: string) => Promise<void>;
+    getUsernameCooldown: () => Promise<{
+        canChange: boolean;
+        cooldownEndsAt?: Date;
+    }>;
+    checkUsernameAvailability: (username: string) => Promise<{
+        available: boolean;
+        suggestion?: string;
+    }>;
+    getUserSessions: () => Promise<SessionInfo[]>;
+    getSessionStats: () => Promise<SessionStats>;
+    revokeSession: (sessionId: string) => Promise<boolean>;
+    revokeAllOtherSessions: () => Promise<boolean>;
+    initialize: () => Promise<void>;
+    forceReInit: () => void;
+    setAuthData: (authData: any) => Promise<void>;
+    verifyMfa: (code: string, method?: string) => Promise<any>;
+    sendMfaEmailCode: (deviceId: string) => Promise<any>;
+    getMfaWebAuthnChallenge: (deviceId: string) => Promise<any>;
+    registerHardwareKey: (deviceName: string, accessToken: string, deviceType?: 'hardware' | 'passkey') => Promise<any>;
+    completeHardwareKeyRegistration: (deviceId: string, credential: any, accessToken: string) => Promise<any>;
+    startTokenRefreshTimer: () => void;
+    stopTokenRefreshTimer: () => void;
+    getAuthHeaders: () => Record<string, string>;
+}
+export interface UseStrandsConfigReturn {
+    config: ComputedRef<StrandsAuthConfig>;
+    endpoints: ComputedRef<StrandsAuthEndpoints>;
+    getUrl: (endpoint: keyof StrandsAuthEndpoints | string) => string;
+    getSupportEmail: () => string | null;
+}
+export interface UseAuthenticatedFetchReturn {
+    $fetch: <T = any>(url: string, options?: AuthenticatedFetchOptions) => Promise<T>;
+    isLoading: Ref<boolean>;
+    error: Ref<Error | null>;
+}
+export interface UseOAuthProvidersReturn {
+    providers: ComputedRef<any[]>;
+    loading: Ref<boolean>;
+    fetchProviders: () => Promise<void>;
+}
+export interface UseThemeReturn {
+    isDark: Ref<boolean>;
+    toggleTheme: () => void;
+    setTheme: (dark: boolean) => void;
+}
+export interface UseFloatingPositionReturn {
+    x: Ref<number>;
+    y: Ref<number>;
+    placement: Ref<string>;
+    update: () => void;
+}
+export interface UseModalStackReturn {
+    modalStack: Ref<string[]>;
+    pushModal: (id: string) => void;
+    popModal: () => void;
+    isTopModal: (id: string) => boolean;
+}
+export interface UseModalTeleportReturn {
+    teleportTarget: Ref<string>;
+    updateTeleportTarget: () => void;
+}
+export interface UseGlobalModalStackReturn {
+    globalModalStack: Ref<string[]>;
+    addModal: (id: string) => void;
+    removeModal: (id: string) => void;
+    isTopModal: (id: string) => boolean;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,263 @@
+export interface User {
+    id: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    avatar?: string;
+    mfaEnabled: boolean;
+    emailVerified: boolean;
+    passwordUpdatedAt?: string | Date;
+    settings?: any;
+    xp: number;
+    level: number;
+    next_level_xp: number;
+    username?: string;
+    usernameLastChangedAt?: string | Date;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}
+export interface AuthenticatedFetchOptions extends RequestInit {
+    /**
+     * Whether to automatically refresh token if the request fails with 401
+     * @default true
+     */
+    autoRefresh?: boolean;
+    /**
+     * Whether to throw an error if user is not authenticated
+     * @default true
+     */
+    requireAuth?: boolean;
+    /**
+     * Base URL for the API requests
+     * If not provided, will use the current origin
+     */
+    baseURL?: string;
+}
+export interface Session {
+    id?: string;
+    userId?: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: Date;
+    createdAt?: Date;
+}
+export interface SessionInfo {
+    id: string;
+    device_name?: string;
+    device_type?: string;
+    ip_address?: string;
+    country?: string;
+    city?: string;
+    application_domain?: string;
+    application_name?: string;
+    created_at: string | Date;
+    last_activity_at?: string | Date;
+    is_current: boolean;
+}
+export interface SessionStats {
+    total_sessions: number;
+    active_sessions: number;
+    devices_by_type: Record<string, number>;
+    unique_locations: string[];
+}
+export interface AuthConfig {
+    apiUrl: string;
+    applicationId: string;
+    publicKey: string;
+    autoRefresh?: boolean;
+    redirectUrl?: string;
+}
+export interface SignInCredentials {
+    email: string;
+    password: string;
+}
+export interface SignUpData {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+}
+export interface OAuthProvider {
+    id: string;
+    name: string;
+    enabled: boolean;
+    clientId?: string;
+    scopes?: string[];
+}
+export interface StrandsAuthConfig {
+    /**
+     * Base URL for the Strands Auth API
+     * @default 'https://your-api.example.com'
+     */
+    baseUrl?: string;
+    /**
+     * Client ID for authentication (optional - authentication is now based on domain)
+     */
+    clientId?: string;
+    /**
+     * Primary accent color for the auth components
+     * @default '#EA00A8'
+     */
+    accentColor?: string;
+    /**
+     * Default redirect URL after successful authentication
+     * @default '/'
+     */
+    redirectUrl?: string;
+    /**
+     * URL to redirect to after successful sign in
+     * @default '/dashboard'
+     */
+    onSignInUrl?: string;
+    /**
+     * URL to redirect to after successful sign out
+     * @default '/'
+     */
+    onSignOutUrl?: string;
+    /**
+     * URL of the authentication/login page (where unauthenticated users are redirected)
+     * @default '/auth'
+     */
+    authUrl?: string;
+    /**
+     * Enable automatic token refresh
+     * @default true
+     */
+    autoRefresh?: boolean;
+    /**
+     * Token refresh interval in minutes
+     * @default 4
+     */
+    refreshInterval?: number;
+    /**
+     * Pages that should redirect to sign in if user is not authenticated
+     * @default []
+     */
+    protectedRoutes?: string[];
+    /**
+     * Pages that should redirect away if user IS authenticated
+     * @default ['/auth', '/login', '/register']
+     */
+    guestOnlyRoutes?: string[];
+    /**
+     * Enable development mode (shows debug info)
+     * @default false
+     */
+    devMode?: boolean;
+    /**
+     * Support email address for contact links
+     * @optional
+     */
+    supportEmail?: string;
+    /**
+     * OAuth2 redirect URL for OAuth providers
+     * If not specified, will use {origin}/auth/callback
+     * @optional
+     */
+    oauth2RedirectUrl?: string;
+    /**
+     * Automatically import CSS styles
+     * Set to false if you want to manually import styles or use custom styling
+     * @default true
+     */
+    styles?: boolean;
+    /**
+     * Custom API endpoints
+     */
+    endpoints?: Partial<StrandsAuthEndpoints>;
+    /**
+     * Enable squircle corners for UI components
+     * @default true
+     */
+    useSquircle?: boolean;
+    /**
+     * Theme mode for the UI components
+     * - 'light': Force light mode
+     * - 'dark': Force dark mode
+     * - 'system': Follow system preference (default)
+     * @default 'system'
+     */
+    theme?: 'light' | 'dark' | 'system';
+}
+export interface StrandsAuthEndpoints {
+    signIn: string;
+    signUp: string;
+    signOut: string;
+    refresh: string;
+    authStatus: string;
+    passwordReset: string;
+    passwordResetConfirm: string;
+    completeRegistration: string;
+    profile: string;
+    verifyEmail: string;
+    oauthProviders: string;
+    oauthProvider: string;
+    changeEmail: string;
+    avatar: string;
+    settings: string;
+    changeUsername: string;
+    usernameCooldown: string;
+    checkUsernameAvailability: string;
+    mfaDevices: string;
+    mfaTotpSetup: string;
+    mfaTotpVerify: string;
+    mfaEmailSetup: string;
+    mfaEmailSend: string;
+    mfaEmailVerify: string;
+    mfaDeviceDisable: string;
+    mfaBackupCodes: string;
+    mfaHardwareStartRegistration: string;
+    mfaHardwareCompleteRegistration: string;
+    mfaSigninSendEmail: string;
+    mfaSigninVerify: string;
+    mfaBackupCodeVerify: string;
+    mfaWebAuthnChallenge: string;
+    sessions: string;
+    sessionsStats: string;
+    sessionRevoke: string;
+    sessionsRevokeAll: string;
+}
+export interface AuthResponse {
+    access_token: string;
+    refresh_token: string;
+    user: User;
+    mfa_required?: boolean;
+    mfa_session_id?: string;
+    available_mfa_methods?: MfaDevice[];
+}
+export interface AuthStatusResponse {
+    authenticated: boolean;
+    user: User | null;
+    /** Unix timestamp (seconds) when the access token expires */
+    expires_at?: number;
+}
+export type MfaDeviceType = 'totp' | 'email' | 'hardware' | 'passkey';
+export interface MfaDevice {
+    id: string;
+    device_type: MfaDeviceType;
+    device_name: string;
+    is_active: boolean;
+    last_used_at?: string | Date;
+    created_at: string | Date;
+}
+export interface MfaDevicesResponse {
+    devices: MfaDevice[];
+    mfa_enabled: boolean;
+}
+export interface TotpSetupResponse {
+    device_id: string;
+    secret: string;
+    qr_code_url: string;
+    backup_codes: string[];
+}
+export interface BackupCodesResponse {
+    backup_codes: string[];
+}
+export interface MfaErrorResponse {
+    code: string;
+    message: string;
+    mfa_session_id?: string;
+    available_methods?: string[];
+}
+export type * from './composables';
+export * from './oauth';