@nebulr-group/bridge-svelte 0.1.0-beta.0

package/dist/client/utils/cn.d.ts

@@ -0,0 +1 @@
+export declare function cn(...classes: (string | undefined | null | false)[]): string;

package/dist/client/utils/cn.js

@@ -0,0 +1,3 @@
+export function cn(...classes) {
+    return classes.filter(Boolean).join(' ');
+}

package/dist/core/bridge-instance.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Singleton BridgeAuth instance + Svelte store adapter.
+ *
+ * This is the architectural keystone of the bridge-svelte ↔ auth-core integration.
+ * It creates a single BridgeAuth instance and wires its events to Svelte stores
+ * so that consumers can keep using `$auth.isAuthenticated`, `$profileStore.profile`, etc.
+ */
+import { BridgeAuth, type AppConfig, type AuthState, type BridgeAuthConfig, type Plan, type Profile, type SubscriptionStatus, type TenantUser, type TokenSet } from '@nebulr-group/bridge-auth-core';
+import { type Readable, type Writable } from 'svelte/store';
+export declare function initBridge(config: BridgeAuthConfig): BridgeAuth;
+export declare function getBridgeAuth(): BridgeAuth;
+export declare function markReady(): void;
+export declare function waitForBridge(): Promise<void>;
+/** Token store — readable. Use `getBridgeAuth()` methods to mutate. */
+export declare const tokenStore: Readable<TokenSet | null>;
+/** Whether user is authenticated */
+export declare const isAuthenticated: Readable<boolean>;
+/** Auth loading state */
+export declare const isLoading: Readable<boolean>;
+/** Last auth error */
+export declare const authError: Readable<string | null>;
+/** Current auth state machine state */
+export declare const authState: Readable<AuthState>;
+/** User profile (undefined = loading, null = no profile, Profile = loaded) */
+export declare const profileStore: Readable<Profile | null | undefined>;
+/** Whether user has completed onboarding */
+export declare const isOnboarded: Readable<boolean>;
+/** Whether user has access to multiple tenants */
+export declare const hasMultiTenantAccess: Readable<boolean>;
+/** Tenant users for multi-tenant selection */
+export declare const tenantUsersStore: Readable<TenantUser[]>;
+/** Feature flags map */
+export declare const flagsStore: Readable<Record<string, boolean>>;
+/** Bridge ready state */
+export declare const bridgeReadyStore: Readable<boolean>;
+/** App-level config (SSO providers, feature flags, etc.) — loaded anonymously on init */
+export declare const appConfigStore: Readable<AppConfig | null>;
+interface SubscriptionState {
+    status: SubscriptionStatus | null;
+    plans: Plan[] | null;
+    loading: boolean;
+    error: string | null;
+}
+/** Subscription status + plan list */
+export declare const subscriptionStore: Readable<SubscriptionState>;
+export declare function loadSubscription(): Promise<void>;
+/** Lazy proxy to the BridgeAuth singleton — call methods directly: `auth.getToken()`, `auth.logout()`, etc. */
+export declare const auth: BridgeAuth;
+export declare const _flagsWritable: Writable<Record<string, boolean>>;
+export declare const _profileWritable: Writable<Profile | null | undefined>;
+export declare const _errorWritable: Writable<string | null>;
+export {};

package/dist/core/bridge-instance.js

