@lenne.tech/ng-base 18.1.3 → 22.0.0

package/types/lenne.tech-ng-base-bug-server.d.ts

@@ -0,0 +1,316 @@
+import { LtEnv, LtNodeMiddleware } from "@lenne.tech/ng-base/server";
+/** Report types (mapped onto Linear labels). */
+export declare const LT_BUG_REPORT_TYPES: readonly ["bug", "feature", "enhancement", "other"];
+/** Kind of report. */
+type LtBugServerReportType = (typeof LT_BUG_REPORT_TYPES)[number];
+/** Size limits applied to an incoming report (texts are cut, lists keep their newest entries). */
+export declare const LT_BUG_REPORT_LIMITS: Readonly<{
+  /** Attachments per report (including the screenshot). */
+  attachments: 10;
+  /** Characters of one attachment / screenshot data URL (about 11 MB decoded). */
+  attachmentDataUrl: 15000000;
+  consoleLogs: 100;
+  description: 20000;
+  networkRequests: 100;
+  text: 10000;
+  title: 255;
+  userInteractions: 200;
+}>;
+/** A decoded file of a report. */
+interface LtBugServerFile {
+  contentType: string;
+  data: Buffer;
+  isScreenshot: boolean;
+  name: string;
+}
+/** Console entry after validation. */
+interface LtBugServerConsoleLog {
+  level: string;
+  message: string[];
+  stack?: string;
+  timestamp: string;
+}
+/** Network entry after validation (headers and request bodies are dropped). */
+interface LtBugServerNetworkRequest {
+  error?: string;
+  method: string;
+  responseBody?: string;
+  status: number;
+  statusText: string;
+  timestamp: string;
+  url: string;
+}
+/** User journey entry after validation. */
+interface LtBugServerInteraction {
+  metadata?: {
+    errorMessage?: string;
+    key?: string;
+    text?: string;
+    toUrl?: string;
+    url?: string;
+    value?: string;
+  };
+  target: string;
+  timestamp: string;
+  type: string;
+}
+/** Browser details after validation. */
+interface LtBugServerBrowserInfo {
+  browser?: {
+    name?: string;
+    version?: string;
+  };
+  language?: string;
+  os?: {
+    name?: string;
+    version?: string;
+  };
+  platform?: string;
+  timestamp?: string;
+  url?: string;
+  userAgent?: string;
+  viewport?: {
+    height: number;
+    width: number;
+  };
+}
+/** A validated, size-capped and redacted report. */
+interface LtBugServerReport {
+  attachments: LtBugServerFile[];
+  browserInfo?: LtBugServerBrowserInfo;
+  consoleLogs: LtBugServerConsoleLog[];
+  description: string;
+  expectedBehavior?: string;
+  networkRequests: LtBugServerNetworkRequest[];
+  /** Attachments dropped because they exceeded the limits. */
+  skippedAttachments: number;
+  stepsToReproduce?: string;
+  title: string;
+  type: LtBugServerReportType;
+  userInteractions: LtBugServerInteraction[];
+}
+/** Result of {@link validateLtBugReport}. */
+type LtBugReportValidation = {
+  error: string;
+  ok: false;
+} | {
+  ok: true;
+  report: LtBugServerReport;
+};
+/** Message for a report without title, type or description (same text as `@lenne.tech/bug.lt`). */
+export declare const LT_BUG_MISSING_FIELDS = "Missing required fields: title, type, and description are required";
+/**
+ * Validate an incoming report by hand: title, type and description are required strings, `type` one of
+ * {@link LT_BUG_REPORT_TYPES}; files must be base64 `data:` URLs (never fetched: no URL is ever requested by the server).
+ * Texts are cut, lists keep their newest entries, files above the limit are dropped and counted, everything is redacted.
+ */
+export declare function validateLtBugReport(body: unknown): LtBugReportValidation;
+/** Default endpoint (the same as `@lenne.tech/bug.lt` and `provideLtBug()`). */
+export declare const LT_BUG_SERVER_DEFAULT_ENDPOINT = "/_bug-lt/report";
+/** Default request body limit (30 MB: one 10 MB file plus screenshot fit, base64 included). */
+export declare const LT_BUG_DEFAULT_MAX_BODY_BYTES: number;
+/** Options of {@link ltBugReport}. */
+interface LtBugReportHandlerOptions {
+  /**
+   * Force the endpoint on or off (env `NG_PUBLIC_LT_BUG_ENABLED` wins). Default: on when `NG_PUBLIC_APP_ENV` is set and
+   * not `production`; without `NG_PUBLIC_APP_ENV` it stays off (fail closed). Off answers `404`.
+   */
+  enabled?: boolean;
+  /** Route (default `/_bug-lt/report`); must match `provideLtBug({ endpoint })`. */
+  endpoint?: string;
+  /** Environment (default `process.env`). */
+  env?: LtEnv;
+  /** `fetch` used for Linear (default the global `fetch`; for tests or an outbound proxy). */
+  fetch?: typeof fetch;
+  /** Linear API key; env `NG_LINEAR_API_KEY` wins. Server only, never sent to the browser. */
+  linearApiKey?: string;
+  /** Linear project name (optional); env `NG_LINEAR_PROJECT_NAME` wins. */
+  linearProjectName?: string;
+  /** Linear team name or key; env `NG_LINEAR_TEAM_NAME` wins. */
+  linearTeamName?: string;
+  /** Logger for server-side diagnostics (default `console`); messages are redacted and never contain the API key. */
+  logger?: Pick<Console, 'error' | 'warn'>;
+  /** Request body limit in bytes (default {@link LT_BUG_DEFAULT_MAX_BODY_BYTES}); larger bodies get `413`. */
+  maxBodyBytes?: number;
+  /** Reports per client address and window (default 20 per 10 minutes); `false` turns the limit off. */
+  rateLimit?: false | {
+    max: number;
+    windowMs: number;
+  };
+  /** Time zone of the times in the issue (default `Europe/Berlin`). */
+  timeZone?: string;
+}
+/** Linear settings of one request. */
+interface LinearConfig {
+  apiKey: string;
+  projectName?: string;
+  teamName: string;
+}
+/**
+ * Whether the bug report endpoint is on, in this order:
+ *
+ * 1. `NG_PUBLIC_LT_BUG_ENABLED` (`true`/`false`), the same switch the browser part reads, so one variable turns the
+ *    reporter on or off per stage on both sides.
+ * 2. The `enabled` option.
+ * 3. On when `NG_PUBLIC_APP_ENV` is set and neither `production` nor `prod`; without `NG_PUBLIC_APP_ENV` it is off
+ *    (fail closed, also locally: set e.g. `local`).
+ */
+export declare function isLtBugServerEnabled(enabled: boolean | undefined, env: LtEnv): boolean;
+/**
+ * `POST /_bug-lt/report`: validates a report of `provideLtBug()` / `<lt-bug-report>` and creates a Linear issue (team
+ * and optional project resolved by name, label per type found or created, screenshot and attachments uploaded and
+ * linked), the counterpart of the Nitro handler of `@lenne.tech/bug.lt`.
+ *
+ * - Credentials only here: `NG_LINEAR_API_KEY`, `NG_LINEAR_TEAM_NAME`, `NG_LINEAR_PROJECT_NAME` (or the options).
+ * - Off (`404`) when `NG_PUBLIC_APP_ENV` is `production` or missing, unless `NG_PUBLIC_LT_BUG_ENABLED` or `enabled` turn it on.
+ * - JSON only (`415` otherwise, which also blocks simple cross-site form posts), body limit (`413`), per-client rate
+ *   limit (`429`), hand-written validation (`400`), files only as base64 data URLs (no URL is ever fetched).
+ * - Redacts tokens, passwords and auth bodies once more before writing to Linear; answers never contain the API key or
+ *   Linear's error messages (`502` with a generic text, details only in the server log).
+ *
+ * Register it before `express.json()` (which would reject large reports with its 100 kB default) and before the Angular
+ * handler.
+ *
+ * @example server.ts
+ * app.use(ltBugReport());
+ */
+export declare function ltBugReport(options?: LtBugReportHandlerOptions): LtNodeMiddleware;
+/** Team or project setup does not match the Linear workspace. */
+export declare class LtBugConfigError extends Error {}
+/**
+ * Create the Linear issue of a validated report: resolve the team (required) and project (optional), find or create
+ * the type label, create the issue, then upload and link every file (failures are logged and skipped).
+ */
+export declare function createLtLinearIssue(report: LtBugServerReport, config: LinearConfig, options?: {
+  fetch?: typeof fetch;
+  logger?: Pick<Console, 'error' | 'warn'>;
+  timeZone?: string;
+}): Promise<{
+  identifier?: string;
+  issueId: string;
+  issueUrl?: string;
+}>;
+/** Linear GraphQL endpoint. */
+export declare const LT_LINEAR_API_URL = "https://api.linear.app/graphql";
+/** Label name and color per report type (same mapping as `@lenne.tech/bug.lt`). */
+export declare const LT_BUG_LABELS: Readonly<Record<string, {
+  color: string;
+  name: string;
+}>>;
+/** Error of a Linear request. The message may contain Linear's answer: log it server-side only, never send it out. */
+export declare class LtLinearError extends Error {
+  readonly status?: number | undefined;
+  constructor(message: string, status?: number | undefined);
+}
+/** Options of {@link LtLinearClient}. */
+interface LtLinearClientOptions {
+  /** Linear personal API key (sent as `Authorization`). */
+  apiKey: string;
+  /** GraphQL endpoint (default {@link LT_LINEAR_API_URL}). */
+  apiUrl?: string;
+  /** `fetch` implementation (default the global `fetch`). */
+  fetch?: typeof fetch;
+  /** Timeout per request in ms (default 15000). */
+  timeoutMs?: number;
+}
+/** Issue created by {@link LtLinearClient.createIssue}. */
+interface LtLinearIssue {
+  id: string;
+  identifier?: string;
+  url?: string;
+}
+/**
+ * Minimal Linear GraphQL client for bug reports (the port of `LinearApiClient` of `@lenne.tech/bug.lt`): team and project
+ * lookup by name (paginated, case-insensitive), label lookup/creation, issue creation and the two-step file upload
+ * (signed URL from `fileUpload`, `PUT` to storage, then `attachmentCreate`).
+ */
+export declare class LtLinearClient {
+  private readonly options;
+  private readonly apiUrl;
+  private readonly fetchFn;
+  private readonly timeoutMs;
+  constructor(options: LtLinearClientOptions);
+  /** Run a GraphQL request; throws {@link LtLinearError} on HTTP and GraphQL errors. */
+  request<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
+  /** All teams (paginated). */
+  getTeams(): Promise<{
+    id: string;
+    key: string;
+    name: string;
+  }[]>;
+  /** Team by name or key (case-insensitive), `null` when none matches. */
+  findTeam(nameOrKey: string): Promise<{
+    id: string;
+    key: string;
+    name: string;
+  } | null>;
+  /** Project by name (case-insensitive), `null` when none matches. */
+  findProject(name: string): Promise<{
+    id: string;
+    name: string;
+  } | null>;
+  /** Id of the label `name` usable in `teamId` (a team label or a workspace label), `null` when there is none. */
+  findLabel(teamId: string, name: string): Promise<string | null>;
+  /** Create a team label; returns its id. */
+  createLabel(teamId: string, name: string, color: string): Promise<string | null>;
+  /** Create an issue. */
+  createIssue(input: {
+    description: string;
+    labelIds?: string[];
+    projectId?: string;
+    teamId: string;
+    title: string;
+  }): Promise<LtLinearIssue>;
+  /** Upload a file to Linear's storage; returns the asset URL. */
+  uploadFile(content: Uint8Array, filename: string, contentType: string): Promise<string>;
+  /** Link an uploaded file to an issue. */
+  createAttachment(issueId: string, url: string, title: string): Promise<string | null>;
+  private collect;
+}
+/** Options of {@link formatLtBugReportForLinear}. */
+interface LtLinearFormatOptions {
+  /** Time zone of the journey times (default `Europe/Berlin`; the browser sends UTC timestamps). */
+  timeZone?: string;
+}
+/** Title and Markdown description of the Linear issue. */
+interface LtLinearIssueText {
+  description: string;
+  title: string;
+}
+/**
+ * Linear issue text of a report, in the layout of `@lenne.tech/bug.lt` (German headings): bug report, context table,
+ * user journey table, technical details (last 10 console logs and network requests, failed requests with the start of
+ * their response) and an attachments note. Table cells are escaped, so `|` or line breaks in data keep the tables intact.
+ */
+export declare function formatLtBugReportForLinear(report: LtBugServerReport, options?: LtLinearFormatOptions): LtLinearIssueText;
+/** Replacement of every redacted value. */
+export declare const LT_BUG_REDACTED = "[redacted]";
+/** Headers whose values are never recorded (compared case-insensitively). */
+export declare const LT_BUG_SENSITIVE_HEADERS: readonly string[];
+/**
+ * Path segments whose request and response bodies are never recorded: nest-server IAM (`/iam/…`: passwords, tokens,
+ * 2FA codes, reset and verify tokens), the first-admin setup (`/system-setup/…`) and other auth-like endpoints.
+ */
+export declare const LT_BUG_BODY_EXCLUDED_SEGMENTS: readonly string[];
+/** Whether a header carries credentials (`Authorization`, `Cookie`, `Set-Cookie`, `X-System-Setup-Token` …). */
+export declare function isLtSensitiveHeader(name: string): boolean;
+/**
+ * Whether an object key / form field name / query parameter holds a secret (`password`, `newPassword`, `token`,
+ * `access_token`, `code`, `otp`, `user[password]` …).
+ */
+export declare function isLtSensitiveKey(key: string): boolean;
+/** Whether request and response bodies of `url` must not be recorded (see {@link LT_BUG_BODY_EXCLUDED_SEGMENTS}). */
+export declare function isLtBodyExcludedUrl(url: string): boolean;
+/**
+ * Redact secrets in free text and URLs: query/hash/form parameters (`token`, `code`, `password`, `secret`, `otp`, …,
+ * also inside nested and percent-encoded `callbackURL` values), tokens in reset/verify paths, URL credentials,
+ * `Bearer` tokens, JWTs, JSON pairs with secret keys and `password: …` labels.
+ */
+export declare function redactLtText(text: string): string;
+/** Redact a URL (alias of {@link redactLtText}, which handles URLs inside text as well). */
+export declare function redactLtUrl(url: string): string;
+/** Redact and truncate a request/response body: JSON deep, everything else (form data, text) as text. */
+export declare function redactLtBody(body: string, maxLength?: number): string;
+/** Copy of a header map with credential headers replaced by `[redacted]` and the other values redacted as text. */
+export declare function redactLtHeaders(headers: Record<string, string>): Record<string, string>;
+export type { LtBugReportHandlerOptions, LtBugReportValidation, LtBugServerBrowserInfo, LtBugServerConsoleLog, LtBugServerFile, LtBugServerInteraction, LtBugServerNetworkRequest, LtBugServerReport, LtBugServerReportType, LtLinearClientOptions, LtLinearFormatOptions, LtLinearIssue, LtLinearIssueText };

