@atlasauth/angular 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atlas
+
+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,195 @@
+# @atlas/angular
+
+The official **Angular** SDK for Atlas — the Angular peer of [`@atlas/react`](../react). It wraps the framework-agnostic [`@atlas/js`](../js) client and exposes Atlas's reactive auth state, sign-in/up flows, prebuilt UI, authorization directives, and route guards as idiomatic modern Angular (standalone APIs, RxJS **and** Signals, DI).
+
+Requires **Angular 17+**.
+
+---
+
+## Install
+
+```bash
+pnpm add @atlas/angular
+# peers: @angular/core, @angular/common (>=17), rxjs (>=7); @angular/router if you use the guards
+```
+
+## Setup
+
+### Standalone (recommended, Angular 17+)
+
+`provideAtlas` is the analogue of wrapping your tree in React's `<AtlasProvider>`. Register it once at the application root:
+
+```ts
+import { bootstrapApplication } from '@angular/platform-browser';
+import { provideRouter } from '@angular/router';
+import { provideAtlas } from '@atlas/angular';
+import { AppComponent } from './app/app.component';
+import { routes } from './app/routes';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideAtlas({
+      publishableKey: 'pk_test_…',
+      // frontendApi: 'https://fapi.your-instance.atlasauth.net', // omit for same-origin
+      // appearance: { baseTheme: 'dark', elements: { formButtonPrimary: 'rounded-xl' } },
+      // localization: myCatalog,
+    }),
+    provideRouter(routes),
+  ],
+});
+```
+
+The service begins booting immediately — completing any OAuth/hosted-page redirect, scrubbing the URL, and reading the session — exactly as the React provider does on first render.
+
+### NgModule
+
+```ts
+import { AtlasModule } from '@atlas/angular';
+
+@NgModule({
+  imports: [AtlasModule.forRoot({ publishableKey: 'pk_test_…' })],
+})
+export class AppModule {}
+```
+
+Feature modules `import { AtlasModule }` (no `forRoot`) to use the directives and components. Standalone components import them individually, or spread `ATLAS_UI`:
+
+```ts
+import { ATLAS_UI } from '@atlas/angular';
+
+@Component({ standalone: true, imports: [...ATLAS_UI], template: '…' })
+export class DashboardComponent {}
+```
+
+---
+
+## `AtlasService`
+
+Injectable, `providedIn: 'root'`. The Angular peer of `<AtlasProvider>` + the React hooks. Exposes state twice so you can pick your idiom.
+
+**RxJS observables** (the primary API):
+
+```ts
+export class HeaderComponent {
+  private atlas = inject(AtlasService);
+
+  user$        = this.atlas.user$;         // Observable<AtlasUser | null>
+  session$     = this.atlas.session$;      // Observable<AtlasSession | null>
+  isSignedIn$  = this.atlas.isSignedIn$;   // Observable<boolean>
+  isLoaded$    = this.atlas.isLoaded$;
+  claims$      = this.atlas.claims$;
+  memberships$ = this.atlas.memberships$;
+  organization$= this.atlas.organization$;
+}
+```
+
+**Signals** (same values, for templates / `computed()`):
+
+```ts
+this.atlas.user();        // Signal<AtlasUser | null>
+this.atlas.isSignedIn();  // Signal<boolean>
+this.atlas.status();      // 'loading' | 'signed_in' | 'signed_out'
+```
+
+**Methods** (mirror the React hooks' actions):
+
+| Method | Mirrors |
+| --- | --- |
+| `getToken(): Promise<string \| null>` | `useAuth().getToken` — always fresh; refreshes if within 5s of expiry |
+| `getProviderToken(provider): Promise<ProviderToken \| null>` | `useUser().getProviderToken` — the user's own live token at a connected provider |
+| `has(condition): boolean` | `useAuth().has` — imperative permission check |
+| `signOut(): Promise<void>` | `useAuth().signOut` |
+| `setActiveOrganization(orgId \| null)` | `useOrganization().setActive` |
+| `reload(): Promise<void>` | re-read `/v1/client` |
+
+The session JWT lives only in memory (a `TokenCache`); the refresh token is HttpOnly and never touched by script. Refresh is proactive and jittered off the token's own expiry.
+
+---
+
+## Directives
+
+All standalone. Structural directives mirror React's `components.tsx`:
+
+```html
+<!-- render only when signed in (after boot) — React <SignedIn> -->
+<div *atlasSignedIn>Welcome back</div>
+
+<!-- render only when signed out — React <SignedOut> -->
+<atlas-sign-in *atlasSignedOut></atlas-sign-in>
+
+<!-- boot-state helpers — React <AtlasLoading> / <AtlasLoaded> -->
+<app-spinner *atlasLoading></app-spinner>
+<main *atlasLoaded>…</main>
+
+<!-- permission-gated rendering — React <Protect permission="…"> -->
+<button *atlasProtect="{ permission: 'org:sys_memberships:manage' }">Invite</button>
+
+<!-- with a fallback (identical microsyntax to *ngIf … else) -->
+<div *atlasProtect="{ role: 'admin' }; else denied">Admin tools</div>
+<ng-template #denied>You lack access.</ng-template>
+```
+
+`*atlasProtect` is a **rendering** helper, never an authorization boundary — the server checking the same permission is what actually stops a request. An empty condition (`*atlasProtect`) means simply "signed in".
+
+**Theming host** — apply the appearance tokens as `--atlas-*` CSS variables (React does this via the provider's wrapping `<div class="atlas-root">`):
+
+```html
+<div atlasRoot>
+  <router-outlet></router-outlet>
+</div>
+```
+
+## Components
+
+Server-driven, rendered in the host DOM (no iframe), themed via the `appearance` option:
+
+| Selector | Mirrors |
+| --- | --- |
+| `<atlas-sign-in>` | `<SignIn/>` |
+| `<atlas-sign-up>` | `<SignUp/>` |
+| `<atlas-user-button>` | `<UserButton/>` |
+| `<atlas-organization-switcher>` | `<OrganizationSwitcher/>` |
+| `<atlas-user-profile>` | `<UserProfile/>` |
+| `<atlas-organization-profile>` | `<OrganizationProfile/>` |
+
+`<atlas-sign-in>` / `<atlas-sign-up>` run the full multi-step flow (identifier → first factor → 2FA / enrollment → email code → completion, plus magic-link polling), driven entirely by the server-side attempt status through the shared `@atlas/js` engine.
+
+---
+
+## Route guards
+
+`atlasGuard` gates a route on session, and optionally on a permission/role — the router equivalent of fencing a page with `<SignedIn>` / `<Protect>`. It waits for boot to settle first, so a hard refresh onto a protected URL doesn't bounce to sign-in prematurely.
+
+```ts
+import { Routes } from '@angular/router';
+import { atlasGuard } from '@atlas/angular';
+
+export const routes: Routes = [
+  {
+    path: 'dashboard',
+    canActivate: [atlasGuard({ redirectTo: '/sign-in' })],
+    loadComponent: () => import('./dashboard.component').then((m) => m.DashboardComponent),
+  },
+  {
+    path: 'admin',
+    canActivate: [atlasGuard({ permission: 'org:admin', redirectTo: '/' })],
+    loadComponent: () => import('./admin.component').then((m) => m.AdminComponent),
+  },
+];
+```
+
+With `redirectTo` set the guard returns a `UrlTree` (redirect, with the attempted URL preserved as `redirect_url`); without it, it returns `false`. `atlasChildGuard` is the `CanActivateChild` form.
+
+Like the components, guards are UX, not security — the server enforces the same checks on every request.
+
+---
+
+## Theming & i18n
+
+`appearance` accepts design tokens + per-element class overrides and a `baseTheme` (`default`, `dark`, `neobrutalist`); overrides are **appended** to the base classes so your Tailwind/CSS just works. `localization` merges a catalog over `en-US`. Both are identical in shape to `@atlas/react` — see `appearance.ts` and `i18n.ts`, which are shared verbatim.
+
+## Build & test
+
+- **Build**: `pnpm --filter @atlas/angular build` (ng-packagr → `dist/`, an Angular Package Format bundle with FESM2022 + type definitions).
+- **Typecheck**: `pnpm --filter @atlas/angular typecheck`.
+- **Test**: unit specs run under the Angular CLI test runner (Karma/Jasmine or your configured runner). A starter spec lives in `src/lib/atlas.service.spec.ts`.

package/dist/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atlas
+
+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/dist/README.md

@@ -0,0 +1,195 @@
+# @atlas/angular
+
+The official **Angular** SDK for Atlas — the Angular peer of [`@atlas/react`](../react). It wraps the framework-agnostic [`@atlas/js`](../js) client and exposes Atlas's reactive auth state, sign-in/up flows, prebuilt UI, authorization directives, and route guards as idiomatic modern Angular (standalone APIs, RxJS **and** Signals, DI).
+
+Requires **Angular 17+**.
+
+---
+
+## Install
+
+```bash
+pnpm add @atlas/angular
+# peers: @angular/core, @angular/common (>=17), rxjs (>=7); @angular/router if you use the guards
+```
+
+## Setup
+
+### Standalone (recommended, Angular 17+)
+
+`provideAtlas` is the analogue of wrapping your tree in React's `<AtlasProvider>`. Register it once at the application root:
+
+```ts
+import { bootstrapApplication } from '@angular/platform-browser';
+import { provideRouter } from '@angular/router';
+import { provideAtlas } from '@atlas/angular';
+import { AppComponent } from './app/app.component';
+import { routes } from './app/routes';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideAtlas({
+      publishableKey: 'pk_test_…',
+      // frontendApi: 'https://fapi.your-instance.atlasauth.net', // omit for same-origin
+      // appearance: { baseTheme: 'dark', elements: { formButtonPrimary: 'rounded-xl' } },
+      // localization: myCatalog,
+    }),
+    provideRouter(routes),
+  ],
+});
+```
+
+The service begins booting immediately — completing any OAuth/hosted-page redirect, scrubbing the URL, and reading the session — exactly as the React provider does on first render.
+
+### NgModule
+
+```ts
+import { AtlasModule } from '@atlas/angular';
+
+@NgModule({
+  imports: [AtlasModule.forRoot({ publishableKey: 'pk_test_…' })],
+})
+export class AppModule {}
+```
+
+Feature modules `import { AtlasModule }` (no `forRoot`) to use the directives and components. Standalone components import them individually, or spread `ATLAS_UI`:
+
+```ts
+import { ATLAS_UI } from '@atlas/angular';
+
+@Component({ standalone: true, imports: [...ATLAS_UI], template: '…' })
+export class DashboardComponent {}
+```
+
+---
+
+## `AtlasService`
+
+Injectable, `providedIn: 'root'`. The Angular peer of `<AtlasProvider>` + the React hooks. Exposes state twice so you can pick your idiom.
+
+**RxJS observables** (the primary API):
+
+```ts
+export class HeaderComponent {
+  private atlas = inject(AtlasService);
+
+  user$        = this.atlas.user$;         // Observable<AtlasUser | null>
+  session$     = this.atlas.session$;      // Observable<AtlasSession | null>
+  isSignedIn$  = this.atlas.isSignedIn$;   // Observable<boolean>
+  isLoaded$    = this.atlas.isLoaded$;
+  claims$      = this.atlas.claims$;
+  memberships$ = this.atlas.memberships$;
+  organization$= this.atlas.organization$;
+}
+```
+
+**Signals** (same values, for templates / `computed()`):
+
+```ts
+this.atlas.user();        // Signal<AtlasUser | null>
+this.atlas.isSignedIn();  // Signal<boolean>
+this.atlas.status();      // 'loading' | 'signed_in' | 'signed_out'
+```
+
+**Methods** (mirror the React hooks' actions):
+
+| Method | Mirrors |
+| --- | --- |
+| `getToken(): Promise<string \| null>` | `useAuth().getToken` — always fresh; refreshes if within 5s of expiry |
+| `getProviderToken(provider): Promise<ProviderToken \| null>` | `useUser().getProviderToken` — the user's own live token at a connected provider |
+| `has(condition): boolean` | `useAuth().has` — imperative permission check |
+| `signOut(): Promise<void>` | `useAuth().signOut` |
+| `setActiveOrganization(orgId \| null)` | `useOrganization().setActive` |
+| `reload(): Promise<void>` | re-read `/v1/client` |
+
+The session JWT lives only in memory (a `TokenCache`); the refresh token is HttpOnly and never touched by script. Refresh is proactive and jittered off the token's own expiry.
+
+---
+
+## Directives
+
+All standalone. Structural directives mirror React's `components.tsx`:
+
+```html
+<!-- render only when signed in (after boot) — React <SignedIn> -->
+<div *atlasSignedIn>Welcome back</div>
+
+<!-- render only when signed out — React <SignedOut> -->
+<atlas-sign-in *atlasSignedOut></atlas-sign-in>
+
+<!-- boot-state helpers — React <AtlasLoading> / <AtlasLoaded> -->
+<app-spinner *atlasLoading></app-spinner>
+<main *atlasLoaded>…</main>
+
+<!-- permission-gated rendering — React <Protect permission="…"> -->
+<button *atlasProtect="{ permission: 'org:sys_memberships:manage' }">Invite</button>
+
+<!-- with a fallback (identical microsyntax to *ngIf … else) -->
+<div *atlasProtect="{ role: 'admin' }; else denied">Admin tools</div>
+<ng-template #denied>You lack access.</ng-template>
+```
+
+`*atlasProtect` is a **rendering** helper, never an authorization boundary — the server checking the same permission is what actually stops a request. An empty condition (`*atlasProtect`) means simply "signed in".
+
+**Theming host** — apply the appearance tokens as `--atlas-*` CSS variables (React does this via the provider's wrapping `<div class="atlas-root">`):
+
+```html
+<div atlasRoot>
+  <router-outlet></router-outlet>
+</div>
+```
+
+## Components
+
+Server-driven, rendered in the host DOM (no iframe), themed via the `appearance` option:
+
+| Selector | Mirrors |
+| --- | --- |
+| `<atlas-sign-in>` | `<SignIn/>` |
+| `<atlas-sign-up>` | `<SignUp/>` |
+| `<atlas-user-button>` | `<UserButton/>` |
+| `<atlas-organization-switcher>` | `<OrganizationSwitcher/>` |
+| `<atlas-user-profile>` | `<UserProfile/>` |
+| `<atlas-organization-profile>` | `<OrganizationProfile/>` |
+
+`<atlas-sign-in>` / `<atlas-sign-up>` run the full multi-step flow (identifier → first factor → 2FA / enrollment → email code → completion, plus magic-link polling), driven entirely by the server-side attempt status through the shared `@atlas/js` engine.
+
+---
+
+## Route guards
+
+`atlasGuard` gates a route on session, and optionally on a permission/role — the router equivalent of fencing a page with `<SignedIn>` / `<Protect>`. It waits for boot to settle first, so a hard refresh onto a protected URL doesn't bounce to sign-in prematurely.
+
+```ts
+import { Routes } from '@angular/router';
+import { atlasGuard } from '@atlas/angular';
+
+export const routes: Routes = [
+  {
+    path: 'dashboard',
+    canActivate: [atlasGuard({ redirectTo: '/sign-in' })],
+    loadComponent: () => import('./dashboard.component').then((m) => m.DashboardComponent),
+  },
+  {
+    path: 'admin',
+    canActivate: [atlasGuard({ permission: 'org:admin', redirectTo: '/' })],
+    loadComponent: () => import('./admin.component').then((m) => m.AdminComponent),
+  },
+];
+```
+
+With `redirectTo` set the guard returns a `UrlTree` (redirect, with the attempted URL preserved as `redirect_url`); without it, it returns `false`. `atlasChildGuard` is the `CanActivateChild` form.
+
+Like the components, guards are UX, not security — the server enforces the same checks on every request.
+
+---
+
+## Theming & i18n
+
+`appearance` accepts design tokens + per-element class overrides and a `baseTheme` (`default`, `dark`, `neobrutalist`); overrides are **appended** to the base classes so your Tailwind/CSS just works. `localization` merges a catalog over `en-US`. Both are identical in shape to `@atlas/react` — see `appearance.ts` and `i18n.ts`, which are shared verbatim.
+
+## Build & test
+
+- **Build**: `pnpm --filter @atlas/angular build` (ng-packagr → `dist/`, an Angular Package Format bundle with FESM2022 + type definitions).
+- **Typecheck**: `pnpm --filter @atlas/angular typecheck`.
+- **Test**: unit specs run under the Angular CLI test runner (Karma/Jasmine or your configured runner). A starter spec lives in `src/lib/atlas.service.spec.ts`.

package/dist/esm2022/atlasauth-angular.mjs

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

package/dist/esm2022/lib/appearance.mjs

@@ -0,0 +1,92 @@
+/**
+ * §10.3 theming.
+ *
+ * "appearance prop: design tokens (colors, radius, font, spacing) + per-element
+ * class overrides (elements: { formButtonPrimary: "…" }). No iframe — components
+ * render in the host DOM so Tailwind/CSS just works."
+ *
+ * Rendering in the host DOM is the decision everything else follows from. An
+ * iframe would isolate styles perfectly and be unusable: it cannot be sized to
+ * its content reliably, it breaks password managers, it breaks autofill, and a
+ * Tailwind class the customer writes has no effect inside it. Sharing the DOM
+ * means the customer's CSS reaches our markup, which is exactly what they want
+ * and what makes an override system necessary rather than decorative.
+ *
+ * Element classes are APPENDED to ours, never replacing them. A customer adding
+ * `className="rounded-xl"` wants a rounder button, not an unstyled one — and
+ * replacement is a support burden where every override starts by rebuilding the
+ * component's base styles from scratch.
+ */
+export const DEFAULT_TOKENS = {
+    colorPrimary: '#5b5bd6',
+    colorText: '#1c1c1f',
+    colorBackground: '#ffffff',
+    colorDanger: '#d64545',
+    colorBorder: '#e4e4e9',
+    borderRadius: '8px',
+    fontFamily: 'ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif',
+    spacingUnit: '4px',
+};
+/**
+ * §10.3: "prebuilt themes shipped (default, dark, neobrutalist as a demo of the
+ * override system)". Neobrutalist exists to prove the token set is expressive
+ * enough for a theme that looks nothing like the default — a theming system
+ * that only produces tasteful variations of itself is not a theming system.
+ */
+export const THEMES = {
+    default: DEFAULT_TOKENS,
+    dark: {
+        ...DEFAULT_TOKENS,
+        colorText: '#e6e9ef',
+        colorBackground: '#14171c',
+        colorBorder: '#242932',
+        colorPrimary: '#6ea8fe',
+    },
+    neobrutalist: {
+        ...DEFAULT_TOKENS,
+        colorPrimary: '#ffe600',
+        colorText: '#000000',
+        colorBackground: '#ffffff',
+        colorBorder: '#000000',
+        borderRadius: '0px',
+        fontFamily: '"Courier New", ui-monospace, monospace',
+    },
+};
+/**
+ * Resolve tokens: defaults, then the base theme, then explicit variables.
+ *
+ * Later wins, and `undefined` never overwrites. A customer setting one variable
+ * on the dark theme expects the other eleven to stay dark, not silently revert
+ * to the light defaults.
+ */
+export function resolveTokens(appearance) {
+    const base = appearance?.baseTheme ? THEMES[appearance.baseTheme] : DEFAULT_TOKENS;
+    const overrides = appearance?.variables ?? {};
+    const resolved = { ...DEFAULT_TOKENS, ...base };
+    for (const [key, value] of Object.entries(overrides)) {
+        if (value !== undefined)
+            resolved[key] = value;
+    }
+    return resolved;
+}
+/** Tokens as CSS custom properties, for the host DOM to inherit. */
+export function cssVariables(tokens) {
+    const vars = {};
+    for (const [key, value] of Object.entries(tokens)) {
+        // camelCase → --atlas-kebab-case, which is what a customer writes in CSS.
+        vars[`--atlas-${key.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)}`] = value;
+    }
+    return vars;
+}
+/**
+ * Combine our base class with the customer's override.
+ *
+ * Appended, never replaced — a customer adding `rounded-xl` wants a rounder
+ * button, not an unstyled one. Theirs comes last so it wins on equal
+ * specificity, which is the behaviour anyone writing Tailwind expects.
+ */
+export function classFor(element, appearance, base) {
+    const override = appearance?.elements?.[element];
+    return override ? `${base} ${override}` : base;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appearance.js","sourceRoot":"","sources":["../../../src/lib/appearance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAwCH,MAAM,CAAC,MAAM,cAAc,GAA2B;IACpD,YAAY,EAAE,SAAS;IACvB,SAAS,EAAE,SAAS;IACpB,eAAe,EAAE,SAAS;IAC1B,WAAW,EAAE,SAAS;IACtB,WAAW,EAAE,SAAS;IACtB,YAAY,EAAE,KAAK;IACnB,UAAU,EAAE,iEAAiE;IAC7E,WAAW,EAAE,KAAK;CACnB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,OAAO,EAAE,cAAc;IACvB,IAAI,EAAE;QACJ,GAAG,cAAc;QACjB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;QAC1B,WAAW,EAAE,SAAS;QACtB,YAAY,EAAE,SAAS;KACxB;IACD,YAAY,EAAE;QACZ,GAAG,cAAc;QACjB,YAAY,EAAE,SAAS;QACvB,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;QAC1B,WAAW,EAAE,SAAS;QACtB,YAAY,EAAE,KAAK;QACnB,UAAU,EAAE,wCAAwC;KACrD;CACwD,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,UAAuB;IACnD,MAAM,IAAI,GAAG,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC;IACnF,MAAM,SAAS,GAAG,UAAU,EAAE,SAAS,IAAI,EAAE,CAAC;IAE9C,MAAM,QAAQ,GAAG,EAAE,GAAG,cAAc,EAAE,GAAG,IAAI,EAAE,CAAC;IAChD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;QACrD,IAAI,KAAK,KAAK,SAAS;YAAE,QAAQ,CAAC,GAAyB,CAAC,GAAG,KAAK,CAAC;IACvE,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,YAAY,CAAC,MAA8B;IACzD,MAAM,IAAI,GAA2B,EAAE,CAAC;IACxC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAClD,0EAA0E;QAC1E,IAAI,CAAC,WAAW,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;IACjF,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CACtB,OAAmB,EACnB,UAAkC,EAClC,IAAY;IAEZ,MAAM,QAAQ,GAAG,UAAU,EAAE,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC;IACjD,OAAO,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACjD,CAAC","sourcesContent":["/**\n * §10.3 theming.\n *\n * \"appearance prop: design tokens (colors, radius, font, spacing) + per-element\n * class overrides (elements: { formButtonPrimary: \"…\" }). No iframe — components\n * render in the host DOM so Tailwind/CSS just works.\"\n *\n * Rendering in the host DOM is the decision everything else follows from. An\n * iframe would isolate styles perfectly and be unusable: it cannot be sized to\n * its content reliably, it breaks password managers, it breaks autofill, and a\n * Tailwind class the customer writes has no effect inside it. Sharing the DOM\n * means the customer's CSS reaches our markup, which is exactly what they want\n * and what makes an override system necessary rather than decorative.\n *\n * Element classes are APPENDED to ours, never replacing them. A customer adding\n * `className=\"rounded-xl\"` wants a rounder button, not an unstyled one — and\n * replacement is a support burden where every override starts by rebuilding the\n * component's base styles from scratch.\n */\n\nexport interface DesignTokens {\n  colorPrimary?: string;\n  colorText?: string;\n  colorBackground?: string;\n  colorDanger?: string;\n  colorBorder?: string;\n  borderRadius?: string;\n  fontFamily?: string;\n  spacingUnit?: string;\n}\n\n/** Every element a customer may target. Named for what it IS, not where it sits. */\nexport type ElementKey =\n  | 'root'\n  | 'card'\n  | 'headerTitle'\n  | 'headerSubtitle'\n  | 'formField'\n  | 'formFieldLabel'\n  | 'formFieldInput'\n  | 'formFieldError'\n  | 'formButtonPrimary'\n  | 'formButtonSecondary'\n  | 'socialButton'\n  | 'dividerText'\n  | 'footerAction'\n  | 'avatar'\n  | 'menu'\n  | 'menuItem'\n  | 'badge';\n\nexport interface Appearance {\n  /** A prebuilt theme to start from. */\n  baseTheme?: keyof typeof THEMES;\n  variables?: DesignTokens;\n  elements?: Partial<Record<ElementKey, string>>;\n}\n\nexport const DEFAULT_TOKENS: Required<DesignTokens> = {\n  colorPrimary: '#5b5bd6',\n  colorText: '#1c1c1f',\n  colorBackground: '#ffffff',\n  colorDanger: '#d64545',\n  colorBorder: '#e4e4e9',\n  borderRadius: '8px',\n  fontFamily: 'ui-sans-serif, system-ui, -apple-system, \"Segoe UI\", sans-serif',\n  spacingUnit: '4px',\n};\n\n/**\n * §10.3: \"prebuilt themes shipped (default, dark, neobrutalist as a demo of the\n * override system)\". Neobrutalist exists to prove the token set is expressive\n * enough for a theme that looks nothing like the default — a theming system\n * that only produces tasteful variations of itself is not a theming system.\n */\nexport const THEMES = {\n  default: DEFAULT_TOKENS,\n  dark: {\n    ...DEFAULT_TOKENS,\n    colorText: '#e6e9ef',\n    colorBackground: '#14171c',\n    colorBorder: '#242932',\n    colorPrimary: '#6ea8fe',\n  },\n  neobrutalist: {\n    ...DEFAULT_TOKENS,\n    colorPrimary: '#ffe600',\n    colorText: '#000000',\n    colorBackground: '#ffffff',\n    colorBorder: '#000000',\n    borderRadius: '0px',\n    fontFamily: '\"Courier New\", ui-monospace, monospace',\n  },\n} as const satisfies Record<string, Required<DesignTokens>>;\n\n/**\n * Resolve tokens: defaults, then the base theme, then explicit variables.\n *\n * Later wins, and `undefined` never overwrites. A customer setting one variable\n * on the dark theme expects the other eleven to stay dark, not silently revert\n * to the light defaults.\n */\nexport function resolveTokens(appearance?: Appearance): Required<DesignTokens> {\n  const base = appearance?.baseTheme ? THEMES[appearance.baseTheme] : DEFAULT_TOKENS;\n  const overrides = appearance?.variables ?? {};\n\n  const resolved = { ...DEFAULT_TOKENS, ...base };\n  for (const [key, value] of Object.entries(overrides)) {\n    if (value !== undefined) resolved[key as keyof DesignTokens] = value;\n  }\n  return resolved;\n}\n\n/** Tokens as CSS custom properties, for the host DOM to inherit. */\nexport function cssVariables(tokens: Required<DesignTokens>): Record<string, string> {\n  const vars: Record<string, string> = {};\n  for (const [key, value] of Object.entries(tokens)) {\n    // camelCase → --atlas-kebab-case, which is what a customer writes in CSS.\n    vars[`--atlas-${key.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)}`] = value;\n  }\n  return vars;\n}\n\n/**\n * Combine our base class with the customer's override.\n *\n * Appended, never replaced — a customer adding `rounded-xl` wants a rounder\n * button, not an unstyled one. Theirs comes last so it wins on equal\n * specificity, which is the behaviour anyone writing Tailwind expects.\n */\nexport function classFor(\n  element: ElementKey,\n  appearance: Appearance | undefined,\n  base: string,\n): string {\n  const override = appearance?.elements?.[element];\n  return override ? `${base} ${override}` : base;\n}\n"]}

package/dist/esm2022/lib/atlas.config.mjs

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * DI token carrying the resolved {@link AtlasOptions}. Populated by
+ * {@link provideAtlas} (standalone) or {@link AtlasModule.forRoot} (NgModule)
+ * and read by {@link AtlasService}. Applications rarely inject this directly.
+ */
+export const ATLAS_OPTIONS = new InjectionToken('ATLAS_OPTIONS');
+//# sourceMappingURL=data:application/json;base64,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