@lenne.tech/ng-base 18.1.3 → 22.0.0

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

@@ -0,0 +1,150 @@
+import * as i0 from "@angular/core";
+import { WritableSignal } from "@angular/core";
+/**
+ * Form helpers that work with Signal Forms, Reactive Forms and plain HTML alike: they look at the rendered DOM
+ * (`aria-invalid="true"`, `:invalid`) instead of a form model.
+ */
+/** The first invalid control inside `root` (default `document`), in DOM order. */
+export declare function ltFirstInvalidControl(root?: ParentNode | null | undefined): HTMLElement | null;
+/**
+ * Scroll to and focus the first invalid control (call it after a failed submit). Returns whether one was found.
+ * `offset` keeps it clear of a sticky header.
+ */
+export declare function ltFocusFirstInvalid(root?: ParentNode | null, options?: {
+  offset?: number;
+}): boolean;
+/** Options of {@link ltMap}. */
+interface LtMapOptions {
+  /** Convert ISO date strings into `Date` (all keys, or only the listed ones). Default `false`. */
+  dateStringToDate?: boolean | string[];
+  /** Copy function values too (default `false`). */
+  funcAllowed?: boolean;
+}
+/**
+ * Copy the properties of `source` that exist on `target` (keys of `target` decide, unknown keys are ignored).
+ * Ported from ng-base 18 `Helper.map` without its defects (the function check was always true, dates were parsed by
+ * default and silently turned any string into an invalid `Date`).
+ */
+export declare function ltMap<T extends object>(source: unknown, target: T, options?: LtMapOptions): T;
+/** Deep equality of JSON-like values (functions ignored, `Date` compared by time). */
+export declare function ltIsEqual(a: unknown, b: unknown): boolean;
+/** First-level properties of `a` that differ from `b` (changed arrays/objects are returned as a whole). */
+export declare function ltGetDiff<T extends object>(a: T, b: Partial<T> | Record<string, unknown>): Partial<T>;
+/**
+ * Base class for client-side models with `map`, `clone` and `getDiff` (the `Standard` idea of ng-base 18). Declare
+ * the properties with initial values (`id = ''`), only declared keys are mapped.
+ *
+ * @example
+ * class Contact extends LtStandard { id = ''; name = ''; createdAt?: Date = undefined; }
+ * const contact = Contact.map({ id: '1', name: 'Ada', role: 'ignored' });
+ */
+export declare class LtStandard {
+  /** Create an instance and map `data` onto it. */
+  static map<T extends LtStandard>(this: new () => T, data: unknown, options?: LtMapOptions): T;
+  /** Map an array (or one item) of plain objects. */
+  static maps<T extends LtStandard>(this: new () => T, data: unknown, options?: LtMapOptions): T[];
+  /** Map `data` onto this instance. */
+  map(data: unknown, options?: LtMapOptions): this;
+  /** Deep copy (structuredClone), optionally with changes. */
+  clone(changes?: Partial<this>): this;
+  /** First-level properties that differ from `compare`. */
+  getDiff(compare: Record<string, unknown>): Partial<this>;
+}
+/**
+ * URL slug: lower case, umlauts transliterated (`ä` → `ae`, `ß` → `ss`), whitespace → `-`, other characters removed,
+ * repeated hyphens collapsed.
+ */
+export declare function ltSlug(value: unknown): string;
+/** Random id of hex characters (default 24, like a MongoDB ObjectId). */
+export declare function ltUid(length?: number): string;
+/** Promise that resolves after `ms` milliseconds. */
+export declare function ltDelay(ms: number): Promise<void>;
+/** Recursively freeze an object (cycle-safe). */
+export declare function ltDeepFreeze<T>(value: T, seen?: WeakSet<object>): Readonly<T>;
+/** Options of {@link LtScrollService.scrollTo}. */
+interface LtScrollOptions {
+  /** Scroll behaviour (default `smooth`, `auto` when the user prefers reduced motion). */
+  behavior?: ScrollBehavior;
+  /** Focus the target after scrolling (default `false`). */
+  focus?: boolean;
+  /** Offset in pixels above the target, e.g. for a sticky header (default `0`). */
+  offset?: number;
+}
+/** Scrolling helpers (browser only, no-ops on the server). */
+export declare class LtScrollService {
+  private readonly document;
+  private readonly isBrowser;
+  /** Scroll to an element (id or element). Returns `false` when it does not exist. */
+  scrollTo(target: string | Element, options?: LtScrollOptions): boolean;
+  /** Scroll to the top of the page. */
+  scrollToTop(behavior?: ScrollBehavior): void;
+  private defaultBehavior;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtScrollService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** SEO data of a page. */
+interface LtSeoData {
+  /** Canonical URL (absolute, or a path resolved against `NG_PUBLIC_SITE_URL`). Default: `url`. */
+  canonical?: string;
+  description?: string;
+  /** Social image (absolute URL, or a path resolved against the site URL). */
+  image?: string;
+  keywords?: string;
+  /** Locale for `og:locale`, e.g. `de_DE`. */
+  locale?: string;
+  /** `false` adds `noindex, nofollow`. Default `true`. */
+  index?: boolean;
+  /** Site name for `og:site_name`. */
+  siteName?: string;
+  title: string;
+  /** `og:type` (default `website`). */
+  type?: string;
+  /** Page URL (absolute, or a path resolved against the site URL). Default: the current URL. */
+  url?: string;
+}
+/**
+ * Title, description, Open Graph, Twitter and robots meta tags, plus the canonical link (SSR-safe: tags are rendered
+ * on the server). Ported from ng-base 18 (`SEOService`, fixed 2026-11-03) and extended by canonical, robots and
+ * site-URL resolution.
+ */
+export declare class LtSeoService {
+  private readonly title;
+  private readonly meta;
+  private readonly document;
+  private readonly runtime;
+  /** Set every tag for a page. Tags of an earlier page that `data` leaves out are removed. */
+  set(data: LtSeoData): void;
+  /** Mark the page as not indexable (`noindex, nofollow`). */
+  setNoIndex(): void;
+  /** Set or remove `<link rel="canonical">`. */
+  setCanonical(url: string | undefined): void;
+  private tag;
+  private absolute;
+  private currentUrl;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtSeoService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * JSON values in `localStorage` (or `sessionStorage`) under the project prefix (`NG_PUBLIC_STORAGE_PREFIX` →
+ * `<prefix>_<key>`). SSR-safe: on the server every read returns the fallback and writes are ignored.
+ */
+export declare class LtStorageService {
+  private readonly isBrowser;
+  private readonly prefix;
+  /** Store a JSON-serialisable value. Returns `false` when no storage is available or it is full. */
+  save(key: string, value: unknown, type?: 'local' | 'session'): boolean;
+  /** Load a value (`fallback` when missing, unparsable or on the server). */
+  load<T>(key: string, fallback: T, type?: 'local' | 'session'): T;
+  load<T>(key: string, fallback?: T, type?: 'local' | 'session'): T | undefined;
+  /** Remove a value. */
+  remove(key: string, type?: 'local' | 'session'): void;
+  /** Remove every value under the project prefix. */
+  clear(type?: 'local' | 'session'): void;
+  /** A writable signal persisted under `key` (initial value from storage, every `set` saved). */
+  signal<T>(key: string, fallback: T, type?: 'local' | 'session'): WritableSignal<T>;
+  private key;
+  private storage;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtStorageService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export type { LtMapOptions, LtScrollOptions, LtSeoData };

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

@@ -0,0 +1,503 @@
+import * as i0 from "@angular/core";
+import { EnvironmentProviders, InjectionToken, Signal } from "@angular/core";
+/** Render scope an API URL is resolved for. */
+type LtRenderScope = 'browser' | 'server';
+/** Outcome of resolving the API base URL for the current render scope. */
+interface LtApiUrlResolution {
+  /** Base URL to prefix onto API paths: `'/api'` in proxy mode, `''` when unresolved. No trailing slash. */
+  baseUrl: string;
+  /** `true` when no API URL is configured for {@link scope}. */
+  missing: boolean;
+  /** `true` when the dev-server proxy prefix `/api` is in use. */
+  proxy: boolean;
+  /** Scope the resolution was performed for. */
+  scope: LtRenderScope;
+}
+/** Inputs of {@link resolveLtApiBaseUrl}. */
+interface LtApiUrlInputs {
+  /** `NG_PUBLIC_API_PROXY` (`null` = unset). */
+  apiProxy: boolean | null;
+  /** `NG_PUBLIC_API_URL`. */
+  apiUrl: string;
+  /** Whether the app runs in dev mode (`isDevMode()`), used when `apiProxy` is unset. */
+  devMode: boolean;
+  /** Render scope. */
+  scope: LtRenderScope;
+  /** `NG_API_URL` (server only). */
+  serverApiUrl?: string;
+}
+/**
+ * Pure resolution of the API base URL (no DI, no logging).
+ *
+ * - Server: `NG_API_URL` → `NG_PUBLIC_API_URL` → `''`. The proxy is never used during SSR.
+ * - Browser: `/api` when the proxy is on (explicitly, or implicitly in dev mode while unset), else `NG_PUBLIC_API_URL` → `''`.
+ *
+ * Trailing slashes are stripped so `${baseUrl}${path}` never produces a double slash.
+ */
+export declare function resolveLtApiBaseUrl(inputs: LtApiUrlInputs): LtApiUrlResolution;
+/** Whether `url` is absolute (`scheme:` or protocol-relative `//`). */
+export declare function isLtAbsoluteUrl(url: string): boolean;
+/**
+ * The single URL builder used by auth, system setup, error translation, files, AI and sync.
+ *
+ * Reads {@link LT_RUNTIME_CONFIG} and, on the server, {@link LT_SERVER_RUNTIME_CONFIG}. A missing API URL is warned
+ * about once per scope; an implicit dev proxy (unset `NG_PUBLIC_API_PROXY` in dev mode) once as well.
+ */
+export declare class LtApiUrlService {
+  private readonly runtimeConfig;
+  private readonly serverConfig;
+  private readonly isServer;
+  /** Resolve the base URL for the current scope without logging. */
+  resolve(): LtApiUrlResolution;
+  /** Base URL (no trailing slash) for the current scope. */
+  baseUrl(): string;
+  /** Build a full API URL for a path such as `/iam/sign-in/email`. Absolute URLs are returned unchanged. */
+  buildUrl(path: string): string;
+  /** Whether browser requests go through the dev-server proxy under `/api`. Always `false` on the server. */
+  isProxy(): boolean;
+  /** Report a missing API URL (`dev`: warning, production: error), at most once per scope. Used by the config check. */
+  reportMissing(): boolean;
+  private resolveAndWarn;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtApiUrlService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Options for {@link LtCookieService.set}. */
+interface LtCookieOptions {
+  /** Cookie domain. Omit for a host-only cookie. */
+  domain?: string;
+  /** Lifetime in seconds. Omit for a session cookie. */
+  maxAge?: number;
+  /** Cookie path (default `/`). */
+  path?: string;
+  /** SameSite attribute (default `lax`). */
+  sameSite?: 'lax' | 'none' | 'strict';
+  /** Secure attribute (default: `true` on `https:`). */
+  secure?: boolean;
+}
+/**
+ * SSR-aware cookie access.
+ *
+ * - Browser: reads and writes `document.cookie`.
+ * - Server: reads the `Cookie` header of the incoming request (`REQUEST`); never writes. A server render must not
+ *   set auth cookies (it would write `{ user: null }` over a valid browser state), so `set`/`delete` are no-ops there.
+ */
+export declare class LtCookieService {
+  private readonly document;
+  private readonly request;
+  private readonly isServer;
+  /** Raw cookie string (`a=1; b=2`) of the current request or document. */
+  raw(): string;
+  /** First decoded value of `name`, or `null`. */
+  get(name: string): string | null;
+  /**
+   * Every decoded value of `name`, in header order. A host-only cookie and a domain-scoped twin can coexist; callers
+   * that must pick the right one (the auth state) look at all of them.
+   */
+  getAll(name: string): string[];
+  /** Write a cookie (browser only). The value is URI-encoded. */
+  set(name: string, value: string, options?: LtCookieOptions): void;
+  /** Delete a cookie on the given path/domain slot (browser only). */
+  delete(name: string, options?: Pick<LtCookieOptions, 'domain' | 'path'>): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtCookieService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Parse every value of cookie `name` out of a raw cookie string (decoded; malformed encodings are kept raw). */
+export declare function parseLtCookies(cookieString: string, name: string): string[];
+/**
+ * SHA-256 of a string as lowercase hex (WebCrypto).
+ *
+ * nest-server expects every password to arrive SHA-256 hashed (it re-hashes server-side). The auth service applies
+ * this to each credential field; use it yourself only for custom endpoints that follow the same rule. Because the
+ * hash hides the length, enforce password rules in the form, not on the server.
+ */
+export declare function ltSha256(message: string): Promise<string>;
+/** Encode bytes as base64url without padding (WebAuthn). */
+export declare function ltArrayBufferToBase64Url(buffer: ArrayBuffer | Uint8Array): string;
+/** Decode base64url (with or without padding) into bytes (WebAuthn). */
+export declare function ltBase64UrlToUint8Array(base64url: string): Uint8Array<ArrayBuffer>;
+/** Response of nest-server `GET /i18n/errors/:locale`. */
+interface LtErrorTranslationResponse {
+  errors: Record<string, string>;
+}
+/** Result of {@link LtErrorTranslationService.parseError}. */
+interface LtParsedError {
+  /** Error code such as `LTNS_0100`, or `null` when the message carries none. */
+  code: string | null;
+  /** Message as sent by the backend (without the `#CODE:` marker). */
+  developerMessage: string;
+  /** Translated message for the active locale; falls back to the developer message, never empty for a message-bearing error. */
+  translatedMessage: string;
+}
+/** Options of the error translation (part of `provideLtNgBase({ errorTranslation })`, runtime `NG_PUBLIC_LT_ERROR_TRANSLATION_*`). */
+interface LtErrorTranslationOptions {
+  /** Locale used when i18n does not decide (default `de`). */
+  defaultLocale?: string;
+  /** Load and apply backend translations (default `true`). */
+  enabled?: boolean;
+  /** Load the translations for the detected locale while the app starts, browser only (default `true`). */
+  preload?: boolean;
+}
+/** Resolved error translation options. */
+export declare const LT_ERROR_TRANSLATION_OPTIONS: InjectionToken<Required<LtErrorTranslationOptions>>;
+/**
+ * Translates nest-server error messages of the form `#LTNS_0100: Developer message` with the backend's
+ * `GET /i18n/errors/:locale` table.
+ */
+export declare class LtErrorTranslationService {
+  private readonly api;
+  private readonly fetch;
+  private readonly i18n;
+  private readonly toast;
+  private readonly options;
+  private readonly isBrowser;
+  private readonly translations;
+  private readonly inFlight;
+  /** Locale used for lookups. */
+  readonly currentLocale: import("@angular/core").Signal<string>;
+  /** Whether translations for the current locale are loaded. */
+  readonly isLoaded: import("@angular/core").Signal<boolean>;
+  /** Whether a load is running. */
+  readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+  /** Load the backend translations for `locale` (default: current locale). Cached per locale, one request in flight per locale. */
+  loadTranslations(locale?: string): Promise<void>;
+  /** Parse any error shape (string, `Error`, `HttpErrorResponse`, response body) into code + messages. */
+  parseError(errorOrMessage: unknown): LtParsedError;
+  /** Translated message for an error (never empty for a message-bearing error). */
+  translateError(errorOrMessage: unknown): string;
+  /** Show the translated error as an error toast (browser only); logs to the console when no toaster is bound. */
+  showErrorToast(errorOrMessage: unknown, title?: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtErrorTranslationService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Extract the human-relevant message from an error.
+ *
+ * The response body wins over a transport message: `HttpErrorResponse.message` is
+ * `Http failure response for …: 400 Bad Request`, while the backend message (the only one that can carry a
+ * `#LTNS_` marker) is in `error.message`. Better Auth errors (`{ code, message }`) and arrays of messages
+ * (class-validator) are handled too.
+ */
+export declare function extractLtErrorMessage(errorOrMessage: unknown): string;
+/** A `fetch`-compatible function. */
+type LtFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * The fetch used by every library call that does not go through `HttpClient`: error translation, system setup,
+ * AI (incl. the SSE stream), offline sync and its hint stream, the Better Auth client.
+ *
+ * The default sends cookies (`credentials: 'include'`). `provideLtAuth()` replaces it with the auth-aware fetch
+ * (Bearer token in JWT mode, cookie → JWT switch on 401, stale-JWT refresh, session-loss handling), so SSE and sync
+ * get the same auth behaviour as `HttpClient` calls behind `ltAuthInterceptor`.
+ */
+export declare const LT_FETCH: InjectionToken<LtFetch>;
+/** `fetch` with `credentials: 'include'` unless the caller decided otherwise. */
+export declare const ltCredentialsFetch: LtFetch;
+/** Nested message tree as in the shipped `i18n/de.json` / `i18n/en.json`. */
+interface LtI18nMessages {
+  [key: string]: LtI18nMessages | string;
+}
+/**
+ * Bridge to the app's translation library (Transloco, ngx-translate, …).
+ *
+ * Bind it when the app already has an i18n setup, so library texts follow the app language and can be overridden
+ * in the app's own translation files (keys `lt.error.*` of the core and `lt.<entry>.*` of the entry points: `lt.auth.*`,
+ * `lt.files.*`, `lt.share.*`, `lt.ui.*`, `lt.bug.*`; shipped as `i18n/{de,en}.json` and `i18n/<entry>/{de,en}.json`).
+ *
+ * @example Transloco
+ * { provide: LT_I18N_ADAPTER, useFactory: () => {
+ *   const transloco = inject(TranslocoService);
+ *   const lang = toSignal(transloco.langChanges$, { initialValue: transloco.getActiveLang() });
+ *   return { locale: lang, translate: (key, params) => transloco.translate(key, params) };
+ * } }
+ */
+interface LtI18nAdapter {
+  /** Active locale (`de`, `en`, …). */
+  readonly locale: Signal<string>;
+  /** Translate a key; return `null` (or the key itself) when the app has no translation, then the library text is used. */
+  translate(key: string, params?: Record<string, unknown>): string | null;
+}
+/** Optional adapter to the app's i18n library. */
+export declare const LT_I18N_ADAPTER: InjectionToken<LtI18nAdapter>;
+/** Options of the built-in i18n (part of `provideLtNgBase({ i18n })`). */
+interface LtI18nOptions {
+  /** Locale used when neither the adapter nor the browser language (de/en) decides. Default `de`. */
+  defaultLocale?: string;
+  /** Additional or overriding messages per locale, merged over the shipped de/en texts. */
+  messages?: Record<string, LtI18nMessages>;
+}
+/** i18n options token (set by `provideLtNgBase`). */
+export declare const LT_I18N_OPTIONS: InjectionToken<LtI18nOptions>;
+/** The core's shipped messages (`lt.error.*`); the entry points register theirs with `registerLibraryMessages()`. */
+export declare const LT_I18N_MESSAGES: Readonly<Record<'de' | 'en', LtI18nMessages>>;
+/**
+ * Signal-based translations for library texts, with an optional adapter to the app's i18n library.
+ *
+ * Lookup order for `t(key)`: adapter → messages of the active locale → German messages → the key.
+ * Locale order: adapter → `setLocale()` → browser language (de/en, browser only) → `defaultLocale` → `de`.
+ */
+export declare class LtI18nService {
+  private readonly adapter;
+  private readonly options;
+  private readonly isBrowser;
+  private readonly explicitLocale;
+  private readonly extraMessages;
+  /**
+   * Texts of the entry points (`lt.ui.*`, `lt.auth.*` …) registered by {@link registerLibraryMessages}. A plain object:
+   * every entry registers its texts before its own components read them, so nothing has to react to a registration.
+   */
+  private readonly libraryMessages;
+  private readonly libraryIds;
+  /** Active locale. */
+  readonly locale: Signal<string>;
+  /** Set the locale (ignored for lookups while an adapter provides one). */
+  setLocale(locale: string): void;
+  /** Merge messages for a locale over the shipped ones. */
+  registerMessages(locale: string, messages: LtI18nMessages): void;
+  /**
+   * Register the default texts of an entry point once per `id` (`ui`, `auth`, `files` …). They rank below the app's
+   * own texts (`provideLtNgBase({ i18n: { messages } })`, `registerMessages()`, the adapter), like the shipped core
+   * texts. Entry points call it when they are first used (synchronously, on the server and in the browser alike), so
+   * their texts travel with their code instead of the initial bundle.
+   */
+  registerLibraryMessages(id: string, messages: Readonly<Record<string, LtI18nMessages>>): void;
+  /** Translate `key`, interpolating `{name}` placeholders from `params`. */
+  t(key: string, params?: Record<string, unknown>): string;
+  private detectBrowserLocale;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtI18nService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Options of the pre-hydration input preservation (`provideLtNgBase({ preHydrationInput })`). */
+interface LtPreHydrationInputOptions {
+  /** Keep what users type before hydration (default `true`). */
+  enabled?: boolean;
+  /**
+   * How long after hydration to keep restoring, in milliseconds (default `1500`; `0` restores once). Clamped to 30000.
+   * When it elapses the snapshot is dropped, so preserved values (passwords included) are not kept for the session.
+   */
+  maxRestoreMs?: number;
+}
+type LtEditableField = HTMLInputElement | HTMLTextAreaElement;
+/** Every `input`/`textarea` under `root` whose value differs from its server-rendered default, with that value. */
+export declare function collectLtEditedFields(root: ParentNode): Map<LtEditableField, string>;
+/**
+ * Write `value` back into `field` and dispatch a bubbling `input` event, so `(input)` handlers, `model()` and Signal
+ * Forms adopt it. Returns `false` when the field is detached or already holds the value.
+ */
+export declare function restoreLtField(field: LtEditableField, value: string): boolean;
+/**
+ * Pre-hydration input preservation (browser only).
+ *
+ * Text typed into a server-rendered field before hydration is in the DOM, but the first change detection after
+ * hydration writes the component's (empty) value over it — `[value]` bindings and Signal Forms do — before the replayed
+ * events run, so `withEventReplay()` alone loses it (measured in the ng-base playground E2E). The fields are snapshot
+ * at app initialisation (the SSR DOM is reused by hydration, so the element references stay valid) and restored once
+ * the app is stable, then every 250 ms for `maxRestoreMs` for fields hydrated late; fields stay ordinary editable
+ * fields throughout (autofill and screen readers untouched).
+ */
+export declare function provideLtPreHydrationInput(options?: LtPreHydrationInputOptions): EnvironmentProviders;
+/**
+ * Inline script (for `<head>`) that blocks the native submission of forms without `action` until the app handles them.
+ * A server-rendered login form submitted before hydration would otherwise send a native GET with the password in the
+ * URL. `ltAngularRequestHandler()` writes it into every SSR HTML response; add it to `index.html` yourself without SSR.
+ */
+export declare const LT_PRE_HYDRATION_SUBMIT_GUARD_SCRIPT = "document.addEventListener('submit',function(e){var f=e.target;if(f instanceof HTMLFormElement&&!f.hasAttribute('action')){e.preventDefault();}},true);";
+/**
+ * Feature options that can be overridden per stage at runtime (`NG_PUBLIC_LT_<FEATURE>_<OPTION>`).
+ *
+ * Each feature provider (`provideLtAuth`, `provideLtFiles`, `provideLtAi`, `provideLtSync`, `provideLtNgBase`)
+ * merges, in this order: its defaults, the options passed in code, and the values found here.
+ */
+interface LtPublicFeatureConfig {
+  ai?: Record<string, unknown>;
+  auth?: Record<string, unknown>;
+  errorTranslation?: Record<string, unknown>;
+  sync?: Record<string, unknown>;
+  tus?: Record<string, unknown>;
+  [feature: string]: Record<string, unknown> | undefined;
+}
+/**
+ * Public runtime configuration of the app, the Angular counterpart of Nuxt's `runtimeConfig.public`.
+ *
+ * With SSR the server reads it per request from the `NG_*` environment (`readLtRequestContext()` in
+ * `@lenne.tech/ng-base/server`), passes it to `AngularNodeAppEngine.handle(req, context)` as request context
+ * (`REQUEST_CONTEXT`) and writes it as JSON `<script id="ng-runtime-config">` into every HTML response, also for
+ * `RenderMode.Client` routes; the browser reads that script. One build can therefore be promoted from stage to stage.
+ * Without SSR the values come from `provideLtNgBase({ runtime })`.
+ *
+ * Projects may carry additional public values (e.g. `plausibleApiHost`); they travel the same way.
+ * Never put a secret here: everything in this object reaches the browser.
+ */
+interface LtRuntimeConfig {
+  [key: string]: unknown;
+  /** Commit of the running build (`NG_PUBLIC_APP_COMMIT`, fallback `APP_VERSION_COMMIT`), `unknown` when unset. */
+  appCommit?: string;
+  /**
+   * Deployment stage (`NG_PUBLIC_APP_ENV`), using nest-server's NODE_ENV block names: `local`, `ci`, `e2e`, `develop`,
+   * `test`, `production`. Only `production` counts as production; features that are off in production fail closed.
+   */
+  appEnv?: string;
+  /** Version of the running build (from the server, e.g. package.json). */
+  appVersion?: string;
+  /** Public API base URL (`NG_PUBLIC_API_URL`), e.g. `https://api.example.com`. Empty = relative to the app origin. */
+  apiUrl: string;
+  /**
+   * Route browser API calls through the dev-server proxy under `/api` (`NG_PUBLIC_API_PROXY`).
+   * `null` = not configured: the proxy is used in dev mode (`isDevMode()`) with a one-time warning.
+   * Never used during SSR.
+   */
+  apiProxy: boolean | null;
+  /** Opt-in cookie namespace (`NG_PUBLIC_COOKIE_PREFIX`); must mirror the backend `COOKIE_PREFIX`. */
+  cookiePrefix: string;
+  /** Feature options overridden at runtime (`NG_PUBLIC_LT_*`). */
+  lt: LtPublicFeatureConfig;
+  /** Absolute public URL of the app (`NG_PUBLIC_SITE_URL`), used for redirect/callback URLs, SEO and security.txt. */
+  siteUrl: string;
+  /** Prefix for `localStorage` keys (`NG_PUBLIC_STORAGE_PREFIX`). */
+  storagePrefix: string;
+}
+/** Defaults of {@link LtRuntimeConfig}. */
+export declare const LT_RUNTIME_CONFIG_DEFAULTS: LtRuntimeConfig;
+/** The resolved public runtime configuration (defaults ← `provideLtNgBase({ runtime })` ← request context / `<script id="ng-runtime-config">`). */
+export declare const LT_RUNTIME_CONFIG: InjectionToken<LtRuntimeConfig>;
+/** What the SSR server passes to `AngularNodeAppEngine.handle(req, context)` (see `readLtRequestContext()`). */
+interface LtRequestContext {
+  /** Public runtime configuration (also written into the HTML as `<script id="ng-runtime-config">`). */
+  runtimeConfig: Partial<LtRuntimeConfig>;
+  /** Internal API URL for SSR requests only (`NG_API_URL`), never sent to the browser. */
+  serverApiUrl?: string;
+}
+/**
+ * Runtime configuration on the server: public part plus the server-only API URL. Read from `REQUEST_CONTEXT`
+ * (an {@link LtRequestContext}) by default; `provideLtServerRuntimeConfig()` provides it from the environment instead
+ * for servers that pass no request context. `null` in the browser.
+ */
+interface LtServerRuntimeConfig {
+  /** Public part. */
+  public: Partial<LtRuntimeConfig>;
+  /** Internal API URL for SSR requests only (`NG_API_URL`), never sent to the browser. */
+  serverApiUrl: string;
+}
+/** Server-only runtime configuration (see {@link LtServerRuntimeConfig}). `null` in the browser. */
+export declare const LT_SERVER_RUNTIME_CONFIG: InjectionToken<LtServerRuntimeConfig | null>;
+/** Id of the JSON `<script>` that carries the public runtime configuration into the browser. */
+export declare const LT_RUNTIME_CONFIG_SCRIPT_ID = "ng-runtime-config";
+/** Read the runtime configuration the server wrote into the document (`null` when missing or unreadable). */
+export declare function readLtRuntimeConfigFromDocument(doc: Document | null | undefined): Partial<LtRuntimeConfig> | null;
+/**
+ * Serialise the public runtime configuration for an inline `<script type="application/json">`: `<`, `>`, `&`, U+2028
+ * and U+2029 are escaped, so a value can never close the script element, open a comment or form an HTML entity.
+ */
+export declare function serializeLtRuntimeConfig(config: Partial<LtRuntimeConfig>): string;
+/**
+ * Insert the runtime configuration as the first child of `<head>` (documents without `<head>` stay untouched), by
+ * default preceded by the pre-hydration submit guard (`LT_PRE_HYDRATION_SUBMIT_GUARD_SCRIPT`).
+ */
+export declare function injectLtRuntimeConfigScript(html: string, config: Partial<LtRuntimeConfig>, options?: {
+  submitGuard?: boolean;
+}): string;
+/**
+ * Merge partial runtime configurations onto a base. `lt` is merged per feature; `undefined` values never
+ * override (an unset env variable keeps the code default).
+ */
+export declare function mergeLtRuntimeConfig(base: LtRuntimeConfig, ...overrides: (Partial<LtRuntimeConfig> | null | undefined)[]): LtRuntimeConfig;
+/**
+ * Merge feature options: defaults ← code options ← runtime overrides. Nested plain objects are merged one level
+ * deep (e.g. `auth.interceptor`), arrays and primitives replace. `undefined` never overrides.
+ */
+export declare function mergeLtFeatureOptions<T extends object>(defaults: T, ...overrides: (object | null | undefined)[]): T;
+/** Options of {@link provideLtNgBase}. */
+interface LtNgBaseConfig {
+  /**
+   * Check at startup that an API URL is configured for the current scope (default `true`): a warning in dev mode, a
+   * console error in production. Turn it off for apps without a backend (ng-base/ui only).
+   */
+  configCheck?: boolean;
+  /** Backend error translation (`#LTNS_xxxx`). Turn it off (`enabled: false`) for apps without nest-server. */
+  errorTranslation?: LtErrorTranslationOptions;
+  /** Library i18n (locale, extra messages). Bind `LT_I18N_ADAPTER` to use the app's i18n library. */
+  i18n?: LtI18nOptions;
+  /** Keep what users type into server-rendered fields before hydration (default on, see `provideLtPreHydrationInput`). */
+  preHydrationInput?: LtPreHydrationInputOptions;
+  /**
+   * Static runtime configuration: the base that the per-request values of the SSR server (`NG_*` via
+   * `readLtRequestContext()`, `<script id="ng-runtime-config">` in the browser) override. Use it for apps without SSR,
+   * tests, or defaults.
+   */
+  runtime?: Partial<LtRuntimeConfig>;
+}
+/** Name of the window flag set once the app is stable (hydrated) in the browser; read by `waitForHydration()`. */
+export declare const LT_HYDRATED_FLAG = "__ltNgBaseHydrated";
+/**
+ * Core providers of `@lenne.tech/ng-base`.
+ *
+ * - {@link LT_RUNTIME_CONFIG}: defaults ← `config.runtime` ← request context (server) / `<script id="ng-runtime-config">` (browser).
+ * - Error translation options and preload of the backend translations (browser only, in the background: the start
+ *   never waits for the API; until they arrive errors show the developer message).
+ * - i18n options.
+ * - API URL config check.
+ * - Pre-hydration input preservation (typed text survives hydration).
+ * - Hydration flag `window.__ltNgBaseHydrated` for the Playwright helpers.
+ *
+ * Feature providers live in the secondary entry points: `provideLtAuth()` (`/auth`), `provideLtFiles()` (`/files`),
+ * `provideLtAi()` (`/ai`), `provideLtSync()` (`/sync`), `provideLtUi()` (`/ui`), `provideLtServerRuntimeConfig()` (`/server`).
+ *
+ * @example app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(withInterceptors([ltAuthInterceptor])),
+ *     provideLtNgBase(),
+ *     provideLtAuth({ systemSetup: { enabled: true } }),
+ *     provideLtUi(),
+ *   ],
+ * };
+ */
+export declare function provideLtNgBase(config?: LtNgBaseConfig): EnvironmentProviders;
+/** Toast colors (same set as Nuxt UI). */
+type LtToastColor = 'error' | 'info' | 'neutral' | 'primary' | 'secondary' | 'success' | 'warning';
+/** A toast message. */
+interface LtToastOptions {
+  color?: LtToastColor;
+  description?: string;
+  /** Display time in milliseconds (adapter default when omitted). */
+  duration?: number;
+  title?: string;
+}
+/**
+ * Bridge to the app's toaster. `provideLtUi()` binds it to Spartan Sonner (`<hlm-toaster />`); bind your own for
+ * another UI library. Return `false` when nothing could be shown, the caller then logs to the console.
+ */
+interface LtToastAdapter {
+  show(options: LtToastOptions): boolean;
+}
+/** Optional toaster bridge (see {@link LtToastAdapter}). */
+export declare const LT_TOAST_ADAPTER: InjectionToken<LtToastAdapter>;
+/** Shows toasts through {@link LT_TOAST_ADAPTER}; without an adapter, `show` returns `false`. */
+export declare class LtToastService {
+  private readonly adapter;
+  /** Show a toast. Returns `false` when no toaster is bound or it threw. */
+  show(options: LtToastOptions): boolean;
+  /** Shortcut for a success toast. */
+  success(title: string, description?: string): boolean;
+  /** Shortcut for an error toast. */
+  error(title: string, description?: string): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtToastService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Identity function and tagged template for Tailwind class strings outside templates, so the Tailwind IntelliSense
+ * extension recognises them (configure `"tailwindCSS.experimental.classRegex": ["tw`([^`]*)`", "tw\\(['\"]([^'\"]*)"]`).
+ *
+ * @example
+ * const card = tw`rounded-lg border p-4`;
+ * const active = tw('bg-primary text-primary-foreground');
+ */
+export declare function tw(strings: TemplateStringsArray | string, ...values: unknown[]): string;
+/** Version of `@lenne.tech/ng-base`; kept in sync with `package.json` by `scripts/sync-version.mjs`. */
+export declare const LT_NG_BASE_VERSION = "22.0.0";
+/**
+ * Log `message` the first time `key` is seen; ignore later calls. The conditions behind these messages (missing API
+ * URL, implicit dev proxy) are constant for the process, so repeating them only drowns other output.
+ */
+export declare function warnLtOnce(key: string, message: string, level?: 'error' | 'warn'): void;
+/** Test only: forget which one-shot messages were emitted. */
+export declare function resetLtWarnOnceState(): void;
+export type { LtApiUrlInputs, LtApiUrlResolution, LtCookieOptions, LtErrorTranslationOptions, LtErrorTranslationResponse, LtFetch, LtI18nAdapter, LtI18nMessages, LtI18nOptions, LtNgBaseConfig, LtParsedError, LtPreHydrationInputOptions, LtPublicFeatureConfig, LtRenderScope, LtRequestContext, LtRuntimeConfig, LtServerRuntimeConfig, LtToastAdapter, LtToastColor, LtToastOptions };

package/ui/styles/components/accordion.css

@@ -0,0 +1,3 @@
+/* Generated by scripts/generate-ui-sources.mjs from ui/src/lib/helm/accordion/index.ts — do not edit. */
+@import './utils.css';
+@source inline("**:data-[slot=accordion-trigger-icon]:ms-auto **:data-[slot=accordion-trigger-icon]:text-[length:--spacing(4)] **:data-[slot=accordion-trigger-icon]:text-muted-foreground! ../../utils ./lib/hlm-accordion ./lib/hlm-accordion-content ./lib/hlm-accordion-content-lazy ./lib/hlm-accordion-item ./lib/hlm-accordion-trigger </button> </div> </h3> <button <div <h3 <ng-content <ng-icon @angular/core @ng-icons/core @ng-icons/lucide @spartan-ng/brain/accordion [&_a]:hover:text-foreground [&_a]:underline [&_a]:underline-offset-3 [hlmAccordionItem],hlm-accordion-item [hlmAccordion], accordion accordion-content accordion-item aria-disabled:opacity-50 aria-disabled:pointer-events-none border border-transparent brnAccordionHeader brnAccordionTrigger clsx data-[state=closed]:h-0 data-[state=open]:h-(--brn-accordion-content-height) data-slot disabled flex flex-1 flex-col focus-visible:after:border-ring focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 font-medium group-aria-expanded/accordion-trigger:inline group/accordion-trigger hlm-accordion hlm-accordion-content hlm-accordion-trigger hlmAccordion hlmAccordionContent hlmAccordionContentLazy hlmAccordionItem hlmAccordionTrigger hover:underline isOpened items-start justify-between ng-template[hlmAccordionContentLazy] not-last:border-b openedChange orientation outline-none pb-4 py-4 relative rounded-md shrink-0 style text-sm text-start transition-all type w-full");