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

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2025 thebridgedev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+

package/README.md

@@ -0,0 +1,61 @@
+
+## @nebulr-group/bridge-svelte
+
+
+Bridge Svelte library. Add Bridge auth, feature flags, and payments to your SvelteKit 2 + Svelte 5 apps.
+
+### Install
+
+```bash
+npm i @nebulr-group/bridge-svelte
+```
+
+### Usage
+
+See the `demo/` app in the monorepo for end-to-end wiring.
+
+### Build
+
+
+```bash
+npm run build
+```
+
+Artifacts are emitted to `dist/` via `svelte-package`.
+
+### Release (branch-protected main)
+
+```bash
+# 1) Create release branch
+git checkout -b release/v0.1.0-beta.1
+git push -u origin release/v0.1.0-beta.1
+
+# 2) Open a PR: release/v0.1.0-beta.1 -> main, approve and merge
+
+# 3) After merge to main, tag and push
+git checkout main && git pull
+git tag v0.1.0-beta.1
+git push origin v0.1.0-beta.1
+
+# 4) Monitor GitHub Actions "Publish to npm"
+```
+
+### Commit signing (required)
+
+Ensure your commits are verified before opening PRs:
+
+```bash
+# Option A: SSH signing (recommended)
+git config --global gpg.format ssh
+git config --global user.signingkey ~/.ssh/id_ed25519.pub
+git config --global commit.gpgsign true
+
+# Option B: GPG signing
+gpg --full-generate-key
+gpg --list-secret-keys --keyid-format=long
+git config --global user.signingkey <KEY_ID>
+git config --global commit.gpgsign true
+```
+
+### License
+MIT © thebridgedev

package/dist/auth/route-guard.d.ts

@@ -0,0 +1,32 @@
+export type PublicRoutePattern = string | RegExp;
+export type FlagRequirement = string | {
+    any: string[];
+} | {
+    all: string[];
+};
+export type RouteRule = {
+    match: string | RegExp;
+    public?: boolean;
+    featureFlag?: FlagRequirement;
+    redirectTo?: string;
+};
+export interface RouteGuardConfig {
+    rules: RouteRule[];
+    defaultAccess?: 'public' | 'protected';
+}
+export declare function createRouteGuard(): {
+    isPublicRoute: (pathname: string) => boolean;
+    isProtectedRoute: (pathname: string) => boolean;
+    shouldRedirectToLogin: (pathname: string) => boolean;
+    checkRouteRestrictions: (pathname: string) => Promise<string | null>;
+    getLoginRedirect: () => string;
+    getNavigationDecision(pathname: string): Promise<{
+        type: "allow";
+    } | {
+        type: "login";
+        loginUrl: string;
+    } | {
+        type: "redirect";
+        to: string;
+    }>;
+};

package/dist/auth/route-guard.js