@@ -0,0 +1,160 @@
+/**
+ * Singleton BridgeAuth instance + Svelte store adapter.
+ *
+ * This is the architectural keystone of the bridge-svelte ↔ auth-core integration.
+ * It creates a single BridgeAuth instance and wires its events to Svelte stores
+ * so that consumers can keep using `$auth.isAuthenticated`, `$profileStore.profile`, etc.
+ */
+import { BridgeAuth } from '@nebulr-group/bridge-auth-core';
+import { derived, get, writable } from 'svelte/store';
+import { logger } from '../shared/logger.js';
+// ── Singleton ──────────────────────────────────────────────────────────────────
+let _instance = null;
+// ── Svelte stores (writable internally, exported as readable) ──────────────────
+const _tokens = writable(null);
+const _appConfig = writable(null);
+const _profile = writable(undefined);
+const _flags = writable({});
+const _authState = writable('unauthenticated');
+const _isLoading = writable(true);
+const _error = writable(null);
+const _tenantUsers = writable([]);
+const _isAuthenticated = derived(_tokens, ($t) => !!$t?.accessToken);
+const _isOnboarded = derived(_profile, ($p) => $p?.onboarded ?? false);
+const _hasMultiTenantAccess = derived(_profile, ($p) => $p?.multiTenantAccess ?? false);
+// ── Ready gate ─────────────────────────────────────────────────────────────────
+const _ready = writable(false);
+let _resolveReady = null;
+const _readyPromise = new Promise((resolve) => {
+    _resolveReady = resolve;
+});
+// ── Init / access ──────────────────────────────────────────────────────────────
+export function initBridge(config) {
+    if (_instance) {
+        logger.debug('[bridge-instance] already initialized, returning existing');
+        return _instance;
+    }
+    _instance = new BridgeAuth(config);
+    // Seed stores from current auth-core state
+    const existingTokens = _instance.getTokens();
+    if (existingTokens) {
+        _tokens.set(existingTokens);
+        // Fetch profile for existing tokens
+        _instance.getProfile().then((p) => _profile.set(p ?? null)).catch(() => { });
+    }
+    _authState.set(_instance.getAuthState());
+    _isLoading.set(false);
+    // Wire auth-core events → Svelte stores
+    _instance.on('auth:login', (tokens) => {
+        _tokens.set(tokens);
+        _instance.getProfile().then((p) => _profile.set(p ?? null)).catch(() => { });
+    });
+    _instance.on('auth:logout', () => {
+        _tokens.set(null);
+        _profile.set(null);
+        _flags.set({});
+    });
+    _instance.on('auth:token-refreshed', (tokens) => {
+        _tokens.set(tokens);
+    });
+    _instance.on('auth:state-change', (state) => {
+        _authState.set(state);
+        if (state === 'tenant-selection') {
+            _tenantUsers.set(_instance.getTenantUsers());
+        }
+        else if (state === 'authenticated' || state === 'unauthenticated') {
+            _tenantUsers.set([]);
+        }
+    });
+    _instance.on('auth:profile', (profile) => {
+        _profile.set(profile);
+    });
+    _instance.on('auth:workspace-changed', (tokens) => {
+        _tokens.set(tokens);
+        _flags.set({});
+        _subscriptionWritable.set({ status: null, plans: null, loading: false, error: null });
+        _instance.getProfile().then((p) => _profile.set(p ?? null)).catch(() => { });
+    });
+    _instance.on('auth:error', (err) => {
+        _error.set(err.message);
+    });
+    // Load app config anonymously (drives SSO buttons etc.)
+    _instance.getAppConfig().then((cfg) => _appConfig.set(cfg)).catch(() => { });
+    logger.debug('[bridge-instance] initialized');
+    return _instance;
+}
+export function getBridgeAuth() {
+    if (!_instance) {
+        throw new Error('BridgeAuth not initialized. Call initBridge() first (via bridgeConfig.initConfig).');
+    }
+    return _instance;
+}
+export function markReady() {
+    if (get(_ready))
+        return;
+    _ready.set(true);
+    _resolveReady?.();
+}
+export function waitForBridge() {
+    return _readyPromise;
+}
+// ── Store exports ──────────────────────────────────────────────────────────────
+/** Token store — readable. Use `getBridgeAuth()` methods to mutate. */
+export const tokenStore = _tokens;
+/** Whether user is authenticated */
+export const isAuthenticated = _isAuthenticated;
+/** Auth loading state */
+export const isLoading = _isLoading;
+/** Last auth error */
+export const authError = _error;
+/** Current auth state machine state */
+export const authState = _authState;
+/** User profile (undefined = loading, null = no profile, Profile = loaded) */
+export const profileStore = _profile;
+/** Whether user has completed onboarding */
+export const isOnboarded = _isOnboarded;
+/** Whether user has access to multiple tenants */
+export const hasMultiTenantAccess = _hasMultiTenantAccess;
+/** Tenant users for multi-tenant selection */
+export const tenantUsersStore = _tenantUsers;
+/** Feature flags map */
+export const flagsStore = _flags;
+/** Bridge ready state */
+export const bridgeReadyStore = _ready;
+/** App-level config (SSO providers, feature flags, etc.) — loaded anonymously on init */
+export const appConfigStore = _appConfig;
+const _subscriptionWritable = writable({
+    status: null,
+    plans: null,
+    loading: false,
+    error: null,
+});
+/** Subscription status + plan list */
+export const subscriptionStore = _subscriptionWritable;
+export async function loadSubscription() {
+    _subscriptionWritable.update((s) => ({ ...s, loading: true, error: null }));
+    try {
+        const [status, plans] = await Promise.all([
+            getBridgeAuth().getSubscriptionStatus(),
+            getBridgeAuth().getPlans(),
+        ]);
+        _subscriptionWritable.set({ status, plans, loading: false, error: null });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Failed to load subscription';
+        _subscriptionWritable.update((s) => ({ ...s, loading: false, error: msg }));
+    }
+}
+// ── Convenience singleton accessor ────────────────────────────────────────────
+/** Lazy proxy to the BridgeAuth singleton — call methods directly: `auth.getToken()`, `auth.logout()`, etc. */
+export const auth = new Proxy({}, {
+    get(_, prop) {
+        const instance = getBridgeAuth();
+        const value = instance[prop];
+        return typeof value === 'function' ? value.bind(instance) : value;
+    },
+});
+// ── Internal-only store writers (for use by wrapper modules) ───────────────────
+export const _flagsWritable = _flags;
+export const _profileWritable = _profile;
+export const _errorWritable = _error;

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+export * from './client/BridgeBootstrap.js';
+export * from './client/stores/config.store.js';
+export { initBridge, getBridgeAuth, markReady, waitForBridge, auth, tokenStore, isAuthenticated, isLoading, authError, authState, isOnboarded, hasMultiTenantAccess, tenantUsersStore, profileStore, flagsStore, bridgeReadyStore, appConfigStore, subscriptionStore, loadSubscription, } from './core/bridge-instance.js';
+export { default as BridgeBootstrap, default as BridgeProvider } from './client/BridgeBootstrap.svelte';
+export { default as ApiTokenManagement } from './client/components/developer/ApiTokenManagement.svelte';
+export { default as FeatureFlag } from './client/components/FeatureFlag.svelte';
+export { default as ProfileName } from './client/components/ProfileName.svelte';
+export { default as TeamManagementPanel } from './client/components/team/TeamManagementPanel.svelte';
+export { default as TeamUserList } from './client/components/team/TeamUserList.svelte';
+export { default as TeamProfileForm } from './client/components/team/TeamProfileForm.svelte';
+export { default as TeamWorkspaceForm } from './client/components/team/TeamWorkspaceForm.svelte';
+export { default as LoginForm } from './client/components/sdk-auth/LoginForm.svelte';
+export { default as MfaChallenge } from './client/components/sdk-auth/MfaChallenge.svelte';
+export { default as MfaSetup } from './client/components/sdk-auth/MfaSetup.svelte';
+export { default as TenantSelector } from './client/components/sdk-auth/TenantSelector.svelte';
+export { default as WorkspaceSelector } from './client/components/sdk-auth/WorkspaceSelector.svelte';
+export { default as SsoButton } from './client/components/sdk-auth/SsoButton.svelte';
+export { default as SignupForm } from './client/components/sdk-auth/SignupForm.svelte';
+export { default as ForgotPassword } from './client/components/sdk-auth/ForgotPassword.svelte';
+export { default as MagicLink } from './client/components/sdk-auth/MagicLink.svelte';
+export { default as PasskeyLogin } from './client/components/sdk-auth/PasskeyLogin.svelte';
+export { default as PasskeyRequestSetupLink } from './client/components/sdk-auth/PasskeyRequestSetupLink.svelte';
+export { default as PasskeySetup } from './client/components/sdk-auth/PasskeySetup.svelte';
+export { default as PlanSelector } from './client/components/subscription/PlanSelector.svelte';
+export * from './shared/feature-flag.js';
+export * from './auth/route-guard.js';
+export * from './shared/profile.js';
+export * from './shared/types/config.js';
+export { logger, setLoggerDebug } from './shared/logger.js';
+export type { AuthConfigResponse, AuthResult, AuthState, BridgeAuthConfig, BridgeAuthEventName, BridgeAuthEvents, FederationConnection, MagicLinkResult, MfaResult, PasskeyAuthOptions, PasskeyRegistrationOptions, PasskeyVerificationResult, SignupResult, SsoOptions, SsoResult, TenantUser, } from '@nebulr-group/bridge-auth-core';
+export { BridgeAuth, BridgeAuthError, HttpError, TeamService, ApiTokenService } from '@nebulr-group/bridge-auth-core';
+export type { ApiToken, CreateApiTokenInput, CreateApiTokenResponse, } from '@nebulr-group/bridge-auth-core';
+export type { TeamProfile, TeamProfileUpdateInput, TeamUser, TeamUserListResult, TeamUserUpdateInput, TeamWorkspace, TeamWorkspaceUpdateInput, } from '@nebulr-group/bridge-auth-core';
+export type { Plan, PriceOfferSdk, SubscriptionStatus, CheckoutSession, Workspace, } from '@nebulr-group/bridge-auth-core';

