@timeback/sdk 0.1.7 → 0.1.9

package/dist/client/adapters/svelte/{stores.d.ts → stores/client.d.ts}

@@ -1,17 +1,20 @@
 /**
- * Svelte Stores
+ * Timeback Client Store
  *
- * Svelte stores for Timeback SDK reactivity.
+ * Core Svelte store for the Timeback client singleton.
  */
 import { TimebackClient } from '@timeback/sdk/client';
+import type { Readable } from 'svelte/store';
 /**
- * Minimal Svelte-compatible store interface.
+ * Internal client store.
+ */
+export declare const clientStore: import("svelte/store").Writable<TimebackClient | undefined>;
+/**
+ * Get the current client instance (for internal use by other stores).
  *
- * This allows the SDK to work without a direct Svelte dependency.
+ * @returns Current client instance or undefined
  */
-interface Readable<T> {
-    subscribe: (run: (value: T) => void) => () => void;
-}
+export declare function getClientInstance(): TimebackClient | undefined;
 /**
  * Initialize the Timeback client.
  *
@@ -61,5 +64,4 @@ export declare function initTimeback(client?: TimebackClient): void;
  * ```
  */
 export declare const timeback: Readable<TimebackClient | undefined>;
-export {};
-//# sourceMappingURL=stores.d.ts.map
+//# sourceMappingURL=client.d.ts.map

package/dist/client/adapters/svelte/stores/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/svelte/stores/client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAyB5C;;GAEG;AACH,eAAO,MAAM,WAAW,6DAAkD,CAAA;AAE1E;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,GAAG,SAAS,CAE9D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAQ1D;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,cAAc,GAAG,SAAS,CAAe,CAAA"}

package/dist/client/adapters/svelte/{stores.ts → stores/client.ts}

@@ -1,51 +1,14 @@
 /**
- * Svelte Stores
+ * Timeback Client Store
  *
- * Svelte stores for Timeback SDK reactivity.
+ * Core Svelte store for the Timeback client singleton.
  */
 
-import { TimebackClient } from '@timeback/sdk/client'
-
-/**
- * Minimal Svelte-compatible store interface.
- *
- * This allows the SDK to work without a direct Svelte dependency.
- */
-interface Readable<T> {
-	subscribe: (run: (value: T) => void) => () => void
-}
-
-interface Writable<T> extends Readable<T> {
-	set: (value: T) => void
-	update: (updater: (value: T) => T) => void
-}
+import { writable } from 'svelte/store'
 
-/**
- * Create a minimal writable store implementation.
- *
- * @param initialValue - Initial store value
- * @returns Writable store
- */
-function writable<T>(initialValue: T): Writable<T> {
-	let value = initialValue
-	const subscribers = new Set<(value: T) => void>()
+import { TimebackClient } from '@timeback/sdk/client'
 
-	return {
-		subscribe(run) {
-			subscribers.add(run)
-			run(value)
-			return () => subscribers.delete(run)
-		},
-		set(newValue) {
-			value = newValue
-			subscribers.forEach(fn => fn(value))
-		},
-		update(updater) {
-			value = updater(value)
-			subscribers.forEach(fn => fn(value))
-		},
-	}
-}
+import type { Readable } from 'svelte/store'
 
 let clientInstance: TimebackClient | undefined
 
@@ -61,10 +24,28 @@ function getOrCreateClient(): TimebackClient {
 	return clientInstance
 }
 
+/**
+ * Check if we're running in the browser.
+ *
+ * @returns True if in browser
+ */
+function isBrowser(): boolean {
+	return typeof window !== 'undefined'
+}
+
 /**
  * Internal client store.
  */
-const clientStore = writable<TimebackClient | undefined>(undefined)
+export const clientStore = writable<TimebackClient | undefined>(undefined)
+
+/**
+ * Get the current client instance (for internal use by other stores).
+ *
+ * @returns Current client instance or undefined
+ */
+export function getClientInstance(): TimebackClient | undefined {
+	return clientInstance
+}
 
 /**
  * Initialize the Timeback client.
@@ -95,15 +76,6 @@ export function initTimeback(client?: TimebackClient): void {
 	clientStore.set(getOrCreateClient())
 }
 
-/**
- * Check if we're running in the browser.
- *
- * @returns True if in browser
- */
-function isBrowser(): boolean {
-	return typeof window !== 'undefined'
-}
-
 /**
  * Auto-initialize on first access in browser.
  */