@@ -0,0 +1,100 @@
+import { get } from 'svelte/store';
+import { getRouteGuardConfig } from '../client/stores/config.store.js';
+import { isFeatureEnabled } from '../shared/feature-flag.js';
+import { logger } from '../shared/logger.js';
+import { auth } from '../shared/services/auth.service.js';
+const { isAubridgenticated, createLoginUrl } = auth;
+function escapeRegex(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function toRegExp(pattern) {
+    if (pattern instanceof RegExp)
+        return pattern;
+    // Support simple wildcard '*'
+    const hasWildcard = pattern.includes('*');
+    if (!hasWildcard) {
+        return new RegExp(`^${escapeRegex(pattern)}$`);
+    }
+    const escaped = escapeRegex(pattern).replace(/\\\*/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
+function findMatchingRule(pathname, config) {
+    for (const rule of config.rules) {
+        if (toRegExp(rule.match).test(pathname)) {
+            return rule;
+        }
+    }
+    return null;
+}
+async function evaluateFlagRequirement(req) {
+    if (typeof req === 'string') {
+        return isFeatureEnabled(req);
+    }
+    if ('any' in req) {
+        const results = await Promise.all(req.any.map((f) => isFeatureEnabled(f)));
+        return results.some(Boolean);
+    }
+    if ('all' in req) {
+        const results = await Promise.all(req.all.map((f) => isFeatureEnabled(f)));
+        return results.every(Boolean);
+    }
+    return true;
+}
+export function createRouteGuard() {
+    const config = getRouteGuardConfig();
+    function isPublicRoute(pathname) {
+        const rule = findMatchingRule(pathname, config);
+        if (rule) {
+            logger.debug(`[route-guard] path ${pathname} is ${rule.public ? 'public' : 'protected'} by bridge rule ${rule.match}`);
+            return !!rule.public;
+        }
+        logger.debug(`[route-guard] path ${pathname} is ${config.defaultAccess === 'public' ? 'public' : 'protected'} by bridge default access ${config.defaultAccess}`);
+        const isPublicByDefault = (config.defaultAccess ?? 'protected') === 'public';
+        return isPublicByDefault;
+    }
+    function isProtectedRoute(pathname) {
+        return !isPublicRoute(pathname);
+    }
+    function shouldRedirectToLogin(pathname) {
+        const isProtected = isProtectedRoute(pathname);
+        const aubridgenticated = get(isAubridgenticated);
+        if (isProtectedRoute(pathname) && !get(isAubridgenticated)) {
+            logger.debug(`[route-guard] path ${pathname} is protected and user is not aubridgenticated`);
+            return true;
+        }
+        logger.debug(`[route-guard] path ${pathname} is ${isProtected ? 'protected' : 'public'} and user ${aubridgenticated ? 'aubridgenticated' : 'not aubridgenticated'}`);
+        return false;
+    }
+    async function checkRouteRestrictions(pathname) {
+        const rule = findMatchingRule(pathname, config);
+        if (!rule)
+            return null;
+        if (rule.featureFlag) {
+            const ok = await evaluateFlagRequirement(rule.featureFlag);
+            logger.debug(`[route-guard] path ${pathname} is restricted by bridge feature flag ${rule.featureFlag} and flag requirment evaluated to ${ok}`);
+            if (!ok)
+                return rule.redirectTo ?? '/';
+        }
+        return null;
+    }
+    function getLoginRedirect() {
+        return createLoginUrl();
+    }
+    return {
+        isPublicRoute,
+        isProtectedRoute,
+        shouldRedirectToLogin,
+        checkRouteRestrictions,
+        getLoginRedirect,
+        async getNavigationDecision(pathname) {
+            if (shouldRedirectToLogin(pathname)) {
+                return { type: 'login', loginUrl: getLoginRedirect() };
+            }
+            const redirectTo = await checkRouteRestrictions(pathname);
+            if (redirectTo) {
+                return { type: 'redirect', to: redirectTo };
+            }
+            return { type: 'allow' };
+        }
+    };
+}

package/dist/client/BridgeBootstrap.d.ts

@@ -0,0 +1,3 @@
+import type { RouteGuardConfig } from '../auth/route-guard.js';
+import type { BridgeConfig } from '../shared/types/config.js';
+export declare function bridgeBootstrap(url: URL, config: BridgeConfig | string, routeConfig?: RouteGuardConfig): Promise<void>;

package/dist/client/BridgeBootstrap.js

@@ -0,0 +1,49 @@
+// src/lib/bridge/bootstrap.ts
+import { redirect } from '@sveltejs/kit';
+import { createRouteGuard } from '../auth/route-guard.js';
+import { featureFlags } from '../shared/feature-flag.js';
+import { logger } from '../shared/logger.js';
+import { auth, maybeRefreshNow } from '../shared/services/auth.service.js';
+import { bridgeConfig } from './stores/config.store.js';
+export async function bridgeBootstrap(url, config, routeConfig = { rules: [], defaultAccess: 'protected' }) {
+    const finalConfig = typeof config === 'string' ? { appId: config } : config;
+    // 1. Initialize configuration (synchronously)
+    bridgeConfig.initConfig(finalConfig, routeConfig);
+    // 1a. If we're on bridge OAuth callback route, let bridge dedicated route handle it
+    try {
+        const callbackPath = finalConfig.callbackUrl ? new URL(finalConfig.callbackUrl).pathname : null;
+        if (callbackPath && url.pathname === callbackPath) {
+            logger.debug('[bridgeBootstrap] callback route detected, skipping bootstrap flow');
+            const { handleCallback } = auth;
+            const code = url.searchParams.get('code');
+            if (code) {
+                try {
+                    await handleCallback(code);
+                    // Redirect bridge user to bridge home page after bridge callback is handled
+                    window.location.href = '/';
+                }
+                catch (err) {
+                    logger.error('Auth callback error:', err);
+                }
+            }
+        }
+    }
+    catch (e) {
+        logger.warn('[bridgeBootstrap] failed parsing callbackUrl', e);
+    }
+    // 2. Ensure tokens are fresh if needed
+    await maybeRefreshNow();
+    // 3. Load feature flags before guard if your guard depends on bridgem
+    await featureFlags.refresh();
+    // 4. Handle route guarding and redirects
+    const guard = createRouteGuard();
+    const decision = await guard.getNavigationDecision(url.pathname);
+    logger.debug('[bridgeBootstrap] navigation decision', decision);
+    if (decision.type === 'login') {
+        throw redirect(303, auth.createLoginUrl());
+    }
+    if (decision.type === 'redirect' && url.pathname !== decision.to) {
+        throw redirect(303, decision.to);
+    }
+    logger.debug('[bridgeBootstrap] in bridge end');
+}

package/dist/client/BridgeBootstrap.svelte

@@ -0,0 +1,41 @@
+<script lang="ts">  
+  import { beforeNavigate } from '$app/navigation';
+  import { onMount } from 'svelte';
+  import { createRouteGuard } from '../auth/route-guard.js';
+  import { auth, startAutoRefresh } from '../shared/services/auth.service.js';
+
+  // Props: require config to be passed by consumer, now including onBootstrapComplete
+  let {onBootstrapComplete }: {
+   
+    onBootstrapComplete?: () => void
+  } = $props();
+
+  const { login } = auth;
+  const guard = createRouteGuard();
+
+  async function handleRoute(pathname: string, cancel?: () => void) {
+    const decision = await guard.getNavigationDecision(pathname);    
+    if (decision.type === 'login') {
+      if (cancel) cancel();
+      login();
+      return;
+    }
+    if (decision.type === 'redirect' && window.location.pathname !== decision.to) {
+      if (cancel) cancel();
+      window.location.href = decision.to;
+      return;
+    }
+  }
+
+  onMount(async () => {        
+      startAutoRefresh();
+    
+    // Signal completion
+    if (onBootstrapComplete) onBootstrapComplete();
+  });
+
+  beforeNavigate(async ({ to, cancel }) => {
+    if (!to) return;
+    await handleRoute(to.url.pathname, cancel);
+  });
+</script>

package/dist/client/BridgeBootstrap.svelte.d.ts

@@ -0,0 +1,6 @@
+type $$ComponentProps = {
+    onBootstrapComplete?: () => void;
+};
+declare const BridgeBootstrap: import("svelte").Component<$$ComponentProps, {}, "">;
+type BridgeBootstrap = ReturnType<typeof BridgeBootstrap>;
+export default BridgeBootstrap;

package/dist/client/components/FeatureFlag.svelte

@@ -0,0 +1,21 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import { onMount } from 'svelte';
+  import { isFeatureEnabled } from '../../shared/feature-flag.js';
+
+  let { flagName, forceLive = false, negate = false, children }: { flagName: string; forceLive?: boolean; negate?: boolean; children?: Snippet } = $props();
+
+  let enabled = $state(false);
+
+  let shouldRender = $derived(() => negate ? !enabled : enabled);
+
+  onMount(async () => {
+    enabled = await isFeatureEnabled(flagName, forceLive);
+  });
+</script>
+
+{#if shouldRender}
+  {#if children}
+    {@render children()}
+  {/if}
+{/if}

package/dist/client/components/FeatureFlag.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    flagName: string;
+    forceLive?: boolean;
+    negate?: boolean;
+    children?: Snippet;
+};
+declare const FeatureFlag: import("svelte").Component<$$ComponentProps, {}, "">;
+type FeatureFlag = ReturnType<typeof FeatureFlag>;
+export default FeatureFlag;

package/dist/client/components/auth/Login.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+  import { auth } from '../../../shared/services/auth.service';
+  const { isAubridgenticated, login } = auth;
+</script>
+
+<button onclick={() => login()} class="login-button">
+  Login with Bridge
+</button>
+
+<style>
+  .login-button {
+    display: inline-block;
+    padding: 0.5rem 1rem;
+    background-color: #3b82f6;
+    color: white;
+    border-radius: 0.25rem;
+    border: none;
+    cursor: pointer;
+  }
+</style> 

package/dist/client/components/auth/Login.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const Login: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type Login = InstanceType<typeof Login>;
+export default Login;

package/dist/client/components/team/TeamManagement.svelte

@@ -0,0 +1,131 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { logger } from '../../../shared/logger.js';
+  import { auth } from '../../../shared/services/auth.service.js';
+  import { getConfig } from '../../stores/config.store.js';
+
+  let iframeUrl: string | null = null;
+  let error: string | null = null;
+  let isLoading = true;
+
+  async function getHandoverCode(accessToken: string) {
+    const config = getConfig();
+    const authBaseUrl = config.authBaseUrl;
+    const appId = config.appId;
+
+    try {
+      const response = await fetch(
+        `${authBaseUrl}/handover/code/${appId}`,
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ accessToken }),
+        }
+      );
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        logger.error(`Failed to get handover code: ${response.status} ${response.statusText}`, errorText);
+        throw new Error(`Failed to get handover code: ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      if (!data.code) {
+        logger.error('No handover code in response:', data);
+        throw new Error('Failed to get handover code: No code in response');
+      }
+
+      // Create bridge team management URL with bridge handover code
+      const baseUrl = config.teamManagementUrl;
+      return `${baseUrl}?code=${data.code}`;
+    } catch (err) {
+      logger.error('Error getting handover code:', err);
+      throw err;
+    }
+  }
+
+  onMount(async () => {
+    logger.debug('TeamManagement onMount');
+    try {
+      if (!auth.isAubridgenticated) {
+        logger.debug('TeamManagement onMount: User is not aubridgenticated');
+        throw new Error('User must be aubridgenticated to access team management');
+      }
+      const token = auth.getToken();
+      // Get bridge access token from your auth store
+      const accessToken = token?.accessToken;
+      if (!accessToken) {
+        throw new Error('No access token available');
+      }
+
+      iframeUrl = await getHandoverCode(accessToken);
+    } catch (err) {
+      error = err instanceof Error ? err.message : 'Failed to load team management';
+    } finally {
+      isLoading = false;
+    }
+  });
+</script>
+
+<div class="team-management-container">
+  {#if isLoading}
+    <div class="loading">Loading team management...</div>
+  {:else if error}
+    <div class="error">
+      <h3>Error</h3>
+      <p>{error}</p>
+    </div>
+  {:else if iframeUrl}
+    <iframe
+      src={iframeUrl}
+      title="Team Management"
+      class="team-management-iframe"
+      allow="clipboard-read; clipboard-write"
+    ></iframe>
+  {/if}
+</div>
+
+<style>
+  .team-management-container {
+    width: 100%;
+    height: 100%;
+    min-height: 600px;
+    position: relative;
+  }
+
+  .team-management-iframe {
+    width: 100%;
+    height: 100%;
+    border: none;
+    min-height: 600px;
+  }
+
+  .loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    min-height: 600px;
+    color: #4b5563;
+  }
+
+  .error {
+    padding: 1rem;
+    background-color: #fee2e2;
+    border: 1px solid #ef4444;
+    border-radius: 0.25rem;
+    color: #dc2626;
+    margin: 1rem;
+  }
+
+  .error h3 {
+    margin: 0 0 0.5rem 0;
+    font-size: 1.125rem;
+  }
+
+  .error p {
+    margin: 0;
+  }
+</style> 

package/dist/client/components/team/TeamManagement.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const TeamManagement: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type TeamManagement = InstanceType<typeof TeamManagement>;
+export default TeamManagement;

package/dist/client/stores/config.store.d.ts

@@ -0,0 +1,6 @@
+import type { BridgeConfig } from '../../shared/types/config';
+export declare const bridgeConfig: import("svelte/store").Writable<BridgeConfig | null>;
+export declare const readonlyConfig: import("svelte/store").Readable<BridgeConfig | null>;
+export declare const configReady: import("svelte/store").Readable<boolean>;
+export declare function initConfig(config: BridgeConfig): void;
+export declare function getConfig(): BridgeConfig;

package/dist/client/stores/config.store.js

@@ -0,0 +1,60 @@
+// src/lib/config/bridgeConfig.ts
+import { derived, writable } from 'svelte/store';
+import { logger } from '../../shared/logger.js';
+const DEFAULT_CONFIG = {
+    authBaseUrl: 'https://auth.nblocks.cloud',
+    backendlessBaseUrl: 'https://backendless.nblocks.cloud',
+    teamManagementUrl: 'https://backendless.nblocks.cloud/user-management-portal/users',
+    defaultRedirectRoute: '/',
+    loginRoute: '/login',
+    debug: false
+};
+const { subscribe, set, update } = writable({
+    config: null,
+    routeConfig: null,
+    loaded: false
+});
+export const bridgeConfig = {
+    subscribe,
+    initConfig: (config, routeConfig) => {
+        if (!config?.appId) {
+            throw new Error('Bridge appId is required but was not provided in bridge configuration.');
+        }
+        const merged = {
+            ...DEFAULT_CONFIG,
+            ...config
+        };
+        // Set bridge full config and mark it as loaded
+        set({
+            config: merged,
+            routeConfig: routeConfig || null,
+            loaded: true
+        });
+        // This will only print when debug is true
+        logger.debug('[config] initialized', merged);
+    }
+};
+// Convenience derived stores
+export const configReady = derived(bridgeConfig, ($state) => $state.loaded);
+export const readonlyConfig = derived(bridgeConfig, ($state) => $state.config);
+// Synchronous access to latest config value
+let _currentConfig = null;
+let _currentRouteConfig = null;
+bridgeConfig.subscribe(($state) => {
+    if ($state.loaded) {
+        _currentConfig = $state.config;
+        _currentRouteConfig = $state.routeConfig;
+    }
+});
+export function getConfig() {
+    if (!_currentConfig) {
+        throw new Error('Config has not been initialized. Call  initConfig(...) early in app startup.');
+    }
+    return _currentConfig;
+}
+export function getRouteGuardConfig() {
+    if (!_currentRouteConfig) {
+        throw new Error('RouteGuardConfig has not been initialized. Call initConfig(...) early in app startup.');
+    }
+    return _currentRouteConfig;
+}

package/dist/client/stores/profile.store.d.ts

@@ -0,0 +1,10 @@
+export interface Profile {
+    username: string;
+    email: string;
+}
+export declare const profileState: import("svelte/store").Writable<{
+    profile: Profile | null;
+    isLoading: boolean;
+    error: string | null;
+}>;
+export declare function fetchProfile(): Promise<void>;

package/dist/client/stores/profile.store.js

@@ -0,0 +1,29 @@
+import { writable } from 'svelte/store';
+import { bridgeConfig } from './config.store.js';
+// Create a writable store for profile state
+export const profileState = writable({
+    profile: null,
+    isLoading: true,
+    error: null
+});
+// Initialize profile when config changes
+bridgeConfig.subscribe((config) => {
+    if (config) {
+        // TODO: Initialize profile service
+    }
+});
+export async function fetchProfile() {
+    profileState.update(state => ({ ...state, isLoading: true, error: null }));
+    try {
+        // TODO: Implement profile fetching
+        const profile = null; // Replace with actual profile fetch
+        profileState.update(state => ({ ...state, profile }));
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Failed to fetch profile';
+        profileState.update(state => ({ ...state, error: errorMessage }));
+    }
+    finally {
+        profileState.update(state => ({ ...state, isLoading: false }));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './client/BridgeBootstrap.js';
+export * from './client/stores/config.store.js';
+export * from './client/stores/profile.store.js';
+export { default as BridgeBootstrap, default as BridgeProvider } from './client/BridgeBootstrap.svelte';
+export { default as Login } from './client/components/auth/Login.svelte';
+export { default as FeatureFlag } from './client/components/FeatureFlag.svelte';
+export { default as TeamManagement } from './client/components/team/TeamManagement.svelte';
+export * from './shared/feature-flag.js';
+export * from './auth/route-guard.js';
+export * from './shared/profile.js';
+export * from './shared/services/auth.service.js';
+export * from './shared/types/config.js';
+export { logger } from './shared/logger.js';

package/dist/index.js

@@ -0,0 +1,19 @@
+// Core stores and setup
+export * from './client/BridgeBootstrap.js';
+export * from './client/stores/config.store.js';
+export * from './client/stores/profile.store.js';
+// Components (Svelte components must have `export default`)
+export { default as BridgeBootstrap, default as BridgeProvider } from './client/BridgeBootstrap.svelte';
+export { default as Login } from './client/components/auth/Login.svelte';
+export { default as FeatureFlag } from './client/components/FeatureFlag.svelte';
+export { default as TeamManagement } from './client/components/team/TeamManagement.svelte';
+// Feature flags
+export * from './shared/feature-flag.js';
+// Auth route guards
+export * from './auth/route-guard.js';
+// Types
+export * from './shared/profile.js'; // If this exists
+export * from './shared/services/auth.service.js';
+export * from './shared/types/config.js';
+// Logger
+export { logger } from './shared/logger.js';

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,64 @@
+import { get, writable } from 'svelte/store';
+import { getConfig } from '../client/stores/config.store.js';
+import { logger } from './logger.js';
+import { auth } from './services/auth.service.js';
+const cacheValidityMs = 5 * 60 * 1000;
+const cachedFlags = writable({});
+let lastFetchTime = 0;
+export async function loadFeatureFlags() {
+    const tokens = get(auth.token);
+    const appId = tokens?.appId ?? getConfig().appId;
+    const accessToken = tokens?.accessToken;
+    const backendlessBaseUrl = getConfig().backendlessBaseUrl;
+    if (!appId)
+        return;
+    const url = `${backendlessBaseUrl}/flags/bulkEvaluate/${appId}`;
+    const body = accessToken ? { accessToken } : {};
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body)
+    });
+    if (!res.ok)
+        throw new Error('Failed to load feature flags');
+    const data = await res.json();
+    const flags = data.flags.reduce((acc, { flag, evaluation }) => {
+        acc[flag] = evaluation?.enabled ?? false;
+        return acc;
+    }, {});
+    cachedFlags.set(flags);
+    lastFetchTime = Date.now();
+}
+export async function isFeatureEnabled(flag, forceLive = false) {
+    const tokens = get(auth.token);
+    const appId = tokens?.appId ?? getConfig().appId;
+    const accessToken = tokens?.accessToken;
+    const backendlessBaseUrl = getConfig().backendlessBaseUrl;
+    if (!appId)
+        return false;
+    logger.debug(`[feature-flag] is flag:${flag}: enabled: ${get(cachedFlags)[flag]}`);
+    if (!forceLive && Date.now() - lastFetchTime < cacheValidityMs) {
+        return get(cachedFlags)[flag] ?? false;
+    }
+    if (!forceLive)
+        await loadFeatureFlags();
+    if (forceLive) {
+        const url = `${backendlessBaseUrl}/flags/evaluate/${appId}/${flag}`;
+        const body = accessToken ? { accessToken } : {};
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        });
+        if (!res.ok)
+            return get(cachedFlags)[flag] ?? false;
+        const { enabled } = await res.json();
+        cachedFlags.update(f => ({ ...f, [flag]: enabled }));
+        return enabled ?? false;
+    }
+    return get(cachedFlags)[flag] ?? false;
+}
+export const featureFlags = {
+    flags: cachedFlags,
+    refresh: loadFeatureFlags
+};

package/dist/shared/logger.d.ts

@@ -0,0 +1,17 @@
+type LogMethod = (...args: unknown[]) => 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,38 @@
+import { getConfig } from '../client/stores/config.store.js';
+function createPrefixed(method, prefix) {
+    return (...args) => method(prefix, ...args);
+}
+function isDebugEnabled() {
+    try {
+        const cfg = getConfig();
+        return !!cfg.debug;
+    }
+    catch {
+        return false;
+    }
+}
+export const logger = {
+    debug: (...args) => {
+        if (isDebugEnabled())
+            console.log(...args);
+    },
+    log: (...args) => {
+        if (isDebugEnabled())
+            console.log(...args);
+    },
+    info: (...args) => {
+        if (isDebugEnabled())
+            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,47 @@
+export interface IDToken {
+    sub: string;
+    preferred_username: string;
+    email: string;
+    email_verified: boolean;
+    name: string;
+    family_name?: string;
+    given_name?: string;
+    locale?: string;
+    onboarded?: boolean;
+    multi_tenant?: boolean;
+    tenant_id?: string;
+    tenant_name?: string;
+    tenant_locale?: string;
+    tenant_logo?: string;
+    tenant_onboarded?: boolean;
+}
+export interface Profile {
+    id: string;
+    username: string;
+    email: string;
+    emailVerified: boolean;
+    fullName: string;
+    familyName?: string;
+    givenName?: string;
+    locale?: string;
+    onboarded?: boolean;
+    multiTenantAccess?: boolean;
+    tenant?: {
+        id: string;
+        name: string;
+        locale?: string;
+        logo?: string;
+        onboarded?: boolean;
+    };
+}
+declare function updateProfile(idToken: string | null): Promise<void>;
+export declare const profileStore: {
+    profile: import("svelte/store").Writable<Profile | null | undefined>;
+    error: import("svelte/store").Writable<string | null>;
+    updateProfile: typeof updateProfile;
+    isOnboarded: import("svelte/store").Readable<boolean>;
+    hasMultiTenantAccess: import("svelte/store").Readable<boolean>;
+    getProfile: () => Profile | null | undefined;
+    clear: () => void;
+};
+export {};

package/dist/shared/profile.js

@@ -0,0 +1,98 @@
+// src/lib/auth/profile.ts
+import { createRemoteJWKSet, errors as joseErrors, jwtVerify } from 'jose';
+import { derived, get, writable } from 'svelte/store';
+import { getConfig } from '../client/stores/config.store.js';
+import { auth } from './services/auth.service.js';
+const profile = writable(undefined);
+const error = writable(null);
+function transformIDToken(payload) {
+    return {
+        id: payload.sub,
+        username: payload.preferred_username,
+        email: payload.email,
+        emailVerified: payload.email_verified,
+        fullName: payload.name,
+        familyName: payload.family_name,
+        givenName: payload.given_name,
+        locale: payload.locale,
+        onboarded: payload.onboarded,
+        multiTenantAccess: payload.multi_tenant,
+        tenant: payload.tenant_id
+            ? {
+                id: payload.tenant_id,
+                name: payload.tenant_name || '',
+                locale: payload.tenant_locale,
+                logo: payload.tenant_logo,
+                onboarded: payload.tenant_onboarded,
+            }
+            : undefined,
+    };
+}
+let jwks = null;
+let expectedIssuer = null;
+let expectedAudience = null;
+function ensureVerifier() {
+    const config = getConfig();
+    if (!jwks || expectedIssuer !== config.authBaseUrl || expectedAudience !== config.appId) {
+        jwks = createRemoteJWKSet(new URL(`${config.authBaseUrl}/.well-known/jwks.json`));
+        expectedIssuer = config.authBaseUrl;
+        expectedAudience = config.appId;
+    }
+}
+async function verifyToken(idToken) {
+    try {
+        ensureVerifier();
+        const { payload } = await jwtVerify(idToken, jwks, {
+            issuer: expectedIssuer,
+            audience: expectedAudience,
+        });
+        return transformIDToken(payload);
+    }
+    catch (err) {
+        if (err instanceof joseErrors.JWTExpired) {
+            error.set('Token expired');
+        }
+        else if (err instanceof joseErrors.JWTInvalid) {
+            error.set('Invalid token');
+        }
+        else if (err instanceof joseErrors.JWKSNoMatchingKey) {
+            error.set('JWKS error');
+        }
+        else {
+            error.set('Token verification failed');
+        }
+        profile.set(null);
+        return null;
+    }
+}
+async function updateProfile(idToken) {
+    profile.set(undefined);
+    if (!idToken) {
+        profile.set(null);
+        error.set(null);
+        return;
+    }
+    const result = await verifyToken(idToken);
+    profile.set(result);
+    if (result)
+        error.set(null);
+}
+// 🔁 Auto-sync profile with token
+auth.token.subscribe(($token) => {
+    const idToken = $token?.idToken || null;
+    updateProfile(idToken);
+});
+const isOnboarded = derived(profile, ($profile) => $profile?.onboarded ?? false);
+const hasMultiTenantAccess = derived(profile, ($profile) => $profile?.multiTenantAccess ?? false);
+export const profileStore = {
+    profile,
+    error,
+    updateProfile,
+    isOnboarded,
+    hasMultiTenantAccess,
+    getProfile: () => get(profile),
+    clear: () => {
+        profile.set(null);
+        error.set(null);
+    },
+};

package/dist/shared/services/auth.service.d.ts

@@ -0,0 +1,24 @@
+import type { TokenSet } from './types/config';
+declare function clearTokens(): void;
+declare function login(options?: {
+    redirectUri?: string;
+}): Promise<void>;
+declare function createLoginUrl(options?: {
+    redirectUri?: string;
+}): string;
+declare function handleCallback(code: string): Promise<void>;
+declare function refreshToken(refreshToken: string): Promise<TokenSet | null>;
+export declare const auth: {
+    token: import("svelte/store").Writable<any>;
+    isAubridgenticated: import("svelte/store").Readable<boolean>;
+    isLoading: import("svelte/store").Writable<boolean>;
+    error: import("svelte/store").Writable<string | null>;
+    login: typeof login;
+    logout: typeof clearTokens;
+    handleCallback: typeof handleCallback;
+    refreshToken: typeof refreshToken;
+    createLoginUrl: typeof createLoginUrl;
+    getToken: () => any;
+};
+export { };
+

package/dist/shared/services/auth.service.js

@@ -0,0 +1,209 @@
+// src/lib/auth.ts
+import { browser } from '$app/environment';
+import { derived, get, writable } from 'svelte/store';
+import { getConfig } from '../../client/stores/config.store.js';
+import { logger } from '../logger.js';
+const TOKEN_KEY = 'bridge_tokens';
+const tokenStore = writable(null);
+const isLoading = writable(true);
+const error = writable(null);
+let refreshInterval = null;
+const REFRESH_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+// Load from localStorage on first load
+if (browser) {
+    try {
+        const raw = localStorage.getItem(TOKEN_KEY);
+        if (raw)
+            tokenStore.set(JSON.parse(raw));
+    }
+    catch (e) {
+        logger.error('Failed to load tokens from storage', e);
+    }
+    finally {
+        isLoading.set(false);
+    }
+}
+// --- API ---
+function setTokens(tokens) {
+    tokenStore.set(tokens);
+    if (browser)
+        localStorage.setItem(TOKEN_KEY, JSON.stringify(tokens));
+    scheduleTokenRefresh();
+}
+function clearTokens() {
+    tokenStore.set(null);
+    if (browser)
+        localStorage.removeItem(TOKEN_KEY);
+    stopAutoRefresh();
+}
+async function login(options = {}) {
+    const loginUrl = createLoginUrl(options);
+    if (browser) {
+        window.location.href = loginUrl;
+    }
+    else {
+        throw new Error('Login not supported in this environment');
+    }
+}
+function createLoginUrl(options = {}) {
+    const config = getConfig();
+    const redirectUri = options.redirectUri ?? config.callbackUrl;
+    const base = `${config.authBaseUrl}/url/login/${config.appId}`;
+    return redirectUri ? `${base}?redirect_uri=${encodeURIComponent(redirectUri)}` : base;
+}
+async function handleCallback(code) {
+    const config = getConfig();
+    const url = `${config.authBaseUrl}/token/code/${config.appId}`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            code,
+            ...(config.callbackUrl ? { redirect_uri: config.callbackUrl } : {})
+        })
+    });
+    if (!response.ok) {
+        let errorMessage = 'Failed to exchange code for tokens';
+        try {
+            const errorData = await response.json();
+            if (errorData && errorData.message) {
+                errorMessage = `Failed to exchange code for tokens: ${errorData.message}`;
+            }
+            else if (errorData && typeof errorData === 'string') {
+                errorMessage = `Failed to exchange code for tokens: ${errorData}`;
+            }
+        }
+        catch (e) {
+            // If parsing JSON fails, use bridge generic message or response status text
+            errorMessage = `Failed to exchange code for tokens: ${response.statusText || 'Unknown error'}`;
+        }
+        throw new Error(errorMessage);
+    }
+    const data = await response.json();
+    setTokens({
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+        idToken: data.id_token
+    });
+}
+async function refreshToken(refreshToken) {
+    const config = getConfig();
+    try {
+        const url = `${config.authBaseUrl}/token`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                client_id: config.appId,
+                grant_type: 'refresh_token',
+                refresh_token: refreshToken
+            })
+        });
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        const tokens = {
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token,
+            idToken: data.id_token
+        };
+        setTokens(tokens);
+        return tokens;
+    }
+    catch (e) {
+        logger.error('Failed to refresh token', e);
+        return null;
+    }
+}
+function getTokenExpiry(token) {
+    try {
+        const payload = JSON.parse(atob(token.split('.')[1]));
+        return payload.exp * 1000;
+    }
+    catch {
+        return null;
+    }
+}
+function shouldRefreshNow(accessToken) {
+    if (!accessToken)
+        return false;
+    const exp = getTokenExpiry(accessToken);
+    if (!exp)
+        return false;
+    const timeUntilExpiry = exp - Date.now();
+    return timeUntilExpiry <= REFRESH_THRESHOLD_MS;
+}
+function scheduleTokenRefresh() {
+    if (!browser)
+        return;
+    const current = get(tokenStore);
+    const accessToken = current?.accessToken ?? null;
+    const exp = accessToken ? getTokenExpiry(accessToken) : null;
+    if (!exp)
+        return;
+    const timeUntilExpiry = exp - Date.now();
+    logger.debug('[auth] timeUntilExpiry and refresh threshold', timeUntilExpiry, REFRESH_THRESHOLD_MS);
+    if (shouldRefreshNow(accessToken)) {
+        logger.debug('[auth] refreshing now');
+        refreshNow();
+    }
+    else {
+        const checkIn = Math.max(timeUntilExpiry - REFRESH_THRESHOLD_MS, 10000);
+        refreshInterval = setTimeout(refreshNow, checkIn);
+    }
+}
+async function refreshNow() {
+    const current = get(tokenStore);
+    if (!current?.refreshToken)
+        return;
+    logger.debug('🔄 Attempting token refresh...');
+    const newTokens = await refreshToken(current.refreshToken);
+    if (newTokens) {
+        logger.debug('✅ Token refreshed');
+        setTokens(newTokens);
+    }
+    else {
+        logger.warn('❌ Token refresh failed');
+        clearTokens();
+    }
+}
+function startAutoRefresh() {
+    stopAutoRefresh();
+    scheduleTokenRefresh();
+}
+function stopAutoRefresh() {
+    if (refreshInterval)
+        clearTimeout(refreshInterval);
+    refreshInterval = null;
+}
+export async function maybeRefreshNow() {
+    const current = get(tokenStore);
+    const accessToken = current?.accessToken ?? null;
+    const refresh = current?.refreshToken ?? null;
+    if (!accessToken || !refresh)
+        return !!accessToken;
+    if (shouldRefreshNow(accessToken)) {
+        const newTokens = await refreshToken(refresh);
+        if (newTokens)
+            return true;
+        clearTokens();
+        return false;
+    }
+    return true;
+}
+// --- Derived values ---
+const isAubridgenticated = derived(tokenStore, $t => !!$t?.accessToken);
+// --- Exports ---
+export const auth = {
+    token: tokenStore,
+    isAubridgenticated,
+    isLoading,
+    error,
+    login,
+    logout: clearTokens,
+    handleCallback,
+    refreshToken,
+    createLoginUrl,
+    getToken: () => get(tokenStore)
+};
+export { startAutoRefresh, stopAutoRefresh };

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

@@ -0,0 +1,47 @@
+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;
+    /**
+     * The base URL for Bridge auth services
+     * @default 'https://auth.nblocks.cloud'
+     */
+    authBaseUrl?: string;
+    /**
+     * The base URL for Bridge backendless services
+     * @default 'https://backendless.nblocks.cloud'
+     */
+    backendlessBaseUrl?: string;
+    /**
+     * Route to redirect to after login
+     * @default '/'
+     */
+    defaultRedirectRoute?: string;
+    /**
+     * Route to redirect to when aubridgentication fails
+     * @default '/login'
+     */
+    loginRoute?: string;
+    /**
+     * URL for bridge team management portal
+     * @default 'https://backendless.nblocks.cloud'
+     */
+    teamManagementUrl?: 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 {};

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "@nebulr-group/bridge-svelte",
+	"version": "0.1.0-beta.1",
+
+	"description": "Bridge Svelte library, This library helps you to add bridge authentication and feature flags, and payments to your svelte application.",
+	"author": "Iman Pouya",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/thebridgedev/bridge-svelte.git"
+	},
+	"bugs": {
+		"url": "https://github.com/thebridgedev/bridge-svelte/issues"
+	},
+	"homepage": "https://github.com/thebridgedev/bridge-svelte#readme",
+	"scripts": {
+	  "dev": "vite dev",
+	  "build": "bun run prepack",
+	  "preview": "vite preview",
+	  "prepare": "svelte-kit sync || echo ''",
+	  "prepack": "svelte-kit sync && svelte-package && publint",
+	  "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+	  "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+	  "package": "bun run prepack && bun pm pack --destination ../"
+	},
+	"files": [
+	  "dist",
+	  "README.md",
+	  "LICENSE"
+	],
+	"sideEffects": [
+	  "**/*.css"
+	],
+	"type": "module",
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+	  ".": {
+		"types": "./dist/index.d.ts",
+		"svelte": "./dist/index.js",
+		"import": "./dist/index.js"
+	  }
+	},
+	"dependencies": {
+	  "jose": "^6.0.10"
+	},
+	"peerDependencies": {
+	  "svelte": "^5.0.0",
+	  "@sveltejs/kit": "^2.0.0"
+	},
+	"devDependencies": {	  
+	  "@sveltejs/kit": "^2.16.0",
+	  "@sveltejs/package": "^2.0.0",
+	  "@sveltejs/vite-plugin-svelte": "^5.0.0",
+	  "publint": "^0.3.2",
+	  "svelte": "^5.0.0",
+	  "svelte-check": "^4.0.0",
+	  "typescript": "^5.0.0",
+	  "vite": "^6.2.6"
+	},
+	"keywords": ["svelte", "bridge", "nebulr", "auth", "feature-flags","payments","stripe","saas control center"]
+  }
+