@marsaude/devtools-shell 0.1.0

package/types/marsaude-devtools-shell.d.ts

@@ -0,0 +1,267 @@
+import * as _angular_core from '@angular/core';
+import { Type, TemplateRef, EnvironmentProviders, OnDestroy, InjectionToken } from '@angular/core';
+import * as _marsaude_devtools_shell from '@marsaude/devtools-shell';
+import { Observable } from 'rxjs';
+
+/**
+ * A single pluggable entry surfaced by the shell. `content` is what the shell
+ * renders inside its container when this action is selected — a standalone
+ * component class or a `TemplateRef`. The shell never knows what the content
+ * does; that is entirely the consumer's domain.
+ */
+interface DevtoolsAction {
+    /** Stable id, used as the panel key. */
+    id: string;
+    /** Human-readable label shown in the action switcher. */
+    label: string;
+    /** Optional Material Symbols glyph name (e.g. `'biotech'`). */
+    icon?: string;
+    /** Component or template rendered in the container for this action. */
+    content?: Type<unknown> | TemplateRef<unknown>;
+    /** Lower comes first. Defaults to registration order. */
+    order?: number;
+}
+/** Where the FAB sits the first time, before any persisted position exists. */
+type DevtoolsCorner = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+/** Look-and-feel + behaviour knobs for the shell. All optional. */
+interface DevtoolsShellConfig {
+    /** Title shown in the container header when no action is active. */
+    title?: string;
+    /** localStorage key used to persist the FAB position. */
+    storageKey?: string;
+    /** Initial corner when there is no persisted position. */
+    initialCorner?: DevtoolsCorner;
+    /** Material Symbols glyph for the FAB itself. Defaults to `developer_mode`. */
+    fabIcon?: string;
+}
+
+type ValidationMedia = 'WHATSAPP' | 'SMS';
+/** Everything environment-specific is passed in by the host — the package
+ *  reads NOTHING from the host app's environment/services. */
+interface DevtoolsConfig {
+    /** API base, e.g. https://api.stag.marsaude.net/v1 */
+    apiBaseUrl: string;
+    /** OTP channel. Default WHATSAPP. */
+    media?: ValidationMedia;
+    /** X-Mar-Locale header value. Default pt_BR. */
+    locale?: string;
+    /** Google OAuth client id for the admin login. */
+    googleClientId?: string;
+    /** Google OAuth redirect_uri (must be whitelisted). */
+    googleRedirectUri?: string;
+    /** reCAPTCHA v3 site key (optional). */
+    recaptchaSiteKey?: string;
+    /** Fixed RH organization id used by the generator. Default 200. */
+    fixedOrgId?: number;
+    /** Fallback admin phone for the SMS-release toggle. */
+    adminPhone?: string;
+}
+
+interface ProvideDevtoolsOptions extends DevtoolsConfig {
+    /** Layer-1 production gate. Pass `!environment.production`. @default true */
+    enabled?: boolean;
+    /** Extra custom panels, appended to the built-in DevTools panels. */
+    actions?: DevtoolsAction[];
+    /** Container header title. */
+    title?: string;
+    /** FAB glyph. @default developer_mode */
+    fabIcon?: string;
+}
+/**
+ * Mount the self-contained DevTools. Add to `bootstrapApplication` providers or
+ * `@NgModule({ providers })`. Everything runs in an ISOLATED environment
+ * injector with the package's OWN HttpClient + interceptor — it never touches
+ * the host app's services, interceptors or session beyond the deliberate
+ * active-session keys used by the Switch panel.
+ */
+declare function provideDevtools(options: ProvideDevtoolsOptions): EnvironmentProviders;
+
+interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Owns the FAB position + side and persists them. The math is ported verbatim
+ * from the `DevTools FAB` prototype (default corner, clamp bounds, edge snap).
+ * Only position/side are stored — no domain/session data.
+ */
+declare class DevtoolsPositionService {
+    private readonly config;
+    private readonly key;
+    /** FAB top-left in viewport coords. Null until first measured/loaded. */
+    readonly position: _angular_core.WritableSignal<Point>;
+    readonly side: _angular_core.WritableSignal<"left" | "right">;
+    /** Live update during drag (not persisted). */
+    move(p: Point): void;
+    /** Commit + persist the final position and side. */
+    commit(p: Point, side: 'left' | 'right'): void;
+    /** Re-clamp against the current viewport. Call on resize. */
+    reclamp(): void;
+    /** Prototype clamp: x ∈ [6, W-S-6], y ∈ [70, H-S-6]. */
+    clamp(p: Point): Point;
+    private persist;
+    /** Prototype default corner: { x: W-74, y: H-150 }. */
+    private load;
+    private loadSide;
+    private defaultPos;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DevtoolsPositionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DevtoolsPositionService>;
+}
+
+/**
+ * Tiny toast surface owned by the shell. Panels (or any consumer) can inject it
+ * to flash a short message inside the shell's own layer — no Material/snackbar
+ * dependency required.
+ */
+declare class DevtoolsToastService {
+    /** Current message, or null when nothing is showing. */
+    readonly message: _angular_core.WritableSignal<string>;
+    private timer;
+    show(message: string, durationMs?: number): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DevtoolsToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DevtoolsToastService>;
+}
+
+interface DialItem {
+    action: DevtoolsAction;
+    style: Record<string, string | number>;
+}
+/**
+ * The invólucro: a draggable FAB that opens an agnostic container.
+ *
+ * Drag, clamp/snap, the radial speed-dial geometry, the collapse-to-edge grip,
+ * the drawer/sheet panel and the toast are ported verbatim from the `DevTools
+ * FAB` prototype (Pointer Events, the exact math and the same CSS/keyframes) —
+ * kept entirely domain-free. Content arrives via {@link DEVTOOLS_ACTION}
+ * (primary) or `<ng-content>` (secondary). Auto-mounted by `provideDevtools()`.
+ */
+declare class DevtoolsShellComponent implements OnDestroy {
+    protected readonly pos: DevtoolsPositionService;
+    protected readonly config: _marsaude_devtools_shell.DevtoolsShellConfig;
+    protected readonly toast: DevtoolsToastService;
+    private readonly registered;
+    protected readonly actions: _angular_core.WritableSignal<DevtoolsAction[]>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly panelId: _angular_core.WritableSignal<string>;
+    protected readonly collapsed: _angular_core.WritableSignal<boolean>;
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    private readonly winW;
+    private readonly winH;
+    protected readonly hasDial: _angular_core.Signal<boolean>;
+    protected readonly activeAction: _angular_core.Signal<DevtoolsAction>;
+    protected readonly isCollapsed: _angular_core.Signal<boolean>;
+    /** FAB style — collapsed grip vs expanded button (prototype values). */
+    protected readonly fabStyle: _angular_core.Signal<Record<string, string>>;
+    /** Radial speed-dial geometry — ported verbatim (R=268, 5°→87°). */
+    protected readonly dialItems: _angular_core.Signal<DialItem[]>;
+    /** Drawer (desktop) / bottom-sheet (mobile) — prototype values. */
+    protected readonly panelStyle: _angular_core.Signal<Record<string, string>>;
+    private drag;
+    private dragEndAt;
+    private collapseTimer;
+    private readonly moveHandler;
+    private readonly upHandler;
+    constructor();
+    ngOnDestroy(): void;
+    protected onResize(): void;
+    protected onFabDown(e: PointerEvent): void;
+    private onMove;
+    private onUp;
+    private detachDragListeners;
+    protected onFabClick(): void;
+    private toggleDial;
+    protected openPanel(id: string): void;
+    protected togglePanel(id: string): void;
+    protected closePanel(): void;
+    protected closeDial(): void;
+    protected asTemplate(c: unknown): TemplateRef<unknown> | null;
+    protected asComponent(c: unknown): Type<unknown> | null;
+    private scheduleCollapse;
+    private clearCollapse;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DevtoolsShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DevtoolsShellComponent, "devtools-shell", never, {}, {}, never, ["*", "*"], true, never>;
+}
+
+/**
+ * Multi-provider token. Each `{ provide: DEVTOOLS_ACTION, useValue, multi: true }`
+ * adds one pluggable panel to the shell. This is the extension point: the shell
+ * collects every registered action and renders it — it has no built-in actions.
+ */
+declare const DEVTOOLS_ACTION: InjectionToken<DevtoolsAction>;
+/** Single-value config token. Falls back to an empty config. */
+declare const DEVTOOLS_SHELL_CONFIG: InjectionToken<DevtoolsShellConfig>;
+
+interface DevtoolsSession {
+    id: string;
+    kind: 'admin' | 'test';
+    name: string;
+    document?: string;
+    accessToken: string;
+    refreshToken: string;
+    profile?: any;
+}
+/**
+ * Manages the *active app session* that the host patient app consumes, letting
+ * the QA switch it between the fixed admin (the DevTools identity) and any saved
+ * generated user — without re-OTP. The DevTools' own API calls do NOT use this;
+ * they always use the admin token via the package interceptor.
+ */
+declare class DevtoolsSessionService {
+    private readonly storage;
+    private readonly auth;
+    private readonly _sessions;
+    readonly sessions: _angular_core.Signal<DevtoolsSession[]>;
+    readonly activeId: _angular_core.WritableSignal<string>;
+    /** Admin session derived from the DevTools identity (auth). */
+    readonly admin: _angular_core.Signal<DevtoolsSession>;
+    saveTestSession(session: Omit<DevtoolsSession, 'id' | 'kind'> & {
+        document: string;
+    }): DevtoolsSession;
+    /** Write a stored session into the host's active-session keys. */
+    switchTo(id: string): DevtoolsSession | null;
+    removeSession(id: string): void;
+    active(): DevtoolsSession | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DevtoolsSessionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DevtoolsSessionService>;
+}
+
+interface TokenResponse {
+    accessToken: string;
+    refreshToken: string;
+}
+
+/**
+ * The DevTools' OWN identity (admin). Completely separate from the host app's
+ * session: its tokens live under `DEVTOOLS_ADMIN_*` and are what the package's
+ * interceptor attaches. The package is "logged in" iff an admin token exists.
+ */
+declare class DevtoolsAuthService {
+    private readonly storage;
+    private readonly config;
+    private readonly api;
+    private readonly _token;
+    readonly logged: _angular_core.Signal<boolean>;
+    adminToken(): string | null;
+    adminRefreshToken(): string | null;
+    adminProfile(): any;
+    isLogged(): boolean;
+    /** Begin Google OAuth for the admin (full-page redirect). */
+    loginGoogleRedirect(): void;
+    /**
+     * Consume a Google OAuth return that WE initiated (guarded by a flag so we
+     * never steal the host app's own OAuth redirect). Exchanges the access token
+     * for admin JWTs and loads the admin profile.
+     */
+    handleGoogleReturn(): void;
+    exchangeGoogle(googleToken: string): Observable<any>;
+    /** Used by the interceptor on 401. */
+    refresh(): Observable<TokenResponse>;
+    setTokens(tokens: TokenResponse): void;
+    logout(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DevtoolsAuthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DevtoolsAuthService>;
+}
+
+export { DEVTOOLS_ACTION, DEVTOOLS_SHELL_CONFIG, DevtoolsAuthService, DevtoolsSessionService, DevtoolsShellComponent, DevtoolsToastService, provideDevtools };
+export type { DevtoolsAction, DevtoolsConfig, DevtoolsCorner, DevtoolsSession, DevtoolsShellConfig, ProvideDevtoolsOptions, ValidationMedia };