package/dist/client/adapters/svelte/stores/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Svelte Stores
+ *
+ * Svelte stores for Timeback SDK reactivity.
+ */
+export { initTimeback, timeback } from './client';
+export { refreshTimebackVerification, timebackVerification } from './verification';
+export { fetchTimebackProfile, refreshTimebackProfile, timebackProfile, timebackProfileCanFetch, } from './profile';
+export type { TimebackProfileState, TimebackVerificationState } from '../types';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/adapters/svelte/stores/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/svelte/stores/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGjD,OAAO,EAAE,2BAA2B,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAGlF,OAAO,EACN,oBAAoB,EACpB,sBAAsB,EACtB,eAAe,EACf,uBAAuB,GACvB,MAAM,WAAW,CAAA;AAGlB,YAAY,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA"}

package/dist/client/adapters/svelte/stores/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Svelte Stores
+ *
+ * Svelte stores for Timeback SDK reactivity.
+ */
+
+// Client
+export { initTimeback, timeback } from './client'
+
+// Verification
+export { refreshTimebackVerification, timebackVerification } from './verification'
+
+// Profile
+export {
+	fetchTimebackProfile,
+	refreshTimebackProfile,
+	timebackProfile,
+	timebackProfileCanFetch,
+} from './profile'
+
+// Types re-exported for convenience
+export type { TimebackProfileState, TimebackVerificationState } from '../types'

package/dist/client/adapters/svelte/stores/profile.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Timeback Profile Store
+ *
+ * Svelte store for user profile state.
+ */
+import type { TimebackProfileState } from '../types';
+import type { Readable } from 'svelte/store';
+/**
+ * Store containing the Timeback profile state.
+ *
+ * Use this to access the current user's Timeback profile.
+ * Call `fetchTimebackProfile()` to manually fetch, or `refreshTimebackProfile()` to force re-fetch.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { timebackProfile, timebackProfileCanFetch, fetchTimebackProfile } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * <button on:click={fetchTimebackProfile} disabled={!$timebackProfileCanFetch}>
+ *   {$timebackProfile.status === 'loading' ? 'Loading...' : 'Fetch Profile'}
+ * </button>
+ *
+ * {#if $timebackProfile.status === 'loaded'}
+ *   <pre>{JSON.stringify($timebackProfile.profile, null, 2)}</pre>
+ * {/if}
+ * ```
+ */
+export declare const timebackProfile: Readable<TimebackProfileState>;
+/**
+ * Store indicating whether the profile can be fetched.
+ *
+ * True when the user is verified and the client is ready.
+ */
+export declare const timebackProfileCanFetch: Readable<boolean>;
+/**
+ * Manually fetch the Timeback profile.
+ *
+ * No-op if the user is not verified or client is not ready.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { fetchTimebackProfile } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * <button on:click={fetchTimebackProfile}>Fetch Profile</button>
+ * ```
+ */
+export declare function fetchTimebackProfile(): void;
+/**
+ * Force a re-fetch of the Timeback profile.
+ *
+ * No-op if the user is not verified or client is not ready.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { refreshTimebackProfile } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * <button on:click={refreshTimebackProfile}>Refresh Profile</button>
+ * ```
+ */
+export declare function refreshTimebackProfile(): void;
+//# sourceMappingURL=profile.d.ts.map

package/dist/client/adapters/svelte/stores/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/svelte/stores/profile.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EAAE,oBAAoB,EAA6B,MAAM,UAAU,CAAA;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AA6E5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,oBAAoB,CAAgB,CAAA;AAE3E;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,OAAO,CAAiB,CAAA;AAEvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAS3C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAS7C"}

package/dist/client/adapters/svelte/stores/profile.ts

