@atlasauth/angular 0.1.0

package/dist/esm2022/lib/directives/loading.directive.mjs

@@ -0,0 +1,23 @@
+import { Directive } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { AtlasToggleDirective } from './toggle.directive';
+import * as i0 from "@angular/core";
+/**
+ * `*atlasLoading` — render the template only while the SDK is still booting. The
+ * Angular peer of React's `<AtlasLoading>`; show a spinner here.
+ */
+export class AtlasLoadingDirective extends AtlasToggleDirective {
+    source() {
+        return this.atlas.isLoaded$.pipe(map((loaded) => !loaded));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasLoadingDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AtlasLoadingDirective, isStandalone: true, selector: "[atlasLoading]", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasLoadingDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[atlasLoading]',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGluZy5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2RpcmVjdGl2ZXMvbG9hZGluZy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUxQyxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDckMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBRTFEOzs7R0FHRztBQUtILE1BQU0sT0FBTyxxQkFBc0IsU0FBUSxvQkFBb0I7SUFDMUMsTUFBTTtRQUN2QixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztJQUM3RCxDQUFDO3dHQUhVLHFCQUFxQjs0RkFBckIscUJBQXFCOzs0RkFBckIscUJBQXFCO2tCQUpqQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgbWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuaW1wb3J0IHsgQXRsYXNUb2dnbGVEaXJlY3RpdmUgfSBmcm9tICcuL3RvZ2dsZS5kaXJlY3RpdmUnO1xuXG4vKipcbiAqIGAqYXRsYXNMb2FkaW5nYCDigJQgcmVuZGVyIHRoZSB0ZW1wbGF0ZSBvbmx5IHdoaWxlIHRoZSBTREsgaXMgc3RpbGwgYm9vdGluZy4gVGhlXG4gKiBBbmd1bGFyIHBlZXIgb2YgUmVhY3QncyBgPEF0bGFzTG9hZGluZz5gOyBzaG93IGEgc3Bpbm5lciBoZXJlLlxuICovXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbYXRsYXNMb2FkaW5nXScsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIEF0bGFzTG9hZGluZ0RpcmVjdGl2ZSBleHRlbmRzIEF0bGFzVG9nZ2xlRGlyZWN0aXZlIHtcbiAgcHJvdGVjdGVkIG92ZXJyaWRlIHNvdXJjZSgpOiBPYnNlcnZhYmxlPGJvb2xlYW4+IHtcbiAgICByZXR1cm4gdGhpcy5hdGxhcy5pc0xvYWRlZCQucGlwZShtYXAoKGxvYWRlZCkgPT4gIWxvYWRlZCkpO1xuICB9XG59XG4iXX0=

package/dist/esm2022/lib/directives/protect.directive.mjs

@@ -0,0 +1,82 @@
+import { Directive, Input, TemplateRef, ViewContainerRef, inject, } from '@angular/core';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { AtlasService } from '../atlas.service';
+import { evaluate } from '@atlasauth/authz';
+import * as i0 from "@angular/core";
+/**
+ * `*atlasProtect` — render the template only when the active organization role
+ * satisfies a {@link ProtectCondition}. The Angular peer of React's
+ * `<Protect permission="…">`.
+ *
+ * A RENDERING helper, never an authorization boundary: anyone can flip the
+ * condition in devtools. The server checking the same permission is what
+ * actually stops them — this directive's only job is to avoid showing a control
+ * that would fail.
+ *
+ * ```html
+ * <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>
+ * ```
+ *
+ * An empty condition (`*atlasProtect`) means simply "signed in".
+ */
+export class AtlasProtectDirective {
+    atlas = inject(AtlasService);
+    templateRef = inject(TemplateRef);
+    viewContainer = inject(ViewContainerRef);
+    condition$ = new BehaviorSubject({});
+    elseTemplate = null;
+    sub;
+    rendered = 'none';
+    /** The condition to evaluate. An empty/omitted value means "signed in". */
+    set atlasProtect(condition) {
+        this.condition$.next(condition || {});
+    }
+    /** Template rendered when the condition is not met (the `else` branch). */
+    set atlasProtectElse(template) {
+        this.elseTemplate = template;
+        // Re-render against the current state so a late-bound else takes effect.
+        this.condition$.next(this.condition$.value);
+    }
+    ngOnInit() {
+        this.sub = combineLatest([this.atlas.status$, this.atlas.claims$, this.condition$]).subscribe(([status, claims, condition]) => {
+            if (status === 'loading') {
+                this.show('none');
+                return;
+            }
+            this.show(evaluate(claims, condition).allowed ? 'main' : 'else');
+        });
+    }
+    ngOnDestroy() {
+        this.sub?.unsubscribe();
+    }
+    show(which) {
+        if (which === this.rendered)
+            return;
+        this.viewContainer.clear();
+        if (which === 'main') {
+            this.viewContainer.createEmbeddedView(this.templateRef);
+        }
+        else if (which === 'else' && this.elseTemplate) {
+            this.viewContainer.createEmbeddedView(this.elseTemplate);
+        }
+        this.rendered = which;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasProtectDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AtlasProtectDirective, isStandalone: true, selector: "[atlasProtect]", inputs: { atlasProtect: "atlasProtect", atlasProtectElse: "atlasProtectElse" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasProtectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[atlasProtect]',
+                    standalone: true,
+                }]
+        }], propDecorators: { atlasProtect: [{
+                type: Input
+            }], atlasProtectElse: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/directives/signed-in.directive.mjs

@@ -0,0 +1,29 @@
+import { Directive } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AtlasToggleDirective } from './toggle.directive';
+import * as i0 from "@angular/core";
+/**
+ * `*atlasSignedIn` — render the template only when the SDK has loaded AND the
+ * user is signed in. The Angular peer of React's `<SignedIn>`. Renders nothing
+ * while loading, so no signed-in UI flashes before boot completes.
+ *
+ * ```html
+ * <div *atlasSignedIn>Welcome back</div>
+ * ```
+ */
+export class AtlasSignedInDirective extends AtlasToggleDirective {
+    source() {
+        return combineLatest([this.atlas.isLoaded$, this.atlas.isSignedIn$]).pipe(map(([loaded, signedIn]) => loaded && signedIn));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasSignedInDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AtlasSignedInDirective, isStandalone: true, selector: "[atlasSignedIn]", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasSignedInDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[atlasSignedIn]',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/directives/signed-out.directive.mjs

@@ -0,0 +1,29 @@
+import { Directive } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AtlasToggleDirective } from './toggle.directive';
+import * as i0 from "@angular/core";
+/**
+ * `*atlasSignedOut` — render the template only when the SDK has loaded AND the
+ * user is signed out. The Angular peer of React's `<SignedOut>`. Renders nothing
+ * while loading, the symmetric partner of `*atlasSignedIn`.
+ *
+ * ```html
+ * <atlas-sign-in *atlasSignedOut></atlas-sign-in>
+ * ```
+ */
+export class AtlasSignedOutDirective extends AtlasToggleDirective {
+    source() {
+        return combineLatest([this.atlas.isLoaded$, this.atlas.isSignedIn$]).pipe(map(([loaded, signedIn]) => loaded && !signedIn));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasSignedOutDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AtlasSignedOutDirective, isStandalone: true, selector: "[atlasSignedOut]", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasSignedOutDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[atlasSignedOut]',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/directives/toggle.directive.mjs

@@ -0,0 +1,42 @@
+import { Directive, TemplateRef, ViewContainerRef, inject, } from '@angular/core';
+import { distinctUntilChanged } from 'rxjs/operators';
+import { AtlasService } from '../atlas.service';
+import * as i0 from "@angular/core";
+/**
+ * Shared machinery for the boolean structural directives (`*atlasSignedIn`,
+ * `*atlasSignedOut`, `*atlasLoading`, `*atlasLoaded`). A subclass names the
+ * stream to gate on; this base mounts the embedded view exactly when that stream
+ * is true and tears it down otherwise, mirroring how the React `<SignedIn>` /
+ * `<SignedOut>` components render `children` or `null`.
+ */
+export class AtlasToggleDirective {
+    atlas = inject(AtlasService);
+    templateRef = inject(TemplateRef);
+    viewContainer = inject(ViewContainerRef);
+    sub;
+    shown = false;
+    ngOnInit() {
+        this.sub = this.source()
+            .pipe(distinctUntilChanged())
+            .subscribe((show) => this.render(show));
+    }
+    ngOnDestroy() {
+        this.sub?.unsubscribe();
+    }
+    render(show) {
+        if (show && !this.shown) {
+            this.viewContainer.createEmbeddedView(this.templateRef);
+            this.shown = true;
+        }
+        else if (!show && this.shown) {
+            this.viewContainer.clear();
+            this.shown = false;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasToggleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AtlasToggleDirective, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasToggleDirective, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/fapi.mjs

@@ -0,0 +1,9 @@
+/**
+ * The FAPI client and the server-driven sign-in flow driver live in `@atlasauth/js`
+ * — the pure, framework-agnostic browser flow. This thin re-export lets the
+ * Angular components, guards and services resolve the driver from one place, so
+ * the Angular `<atlas-sign-in>` and the React `<SignIn/>` drive the exact same
+ * endpoints and cannot diverge in what the server sees.
+ */
+export { FapiClient, advance, prepareFactor, pollAttempt, shouldKeepPolling, requestForStep, flowFromPending, initialFlow, getProviderToken, } from '@atlasauth/js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvZmFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEVBQ0wsVUFBVSxFQUNWLE9BQU8sRUFDUCxhQUFhLEVBQ2IsV0FBVyxFQUNYLGlCQUFpQixFQUNqQixjQUFjLEVBQ2QsZUFBZSxFQUNmLFdBQVcsRUFDWCxnQkFBZ0IsR0FLakIsTUFBTSxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRoZSBGQVBJIGNsaWVudCBhbmQgdGhlIHNlcnZlci1kcml2ZW4gc2lnbi1pbiBmbG93IGRyaXZlciBsaXZlIGluIGBAYXRsYXNhdXRoL2pzYFxuICog4oCUIHRoZSBwdXJlLCBmcmFtZXdvcmstYWdub3N0aWMgYnJvd3NlciBmbG93LiBUaGlzIHRoaW4gcmUtZXhwb3J0IGxldHMgdGhlXG4gKiBBbmd1bGFyIGNvbXBvbmVudHMsIGd1YXJkcyBhbmQgc2VydmljZXMgcmVzb2x2ZSB0aGUgZHJpdmVyIGZyb20gb25lIHBsYWNlLCBzb1xuICogdGhlIEFuZ3VsYXIgYDxhdGxhcy1zaWduLWluPmAgYW5kIHRoZSBSZWFjdCBgPFNpZ25Jbi8+YCBkcml2ZSB0aGUgZXhhY3Qgc2FtZVxuICogZW5kcG9pbnRzIGFuZCBjYW5ub3QgZGl2ZXJnZSBpbiB3aGF0IHRoZSBzZXJ2ZXIgc2Vlcy5cbiAqL1xuZXhwb3J0IHtcbiAgRmFwaUNsaWVudCxcbiAgYWR2YW5jZSxcbiAgcHJlcGFyZUZhY3RvcixcbiAgcG9sbEF0dGVtcHQsXG4gIHNob3VsZEtlZXBQb2xsaW5nLFxuICByZXF1ZXN0Rm9yU3RlcCxcbiAgZmxvd0Zyb21QZW5kaW5nLFxuICBpbml0aWFsRmxvdyxcbiAgZ2V0UHJvdmlkZXJUb2tlbixcbiAgdHlwZSBGYXBpQ2xpZW50T3B0aW9ucyxcbiAgdHlwZSBGYXBpUmVzcG9uc2UsXG4gIHR5cGUgRmxvd1N0YXRlLFxuICB0eXBlIFByb3ZpZGVyVG9rZW4sXG59IGZyb20gJ0BhdGxhc2F1dGgvanMnO1xuIl19

package/dist/esm2022/lib/guards/atlas.guard.mjs

@@ -0,0 +1,54 @@
+import { inject } from '@angular/core';
+import { Router, } from '@angular/router';
+import { firstValueFrom } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
+import { evaluate } from '@atlasauth/authz';
+import { AtlasService } from '../atlas.service';
+/**
+ * Route guard factory that gates a route on session — and optionally on a
+ * permission/role. The Angular peer of using `<SignedIn>` / `<Protect>` to fence
+ * a page, expressed as a `CanActivateFn`.
+ *
+ * ```ts
+ * export const routes: Routes = [
+ *   { path: 'dashboard', canActivate: [atlasGuard({ redirectTo: '/sign-in' })], ... },
+ *   {
+ *     path: 'admin',
+ *     canActivate: [atlasGuard({ permission: 'org:admin', redirectTo: '/' })],
+ *     ...
+ *   },
+ * ];
+ * ```
+ *
+ * The guard first waits for the SDK to finish booting, so a hard refresh onto a
+ * protected URL does not bounce to sign-in before the session has been read.
+ * Like the components, this is UX, not security: the server enforces the same
+ * checks on every request.
+ */
+export function atlasGuard(options = {}) {
+    const { redirectTo, preserveReturnUrl = true, ...condition } = options;
+    return async (_route, state) => {
+        const atlas = inject(AtlasService);
+        const router = inject(Router);
+        // Wait for boot to settle so we judge against a real answer, not `loading`.
+        await firstValueFrom(atlas.status$.pipe(filter((s) => s !== 'loading'), take(1)));
+        const allowed = evaluate(atlas.claims(), condition).allowed;
+        if (allowed)
+            return true;
+        if (redirectTo) {
+            return router.createUrlTree([redirectTo], {
+                queryParams: preserveReturnUrl ? { redirect_url: state.url } : undefined,
+            });
+        }
+        return false;
+    };
+}
+/**
+ * The `CanActivateChild` form of {@link atlasGuard}, for gating a whole child
+ * route subtree with one declaration.
+ */
+export function atlasChildGuard(options = {}) {
+    const guard = atlasGuard(options);
+    return (route, state) => guard(route, state);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/i18n.mjs

@@ -0,0 +1,78 @@
+/**
+ * §10.3: "Every string passes through an i18n catalog; en-US ships, catalog
+ * format documented for community locales."
+ *
+ * A flat key-to-string map rather than nested objects, because nesting looks
+ * tidier and makes a missing key a runtime crash on `undefined.of.a.chain`
+ * rather than a visible fallback.
+ *
+ * A missing key renders the KEY, not an empty string. A blank button is a bug
+ * nobody can report; a button reading `signIn.submit` is one anyone can.
+ */
+export const EN_US = {
+    'signIn.title': 'Sign in',
+    'signIn.subtitle': 'to continue to {application}',
+    'signIn.identifierLabel': 'Email address',
+    'signIn.passwordLabel': 'Password',
+    'signIn.submit': 'Continue',
+    'signIn.forgotPassword': 'Forgot password?',
+    'signIn.noAccount': 'No account?',
+    'signIn.signUpLink': 'Sign up',
+    'signIn.orDivider': 'or',
+    'signIn.socialButton': 'Continue with {provider}',
+    'signIn.emailCodeLabel': 'Verification code',
+    'signIn.magicLinkSent': 'Check your email for a sign-in link.',
+    'signIn.checkOtherTab': 'You can close this tab — you are signed in where you started.',
+    'signUp.title': 'Create your account',
+    'signUp.submit': 'Continue',
+    'signUp.haveAccount': 'Already have an account?',
+    'signUp.signInLink': 'Sign in',
+    'mfa.title': 'Two-step verification',
+    'mfa.subtitle': 'Enter the code from your authenticator app.',
+    'mfa.codeLabel': 'Code',
+    'mfa.enrollFirstCodeLabel': 'Code from your authenticator app',
+    'mfa.enrollSecondCodeLabel': 'The next code it shows',
+    'mfa.usePasskey': 'Use a passkey instead',
+    'mfa.useBackupCode': 'Use a recovery code',
+    'mfa.submit': 'Verify',
+    'reset.title': 'Reset your password',
+    'reset.submit': 'Send reset code',
+    'reset.newPasswordLabel': 'New password',
+    'userButton.manageAccount': 'Manage account',
+    'userButton.signOut': 'Sign out',
+    'userButton.signOutAll': 'Sign out of all devices',
+    'userProfile.title': 'Account',
+    'userProfile.profileSection': 'Profile',
+    'userProfile.emailsSection': 'Email addresses',
+    'userProfile.securitySection': 'Security',
+    'userProfile.devicesSection': 'Active devices',
+    'userProfile.dangerSection': 'Danger zone',
+    'userProfile.addEmail': 'Add an email address',
+    'userProfile.makePrimary': 'Make primary',
+    'userProfile.unverified': 'Unverified',
+    'userProfile.revokeDevice': 'Sign out',
+    'userProfile.deleteAccount': 'Delete account',
+    'organization.switcher': 'Switch organization',
+    'organization.personal': 'Personal account',
+    'organization.members': 'Members',
+    'organization.invite': 'Invite member',
+    'organization.roleLabel': 'Role',
+    'error.generic': 'Something went wrong. Please try again.',
+    'error.network': 'We could not reach the server. Check your connection.',
+};
+/**
+ * Look up a key and interpolate `{placeholders}`.
+ *
+ * An unknown placeholder is left visible for the same reason a missing key is:
+ * `Continue with {provider}` in the UI is a bug report waiting to be filed,
+ * whereas `Continue with ` is one nobody notices until a customer does.
+ */
+export function translate(catalog, key, variables = {}) {
+    const template = catalog[key] ?? EN_US[key] ?? key;
+    return template.replace(/\{(\w+)\}/g, (match, name) => variables[name] ?? match);
+}
+/** Merge a community locale over en-US so a partial translation still renders. */
+export function withFallback(locale) {
+    return { ...EN_US, ...locale };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/protect.mjs

@@ -0,0 +1,9 @@
+/**
+ * Conditional-rendering authorization primitive — re-exported unchanged from
+ * `@atlasauth/authz`, the ONE evaluator every Atlas SDK shares. `*atlasProtect` in
+ * this package and `<Protect>` in `@atlasauth/react` therefore judge a condition
+ * identically, and the server checking the same permission is what actually
+ * stops a request; these helpers only decide what a user is shown.
+ */
+export { evaluate, hasFromClaims, } from '@atlasauth/authz';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdGVjdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvcHJvdGVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEVBSUwsUUFBUSxFQUNSLGFBQWEsR0FDZCxNQUFNLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb25kaXRpb25hbC1yZW5kZXJpbmcgYXV0aG9yaXphdGlvbiBwcmltaXRpdmUg4oCUIHJlLWV4cG9ydGVkIHVuY2hhbmdlZCBmcm9tXG4gKiBgQGF0bGFzYXV0aC9hdXRoemAsIHRoZSBPTkUgZXZhbHVhdG9yIGV2ZXJ5IEF0bGFzIFNESyBzaGFyZXMuIGAqYXRsYXNQcm90ZWN0YCBpblxuICogdGhpcyBwYWNrYWdlIGFuZCBgPFByb3RlY3Q+YCBpbiBgQGF0bGFzYXV0aC9yZWFjdGAgdGhlcmVmb3JlIGp1ZGdlIGEgY29uZGl0aW9uXG4gKiBpZGVudGljYWxseSwgYW5kIHRoZSBzZXJ2ZXIgY2hlY2tpbmcgdGhlIHNhbWUgcGVybWlzc2lvbiBpcyB3aGF0IGFjdHVhbGx5XG4gKiBzdG9wcyBhIHJlcXVlc3Q7IHRoZXNlIGhlbHBlcnMgb25seSBkZWNpZGUgd2hhdCBhIHVzZXIgaXMgc2hvd24uXG4gKi9cbmV4cG9ydCB7XG4gIHR5cGUgUHJvdGVjdENvbmRpdGlvbixcbiAgdHlwZSBQcm90ZWN0T3V0Y29tZSxcbiAgdHlwZSBQcm90ZWN0UmVhc29uLFxuICBldmFsdWF0ZSxcbiAgaGFzRnJvbUNsYWltcyxcbn0gZnJvbSAnQGF0bGFzYXV0aC9hdXRoeic7XG4iXX0=

package/dist/esm2022/lib/provide-atlas.mjs

@@ -0,0 +1,85 @@
+import { ENVIRONMENT_INITIALIZER, NgModule, inject, makeEnvironmentProviders, } from '@angular/core';
+import { ATLAS_OPTIONS } from './atlas.config';
+import { AtlasService } from './atlas.service';
+import { ATLAS_UI } from './atlas.ui';
+import * as i0 from "@angular/core";
+import * as i1 from "./directives/signed-in.directive";
+import * as i2 from "./directives/signed-out.directive";
+import * as i3 from "./directives/loading.directive";
+import * as i4 from "./directives/loaded.directive";
+import * as i5 from "./directives/protect.directive";
+import * as i6 from "./directives/atlas-root.directive";
+import * as i7 from "./components/sign-in.component";
+import * as i8 from "./components/sign-up.component";
+import * as i9 from "./components/user-button.component";
+import * as i10 from "./components/organization-switcher.component";
+import * as i11 from "./components/user-profile.component";
+import * as i12 from "./components/organization-profile.component";
+/**
+ * Standalone-provider entry point (Angular 17+). Register Atlas once at the
+ * application root — the direct analogue of wrapping the tree in React's
+ * `<AtlasProvider publishableKey>`:
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideAtlas({ publishableKey: 'pk_test_…' }),
+ *     provideRouter(routes),
+ *   ],
+ * });
+ * ```
+ *
+ * The returned providers make {@link AtlasService} injectable and eagerly
+ * construct it, so the SDK begins its first boot (redirect-completion + session
+ * read) as soon as the app starts — matching the React provider mounting on the
+ * first render.
+ */
+export function provideAtlas(options) {
+    return makeEnvironmentProviders([
+        { provide: ATLAS_OPTIONS, useValue: options },
+        AtlasService,
+        {
+            // Eagerly instantiate AtlasService so its boot runs at startup rather than
+            // lazily on first injection — the equivalent of the provider mounting.
+            provide: ENVIRONMENT_INITIALIZER,
+            multi: true,
+            useValue: () => {
+                inject(AtlasService);
+            },
+        },
+    ]);
+}
+/**
+ * NgModule entry point for apps not yet on the standalone bootstrap. Import
+ * `AtlasModule.forRoot({ publishableKey })` once in the root module; feature
+ * modules import `AtlasModule` (no args) to use the directives/components.
+ */
+export class AtlasModule {
+    static forRoot(options) {
+        const providers = [
+            { provide: ATLAS_OPTIONS, useValue: options },
+            AtlasService,
+            {
+                provide: ENVIRONMENT_INITIALIZER,
+                multi: true,
+                useValue: () => {
+                    inject(AtlasService);
+                },
+            },
+        ];
+        return { ngModule: AtlasModule, providers };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: AtlasModule, imports: [i1.AtlasSignedInDirective, i2.AtlasSignedOutDirective, i3.AtlasLoadingDirective, i4.AtlasLoadedDirective, i5.AtlasProtectDirective, i6.AtlasRootDirective, i7.SignInComponent, i8.SignUpComponent, i9.UserButtonComponent, i10.OrganizationSwitcherComponent, i11.UserProfileComponent, i12.OrganizationProfileComponent], exports: [i1.AtlasSignedInDirective, i2.AtlasSignedOutDirective, i3.AtlasLoadingDirective, i4.AtlasLoadedDirective, i5.AtlasProtectDirective, i6.AtlasRootDirective, i7.SignInComponent, i8.SignUpComponent, i9.UserButtonComponent, i10.OrganizationSwitcherComponent, i11.UserProfileComponent, i12.OrganizationProfileComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AtlasModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    // Standalone directives/components are re-exported so NgModule consumers get
+                    // them just by importing AtlasModule, the way they would with a classic module.
+                    imports: [...ATLAS_UI],
+                    exports: [...ATLAS_UI],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/types.mjs

@@ -0,0 +1,6 @@
+/**
+ * Public data shapes, mirrored 1:1 from `@atlasauth/react`'s `types.ts` so an app
+ * can move between the React and Angular SDKs without re-typing its models.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIGRhdGEgc2hhcGVzLCBtaXJyb3JlZCAxOjEgZnJvbSBgQGF0bGFzYXV0aC9yZWFjdGAncyBgdHlwZXMudHNgIHNvIGFuIGFwcFxuICogY2FuIG1vdmUgYmV0d2VlbiB0aGUgUmVhY3QgYW5kIEFuZ3VsYXIgU0RLcyB3aXRob3V0IHJlLXR5cGluZyBpdHMgbW9kZWxzLlxuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgU2Vzc2lvbkNsYWltcyB7XG4gIHN1Yjogc3RyaW5nO1xuICBzaWQ6IHN0cmluZztcbiAgZXhwOiBudW1iZXI7XG4gIG9yZ19pZD86IHN0cmluZztcbiAgb3JnX3NsdWc/OiBzdHJpbmc7XG4gIG9yZ19yb2xlPzogc3RyaW5nO1xuICBvcmdfcGVybWlzc2lvbnM/OiBzdHJpbmdbXTtcbiAgbWZhPzogYm9vbGVhbjtcbiAgW2NsYWltOiBzdHJpbmddOiB1bmtub3duO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEF0bGFzVXNlciB7XG4gIGlkOiBzdHJpbmc7XG4gIGZpcnN0X25hbWU6IHN0cmluZyB8IG51bGw7XG4gIGxhc3RfbmFtZTogc3RyaW5nIHwgbnVsbDtcbiAgdXNlcm5hbWU6IHN0cmluZyB8IG51bGw7XG4gIGltYWdlX3VybDogc3RyaW5nIHwgbnVsbDtcbiAgcHVibGljX21ldGFkYXRhOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgdW5zYWZlX21ldGFkYXRhOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgbWZhX2VuYWJsZWQ6IGJvb2xlYW47XG4gIGhhc19wYXNzd29yZDogYm9vbGVhbjtcbiAgZW1haWxfYWRkcmVzc2VzPzogQXJyYXk8e1xuICAgIGlkOiBzdHJpbmc7XG4gICAgZW1haWxfYWRkcmVzczogc3RyaW5nO1xuICAgIHZlcmlmaWVkOiBib29sZWFuO1xuICAgIHByaW1hcnk6IGJvb2xlYW47XG4gIH0+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEF0bGFzT3JnYW5pemF0aW9uTWVtYmVyc2hpcCB7XG4gIHJvbGU6IHN0cmluZztcbiAgb3JnYW5pemF0aW9uOiB7XG4gICAgaWQ6IHN0cmluZztcbiAgICBuYW1lOiBzdHJpbmc7XG4gICAgc2x1Zzogc3RyaW5nO1xuICAgIGltYWdlX3VybDogc3RyaW5nIHwgbnVsbDtcbiAgfTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBBdGxhc1Nlc3Npb24ge1xuICBpZDogc3RyaW5nO1xuICBzdGF0dXM6IHN0cmluZztcbiAgbGFzdF9hY3RpdmVfb3JnYW5pemF0aW9uX2lkOiBzdHJpbmcgfCBudWxsO1xufVxuXG4vKiogVGhlIHRocmVlLXN0YXRlIGF1dGggbGlmZWN5Y2xlLCBpZGVudGljYWwgdG8gdGhlIFJlYWN0IHByb3ZpZGVyJ3MuICovXG5leHBvcnQgdHlwZSBBdXRoU3RhdHVzID0gJ2xvYWRpbmcnIHwgJ3NpZ25lZF9pbicgfCAnc2lnbmVkX291dCc7XG4iXX0=

package/dist/esm2022/public-api.mjs

@@ -0,0 +1,35 @@
+/**
+ * `@atlasauth/angular` — the official Angular SDK for Atlas, the Angular peer of
+ * `@atlasauth/react`. Public surface.
+ */
+// Configuration + DI
+export { ATLAS_OPTIONS } from './lib/atlas.config';
+export { provideAtlas, AtlasModule } from './lib/provide-atlas';
+// Core service (the AtlasProvider + hooks equivalent)
+export { AtlasService } from './lib/atlas.service';
+// Structural directives + the theming host directive
+export { AtlasSignedInDirective } from './lib/directives/signed-in.directive';
+export { AtlasSignedOutDirective } from './lib/directives/signed-out.directive';
+export { AtlasLoadingDirective } from './lib/directives/loading.directive';
+export { AtlasLoadedDirective } from './lib/directives/loaded.directive';
+export { AtlasProtectDirective } from './lib/directives/protect.directive';
+export { AtlasRootDirective } from './lib/directives/atlas-root.directive';
+// Components
+export { SignInComponent } from './lib/components/sign-in.component';
+export { SignUpComponent } from './lib/components/sign-up.component';
+export { UserButtonComponent } from './lib/components/user-button.component';
+export { OrganizationSwitcherComponent } from './lib/components/organization-switcher.component';
+export { UserProfileComponent } from './lib/components/user-profile.component';
+export { OrganizationProfileComponent } from './lib/components/organization-profile.component';
+export { AttemptFlowComponent } from './lib/components/attempt-flow.component';
+export { AtlasFlowController } from './lib/components/flow-controller';
+export { ATLAS_UI } from './lib/atlas.ui';
+// Route guards
+export { atlasGuard, atlasChildGuard, } from './lib/guards/atlas.guard';
+// Theming, i18n, authorization, data shapes, FAPI re-exports
+export * from './lib/appearance';
+export * from './lib/i18n';
+export * from './lib/protect';
+export * from './lib/types';
+export * from './lib/fapi';
+//# sourceMappingURL=data:application/json;base64,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