package/dist/index.js

@@ -0,0 +1,39 @@
+// Core stores and setup
+export * from './client/BridgeBootstrap.js';
+export * from './client/stores/config.store.js';
+// Bridge instance (singleton + Svelte stores)
+export { initBridge, getBridgeAuth, markReady, waitForBridge, auth, tokenStore, isAuthenticated, isLoading, authError, authState, isOnboarded, hasMultiTenantAccess, tenantUsersStore, profileStore, flagsStore, bridgeReadyStore, appConfigStore, subscriptionStore, loadSubscription, } from './core/bridge-instance.js';
+// Components (Svelte components must have `export default`)
+export { default as BridgeBootstrap, default as BridgeProvider } from './client/BridgeBootstrap.svelte';
+export { default as ApiTokenManagement } from './client/components/developer/ApiTokenManagement.svelte';
+export { default as FeatureFlag } from './client/components/FeatureFlag.svelte';
+export { default as ProfileName } from './client/components/ProfileName.svelte';
+export { default as TeamManagementPanel } from './client/components/team/TeamManagementPanel.svelte';
+export { default as TeamUserList } from './client/components/team/TeamUserList.svelte';
+export { default as TeamProfileForm } from './client/components/team/TeamProfileForm.svelte';
+export { default as TeamWorkspaceForm } from './client/components/team/TeamWorkspaceForm.svelte';
+// SDK Auth Components
+export { default as LoginForm } from './client/components/sdk-auth/LoginForm.svelte';
+export { default as MfaChallenge } from './client/components/sdk-auth/MfaChallenge.svelte';
+export { default as MfaSetup } from './client/components/sdk-auth/MfaSetup.svelte';
+export { default as TenantSelector } from './client/components/sdk-auth/TenantSelector.svelte';
+export { default as WorkspaceSelector } from './client/components/sdk-auth/WorkspaceSelector.svelte';
+export { default as SsoButton } from './client/components/sdk-auth/SsoButton.svelte';
+export { default as SignupForm } from './client/components/sdk-auth/SignupForm.svelte';
+export { default as ForgotPassword } from './client/components/sdk-auth/ForgotPassword.svelte';
+export { default as MagicLink } from './client/components/sdk-auth/MagicLink.svelte';
+export { default as PasskeyLogin } from './client/components/sdk-auth/PasskeyLogin.svelte';
+export { default as PasskeyRequestSetupLink } from './client/components/sdk-auth/PasskeyRequestSetupLink.svelte';
+export { default as PasskeySetup } from './client/components/sdk-auth/PasskeySetup.svelte';
+// Subscription components
+export { default as PlanSelector } from './client/components/subscription/PlanSelector.svelte';
+// Feature flags
+export * from './shared/feature-flag.js';
+// Auth route guards
+export * from './auth/route-guard.js';
+// Types
+export * from './shared/profile.js';
+export * from './shared/types/config.js';
+// Logger
+export { logger, setLoggerDebug } from './shared/logger.js';
+export { BridgeAuth, BridgeAuthError, HttpError, TeamService, ApiTokenService } from '@nebulr-group/bridge-auth-core';