@@ -0,0 +1,168 @@
+/**
+ * Timeback Profile Store
+ *
+ * Svelte store for user profile state.
+ */
+
+import { fetchProfileOnce, getProfileCache } from '../../../lib/user-cache'
+import { getClientInstance } from './client'
+import { writable } from 'svelte/store'
+import { verificationStore } from './verification'
+
+import type { TimebackProfileState, TimebackVerificationState } from '../types'
+import type { Readable } from 'svelte/store'
+
+const profileStore = writable<TimebackProfileState>({ status: 'idle' })
+const canFetchStore = writable<boolean>(false)
+let profileInitialized = false
+
+/**
+ * Check if we're running in the browser.
+ *
+ * @returns True if in browser
+ */
+function isBrowser(): boolean {
+	return typeof window !== 'undefined'
+}
+
+/**
+ * Run the profile fetch.
+ *
+ * @param force - If true, bypass cache and force a fresh fetch
+ */
+async function runProfileFetch(force: boolean): Promise<void> {
+	const client = getClientInstance()
+	if (!client) return
+
+	if (!force) {
+		const cached = getProfileCache(client)
+		if (cached) {
+			profileStore.set({ status: 'loaded', profile: cached })
+			return
+		}
+	}
+
+	profileStore.set({ status: 'loading' })
+
+	try {
+		const profile = await fetchProfileOnce(client, force)
+		profileStore.set({ status: 'loaded', profile })
+	} catch (err) {
+		profileStore.set({
+			status: 'error',
+			message: err instanceof Error ? err.message : 'Failed to fetch profile',
+		})
+	}
+}
+
+/**
+ * Update canFetch based on verification state.
+ *
+ * @param verification - Current verification state
+ */
+function updateCanFetch(verification: TimebackVerificationState): void {
+	const can = verification.status === 'verified' && !!getClientInstance()
+	canFetchStore.set(can)
+}
+
+/**
+ * Initialize profile store subscriptions.
+ */
+function initProfile(): void {
+	if (profileInitialized) return
+	profileInitialized = true
+
+	verificationStore.subscribe(verification => {
+		updateCanFetch(verification)
+
+		// Reset to idle if not verified
+		if (verification.status !== 'verified') {
+			profileStore.set({ status: 'idle' })
+		}
+	})
+}
+
+// Auto-init in browser
+if (isBrowser()) {
+	initProfile()
+}
+
+/**
+ * Store containing the Timeback profile state.
+ *
+ * Use this to access the current user's Timeback profile.
+ * Call `fetchTimebackProfile()` to manually fetch, or `refreshTimebackProfile()` to force re-fetch.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { timebackProfile, timebackProfileCanFetch, fetchTimebackProfile } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * <button on:click={fetchTimebackProfile} disabled={!$timebackProfileCanFetch}>
+ *   {$timebackProfile.status === 'loading' ? 'Loading...' : 'Fetch Profile'}
+ * </button>
+ *
+ * {#if $timebackProfile.status === 'loaded'}
+ *   <pre>{JSON.stringify($timebackProfile.profile, null, 2)}</pre>
+ * {/if}
+ * ```
+ */
+export const timebackProfile: Readable<TimebackProfileState> = profileStore
+
+/**
+ * Store indicating whether the profile can be fetched.
+ *
+ * True when the user is verified and the client is ready.
+ */
+export const timebackProfileCanFetch: Readable<boolean> = canFetchStore
+
+/**
+ * Manually fetch the Timeback profile.
+ *
+ * No-op if the user is not verified or client is not ready.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { fetchTimebackProfile } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * <button on:click={fetchTimebackProfile}>Fetch Profile</button>
+ * ```
+ */
+export function fetchTimebackProfile(): void {
+	if (!isBrowser()) return
+
+	let canFetch = false
+	canFetchStore.subscribe(v => (canFetch = v))()
+
+	if (!canFetch) return
+
+	void runProfileFetch(false)
+}
+
+/**
+ * Force a re-fetch of the Timeback profile.
+ *
+ * No-op if the user is not verified or client is not ready.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { refreshTimebackProfile } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * <button on:click={refreshTimebackProfile}>Refresh Profile</button>
+ * ```
+ */
+export function refreshTimebackProfile(): void {
+	if (!isBrowser()) return
+
+	let canFetch = false
+	canFetchStore.subscribe(v => (canFetch = v))()
+
+	if (!canFetch) return
+
+	void runProfileFetch(true)
+}

