@authon/angular 0.1.0

package/README.md

@@ -0,0 +1,115 @@
+# @authon/angular
+
+Angular SDK for [Authon](https://authon.dev) — service, guard, and interceptor.
+
+## Install
+
+```bash
+npm install @authon/angular
+# or
+pnpm add @authon/angular
+```
+
+Requires `@angular/core >= 16.0.0`.
+
+## Quick Start
+
+### 1. Import Module
+
+```ts
+// app.config.ts
+import { provideAuthon } from '@authon/angular';
+
+export const appConfig = {
+  providers: [
+    provideAuthon({
+      publishableKey: 'pk_live_...',
+    }),
+  ],
+};
+```
+
+### 2. Use the Service
+
+```ts
+import { Component } from '@angular/core';
+import { AuthonService } from '@authon/angular';
+
+@Component({
+  selector: 'app-header',
+  template: `
+    @if (auth.isSignedIn()) {
+      <button (click)="auth.signOut()">Sign Out</button>
+      <p>{{ auth.user()?.displayName }}</p>
+    } @else {
+      <button (click)="auth.openSignIn()">Sign In</button>
+    }
+  `,
+})
+export class HeaderComponent {
+  constructor(public auth: AuthonService) {}
+}
+```
+
+### 3. Route Guard
+
+```ts
+// app.routes.ts
+import { authGuard } from '@authon/angular';
+
+export const routes = [
+  { path: 'dashboard', component: DashboardComponent, canActivate: [authGuard] },
+  { path: 'login', component: LoginComponent },
+];
+```
+
+### 4. HTTP Interceptor
+
+Automatically attach the access token to outgoing requests:
+
+```ts
+// app.config.ts
+import { provideAuthon, authInterceptor } from '@authon/angular';
+import { provideHttpClient, withInterceptors } from '@angular/common/http';
+
+export const appConfig = {
+  providers: [
+    provideAuthon({ publishableKey: 'pk_live_...' }),
+    provideHttpClient(withInterceptors([authInterceptor])),
+  ],
+};
+```
+
+## API Reference
+
+### `AuthonService`
+
+| Property / Method | Type | Description |
+|-------------------|------|-------------|
+| `user()` | `Signal<AuthonUser \| null>` | Current user signal |
+| `isSignedIn()` | `Signal<boolean>` | Whether signed in |
+| `isLoading()` | `Signal<boolean>` | Loading state |
+| `openSignIn()` | `Promise<void>` | Open sign-in modal |
+| `openSignUp()` | `Promise<void>` | Open sign-up modal |
+| `signOut()` | `Promise<void>` | Sign out |
+| `getToken()` | `string \| null` | Get current access token |
+
+### Guard
+
+| Export | Description |
+|--------|-------------|
+| `authGuard` | `CanActivateFn` that redirects unauthenticated users |
+
+### Interceptor
+
+| Export | Description |
+|--------|-------------|
+| `authInterceptor` | `HttpInterceptorFn` that adds Bearer token to requests |
+
+## Documentation
+
+[authon.dev/docs](https://authon.dev/docs)
+
+## License
+
+[MIT](../../LICENSE)

package/dist/index.cjs

@@ -0,0 +1,132 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AUTHON_CONFIG: () => AUTHON_CONFIG,
+  AuthonService: () => AuthonService,
+  authGuard: () => authGuard,
+  provideAuthon: () => provideAuthon
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/service.ts
+var import_js = require("@authon/js");
+var AUTHON_CONFIG = "AUTHON_CONFIG";
+var AuthonService = class {
+  client;
+  _user = null;
+  _isSignedIn = false;
+  _isLoading = true;
+  _listeners = [];
+  constructor(config) {
+    this.client = new import_js.Authon(config.publishableKey, config.config);
+    this.client.on("signedIn", (user) => {
+      this._user = user;
+      this._isSignedIn = true;
+      this._isLoading = false;
+      this.notifyListeners();
+    });
+    this.client.on("signedOut", () => {
+      this._user = null;
+      this._isSignedIn = false;
+      this.notifyListeners();
+    });
+    this.client.on("error", () => {
+      this._isLoading = false;
+      this.notifyListeners();
+    });
+    this._isLoading = false;
+  }
+  get user() {
+    return this._user;
+  }
+  get isSignedIn() {
+    return this._isSignedIn;
+  }
+  get isLoading() {
+    return this._isLoading;
+  }
+  async openSignIn() {
+    await this.client.openSignIn();
+  }
+  async openSignUp() {
+    await this.client.openSignUp();
+  }
+  async signOut() {
+    await this.client.signOut();
+    this._user = null;
+    this._isSignedIn = false;
+    this.notifyListeners();
+  }
+  getToken() {
+    return this.client.getToken();
+  }
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Subscribe to auth state changes.
+   * Returns an unsubscribe function.
+   */
+  onStateChange(callback) {
+    this._listeners.push(callback);
+    return () => {
+      this._listeners = this._listeners.filter((l) => l !== callback);
+    };
+  }
+  destroy() {
+    this.client.destroy();
+    this._listeners = [];
+  }
+  notifyListeners() {
+    for (const listener of this._listeners) {
+      listener();
+    }
+  }
+};
+
+// src/guard.ts
+function authGuard(authonService, redirectTo = "/sign-in") {
+  if (authonService.isLoading) {
+    return false;
+  }
+  if (!authonService.isSignedIn) {
+    return { path: redirectTo };
+  }
+  return true;
+}
+
+// src/helpers.ts
+function provideAuthon(config) {
+  const service = new AuthonService(config);
+  return [
+    { provide: AUTHON_CONFIG, useValue: config },
+    { provide: "AuthonService", useValue: service }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTHON_CONFIG,
+  AuthonService,
+  authGuard,
+  provideAuthon
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/service.ts","../src/guard.ts","../src/helpers.ts"],"sourcesContent":["export { AuthonService, AUTHON_CONFIG, type AuthonServiceConfig } from './service';\nexport { authGuard } from './guard';\nexport { provideAuthon } from './helpers';\n","import { Authon } from '@authon/js';\nimport type { AuthonConfig } from '@authon/js';\nimport type { AuthonUser } from '@authon/shared';\n\n/**\n * Injection token key for Authon configuration.\n * Used with Angular's InjectionToken.\n */\nexport const AUTHON_CONFIG = 'AUTHON_CONFIG';\n\nexport interface AuthonServiceConfig {\n  publishableKey: string;\n  config?: Omit<AuthonConfig, 'mode'>;\n}\n\n/**\n * Plain class wrapping @authon/js for Angular dependency injection.\n *\n * Since tsup cannot compile Angular decorators, this is a plain class.\n * Users should wrap it in their own injectable service:\n *\n * ```ts\n * import { Injectable } from '@angular/core';\n * import { AuthonService as BaseAuthonService } from '@authon/angular';\n *\n * @Injectable({ providedIn: 'root' })\n * export class AuthonService extends BaseAuthonService {\n *   constructor() {\n *     super({ publishableKey: 'pk_live_...' });\n *   }\n * }\n * ```\n *\n * Or use the `provideAuthon()` helper for standalone components.\n */\nexport class AuthonService {\n  private client: Authon;\n  private _user: AuthonUser | null = null;\n  private _isSignedIn = false;\n  private _isLoading = true;\n  private _listeners: Array<() => void> = [];\n\n  constructor(config: AuthonServiceConfig) {\n    this.client = new Authon(config.publishableKey, config.config);\n\n    this.client.on('signedIn', (user) => {\n      this._user = user as AuthonUser;\n      this._isSignedIn = true;\n      this._isLoading = false;\n      this.notifyListeners();\n    });\n\n    this.client.on('signedOut', () => {\n      this._user = null;\n      this._isSignedIn = false;\n      this.notifyListeners();\n    });\n\n    this.client.on('error', () => {\n      this._isLoading = false;\n      this.notifyListeners();\n    });\n\n    this._isLoading = false;\n  }\n\n  get user(): AuthonUser | null {\n    return this._user;\n  }\n\n  get isSignedIn(): boolean {\n    return this._isSignedIn;\n  }\n\n  get isLoading(): boolean {\n    return this._isLoading;\n  }\n\n  async openSignIn(): Promise<void> {\n    await this.client.openSignIn();\n  }\n\n  async openSignUp(): Promise<void> {\n    await this.client.openSignUp();\n  }\n\n  async signOut(): Promise<void> {\n    await this.client.signOut();\n    this._user = null;\n    this._isSignedIn = false;\n    this.notifyListeners();\n  }\n\n  getToken(): string | null {\n    return this.client.getToken();\n  }\n\n  getClient(): Authon {\n    return this.client;\n  }\n\n  /**\n   * Subscribe to auth state changes.\n   * Returns an unsubscribe function.\n   */\n  onStateChange(callback: () => void): () => void {\n    this._listeners.push(callback);\n    return () => {\n      this._listeners = this._listeners.filter((l) => l !== callback);\n    };\n  }\n\n  destroy(): void {\n    this.client.destroy();\n    this._listeners = [];\n  }\n\n  private notifyListeners(): void {\n    for (const listener of this._listeners) {\n      listener();\n    }\n  }\n}\n","import type { AuthonService } from './service';\n\n/**\n * Route guard factory for Angular Router (CanActivateFn style).\n *\n * Since tsup can't compile Angular decorators, this returns a plain function.\n * Users wire it up in their route config:\n *\n * ```ts\n * import { inject } from '@angular/core';\n * import { authGuard } from '@authon/angular';\n * import { AuthonService } from './authon.service'; // your injectable wrapper\n *\n * const routes = [\n *   {\n *     path: 'dashboard',\n *     component: DashboardComponent,\n *     canActivate: [() => {\n *       const authon = inject(AuthonService);\n *       return authGuard(authon, '/login');\n *     }],\n *   },\n * ];\n * ```\n */\nexport function authGuard(\n  authonService: AuthonService,\n  redirectTo = '/sign-in',\n): boolean | { path: string } {\n  if (authonService.isLoading) {\n    return false;\n  }\n\n  if (!authonService.isSignedIn) {\n    return { path: redirectTo };\n  }\n\n  return true;\n}\n","import { AuthonService, AUTHON_CONFIG, type AuthonServiceConfig } from './service';\n\n/**\n * Provider factory for Angular standalone components.\n *\n * Usage in app.config.ts:\n * ```ts\n * import { provideAuthon } from '@authon/angular';\n *\n * export const appConfig = {\n *   providers: [\n *     ...provideAuthon({ publishableKey: 'pk_live_...' }),\n *   ],\n * };\n * ```\n *\n * Then inject in your components:\n * ```ts\n * import { Inject } from '@angular/core';\n * import { AUTHON_CONFIG, AuthonService } from '@authon/angular';\n *\n * constructor(@Inject('AuthonService') private authon: AuthonService) {}\n * ```\n */\nexport function provideAuthon(config: AuthonServiceConfig) {\n  const service = new AuthonService(config);\n\n  return [\n    { provide: AUTHON_CONFIG, useValue: config },\n    { provide: 'AuthonService', useValue: service },\n  ];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,gBAAuB;AAQhB,IAAM,gBAAgB;AA2BtB,IAAM,gBAAN,MAAoB;AAAA,EACjB;AAAA,EACA,QAA2B;AAAA,EAC3B,cAAc;AAAA,EACd,aAAa;AAAA,EACb,aAAgC,CAAC;AAAA,EAEzC,YAAY,QAA6B;AACvC,SAAK,SAAS,IAAI,iBAAO,OAAO,gBAAgB,OAAO,MAAM;AAE7D,SAAK,OAAO,GAAG,YAAY,CAAC,SAAS;AACnC,WAAK,QAAQ;AACb,WAAK,cAAc;AACnB,WAAK,aAAa;AAClB,WAAK,gBAAgB;AAAA,IACvB,CAAC;AAED,SAAK,OAAO,GAAG,aAAa,MAAM;AAChC,WAAK,QAAQ;AACb,WAAK,cAAc;AACnB,WAAK,gBAAgB;AAAA,IACvB,CAAC;AAED,SAAK,OAAO,GAAG,SAAS,MAAM;AAC5B,WAAK,aAAa;AAClB,WAAK,gBAAgB;AAAA,IACvB,CAAC;AAED,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,IAAI,OAA0B;AAC5B,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,aAAsB;AACxB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,YAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAM,aAA4B;AAChC,UAAM,KAAK,OAAO,WAAW;AAAA,EAC/B;AAAA,EAEA,MAAM,aAA4B;AAChC,UAAM,KAAK,OAAO,WAAW;AAAA,EAC/B;AAAA,EAEA,MAAM,UAAyB;AAC7B,UAAM,KAAK,OAAO,QAAQ;AAC1B,SAAK,QAAQ;AACb,SAAK,cAAc;AACnB,SAAK,gBAAgB;AAAA,EACvB;AAAA,EAEA,WAA0B;AACxB,WAAO,KAAK,OAAO,SAAS;AAAA,EAC9B;AAAA,EAEA,YAAoB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,cAAc,UAAkC;AAC9C,SAAK,WAAW,KAAK,QAAQ;AAC7B,WAAO,MAAM;AACX,WAAK,aAAa,KAAK,WAAW,OAAO,CAAC,MAAM,MAAM,QAAQ;AAAA,IAChE;AAAA,EACF;AAAA,EAEA,UAAgB;AACd,SAAK,OAAO,QAAQ;AACpB,SAAK,aAAa,CAAC;AAAA,EACrB;AAAA,EAEQ,kBAAwB;AAC9B,eAAW,YAAY,KAAK,YAAY;AACtC,eAAS;AAAA,IACX;AAAA,EACF;AACF;;;ACjGO,SAAS,UACd,eACA,aAAa,YACe;AAC5B,MAAI,cAAc,WAAW;AAC3B,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,cAAc,YAAY;AAC7B,WAAO,EAAE,MAAM,WAAW;AAAA,EAC5B;AAEA,SAAO;AACT;;;ACdO,SAAS,cAAc,QAA6B;AACzD,QAAM,UAAU,IAAI,cAAc,MAAM;AAExC,SAAO;AAAA,IACL,EAAE,SAAS,eAAe,UAAU,OAAO;AAAA,IAC3C,EAAE,SAAS,iBAAiB,UAAU,QAAQ;AAAA,EAChD;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,114 @@
+import { AuthonConfig, Authon } from '@authon/js';
+import { AuthonUser } from '@authon/shared';
+
+/**
+ * Injection token key for Authon configuration.
+ * Used with Angular's InjectionToken.
+ */
+declare const AUTHON_CONFIG = "AUTHON_CONFIG";
+interface AuthonServiceConfig {
+    publishableKey: string;
+    config?: Omit<AuthonConfig, 'mode'>;
+}
+/**
+ * Plain class wrapping @authon/js for Angular dependency injection.
+ *
+ * Since tsup cannot compile Angular decorators, this is a plain class.
+ * Users should wrap it in their own injectable service:
+ *
+ * ```ts
+ * import { Injectable } from '@angular/core';
+ * import { AuthonService as BaseAuthonService } from '@authon/angular';
+ *
+ * @Injectable({ providedIn: 'root' })
+ * export class AuthonService extends BaseAuthonService {
+ *   constructor() {
+ *     super({ publishableKey: 'pk_live_...' });
+ *   }
+ * }
+ * ```
+ *
+ * Or use the `provideAuthon()` helper for standalone components.
+ */
+declare class AuthonService {
+    private client;
+    private _user;
+    private _isSignedIn;
+    private _isLoading;
+    private _listeners;
+    constructor(config: AuthonServiceConfig);
+    get user(): AuthonUser | null;
+    get isSignedIn(): boolean;
+    get isLoading(): boolean;
+    openSignIn(): Promise<void>;
+    openSignUp(): Promise<void>;
+    signOut(): Promise<void>;
+    getToken(): string | null;
+    getClient(): Authon;
+    /**
+     * Subscribe to auth state changes.
+     * Returns an unsubscribe function.
+     */
+    onStateChange(callback: () => void): () => void;
+    destroy(): void;
+    private notifyListeners;
+}
+
+/**
+ * Route guard factory for Angular Router (CanActivateFn style).
+ *
+ * Since tsup can't compile Angular decorators, this returns a plain function.
+ * Users wire it up in their route config:
+ *
+ * ```ts
+ * import { inject } from '@angular/core';
+ * import { authGuard } from '@authon/angular';
+ * import { AuthonService } from './authon.service'; // your injectable wrapper
+ *
+ * const routes = [
+ *   {
+ *     path: 'dashboard',
+ *     component: DashboardComponent,
+ *     canActivate: [() => {
+ *       const authon = inject(AuthonService);
+ *       return authGuard(authon, '/login');
+ *     }],
+ *   },
+ * ];
+ * ```
+ */
+declare function authGuard(authonService: AuthonService, redirectTo?: string): boolean | {
+    path: string;
+};
+
+/**
+ * Provider factory for Angular standalone components.
+ *
+ * Usage in app.config.ts:
+ * ```ts
+ * import { provideAuthon } from '@authon/angular';
+ *
+ * export const appConfig = {
+ *   providers: [
+ *     ...provideAuthon({ publishableKey: 'pk_live_...' }),
+ *   ],
+ * };
+ * ```
+ *
+ * Then inject in your components:
+ * ```ts
+ * import { Inject } from '@angular/core';
+ * import { AUTHON_CONFIG, AuthonService } from '@authon/angular';
+ *
+ * constructor(@Inject('AuthonService') private authon: AuthonService) {}
+ * ```
+ */
+declare function provideAuthon(config: AuthonServiceConfig): ({
+    provide: string;
+    useValue: AuthonServiceConfig;
+} | {
+    provide: string;
+    useValue: AuthonService;
+})[];
+
+export { AUTHON_CONFIG, AuthonService, type AuthonServiceConfig, authGuard, provideAuthon };

package/dist/index.d.ts

@@ -0,0 +1,114 @@
+import { AuthonConfig, Authon } from '@authon/js';
+import { AuthonUser } from '@authon/shared';
+
+/**
+ * Injection token key for Authon configuration.
+ * Used with Angular's InjectionToken.
+ */
+declare const AUTHON_CONFIG = "AUTHON_CONFIG";
+interface AuthonServiceConfig {
+    publishableKey: string;
+    config?: Omit<AuthonConfig, 'mode'>;
+}
+/**
+ * Plain class wrapping @authon/js for Angular dependency injection.
+ *
+ * Since tsup cannot compile Angular decorators, this is a plain class.
+ * Users should wrap it in their own injectable service:
+ *
+ * ```ts
+ * import { Injectable } from '@angular/core';
+ * import { AuthonService as BaseAuthonService } from '@authon/angular';
+ *
+ * @Injectable({ providedIn: 'root' })
+ * export class AuthonService extends BaseAuthonService {
+ *   constructor() {
+ *     super({ publishableKey: 'pk_live_...' });
+ *   }
+ * }
+ * ```
+ *
+ * Or use the `provideAuthon()` helper for standalone components.
+ */
+declare class AuthonService {
+    private client;
+    private _user;
+    private _isSignedIn;
+    private _isLoading;
+    private _listeners;
+    constructor(config: AuthonServiceConfig);
+    get user(): AuthonUser | null;
+    get isSignedIn(): boolean;
+    get isLoading(): boolean;
+    openSignIn(): Promise<void>;
+    openSignUp(): Promise<void>;
+    signOut(): Promise<void>;
+    getToken(): string | null;
+    getClient(): Authon;
+    /**
+     * Subscribe to auth state changes.
+     * Returns an unsubscribe function.
+     */
+    onStateChange(callback: () => void): () => void;
+    destroy(): void;
+    private notifyListeners;
+}
+
+/**
+ * Route guard factory for Angular Router (CanActivateFn style).
+ *
+ * Since tsup can't compile Angular decorators, this returns a plain function.
+ * Users wire it up in their route config:
+ *
+ * ```ts
+ * import { inject } from '@angular/core';
+ * import { authGuard } from '@authon/angular';
+ * import { AuthonService } from './authon.service'; // your injectable wrapper
+ *
+ * const routes = [
+ *   {
+ *     path: 'dashboard',
+ *     component: DashboardComponent,
+ *     canActivate: [() => {
+ *       const authon = inject(AuthonService);
+ *       return authGuard(authon, '/login');
+ *     }],
+ *   },
+ * ];
+ * ```
+ */
+declare function authGuard(authonService: AuthonService, redirectTo?: string): boolean | {
+    path: string;
+};
+
+/**
+ * Provider factory for Angular standalone components.
+ *
+ * Usage in app.config.ts:
+ * ```ts
+ * import { provideAuthon } from '@authon/angular';
+ *
+ * export const appConfig = {
+ *   providers: [
+ *     ...provideAuthon({ publishableKey: 'pk_live_...' }),
+ *   ],
+ * };
+ * ```
+ *
+ * Then inject in your components:
+ * ```ts
+ * import { Inject } from '@angular/core';
+ * import { AUTHON_CONFIG, AuthonService } from '@authon/angular';
+ *
+ * constructor(@Inject('AuthonService') private authon: AuthonService) {}
+ * ```
+ */
+declare function provideAuthon(config: AuthonServiceConfig): ({
+    provide: string;
+    useValue: AuthonServiceConfig;
+} | {
+    provide: string;
+    useValue: AuthonService;
+})[];
+
+export { AUTHON_CONFIG, AuthonService, type AuthonServiceConfig, authGuard, provideAuthon };

package/dist/index.js

@@ -0,0 +1,102 @@
+// src/service.ts
+import { Authon } from "@authon/js";
+var AUTHON_CONFIG = "AUTHON_CONFIG";
+var AuthonService = class {
+  client;
+  _user = null;
+  _isSignedIn = false;
+  _isLoading = true;
+  _listeners = [];
+  constructor(config) {
+    this.client = new Authon(config.publishableKey, config.config);
+    this.client.on("signedIn", (user) => {
+      this._user = user;
+      this._isSignedIn = true;
+      this._isLoading = false;
+      this.notifyListeners();
+    });
+    this.client.on("signedOut", () => {
+      this._user = null;
+      this._isSignedIn = false;
+      this.notifyListeners();
+    });
+    this.client.on("error", () => {
+      this._isLoading = false;
+      this.notifyListeners();
+    });
+    this._isLoading = false;
+  }
+  get user() {
+    return this._user;
+  }
+  get isSignedIn() {
+    return this._isSignedIn;
+  }
+  get isLoading() {
+    return this._isLoading;
+  }
+  async openSignIn() {
+    await this.client.openSignIn();
+  }
+  async openSignUp() {
+    await this.client.openSignUp();
+  }
+  async signOut() {
+    await this.client.signOut();
+    this._user = null;
+    this._isSignedIn = false;
+    this.notifyListeners();
+  }
+  getToken() {
+    return this.client.getToken();
+  }
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Subscribe to auth state changes.
+   * Returns an unsubscribe function.
+   */
+  onStateChange(callback) {
+    this._listeners.push(callback);
+    return () => {
+      this._listeners = this._listeners.filter((l) => l !== callback);
+    };
+  }
+  destroy() {
+    this.client.destroy();
+    this._listeners = [];
+  }
+  notifyListeners() {
+    for (const listener of this._listeners) {
+      listener();
+    }
+  }
+};
+
+// src/guard.ts
+function authGuard(authonService, redirectTo = "/sign-in") {
+  if (authonService.isLoading) {
+    return false;
+  }
+  if (!authonService.isSignedIn) {
+    return { path: redirectTo };
+  }
+  return true;
+}
+
+// src/helpers.ts
+function provideAuthon(config) {
+  const service = new AuthonService(config);
+  return [
+    { provide: AUTHON_CONFIG, useValue: config },
+    { provide: "AuthonService", useValue: service }
+  ];
+}
+export {
+  AUTHON_CONFIG,
+  AuthonService,
+  authGuard,
+  provideAuthon
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/service.ts","../src/guard.ts","../src/helpers.ts"],"sourcesContent":["import { Authon } from '@authon/js';\nimport type { AuthonConfig } from '@authon/js';\nimport type { AuthonUser } from '@authon/shared';\n\n/**\n * Injection token key for Authon configuration.\n * Used with Angular's InjectionToken.\n */\nexport const AUTHON_CONFIG = 'AUTHON_CONFIG';\n\nexport interface AuthonServiceConfig {\n  publishableKey: string;\n  config?: Omit<AuthonConfig, 'mode'>;\n}\n\n/**\n * Plain class wrapping @authon/js for Angular dependency injection.\n *\n * Since tsup cannot compile Angular decorators, this is a plain class.\n * Users should wrap it in their own injectable service:\n *\n * ```ts\n * import { Injectable } from '@angular/core';\n * import { AuthonService as BaseAuthonService } from '@authon/angular';\n *\n * @Injectable({ providedIn: 'root' })\n * export class AuthonService extends BaseAuthonService {\n *   constructor() {\n *     super({ publishableKey: 'pk_live_...' });\n *   }\n * }\n * ```\n *\n * Or use the `provideAuthon()` helper for standalone components.\n */\nexport class AuthonService {\n  private client: Authon;\n  private _user: AuthonUser | null = null;\n  private _isSignedIn = false;\n  private _isLoading = true;\n  private _listeners: Array<() => void> = [];\n\n  constructor(config: AuthonServiceConfig) {\n    this.client = new Authon(config.publishableKey, config.config);\n\n    this.client.on('signedIn', (user) => {\n      this._user = user as AuthonUser;\n      this._isSignedIn = true;\n      this._isLoading = false;\n      this.notifyListeners();\n    });\n\n    this.client.on('signedOut', () => {\n      this._user = null;\n      this._isSignedIn = false;\n      this.notifyListeners();\n    });\n\n    this.client.on('error', () => {\n      this._isLoading = false;\n      this.notifyListeners();\n    });\n\n    this._isLoading = false;\n  }\n\n  get user(): AuthonUser | null {\n    return this._user;\n  }\n\n  get isSignedIn(): boolean {\n    return this._isSignedIn;\n  }\n\n  get isLoading(): boolean {\n    return this._isLoading;\n  }\n\n  async openSignIn(): Promise<void> {\n    await this.client.openSignIn();\n  }\n\n  async openSignUp(): Promise<void> {\n    await this.client.openSignUp();\n  }\n\n  async signOut(): Promise<void> {\n    await this.client.signOut();\n    this._user = null;\n    this._isSignedIn = false;\n    this.notifyListeners();\n  }\n\n  getToken(): string | null {\n    return this.client.getToken();\n  }\n\n  getClient(): Authon {\n    return this.client;\n  }\n\n  /**\n   * Subscribe to auth state changes.\n   * Returns an unsubscribe function.\n   */\n  onStateChange(callback: () => void): () => void {\n    this._listeners.push(callback);\n    return () => {\n      this._listeners = this._listeners.filter((l) => l !== callback);\n    };\n  }\n\n  destroy(): void {\n    this.client.destroy();\n    this._listeners = [];\n  }\n\n  private notifyListeners(): void {\n    for (const listener of this._listeners) {\n      listener();\n    }\n  }\n}\n","import type { AuthonService } from './service';\n\n/**\n * Route guard factory for Angular Router (CanActivateFn style).\n *\n * Since tsup can't compile Angular decorators, this returns a plain function.\n * Users wire it up in their route config:\n *\n * ```ts\n * import { inject } from '@angular/core';\n * import { authGuard } from '@authon/angular';\n * import { AuthonService } from './authon.service'; // your injectable wrapper\n *\n * const routes = [\n *   {\n *     path: 'dashboard',\n *     component: DashboardComponent,\n *     canActivate: [() => {\n *       const authon = inject(AuthonService);\n *       return authGuard(authon, '/login');\n *     }],\n *   },\n * ];\n * ```\n */\nexport function authGuard(\n  authonService: AuthonService,\n  redirectTo = '/sign-in',\n): boolean | { path: string } {\n  if (authonService.isLoading) {\n    return false;\n  }\n\n  if (!authonService.isSignedIn) {\n    return { path: redirectTo };\n  }\n\n  return true;\n}\n","import { AuthonService, AUTHON_CONFIG, type AuthonServiceConfig } from './service';\n\n/**\n * Provider factory for Angular standalone components.\n *\n * Usage in app.config.ts:\n * ```ts\n * import { provideAuthon } from '@authon/angular';\n *\n * export const appConfig = {\n *   providers: [\n *     ...provideAuthon({ publishableKey: 'pk_live_...' }),\n *   ],\n * };\n * ```\n *\n * Then inject in your components:\n * ```ts\n * import { Inject } from '@angular/core';\n * import { AUTHON_CONFIG, AuthonService } from '@authon/angular';\n *\n * constructor(@Inject('AuthonService') private authon: AuthonService) {}\n * ```\n */\nexport function provideAuthon(config: AuthonServiceConfig) {\n  const service = new AuthonService(config);\n\n  return [\n    { provide: AUTHON_CONFIG, useValue: config },\n    { provide: 'AuthonService', useValue: service },\n  ];\n}\n"],"mappings":";AAAA,SAAS,cAAc;AAQhB,IAAM,gBAAgB;AA2BtB,IAAM,gBAAN,MAAoB;AAAA,EACjB;AAAA,EACA,QAA2B;AAAA,EAC3B,cAAc;AAAA,EACd,aAAa;AAAA,EACb,aAAgC,CAAC;AAAA,EAEzC,YAAY,QAA6B;AACvC,SAAK,SAAS,IAAI,OAAO,OAAO,gBAAgB,OAAO,MAAM;AAE7D,SAAK,OAAO,GAAG,YAAY,CAAC,SAAS;AACnC,WAAK,QAAQ;AACb,WAAK,cAAc;AACnB,WAAK,aAAa;AAClB,WAAK,gBAAgB;AAAA,IACvB,CAAC;AAED,SAAK,OAAO,GAAG,aAAa,MAAM;AAChC,WAAK,QAAQ;AACb,WAAK,cAAc;AACnB,WAAK,gBAAgB;AAAA,IACvB,CAAC;AAED,SAAK,OAAO,GAAG,SAAS,MAAM;AAC5B,WAAK,aAAa;AAClB,WAAK,gBAAgB;AAAA,IACvB,CAAC;AAED,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,IAAI,OAA0B;AAC5B,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,aAAsB;AACxB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,YAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAM,aAA4B;AAChC,UAAM,KAAK,OAAO,WAAW;AAAA,EAC/B;AAAA,EAEA,MAAM,aAA4B;AAChC,UAAM,KAAK,OAAO,WAAW;AAAA,EAC/B;AAAA,EAEA,MAAM,UAAyB;AAC7B,UAAM,KAAK,OAAO,QAAQ;AAC1B,SAAK,QAAQ;AACb,SAAK,cAAc;AACnB,SAAK,gBAAgB;AAAA,EACvB;AAAA,EAEA,WAA0B;AACxB,WAAO,KAAK,OAAO,SAAS;AAAA,EAC9B;AAAA,EAEA,YAAoB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,cAAc,UAAkC;AAC9C,SAAK,WAAW,KAAK,QAAQ;AAC7B,WAAO,MAAM;AACX,WAAK,aAAa,KAAK,WAAW,OAAO,CAAC,MAAM,MAAM,QAAQ;AAAA,IAChE;AAAA,EACF;AAAA,EAEA,UAAgB;AACd,SAAK,OAAO,QAAQ;AACpB,SAAK,aAAa,CAAC;AAAA,EACrB;AAAA,EAEQ,kBAAwB;AAC9B,eAAW,YAAY,KAAK,YAAY;AACtC,eAAS;AAAA,IACX;AAAA,EACF;AACF;;;ACjGO,SAAS,UACd,eACA,aAAa,YACe;AAC5B,MAAI,cAAc,WAAW;AAC3B,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,cAAc,YAAY;AAC7B,WAAO,EAAE,MAAM,WAAW;AAAA,EAC5B;AAEA,SAAO;AACT;;;ACdO,SAAS,cAAc,QAA6B;AACzD,QAAM,UAAU,IAAI,cAAc,MAAM;AAExC,SAAO;AAAA,IACL,EAAE,SAAS,eAAe,UAAU,OAAO;AAAA,IAC3C,EAAE,SAAS,iBAAiB,UAAU,QAAQ;AAAA,EAChD;AACF;","names":[]}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@authon/angular",
+  "version": "0.1.0",
+  "description": "Authon Angular SDK — service, guard, and components",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mikusnuz/authon-sdk.git",
+    "directory": "packages/angular"
+  },
+  "homepage": "https://github.com/mikusnuz/authon-sdk/tree/main/packages/angular",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": ["authon", "angular", "auth", "guard"],
+  "dependencies": {
+    "@authon/js": "workspace:*",
+    "@authon/shared": "workspace:*"
+  },
+  "peerDependencies": {
+    "@angular/core": "^17.0.0 || ^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3"
+  }
+}