@capitalos/angular 0.1.0-rc.1

package/README.md

@@ -0,0 +1,119 @@
+# CapitalOS for Angular
+
+Angular components and services for integrating with CapitalOS.
+
+## Requirements
+
+- Angular 14.0.0 or higher
+
+## Installation
+
+### pnpm
+
+```bash
+pnpm add @capitalos/angular
+```
+
+### npm
+
+```bash
+npm install @capitalos/angular
+```
+
+### yarn
+
+```bash
+yarn add @capitalos/angular
+```
+
+## Documentation
+
+Please refer to the [official docs](https://docs.capitalos.com/docs/using-angular-client-library) for more details.
+
+## Usage
+
+### 1) Provide SDK configuration
+
+You must provide a `getToken()` function which returns a **one-time token** from your backend (your backend should call CapitalOS "initiate login" for the relevant account/user).
+
+#### Standalone apps
+
+```ts
+import { bootstrapApplication } from '@angular/platform-browser'
+import { provideCapitalOs } from '@capitalos/angular'
+import { AppComponent } from './app/app.component'
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideCapitalOs({
+      getToken: async () => {
+        const res = await fetch('/api/capitalos/initiate-login', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ accountId: 'act_...' }),
+        })
+        const json = await res.json()
+        return json.token
+      },
+      enableLogging: true,
+    }),
+  ],
+})
+```
+
+#### NgModule apps
+
+```ts
+import { NgModule } from '@angular/core'
+import { BrowserModule } from '@angular/platform-browser'
+import { CapitalOsModule } from '@capitalos/angular'
+
+@NgModule({
+  imports: [
+    BrowserModule,
+    CapitalOsModule.forRoot({
+      getToken: async () => {
+        const res = await fetch('/api/capitalos/initiate-login', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ accountId: 'act_...' }),
+        })
+        const json = await res.json()
+        return json.token
+      },
+      enableLogging: true,
+    }),
+  ],
+  bootstrap: [AppComponent],
+})
+export class AppModule {}
+```
+
+### 2) Render the Cards app
+
+```ts
+import { Component } from '@angular/core'
+import { CardsAppComponent, CapitalOSError } from '@capitalos/angular'
+
+@Component({
+  selector: 'app-root',
+  standalone: true,
+  imports: [CardsAppComponent],
+  template: ` <capitalos-cards-app (loaded)="onLoaded()" (error)="onError($event)" /> `,
+})
+export class AppComponent {
+  onLoaded(): void {
+    // iframe + app content loaded
+  }
+
+  onError(error: CapitalOSError): void {
+    // handle auth / connection / iframe errors
+    console.error(error)
+  }
+}
+```
+
+## Notes
+
+- The SDK automatically performs **token exchange** (one-time token → long-lived JWT) using a hidden iframe.
+- You control loading UI in your app via the component’s `(loaded)` and `(error)` events.

package/esm2020/capitalos-angular.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FwaXRhbG9zLWFuZ3VsYXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9jYXBpdGFsb3MtYW5ndWxhci9zcmMvY2FwaXRhbG9zLWFuZ3VsYXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/lib/capitalos-auth.service.mjs

@@ -0,0 +1,134 @@
+import { Injectable, inject } from '@angular/core';
+import { BehaviorSubject, combineLatest, map } from 'rxjs';
+import { TokenType, TokenParamKey, TokenParamLocation, createLogger } from '@capitalos/core';
+import { TokenExchangeService } from './token-exchange.service';
+import { CAPITALOS_CONFIG } from './provide-capitalos';
+import * as i0 from "@angular/core";
+/**
+ * Converts an unknown error to an Error object
+ */
+function toError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}
+/**
+ * Service that manages CapitalOS authentication state.
+ * This is the Angular equivalent of React's CapitalOsAuthenticationProvider.
+ *
+ * It handles:
+ * - Fetching one-time tokens via the provided getToken callback
+ * - Exchanging one-time tokens for long-lived JWTs
+ * - Managing token state via observables
+ * - Auto-refreshing tokens when they expire
+ */
+export class CapitalOsAuthService {
+    constructor() {
+        this.config = inject(CAPITALOS_CONFIG);
+        this.tokenExchangeService = inject(TokenExchangeService);
+        // Private BehaviorSubjects for internal state
+        this._longLivedToken$ = new BehaviorSubject(undefined);
+        this._baseUrl$ = new BehaviorSubject(undefined);
+        this._isLoading$ = new BehaviorSubject(false);
+        this._error$ = new BehaviorSubject(undefined);
+        // Public observable for token data
+        this.tokenData$ = combineLatest([this._longLivedToken$, this._baseUrl$]).pipe(map(([token, baseUrl]) => {
+            if (!token || !baseUrl) {
+                return undefined;
+            }
+            return {
+                token,
+                tokenType: TokenType.longLived,
+                baseUrl,
+                paramKey: TokenParamKey.accessToken,
+                paramLocation: TokenParamLocation.hash,
+            };
+        }));
+        // Public observables for UI state
+        this.isLoading$ = this._isLoading$.asObservable();
+        this.error$ = this._error$.asObservable();
+        this.authState$ = combineLatest([this._isLoading$, this._error$, this.tokenData$]).pipe(map(([isLoading, error, tokenData]) => {
+            if (isLoading)
+                return 'loading';
+            if (error)
+                return 'error';
+            if (tokenData)
+                return 'authenticated';
+            return 'idle';
+        }));
+        this.isDestroyed = false;
+        this.logger = createLogger(this.config.enableLogging, this.config.logger);
+        // Start authentication flow eagerly on construction.
+        // This is intentional: auth begins as soon as the app boots so the token
+        // is ready when CardsAppComponent renders, reducing perceived load time.
+        this.refreshToken();
+    }
+    ngOnDestroy() {
+        this.isDestroyed = true;
+    }
+    /**
+     * Invalidates the current token, triggering a refresh.
+     * Called when the iframe signals that the token has expired.
+     */
+    invalidateToken() {
+        this.logger.log('CapitalOsAuthService: Invalidating token');
+        this._longLivedToken$.next(undefined);
+        this._baseUrl$.next(undefined);
+        this._error$.next(undefined);
+        this.refreshToken();
+    }
+    /**
+     * Refreshes the token by fetching a new one-time token and exchanging it.
+     */
+    async refreshToken() {
+        if (this.isDestroyed) {
+            return;
+        }
+        // Prevent concurrent refresh calls - if already loading, skip
+        if (this._isLoading$.value) {
+            this.logger.log('CapitalOsAuthService: Token refresh already in progress, skipping');
+            return;
+        }
+        this.logger.log('CapitalOsAuthService: Starting token refresh');
+        this._isLoading$.next(true);
+        this._error$.next(undefined);
+        try {
+            // Get one-time token from platform
+            const oneTimeToken = await this.config.getToken();
+            this.logger.log('CapitalOsAuthService: Received one-time token');
+            if (this.isDestroyed) {
+                return;
+            }
+            // Exchange for long-lived token
+            const result = await this.tokenExchangeService.exchange(oneTimeToken, {
+                enableLogging: this.config.enableLogging,
+            });
+            if (this.isDestroyed) {
+                return;
+            }
+            this._longLivedToken$.next(result.longLivedToken);
+            this._baseUrl$.next(result.baseUrl);
+            this._error$.next(undefined);
+            this.logger.log('CapitalOsAuthService: Token exchange complete');
+        }
+        catch (rawError) {
+            if (!this.isDestroyed) {
+                const error = toError(rawError);
+                this.logger.error(`CapitalOsAuthService: Token refresh failed: ${error.message}`);
+                this._error$.next(error);
+            }
+        }
+        finally {
+            if (!this.isDestroyed) {
+                this._isLoading$.next(false);
+            }
+        }
+    }
+}
+CapitalOsAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CapitalOsAuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CapitalOsAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CapitalOsAuthService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CapitalOsAuthService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capitalos-auth.service.js","sourceRoot":"","sources":["../../../../projects/capitalos-angular/src/lib/capitalos-auth.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAa,MAAM,eAAe,CAAA;AAC7D,OAAO,EAAE,eAAe,EAAc,aAAa,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AACtE,OAAO,EAAa,SAAS,EAAE,aAAa,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACvG,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;;AAEtD;;GAEG;AACH,SAAS,OAAO,CAAC,KAAc;IAC7B,IAAI,KAAK,YAAY,KAAK,EAAE;QAC1B,OAAO,KAAK,CAAA;KACb;IACD,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;AACjC,CAAC;AAOD;;;;;;;;;GASG;AAEH,MAAM,OAAO,oBAAoB;IA0C/B;QAzCiB,WAAM,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAA;QACjC,yBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAAA;QAEpE,8CAA8C;QAC7B,qBAAgB,GAAG,IAAI,eAAe,CAAqB,SAAS,CAAC,CAAA;QACrE,cAAS,GAAG,IAAI,eAAe,CAAqB,SAAS,CAAC,CAAA;QAC9D,gBAAW,GAAG,IAAI,eAAe,CAAC,KAAK,CAAC,CAAA;QACxC,YAAO,GAAG,IAAI,eAAe,CAAoB,SAAS,CAAC,CAAA;QAE5E,mCAAmC;QAC1B,eAAU,GAAsC,aAAa,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAClH,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE;YACvB,IAAI,CAAC,KAAK,IAAI,CAAC,OAAO,EAAE;gBACtB,OAAO,SAAS,CAAA;aACjB;YAED,OAAO;gBACL,KAAK;gBACL,SAAS,EAAE,SAAS,CAAC,SAAS;gBAC9B,OAAO;gBACP,QAAQ,EAAE,aAAa,CAAC,WAAW;gBACnC,aAAa,EAAE,kBAAkB,CAAC,IAAI;aACvC,CAAA;QACH,CAAC,CAAC,CACH,CAAA;QAED,kCAAkC;QACzB,eAAU,GAAwB,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAA;QACjE,WAAM,GAAkC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAA;QACnE,eAAU,GAA0B,aAAa,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAChH,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE;YACpC,IAAI,SAAS;gBAAE,OAAO,SAAS,CAAA;YAC/B,IAAI,KAAK;gBAAE,OAAO,OAAO,CAAA;YACzB,IAAI,SAAS;gBAAE,OAAO,eAAe,CAAA;YACrC,OAAO,MAAM,CAAA;QACf,CAAC,CAAC,CACH,CAAA;QAEO,gBAAW,GAAG,KAAK,CAAA;QAIzB,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;QAEzE,qDAAqD;QACrD,yEAAyE;QACzE,yEAAyE;QACzE,IAAI,CAAC,YAAY,EAAE,CAAA;IACrB,CAAC;IAED,WAAW;QACT,IAAI,CAAC,WAAW,GAAG,IAAI,CAAA;IACzB,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,0CAA0C,CAAC,CAAA;QAC3D,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACrC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAC9B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAC5B,IAAI,CAAC,YAAY,EAAE,CAAA;IACrB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY;QAChB,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,OAAM;SACP;QAED,8DAA8D;QAC9D,IAAI,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE;YAC1B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,mEAAmE,CAAC,CAAA;YACpF,OAAM;SACP;QAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,8CAA8C,CAAC,CAAA;QAC/D,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAC3B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAE5B,IAAI;YACF,mCAAmC;YACnC,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAA;YACjD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAA;YAEhE,IAAI,IAAI,CAAC,WAAW,EAAE;gBACpB,OAAM;aACP;YAED,gCAAgC;YAChC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,YAAY,EAAE;gBACpE,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa;aACzC,CAAC,CAAA;YAEF,IAAI,IAAI,CAAC,WAAW,EAAE;gBACpB,OAAM;aACP;YAED,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,CAAA;YACjD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;YACnC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YAC5B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAA;SACjE;QAAC,OAAO,QAAQ,EAAE;YACjB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gBACrB,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;gBAC/B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,+CAA+C,KAAK,CAAC,OAAO,EAAE,CAAC,CAAA;gBACjF,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;aACzB;SACF;gBAAS;YACR,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gBACrB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;aAC7B;SACF;IACH,CAAC;;iHAtHU,oBAAoB;qHAApB,oBAAoB;2FAApB,oBAAoB;kBADhC,UAAU","sourcesContent":["import { Injectable, inject, OnDestroy } from '@angular/core'\nimport { BehaviorSubject, Observable, combineLatest, map } from 'rxjs'\nimport { TokenData, TokenType, TokenParamKey, TokenParamLocation, createLogger } from '@capitalos/core'\nimport { TokenExchangeService } from './token-exchange.service'\nimport { CAPITALOS_CONFIG } from './provide-capitalos'\n\n/**\n * Converts an unknown error to an Error object\n */\nfunction toError(error: unknown): Error {\n  if (error instanceof Error) {\n    return error\n  }\n  return new Error(String(error))\n}\n\n/**\n * Authentication state enum\n */\nexport type AuthState = 'idle' | 'loading' | 'authenticated' | 'error'\n\n/**\n * Service that manages CapitalOS authentication state.\n * This is the Angular equivalent of React's CapitalOsAuthenticationProvider.\n *\n * It handles:\n * - Fetching one-time tokens via the provided getToken callback\n * - Exchanging one-time tokens for long-lived JWTs\n * - Managing token state via observables\n * - Auto-refreshing tokens when they expire\n */\n@Injectable()\nexport class CapitalOsAuthService implements OnDestroy {\n  private readonly config = inject(CAPITALOS_CONFIG)\n  private readonly tokenExchangeService = inject(TokenExchangeService)\n\n  // Private BehaviorSubjects for internal state\n  private readonly _longLivedToken$ = new BehaviorSubject<string | undefined>(undefined)\n  private readonly _baseUrl$ = new BehaviorSubject<string | undefined>(undefined)\n  private readonly _isLoading$ = new BehaviorSubject(false)\n  private readonly _error$ = new BehaviorSubject<Error | undefined>(undefined)\n\n  // Public observable for token data\n  readonly tokenData$: Observable<TokenData | undefined> = combineLatest([this._longLivedToken$, this._baseUrl$]).pipe(\n    map(([token, baseUrl]) => {\n      if (!token || !baseUrl) {\n        return undefined\n      }\n\n      return {\n        token,\n        tokenType: TokenType.longLived,\n        baseUrl,\n        paramKey: TokenParamKey.accessToken,\n        paramLocation: TokenParamLocation.hash,\n      }\n    })\n  )\n\n  // Public observables for UI state\n  readonly isLoading$: Observable<boolean> = this._isLoading$.asObservable()\n  readonly error$: Observable<Error | undefined> = this._error$.asObservable()\n  readonly authState$: Observable<AuthState> = combineLatest([this._isLoading$, this._error$, this.tokenData$]).pipe(\n    map(([isLoading, error, tokenData]) => {\n      if (isLoading) return 'loading'\n      if (error) return 'error'\n      if (tokenData) return 'authenticated'\n      return 'idle'\n    })\n  )\n\n  private isDestroyed = false\n  private logger: ReturnType<typeof createLogger>\n\n  constructor() {\n    this.logger = createLogger(this.config.enableLogging, this.config.logger)\n\n    // Start authentication flow eagerly on construction.\n    // This is intentional: auth begins as soon as the app boots so the token\n    // is ready when CardsAppComponent renders, reducing perceived load time.\n    this.refreshToken()\n  }\n\n  ngOnDestroy(): void {\n    this.isDestroyed = true\n  }\n\n  /**\n   * Invalidates the current token, triggering a refresh.\n   * Called when the iframe signals that the token has expired.\n   */\n  invalidateToken(): void {\n    this.logger.log('CapitalOsAuthService: Invalidating token')\n    this._longLivedToken$.next(undefined)\n    this._baseUrl$.next(undefined)\n    this._error$.next(undefined)\n    this.refreshToken()\n  }\n\n  /**\n   * Refreshes the token by fetching a new one-time token and exchanging it.\n   */\n  async refreshToken(): Promise<void> {\n    if (this.isDestroyed) {\n      return\n    }\n\n    // Prevent concurrent refresh calls - if already loading, skip\n    if (this._isLoading$.value) {\n      this.logger.log('CapitalOsAuthService: Token refresh already in progress, skipping')\n      return\n    }\n\n    this.logger.log('CapitalOsAuthService: Starting token refresh')\n    this._isLoading$.next(true)\n    this._error$.next(undefined)\n\n    try {\n      // Get one-time token from platform\n      const oneTimeToken = await this.config.getToken()\n      this.logger.log('CapitalOsAuthService: Received one-time token')\n\n      if (this.isDestroyed) {\n        return\n      }\n\n      // Exchange for long-lived token\n      const result = await this.tokenExchangeService.exchange(oneTimeToken, {\n        enableLogging: this.config.enableLogging,\n      })\n\n      if (this.isDestroyed) {\n        return\n      }\n\n      this._longLivedToken$.next(result.longLivedToken)\n      this._baseUrl$.next(result.baseUrl)\n      this._error$.next(undefined)\n      this.logger.log('CapitalOsAuthService: Token exchange complete')\n    } catch (rawError) {\n      if (!this.isDestroyed) {\n        const error = toError(rawError)\n        this.logger.error(`CapitalOsAuthService: Token refresh failed: ${error.message}`)\n        this._error$.next(error)\n      }\n    } finally {\n      if (!this.isDestroyed) {\n        this._isLoading$.next(false)\n      }\n    }\n  }\n}\n"]}

package/esm2020/lib/capitalos.module.mjs

@@ -0,0 +1,48 @@
+import { NgModule } from '@angular/core';
+import { CardsAppComponent } from './cards-app.component';
+import { CAPITALOS_CONFIG } from './provide-capitalos';
+import { CapitalOsAuthService } from './capitalos-auth.service';
+import { TokenExchangeService } from './token-exchange.service';
+import * as i0 from "@angular/core";
+/**
+ * NgModule for CapitalOS SDK.
+ *
+ * Use this module for NgModule-based Angular applications.
+ * For standalone applications, use provideCapitalOs() instead.
+ *
+ * Usage:
+ * ```typescript
+ * @NgModule({
+ *   imports: [
+ *     CapitalOsModule.forRoot({
+ *       getToken: async () => {
+ *         const response = await fetch('/api/capitalos/token');
+ *         const data = await response.json();
+ *         return data.token;
+ *       },
+ *       enableLogging: true,
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export class CapitalOsModule {
+    static forRoot(config) {
+        return {
+            ngModule: CapitalOsModule,
+            providers: [{ provide: CAPITALOS_CONFIG, useValue: config }, TokenExchangeService, CapitalOsAuthService],
+        };
+    }
+}
+CapitalOsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CapitalOsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CapitalOsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: CapitalOsModule, imports: [CardsAppComponent], exports: [CardsAppComponent] });
+CapitalOsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CapitalOsModule, imports: [CardsAppComponent] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CapitalOsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CardsAppComponent],
+                    exports: [CardsAppComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/cards-app.component.mjs

@@ -0,0 +1,93 @@
+import { Component, inject, Input, Output, EventEmitter, ViewChild, } from '@angular/core';
+import { IframeManager, CapitalOSError } from '@capitalos/core';
+import { CapitalOsAuthService } from './capitalos-auth.service';
+import { CAPITALOS_CONFIG } from './provide-capitalos';
+import * as i0 from "@angular/core";
+// TODO: Automate version injection at build time
+const SDK_VERSION = '0.1.0-rc.1';
+/**
+ * CardsApp component that renders the CapitalOS cards interface in an iframe.
+ *
+ * The component emits events for loading state - consumers should handle their own loading UI:
+ *
+ * ```html
+ * <div *ngIf="!cardsLoaded">
+ *   <my-loading-spinner></my-loading-spinner>
+ * </div>
+ * <capitalos-cards-app
+ *   (loaded)="cardsLoaded = true"
+ *   (error)="onCardsError($event)"
+ * ></capitalos-cards-app>
+ * ```
+ */
+export class CardsAppComponent {
+    constructor() {
+        // Injected services
+        this.authService = inject(CapitalOsAuthService);
+        this.config = inject(CAPITALOS_CONFIG);
+        this.heightOffsetPx = 12;
+        // Outputs
+        this.loaded = new EventEmitter();
+        this.error = new EventEmitter();
+    }
+    ngAfterViewInit() {
+        // Subscribe to tokenData$ and initialize iframe when ready
+        this.tokenDataSubscription = this.authService.tokenData$.subscribe((tokenData) => {
+            if (tokenData && this.iframeContainer) {
+                this.initializeIframe(tokenData, this.iframeContainer.nativeElement);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.tokenDataSubscription?.unsubscribe();
+        this.iframeManager?.destroy();
+    }
+    initializeIframe(tokenData, container) {
+        // Destroy previous iframe if exists
+        this.iframeManager?.destroy();
+        const resolvedEnableLogging = this.enableLogging ?? this.config.enableLogging ?? false;
+        const resolvedTheme = this.theme ?? this.config.theme;
+        this.iframeManager = new IframeManager({
+            container,
+            tokenData,
+            renderingContext: { entryPoint: 'cardsApp' },
+            theme: resolvedTheme,
+            enableLogging: resolvedEnableLogging,
+            logger: this.config.logger,
+            sdkVersion: SDK_VERSION,
+            heightOffsetPx: this.heightOffsetPx,
+            callbacks: {
+                onLoad: () => {
+                    this.loaded.emit();
+                },
+                onError: (rawError) => {
+                    const capitalOsError = new CapitalOSError(rawError);
+                    this.error.emit(capitalOsError);
+                },
+                onTokenExpired: () => {
+                    this.authService.invalidateToken();
+                },
+            },
+        });
+    }
+}
+CardsAppComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CardsAppComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CardsAppComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: CardsAppComponent, isStandalone: true, selector: "capitalos-cards-app", inputs: { theme: "theme", heightOffsetPx: "heightOffsetPx", enableLogging: "enableLogging" }, outputs: { loaded: "loaded", error: "error" }, viewQueries: [{ propertyName: "iframeContainer", first: true, predicate: ["iframeContainer"], descendants: true }], ngImport: i0, template: `<div #iframeContainer class="capitalos-iframe-container"></div>`, isInline: true, styles: [":host{display:block;width:100%}.capitalos-iframe-container{width:100%}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CardsAppComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'capitalos-cards-app', standalone: true, template: `<div #iframeContainer class="capitalos-iframe-container"></div>`, styles: [":host{display:block;width:100%}.capitalos-iframe-container{width:100%}\n"] }]
+        }], propDecorators: { theme: [{
+                type: Input
+            }], heightOffsetPx: [{
+                type: Input
+            }], enableLogging: [{
+                type: Input
+            }], loaded: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }], iframeContainer: [{
+                type: ViewChild,
+                args: ['iframeContainer']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/provide-capitalos.mjs

@@ -0,0 +1,39 @@
+import { InjectionToken } from '@angular/core';
+import { CapitalOsAuthService } from './capitalos-auth.service';
+import { TokenExchangeService } from './token-exchange.service';
+/**
+ * Injection token for CapitalOS configuration
+ */
+export const CAPITALOS_CONFIG = new InjectionToken('CAPITALOS_CONFIG');
+/**
+ * Provides the CapitalOS SDK with the specified configuration.
+ *
+ * Usage in app.config.ts (standalone):
+ * ```typescript
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideCapitalOs({
+ *       getToken: async () => {
+ *         const response = await fetch('/api/capitalos/token');
+ *         const data = await response.json();
+ *         return data.token;
+ *       },
+ *       enableLogging: true,
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * For NgModule-based apps, use CapitalOsModule.forRoot() instead.
+ */
+export function provideCapitalOs(config) {
+    return [
+        {
+            provide: CAPITALOS_CONFIG,
+            useValue: config,
+        },
+        TokenExchangeService,
+        CapitalOsAuthService,
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/token-exchange.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable, inject } from '@angular/core';
+import { exchangeOneTimeToken } from '@capitalos/core';
+import { CAPITALOS_CONFIG } from './provide-capitalos';
+import * as i0 from "@angular/core";
+const TOKEN_EXCHANGE_TIMEOUT_MS = 10000;
+/**
+ * Service responsible for exchanging one-time tokens for long-lived JWTs.
+ * Creates a hidden iframe to perform the token exchange securely.
+ */
+export class TokenExchangeService {
+    constructor() {
+        this.config = inject(CAPITALOS_CONFIG);
+        this.isDestroyed = false;
+        this.activeAbortController = null;
+    }
+    ngOnDestroy() {
+        this.isDestroyed = true;
+        this.activeAbortController?.abort();
+        this.activeAbortController = null;
+    }
+    /**
+     * Exchanges a one-time token for a long-lived JWT.
+     * Delegates to @capitalos/core (browser-only) which handles iframe + Penpal lifecycle.
+     */
+    async exchange(oneTimeToken, options = {}) {
+        if (this.isDestroyed) {
+            throw new Error('TokenExchangeService was destroyed');
+        }
+        // Abort any in-flight exchange when a new one begins.
+        this.activeAbortController?.abort();
+        const abortController = new AbortController();
+        this.activeAbortController = abortController;
+        try {
+            return await exchangeOneTimeToken({
+                oneTimeToken,
+                enableLogging: options.enableLogging,
+                logger: this.config.logger,
+                timeoutMs: TOKEN_EXCHANGE_TIMEOUT_MS,
+                signal: abortController.signal,
+            });
+        }
+        finally {
+            if (this.activeAbortController === abortController) {
+                this.activeAbortController = null;
+            }
+        }
+    }
+}
+TokenExchangeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TokenExchangeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TokenExchangeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TokenExchangeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TokenExchangeService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -0,0 +1,13 @@
+/*
+ * Public API Surface of @capitalos/angular
+ */
+// Components
+export { CardsAppComponent } from './lib/cards-app.component';
+// Services
+export { CapitalOsAuthService } from './lib/capitalos-auth.service';
+// Provider (standalone)
+export { provideCapitalOs, CAPITALOS_CONFIG } from './lib/provide-capitalos';
+// Module (NgModule-based apps)
+export { CapitalOsModule } from './lib/capitalos.module';
+export { CapitalOSError, ErrorCode } from '@capitalos/core';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NhcGl0YWxvcy1hbmd1bGFyL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsYUFBYTtBQUNiLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDJCQUEyQixDQUFBO0FBRTdELFdBQVc7QUFDWCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQTtBQUduRSx3QkFBd0I7QUFDeEIsT0FBTyxFQUFFLGdCQUFnQixFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUE7QUFHNUUsK0JBQStCO0FBQy9CLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQTtBQUt4RCxPQUFPLEVBQUUsY0FBYyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlCQUFpQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBAY2FwaXRhbG9zL2FuZ3VsYXJcbiAqL1xuXG4vLyBDb21wb25lbnRzXG5leHBvcnQgeyBDYXJkc0FwcENvbXBvbmVudCB9IGZyb20gJy4vbGliL2NhcmRzLWFwcC5jb21wb25lbnQnXG5cbi8vIFNlcnZpY2VzXG5leHBvcnQgeyBDYXBpdGFsT3NBdXRoU2VydmljZSB9IGZyb20gJy4vbGliL2NhcGl0YWxvcy1hdXRoLnNlcnZpY2UnXG5leHBvcnQgdHlwZSB7IEF1dGhTdGF0ZSB9IGZyb20gJy4vbGliL2NhcGl0YWxvcy1hdXRoLnNlcnZpY2UnXG5cbi8vIFByb3ZpZGVyIChzdGFuZGFsb25lKVxuZXhwb3J0IHsgcHJvdmlkZUNhcGl0YWxPcywgQ0FQSVRBTE9TX0NPTkZJRyB9IGZyb20gJy4vbGliL3Byb3ZpZGUtY2FwaXRhbG9zJ1xuZXhwb3J0IHR5cGUgeyBDYXBpdGFsT3NDb25maWcgfSBmcm9tICcuL2xpYi9wcm92aWRlLWNhcGl0YWxvcydcblxuLy8gTW9kdWxlIChOZ01vZHVsZS1iYXNlZCBhcHBzKVxuZXhwb3J0IHsgQ2FwaXRhbE9zTW9kdWxlIH0gZnJvbSAnLi9saWIvY2FwaXRhbG9zLm1vZHVsZSdcblxuLy8gUmUtZXhwb3J0IGNvbW1vbmx5IHVzZWQgdHlwZXMgZnJvbSBjb3JlXG5leHBvcnQgdHlwZSB7IFRoZW1lQ29sb3JTY2hlbWUsIExvZ2dlciwgVG9rZW5EYXRhLCBSYXdFcnJvckRldGFpbHMgfSBmcm9tICdAY2FwaXRhbG9zL2NvcmUnXG5cbmV4cG9ydCB7IENhcGl0YWxPU0Vycm9yLCBFcnJvckNvZGUgfSBmcm9tICdAY2FwaXRhbG9zL2NvcmUnXG4iXX0=