package/dist/client/adapters/svelte/stores/verification.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Timeback Verification Store
+ *
+ * Svelte store for user verification state.
+ */
+import type { Readable } from 'svelte/store';
+import type { TimebackVerificationState } from '../types';
+export declare const verificationStore: import("svelte/store").Writable<TimebackVerificationState>;
+/**
+ * Store containing the Timeback verification state.
+ *
+ * Use this to check if the current user is verified in Timeback.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { timebackVerification, refreshTimebackVerification } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * {#if $timebackVerification.status === 'verified'}
+ *   <p>Verified! Timeback ID: {$timebackVerification.timebackId}</p>
+ * {:else if $timebackVerification.status === 'loading'}
+ *   <p>Verifying...</p>
+ * {:else}
+ *   <p>Not verified</p>
+ * {/if}
+ * ```
+ */
+export declare const timebackVerification: Readable<TimebackVerificationState>;
+/**
+ * Force a re-verification of the current user.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { refreshTimebackVerification } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * <button on:click={refreshTimebackVerification}>Refresh Verification</button>
+ * ```
+ */
+export declare function refreshTimebackVerification(): void;
+//# sourceMappingURL=verification.d.ts.map

package/dist/client/adapters/svelte/stores/verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/svelte/stores/verification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAczD,eAAO,MAAM,iBAAiB,4DAA6D,CAAA;AA6I3F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,yBAAyB,CAAqB,CAAA;AAE1F;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAGlD"}

package/dist/client/adapters/svelte/stores/verification.ts