package/types/lenne.tech-ng-base-bug.d.ts

@@ -0,0 +1,202 @@
+import { LtBugOptions, LtResolvedBugOptions } from "@lenne.tech/ng-base/bug/provide";
+import * as i0 from "@angular/core";
+import { InjectionToken } from "@angular/core";
+import { LtI18nService } from "@lenne.tech/ng-base";
+export * from "@lenne.tech/ng-base/bug/provide";
+/** Default endpoint, the same as `@lenne.tech/bug.lt` (outside `/api`, so an API proxy does not swallow it). */
+export declare const LT_BUG_DEFAULT_ENDPOINT = "/_bug-lt/report";
+/** Defaults of {@link LtBugOptions} (the module defaults of `@lenne.tech/bug.lt` 1.6.9, except the button color). */
+export declare const LT_BUG_DEFAULTS: LtResolvedBugOptions;
+/** Resolved options: defaults ← `provideLtBug(options)` ← runtime `lt.bug` (`LT_RUNTIME_CONFIG`). */
+export declare const LT_BUG_OPTIONS: InjectionToken<LtResolvedBugOptions>;
+/** Merge options onto the defaults; `userJourney` is merged per key, `undefined` never overrides, sizes are clamped. */
+export declare function resolveLtBugOptions(...overrides: (LtBugOptions | Record<string, unknown> | null | undefined)[]): LtResolvedBugOptions;
+import * as import__lenne_tech_ng_base_bug_provide$1 from "@lenne.tech/ng-base/bug/provide";
+/** Values of the report form. */
+interface LtBugReportFormValue {
+  description: string;
+  expectedBehavior: string;
+  stepsToReproduce: string;
+  title: string;
+  type: bug_types_d_exports.LtBugReportType | null;
+}
+/** Which collected data the user chose to include. */
+interface LtBugReportIncludes {
+  browserInfo: boolean;
+  consoleLogs: boolean;
+  networkRequests: boolean;
+  userJourney: boolean;
+}
+/** Error of {@link LtBugReportService.submit}; `message` is the translated text shown to the user. */
+export declare class LtBugSubmitError extends Error {
+  readonly status: number;
+  constructor(message: string, status: number);
+}
+/**
+ * State and actions of the bug reporter, the counterpart of `useBugReport()` of `@lenne.tech/bug.lt`.
+ *
+ * `<lt-bug-report>` calls {@link start} when it is created: when the reporter is {@link active} it loads the capture engine
+ * (a chunk of its own) and installs the hooks (console, `fetch`/`XMLHttpRequest`, user journey, `ErrorHandler`);
+ * otherwise it loads and installs nothing. `<lt-bug-report>` renders the button and opens the dialog for {@link open}
+ * requests.
+ */
+export declare class LtBugReportService {
+  /** Resolved options. */
+  readonly options: import("@lenne.tech/ng-base/bug").LtResolvedBugOptions;
+  private readonly document;
+  private readonly injector;
+  private readonly i18n;
+  private readonly i18nOptions;
+  private readonly toast;
+  private readonly screenshotLoader;
+  /**
+   * Whether the reporter runs: `provideLtBug()` is present, the code runs in the browser and the runtime decision says
+   * on (`enabled`, else app env not `production`, else dev mode only). Decided once at startup.
+   */
+  readonly active: boolean;
+  /** The dialog is open (or about to open). */
+  readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  /** A report is being sent. */
+  readonly isSubmitting: import("@angular/core").WritableSignal<boolean>;
+  /** Message of the last failed submission (shown in the dialog). */
+  readonly error: import("@angular/core").WritableSignal<string | null>;
+  /** The last captured error (pre-fills the form). */
+  readonly lastError: import("@angular/core").WritableSignal<bug_types_d_exports.LtBugErrorInfo | null>;
+  /** Screenshot taken before the dialog opened (data URL). */
+  readonly screenshot: import("@angular/core").WritableSignal<string | null>;
+  /** A screenshot is being taken. */
+  readonly capturingScreenshot: import("@angular/core").WritableSignal<boolean>;
+  /** Whether `modern-screenshot` could be loaded (`null` until the first attempt). */
+  readonly screenshotAvailable: import("@angular/core").WritableSignal<boolean | null>;
+  /** An {@link open} request waits for `<lt-bug-report>` (read and reset by the component). */
+  readonly openRequested: import("@angular/core").WritableSignal<boolean>;
+  private engine;
+  private engineLoad;
+  private pendingErrors;
+  private started;
+  constructor();
+  /** Whether the capture hooks are installed. */
+  get running(): boolean;
+  /**
+   * Load the capture engine and install the hooks for the enabled features (idempotent; does nothing while not
+   * {@link active}). Errors reported before the engine is ready are handed over once it is.
+   */
+  start(): void;
+  /** Resolves once {@link start} has installed the hooks (`false` when inactive or the engine failed to load). */
+  whenReady(): Promise<boolean>;
+  /** Remove every capture hook and restore the patched globals. */
+  stop(): void;
+  /**
+   * Ask `<lt-bug-report>` to take a screenshot and open the dialog (also when the floating button is hidden with
+   * `autoShow: false`); `error` pre-fills the form. Ignored while the reporter is not active.
+   */
+  open(error?: bug_types_d_exports.LtBugErrorInfo): void;
+  /** Report an error by hand (e.g. from a `catch` block): it becomes {@link lastError} and may auto-open the dialog. */
+  reportError(error: unknown, source?: string): void;
+  /** Record a custom user journey event (no-op while the journey is off). */
+  recordInteraction(type: bug_types_d_exports.LtUserInteractionType, target: string, metadata?: bug_types_d_exports.LtUserInteractionMetadata): void;
+  /** The captured console entries (newest `maxConsoleLogs`). */
+  getConsoleLogs(): bug_types_d_exports.LtConsoleLogEntry[];
+  /** The captured network requests (newest `maxNetworkRequests`). */
+  getNetworkRequests(): bug_types_d_exports.LtNetworkRequestEntry[];
+  /** The captured user journey (newest `userJourney.maxEvents`). */
+  getUserJourney(): bug_types_d_exports.LtUserInteractionEvent[];
+  /** Browser details of the current page (`null` while inactive or outside the browser). */
+  getBrowserInfo(): bug_types_d_exports.LtBrowserInfo | null;
+  /**
+   * Take a viewport screenshot into {@link screenshot} (without the reporter's UI; network capture paused meanwhile).
+   * Resolves `null` when screenshots are disabled, `modern-screenshot` is missing or the capture failed.
+   */
+  captureScreenshot(): Promise<string | null>;
+  /** Assemble the payload from the form, the attachments and the collected data the user kept switched on. */
+  buildReport(form: LtBugReportFormValue, attachments: readonly bug_types_d_exports.LtBugAttachment[], includes: LtBugReportIncludes): Promise<bug_types_d_exports.LtBugReportData>;
+  /**
+   * POST the report to the endpoint. Shows a success or error toast; on failure sets {@link error} and rejects with a
+   * {@link LtBugSubmitError} carrying the translated message.
+   */
+  submit(report: bug_types_d_exports.LtBugReportData): Promise<bug_types_d_exports.LtBugReportResponse>;
+  /** Forget screenshot, pre-fill error and submission error (after a sent report). */
+  reset(): void;
+  private onCapturedError;
+  private messageForStatus;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtBugReportService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Attribute that marks the reporter's own UI (button, dialog): left out of the user journey and the screenshot. */
+export declare const LT_BUG_UI_ATTRIBUTE = "data-lt-bug-ui";
+/** The part of `modern-screenshot` the reporter uses (structural, so the peer stays optional). */
+interface LtScreenshotLibrary {
+  domToPng(node: Node, options?: Record<string, unknown>): Promise<string>;
+}
+/**
+ * Loader of the screenshot library (default: lazy `import('modern-screenshot')`, `null` when the optional peer is
+ * missing: the screenshot feature is then hidden). Replace it in tests.
+ */
+export declare const LT_BUG_SCREENSHOT_LOADER: InjectionToken<() => Promise<LtScreenshotLibrary | null>>;
+/**
+ * Floating bug report button (the counterpart of `<BugReportButton>` of `@lenne.tech/bug.lt`). A click takes a
+ * screenshot of the current page and opens the report dialog; the dialog (form, attachments, user journey) is loaded
+ * on first use, so this component stays small. Creating it starts the capture (`LtBugReportService.start()`), it
+ * serves `LtBugReportService.open()` requests, e.g. from `autoOpenOnError`, and renders nothing while the reporter is
+ * inactive (production, or without `provideLtBug()`).
+ *
+ * Inputs override the `provideLtBug()` options for this instance. Render it once in the app shell, deferred and only
+ * while the reporter is active (`LT_BUG_ACTIVE` from `@lenne.tech/ng-base/bug/provide`):
+ *
+ * @example
+ * @if (bugActive) { @defer (on immediate) { <lt-bug-report /> } }
+ */
+export declare class LtBugReport {
+  /** Button background (default option `buttonColor`). */
+  readonly color: import("@angular/core").InputSignal<string | undefined>;
+  /** ng-icons name of the icon (default option `buttonIcon`, else the Lucide bug); register custom icons yourself. */
+  readonly icon: import("@angular/core").InputSignal<string | undefined>;
+  /** Corner (default option `position`). */
+  readonly position: import("@angular/core").InputSignal<bug_types_d_exports.LtBugPosition | undefined>;
+  /** Show the floating button (default option `autoShow`). */
+  readonly show: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Text next to the icon (default option `buttonText`). */
+  readonly text: import("@angular/core").InputSignal<string | undefined>;
+  protected readonly bug: LtBugReportService;
+  protected readonly i18n: LtI18nService;
+  private readonly injector;
+  /** Polite announcement after a sent report. */
+  protected readonly announcement: import("@angular/core").WritableSignal<string>;
+  protected readonly visible: import("@angular/core").Signal<boolean>;
+  protected readonly positionClass: import("@angular/core").Signal<string>;
+  protected readonly buttonColor: import("@angular/core").Signal<string>;
+  protected readonly buttonText: import("@angular/core").Signal<string>;
+  protected readonly buttonIcon: import("@angular/core").Signal<string>;
+  constructor();
+  /** Take the screenshot, then open the dialog; resolves `true` when a report was sent. */
+  openDialog(): Promise<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtBugReport, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<LtBugReport, "lt-bug-report", never, {
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "position": {
+      "alias": "position";
+      "required": false;
+      "isSignal": true;
+    };
+    "show": {
+      "alias": "show";
+      "required": false;
+      "isSignal": true;
+    };
+    "text": {
+      "alias": "text";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { LtBugReportFormValue, LtBugReportIncludes, LtScreenshotLibrary };

package/types/lenne.tech-ng-base-files-ui.d.ts

@@ -0,0 +1,116 @@
+import { LtUploadItem, LtUploadStatus, formatLtFileSize } from "@lenne.tech/ng-base/files";
+import * as i0 from "@angular/core";
+/**
+ * Upload UI (drop zone, file list with progress, pause/resume/cancel/retry), the counterpart of the Nuxt starter's
+ * `TusFileUpload.vue`. Built on `injectLtTusUpload()` and the `/ui` helm components.
+ *
+ * Keyboard: the drop zone holds a real button that opens the file dialog; every row action is a labelled button.
+ * Validation (`accept` for dropped files, `maxFileSize`, `maxFiles`, single file without `multiple`) rejects files with a
+ * message (`role="alert"`); finished and failed uploads are announced in a polite live region. With `multiple` off a new
+ * file replaces the previous one. Inputs are read when a file is added or started, so changing them takes effect for
+ * the next file.
+ *
+ * @example <lt-tus-upload accept="image/*" [multiple]="true" (uploaded)="onUploaded($event)" />
+ */
+export declare class LtTusUploadComponent {
+  /** `accept` attribute of the file input; dropped files are checked against it as well. */
+  readonly accept: import("@angular/core").InputSignal<string>;
+  /** Start uploads right after selection (default `true`). */
+  readonly autoStart: import("@angular/core").InputSignal<boolean>;
+  /** Disable the drop zone. */
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /** TUS endpoint (default from `provideLtFiles()`). */
+  readonly endpoint: import("@angular/core").InputSignal<string | undefined>;
+  /** Maximum file size in bytes (`0` = unlimited); larger files are rejected with a message. */
+  readonly maxFileSize: import("@angular/core").InputSignal<number>;
+  /** Maximum number of files (`0` = unlimited). */
+  readonly maxFiles: import("@angular/core").InputSignal<number>;
+  /** Extra TUS metadata for every file. */
+  readonly metadata: import("@angular/core").InputSignal<Record<string, string>>;
+  /** Allow several files. */
+  readonly multiple: import("@angular/core").InputSignal<boolean>;
+  /** A file finished uploading (`fileId` from `X-File-Id`). */
+  readonly uploaded: import("@angular/core").OutputEmitterRef<LtUploadItem>;
+  /** A file failed. */
+  readonly failed: import("@angular/core").OutputEmitterRef<LtUploadItem>;
+  /** Files were selected or dropped (the ones that passed validation and were added to the queue). */
+  readonly filesAdded: import("@angular/core").OutputEmitterRef<File[]>;
+  protected readonly i18n: import("@lenne.tech/ng-base").LtI18nService;
+  protected readonly upload: import("@lenne.tech/ng-base/files").LtTusUploadState;
+  protected readonly hintId: string;
+  protected readonly dragging: import("@angular/core").WritableSignal<boolean>;
+  protected readonly rejections: import("@angular/core").WritableSignal<string[]>;
+  protected readonly announcement: import("@angular/core").WritableSignal<string>;
+  protected readonly formatSize: typeof formatLtFileSize;
+  protected readonly hint: import("@angular/core").Signal<string>;
+  private dragDepth;
+  /** Status text of an item. */
+  protected statusLabel(status: LtUploadStatus): string;
+  /** Progress details of an uploading item (`42 % · 1.2 MB/s · noch 5s`). */
+  protected progressLabel(item: LtUploadItem): string;
+  /** Accessible label of a row action, naming the file. */
+  protected actionLabel(key: string, item: LtUploadItem): string;
+  /** Progress value clamped into the range the progress bar accepts. */
+  protected progressValue(item: LtUploadItem): number;
+  protected openFileDialog(input: HTMLInputElement): void;
+  protected onInputChange(input: HTMLInputElement): void;
+  protected onDragEnter(event: DragEvent): void;
+  protected onDragOver(event: DragEvent): void;
+  protected onDragLeave(event: DragEvent): void;
+  protected onDrop(event: DragEvent): void;
+  /** Validate and queue files; returns the accepted ones. */
+  private handleFiles;
+  private uploadOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtTusUploadComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<LtTusUploadComponent, "lt-tus-upload", never, {
+    "accept": {
+      "alias": "accept";
+      "required": false;
+      "isSignal": true;
+    };
+    "autoStart": {
+      "alias": "autoStart";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "endpoint": {
+      "alias": "endpoint";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxFileSize": {
+      "alias": "maxFileSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxFiles": {
+      "alias": "maxFiles";
+      "required": false;
+      "isSignal": true;
+    };
+    "metadata": {
+      "alias": "metadata";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiple": {
+      "alias": "multiple";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "uploaded": "uploaded";
+    "failed": "failed";
+    "filesAdded": "filesAdded";
+  }, never, never, true, never>;
+}
+/**
+ * Whether `file` matches an `accept` attribute value (`image/*`, `application/pdf`, `.png`, comma separated). An empty
+ * value and `*` / `*\/*` accept everything.
+ */
+export declare function matchesLtAccept(file: File, accept: string): boolean;