@mintplayer/ng-spark 22.30.0 → 22.32.0

package/types/mintplayer-ng-spark-auth-external-login.d.ts

@@ -0,0 +1,132 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { Color } from "@mintplayer/ng-bootstrap";
+import { SparkExternalLoginMode, SparkExternalProvider } from "@mintplayer/ng-spark/auth/models";
+/**
+ * One provider's button, as the template sees it: the provider itself, and the call that signs in
+ * with it.
+ *
+ * **Passing the closure is the point.** A consumer never touches `provider.scheme`, so the failure
+ * this component exists to prevent — a hard-coded scheme string that silently stops matching when
+ * the server's registration changes — is unreachable by construction. It also means busy state,
+ * `returnUrl` handling and popup-versus-redirect can move behind `signIn` later without a
+ * consumer-facing change.
+ */
+export interface SparkProviderButtonContext {
+  $implicit: SparkExternalProviderView;
+  signIn: () => void;
+  /**
+   * Whether a sign-in popup is open: disable the button while it is. Read from the service's
+   * `externalLoginPending`, never from the sign-in promise (D2).
+   */
+  pending: boolean;
+}
+/** A provider the server reported, merged with whatever presentation the app declared for it. */
+export interface SparkExternalProviderView extends SparkExternalProvider {
+  iconClass?: string;
+}
+/**
+ * A button per external provider the server reports, and the outcome of the last attempt with one.
+ *
+ * Shared by the sign-in landing page and the password login page, so both offer the same providers
+ * with the same behaviour. Hostable on any page of an application's own as well.
+ *
+ * The providers come from `GET /spark/auth/capabilities` rather than from a list the application
+ * hard-codes: every consumer that hand-rolled this before wrote the scheme name as a string literal,
+ * which is a silent mismatch waiting to happen the moment the server's provider registration
+ * changes. A `withExternalLogin(githubProvider())` declaration only *decorates* what the server
+ * reports — it cannot conjure a provider the server does not have.
+ *
+ * Renders nothing while the capabilities load, when they fail to load (the host decides what that
+ * means for its page), and when the server reports no providers. {@link hasProviders} tells a host
+ * which of those it is, e.g. to draw an "or" divider only when there is something to divide.
+ */
+export declare class SparkExternalLoginButtonsComponent {
+  private readonly authService;
+  private readonly declaredProviders;
+  private readonly route;
+  private readonly router;
+  private readonly config;
+  readonly colors: typeof Color;
+  /**
+   * Where to land after a successful external sign-in.
+   *
+   * Falls back to a `?returnUrl=` query parameter, matching what the login page already does — so a
+   * plain `<a routerLink="/sign-in" [queryParams]="{ returnUrl: '/somewhere' }">` works with no
+   * wiring, which is what a routed page needs since the router passes it no inputs. The query value
+   * is validated as a local path before use; an off-site one is dropped rather than followed.
+   */
+  readonly returnUrl: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * Replaces the default provider button. Rendered once per provider with a
+   * {@link SparkProviderButtonContext}.
+   */
+  readonly providerTemplate: import("@angular/core").InputSignal<TemplateRef<SparkProviderButtonContext> | null>;
+  private readonly reported;
+  /** The capabilities arrived. Until then, and when they fail, nothing renders. */
+  readonly loaded: import("@angular/core").WritableSignal<boolean>;
+  /**
+   * The translation key of the last external sign-in failure, from the popup's result or from the
+   * `?sparkExternalLogin` a redirect came back with.
+   */
+  readonly externalError: import("@angular/core").WritableSignal<string>;
+  /** `link_confirmation_sent` travels as a failure but is news (check your mail), not an error. */
+  readonly externalErrorIsNotice: import("@angular/core").Signal<boolean>;
+  /**
+   * The provider whose popup `window.open` refused. The component then offers "Continue in this
+   * tab": the same provider in redirect mode. Not automatic (F10): in Firefox's installed web app a
+   * null handle may still have started the flow inside the app, and a redirect would run a second one.
+   */
+  readonly blockedProvider: import("@angular/core").WritableSignal<SparkExternalProviderView | null>;
+  /**
+   * While a sign-in popup is open. The buttons follow this, not the promise: under COOP the popup
+   * reads closed long before its result arrives, and the attempt keeps listening (D2).
+   */
+  readonly externalPending: import("@angular/core").Signal<boolean>;
+  /**
+   * The server's list, decorated and ordered by whatever the application declared. Declared-but-not-
+   * reported schemes are dropped and reported-but-not-declared ones keep a default button, so
+   * neither side can produce a provider the other does not have.
+   */
+  readonly providers: import("@angular/core").Signal<SparkExternalProviderView[]>;
+  /** Whether the server reported at least one provider, i.e. whether this component shows buttons. */
+  readonly hasProviders: import("@angular/core").Signal<boolean>;
+  constructor();
+  private load;
+  private effectiveReturnUrl;
+  /** `popup_closed` is "not now", not an error, so it shows nothing. */
+  private showExternalError;
+  /** The closure handed to a projected template, so a consumer never names a scheme itself. */
+  contextFor(provider: SparkExternalProviderView): SparkProviderButtonContext;
+  /**
+   * Signs in, then *leaves this page*.
+   *
+   * The navigation is the part that is easy to miss. In `'popup'` mode the `returnUrl` is consumed
+   * by the popup — it tells the server where to send that window before it closes — and the opener,
+   * which is the tab the user is actually looking at, is never touched. So without this the sign-in
+   * succeeds, the topbar flips to the signed-in state, and the user is left staring at the login
+   * page wondering whether it worked.
+   *
+   * Failures deliberately do not navigate: the component renders the error, and moving away would
+   * hide it. `popup_closed` is not an error — it is "not now" — so it shows nothing. `popup_blocked`
+   * also offers "Continue in this tab" ({@link continueInThisTab}).
+   *
+   * `mode` is left out unless given, so the configured `externalLoginMode` decides.
+   */
+  signInWith(provider: SparkExternalProviderView, mode?: SparkExternalLoginMode): Promise<void>;
+  /** Retries the provider whose popup was blocked as a full-page redirect in this tab. */
+  continueInThisTab(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkExternalLoginButtonsComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkExternalLoginButtonsComponent, "spark-external-login-buttons", never, {
+    "returnUrl": {
+      "alias": "returnUrl";
+      "required": false;
+      "isSignal": true;
+    };
+    "providerTemplate": {
+      "alias": "providerTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/mintplayer-ng-spark-auth-forgot-password.d.ts

@@ -0,0 +1,18 @@
+import { Color } from "@mintplayer/ng-bootstrap";
+import * as i0 from "@angular/core";
+export declare class SparkForgotPasswordComponent {
+  private readonly fb;
+  private readonly authService;
+  private readonly translation;
+  readonly routePaths: Partial<Record<keyof import("@mintplayer/ng-spark/auth/models").SparkAuthRouteEntries, string>>;
+  colors: typeof Color;
+  readonly loading: import("@angular/core").WritableSignal<boolean>;
+  readonly errorMessage: import("@angular/core").WritableSignal<string>;
+  readonly successMessage: import("@angular/core").WritableSignal<string>;
+  readonly form: import("@angular/forms").FormGroup<{
+    email: import("@angular/forms").FormControl<string | null>;
+  }>;
+  onSubmit(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkForgotPasswordComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkForgotPasswordComponent, "spark-forgot-password", never, {}, {}, never, never, true, never>;
+}

package/types/mintplayer-ng-spark-auth-guards.d.ts

@@ -0,0 +1,15 @@
+import { CanActivateFn } from "@angular/router";
+/**
+ * Lets a signed-in user through and sends everyone else to the sign-in page with a `returnUrl`.
+ *
+ * `SparkAuthService` reads `/me` asynchronously at start-up, so on a hard reload the user is not
+ * known to be signed in yet when the router runs this guard. When the session is not known, the
+ * guard waits for the session check before deciding, so a signed-in user is never bounced to the
+ * sign-in page. A session that is already known passes without a round trip.
+ */
+export declare const sparkAuthGuard: CanActivateFn;
+/**
+ * The same guard as {@link sparkAuthGuard}. It existed separately while `sparkAuthGuard` decided
+ * before the session check had finished; both now wait for it.
+ */
+export declare const sparkAuthenticatedGuard: CanActivateFn;

package/types/mintplayer-ng-spark-auth-interceptors.d.ts

@@ -0,0 +1,2 @@
+import { HttpInterceptorFn } from "@angular/common/http";
+export declare const sparkAuthInterceptor: HttpInterceptorFn;

package/types/mintplayer-ng-spark-auth-login.d.ts

@@ -0,0 +1,46 @@
+import { Color } from "@mintplayer/ng-bootstrap";
+import * as i0 from "@angular/core";
+export declare class SparkLoginComponent {
+  private readonly fb;
+  private readonly authService;
+  private readonly router;
+  private readonly route;
+  private readonly config;
+  private readonly translation;
+  readonly routePaths: Partial<Record<keyof import("@mintplayer/ng-spark/auth/models").SparkAuthRouteEntries, string>>;
+  colors: typeof Color;
+  readonly loading: import("@angular/core").WritableSignal<boolean>;
+  readonly errorMessage: import("@angular/core").WritableSignal<string>;
+  /**
+   * The passkey button belongs here as well as on the sign-in landing page.
+   *
+   * ⚠️ Without it an application using `withLocalLogin()` can *enroll* a passkey and then have no way
+   * to use it, because the landing page it would otherwise appear on is only mounted by
+   * `withExternalLogin()`. Passkeys are independent of both features, so the button has to be
+   * reachable from whichever sign-in page the application actually mounted.
+   */
+  readonly passkeysAvailable: import("@angular/core").WritableSignal<boolean>;
+  readonly passkeyBusy: import("@angular/core").WritableSignal<boolean>;
+  /**
+   * What the server's `SignInIdentifiers` accepts, which shapes the identifier field's label, input
+   * type and autocomplete. Both until the capabilities arrive, and when the server does not say.
+   */
+  private readonly signInIdentifiers;
+  readonly identifierField: import("@angular/core").Signal<{
+    label: string;
+    type: string;
+    autocomplete: string;
+  }>;
+  constructor();
+  private loadCapabilities;
+  /** Same shape as {@link onSubmit}'s success path — sign in, then leave the page. */
+  signInWithPasskey(): Promise<void>;
+  readonly form: import("@angular/forms").FormGroup<{
+    email: import("@angular/forms").FormControl<string | null>;
+    password: import("@angular/forms").FormControl<string | null>;
+    rememberMe: import("@angular/forms").FormControl<boolean | null>;
+  }>;
+  onSubmit(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkLoginComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkLoginComponent, "spark-login", never, {}, {}, never, never, true, never>;
+}