package/dist/shared/feature-flag.d.ts

@@ -0,0 +1,6 @@
+export declare function loadFeatureFlags(): Promise<void>;
+export declare function isFeatureEnabled(flag: string, forceLive?: boolean): Promise<boolean>;
+export declare const featureFlags: {
+    flags: import("svelte/store").Writable<Record<string, boolean>>;
+    refresh: typeof loadFeatureFlags;
+};

package/dist/shared/feature-flag.js

@@ -0,0 +1,13 @@
+// src/lib/shared/feature-flag.ts — thin wrapper delegating to bridge-instance
+import { getBridgeAuth, _flagsWritable, flagsStore } from '../core/bridge-instance.js';
+export async function loadFeatureFlags() {
+    const flags = await getBridgeAuth().loadFeatureFlags();
+    _flagsWritable.set(flags);
+}
+export async function isFeatureEnabled(flag, forceLive = false) {
+    return getBridgeAuth().isFeatureEnabled(flag, { forceLive });
+}
+export const featureFlags = {
+    flags: flagsStore,
+    refresh: loadFeatureFlags
+};

package/dist/shared/logger.d.ts

@@ -0,0 +1,18 @@
+type LogMethod = (...args: unknown[]) => void;
+export declare function setLoggerDebug(debug: boolean): void;
+export declare const logger: {
+    readonly debug: (...args: unknown[]) => void;
+    readonly log: (...args: unknown[]) => void;
+    readonly info: (...args: unknown[]) => void;
+    readonly warn: (...args: unknown[]) => void;
+    readonly error: (...args: unknown[]) => void;
+    readonly withPrefix: (prefix: string) => {
+        readonly debug: (...args: unknown[]) => void;
+        readonly log: (...args: unknown[]) => void;
+        readonly info: (...args: unknown[]) => void;
+        readonly warn: LogMethod;
+        readonly error: LogMethod;
+    };
+};
+export type Logger = typeof logger;
+export {};