@@ -0,0 +1,208 @@
+/**
+ * Timeback Verification Store
+ *
+ * Svelte store for user verification state.
+ */
+
+import { writable } from 'svelte/store'
+
+import { DEFAULT_RETRY_ATTEMPTS, DEFAULT_RETRY_DELAYS_MS } from '../../../../shared/constants'
+import { getVerifyCache, verifyOnce } from '../../../lib/user-cache'
+import { getRetryDelay, sleep } from '../../../lib/utils'
+import { clientStore, getClientInstance } from './client'
+
+import type { Readable } from 'svelte/store'
+import type { TimebackVerifyResult } from '../../../../shared/types'
+import type { TimebackVerificationState } from '../types'
+
+/**
+ * Convert a verify result into a store-friendly state machine.
+ *
+ * @param result - Raw verify result from the SDK client
+ * @returns Mapped verification state
+ */
+function toVerificationState(result: TimebackVerifyResult): TimebackVerificationState {
+	return result.verified
+		? { status: 'verified', timebackId: result.timebackId }
+		: { status: 'unverified' }
+}
+
+export const verificationStore = writable<TimebackVerificationState>({ status: 'loading' })
+let verificationInitialized = false
+
+/**
+ * Counter tracking the current verification run.
+ *
+ * Each call to `runVerification` increments this counter and captures
+ * its value. Before updating state, the run checks if it's still current.
+ * This prevents stale results from overwriting fresh ones when multiple
+ * verification attempts overlap (e.g., initial retry + user refresh).
+ */
+let currentRunId = 0
+
+/**
+ * Check if we're running in the browser.
+ *
+ * @returns True if in browser
+ */
+function isBrowser(): boolean {
+	return typeof window !== 'undefined'
+}
+
+/**
+ * Run the verification check with retry logic.
+ *
+ * Uses a run ID to prevent race conditions when multiple verification
+ * attempts overlap. Each run captures the current ID and only updates
+ * state if it's still the active run.
+ *
+ * @param force - If true, bypass cache and force a fresh verification
+ */
+async function runVerification(force: boolean): Promise<void> {
+	const client = getClientInstance()
+	if (!client) return
+
+	/**
+	 * Capture this run's ID. Any subsequent call to runVerification
+	 * will increment currentRunId, making this run "cancelled".
+	 */
+	const runId = ++currentRunId
+
+	/**
+	 * Check if this run is still the active one.
+	 *
+	 * @returns False if a newer verification run has started
+	 */
+	const isCurrentRun = () => runId === currentRunId
+
+	if (!force) {
+		const cached = getVerifyCache(client)
+		if (cached) {
+			if (isCurrentRun()) {
+				verificationStore.set(toVerificationState(cached))
+			}
+			return
+		}
+	}
+
+	if (isCurrentRun()) {
+		verificationStore.set({ status: 'loading' })
+	}
+
+	let lastError: Error | undefined
+
+	for (let attempt = 0; attempt <= DEFAULT_RETRY_ATTEMPTS; attempt++) {
+		if (!isCurrentRun()) return
+
+		/**
+		 * Wait for a calculated delay before retrying the verification request.
+		 *
+		 * This occurs only on subsequent attempts (not the initial try),
+		 * introducing a backoff based on the configured retry delays.
+		 */
+		if (attempt > 0) {
+			const delay = getRetryDelay(DEFAULT_RETRY_DELAYS_MS, attempt - 1)
+			await sleep(delay)
+			if (!isCurrentRun()) return
+		}
+
+		try {
+			const result = await verifyOnce(client, force || attempt > 0)
+
+			if (!isCurrentRun()) return
+
+			verificationStore.set(toVerificationState(result))
+
+			return
+		} catch (err) {
+			lastError = err instanceof Error ? err : new Error('Failed to verify Timeback user')
+			/**
+			 * An error occurred during this verification attempt.
+			 * Proceeding to the next retry attempt if any remain.
+			 *
+			 * The last encountered error is saved for potential error state handling.
+			 */
+		}
+	}
+
+	/**
+	 * All verification attempts have failed after exhausting
+	 * the configured retry policy. The verification state will
+	 * transition to "error" if this run is still current, and the last
+	 * encountered error message (if available) will be presented to the consumer.
+	 */
+	if (isCurrentRun() && lastError) {
+		verificationStore.set({
+			status: 'error',
+			message: lastError.message,
+		})
+	}
+}
+
+/**
+ * Initialize verification when client becomes available.
+ */
+function initVerification(): void {
+	if (verificationInitialized) return
+	verificationInitialized = true
+
+	/**
+	 * Subscribes to changes in the Timeback client store.
+	 *
+	 * Any time the client instance becomes available or changes,
+	 * automatically triggers a verification attempt to ensure the
+	 * user's Timeback verification status is kept up-to-date.
+	 *
+	 * This enables responsive status updates when authentication
+	 * state changes or when the client instance is re-initialized,
+	 * providing a seamless verification experience in Svelte apps.
+	 */
+	clientStore.subscribe(client => {
+		if (client && isBrowser()) {
+			void runVerification(false)
+		}
+	})
+}
+
+if (isBrowser()) {
+	initVerification()
+}
+
+/**
+ * Store containing the Timeback verification state.
+ *
+ * Use this to check if the current user is verified in Timeback.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { timebackVerification, refreshTimebackVerification } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * {#if $timebackVerification.status === 'verified'}
+ *   <p>Verified! Timeback ID: {$timebackVerification.timebackId}</p>
+ * {:else if $timebackVerification.status === 'loading'}
+ *   <p>Verifying...</p>
+ * {:else}
+ *   <p>Not verified</p>
+ * {/if}
+ * ```
+ */
+export const timebackVerification: Readable<TimebackVerificationState> = verificationStore
+
+/**
+ * Force a re-verification of the current user.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { refreshTimebackVerification } from '@timeback/sdk/svelte'
+ * </script>
+ *
+ * <button on:click={refreshTimebackVerification}>Refresh Verification</button>
+ * ```
+ */
+export function refreshTimebackVerification(): void {
+	if (!isBrowser()) return
+	void runVerification(true)
+}