package/dist/shared/logger.js

@@ -0,0 +1,32 @@
+let _debug = false;
+export function setLoggerDebug(debug) {
+    _debug = debug;
+}
+function createPrefixed(method, prefix) {
+    return (...args) => method(prefix, ...args);
+}
+export const logger = {
+    debug: (...args) => {
+        if (_debug)
+            console.log(...args);
+    },
+    log: (...args) => {
+        if (_debug)
+            console.log(...args);
+    },
+    info: (...args) => {
+        if (_debug)
+            console.info(...args);
+    },
+    warn: (...args) => console.warn(...args),
+    error: (...args) => console.error(...args),
+    withPrefix(prefix) {
+        return {
+            debug: (...args) => logger.debug(prefix, ...args),
+            log: (...args) => logger.log(prefix, ...args),
+            info: (...args) => logger.info(prefix, ...args),
+            warn: createPrefixed(console.warn, prefix),
+            error: createPrefixed(console.error, prefix)
+        };
+    }
+};

package/dist/shared/profile.d.ts

@@ -0,0 +1,18 @@
+import { _errorWritable } from '../core/bridge-instance.js';
+export type { IDToken, Profile } from '@nebulr-group/bridge-auth-core';
+export declare const profileStore: {
+    /** User profile (undefined = loading, null = no profile, Profile = loaded) */
+    profile: import("svelte/store").Readable<import("@nebulr-group/bridge-auth-core").Profile | null | undefined>;
+    /** Last profile error */
+    error: typeof _errorWritable;
+    /** Whether user has completed onboarding */
+    isOnboarded: import("svelte/store").Readable<boolean>;
+    /** Whether user has access to multiple tenants */
+    hasMultiTenantAccess: import("svelte/store").Readable<boolean>;
+    /** Refresh profile from auth-core */
+    updateProfile: () => Promise<void>;
+    /** Synchronous access to current profile */
+    getProfile: () => import("@nebulr-group/bridge-auth-core").Profile | null;
+    /** Clear profile */
+    clear: () => void;
+};

package/dist/shared/profile.js

@@ -0,0 +1,25 @@
+// src/lib/auth/profile.ts — thin wrapper delegating to bridge-instance
+import { get } from 'svelte/store';
+import { getBridgeAuth, profileStore as _profileReadable, _profileWritable, _errorWritable, isOnboarded, hasMultiTenantAccess, } from '../core/bridge-instance.js';
+export const profileStore = {
+    /** User profile (undefined = loading, null = no profile, Profile = loaded) */
+    profile: _profileReadable,
+    /** Last profile error */
+    error: _errorWritable,
+    /** Whether user has completed onboarding */
+    isOnboarded,
+    /** Whether user has access to multiple tenants */
+    hasMultiTenantAccess,
+    /** Refresh profile from auth-core */
+    updateProfile: async () => {
+        const profile = await getBridgeAuth().getProfile();
+        _profileWritable.set(profile ?? null);
+    },
+    /** Synchronous access to current profile */
+    getProfile: () => get(_profileReadable) ?? null,
+    /** Clear profile */
+    clear: () => {
+        _profileWritable.set(null);
+        _errorWritable.set(null);
+    },
+};

package/dist/shared/types/config.d.ts

@@ -0,0 +1,42 @@
+export interface BridgeConfig {
+    /**
+     * Your Bridge application ID
+     * @required
+     */
+    appId: string;
+    /**
+     * The URL to redirect to after successful login
+     * @default The current origin + '/auth/callback'
+     */
+    callbackUrl?: string;
+    /**
+     * Root URL of the Bridge API.
+     * @default 'https://api.thebridge.dev'
+     */
+    apiBaseUrl?: string;
+    /**
+     * Base URL of the Bridge hosted UI (cloud-views).
+     * @default 'https://auth.thebridge.dev'
+     */
+    hostedUrl?: string;
+    /**
+     * Route to redirect to after login
+     * @default '/'
+     */
+    defaultRedirectRoute?: string;
+    /**
+     * Route to redirect to when authentication fails
+     * @default '/login'
+     */
+    loginRoute?: string;
+    /**
+     * Debug mode
+     * @default false
+     */
+    debug?: boolean;
+}
+export interface TokenSet {
+    accessToken: string;
+    refreshToken: string;
+    idToken: string;
+}

package/dist/shared/types/config.js

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