@ng-doc/app 22.0.0-beta.2 → 22.0.0

package/types/ng-doc-app-services-route-preloader.d.ts

@@ -0,0 +1,109 @@
+import { PreloadingStrategy, Route, UrlTree } from '@angular/router';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+/**
+ * The router preloading strategy of NgDoc: it loads a lazy route only when the reader is about
+ * to open one of its pages, as `NgDocRoutePreloader` decides, instead of every route at once.
+ *
+ * Set it as the router's preloading strategy to preload pages on intent:
+ *
+ * ```ts
+ * provideRouter(routes, withPreloading(NgDocPreloadingStrategy));
+ * ```
+ */
+declare class NgDocPreloadingStrategy implements PreloadingStrategy {
+    private readonly preloader;
+    constructor();
+    /**
+     * Loads a lazy route when it leads to a page that is being preloaded.
+     * @param route - A lazy route that the router has not loaded yet.
+     * @param load - Loads the route.
+     * @returns The load, or an observable of `null` when the route is not loaded now.
+     */
+    preload(route: Route, load: () => Observable<unknown>): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocPreloadingStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * Preloads the pages that the reader is about to open, so that opening them shows them at once.
+ *
+ * It preloads a page when the reader points at, focuses or touches a link to it, anywhere in the
+ * document: the sidebar, the previous and next page links, links in the page content, search
+ * results and the table of contents. It also preloads the previous and next pages of a guide once
+ * the browser is idle after the guide has rendered. A preload loads the code of the page's route
+ * and its content, once per page. Nothing is preloaded on the server, when the reader asked the
+ * browser to save data, or on a 2G connection.
+ *
+ * The router loads the code through its preloading strategy, so preloading works only when the
+ * application sets `NgDocPreloadingStrategy` as that strategy:
+ *
+ * ```ts
+ * provideRouter(routes, withPreloading(NgDocPreloadingStrategy));
+ * ```
+ */
+declare class NgDocRoutePreloader {
+    private readonly document;
+    private readonly injector;
+    private readonly ngZone;
+    private readonly router;
+    private readonly locationStrategy;
+    private readonly browser;
+    /** The path segments under which the documentation's routes live (`routePrefix`). */
+    private readonly prefix;
+    /** The pages that were asked for, by path, so each page is preloaded once. */
+    private readonly requested;
+    /** The paths, as URL segments, whose routes are being loaded. */
+    private readonly loading;
+    private enabled;
+    private destroyed;
+    private lastAnchor?;
+    private cancelIdle?;
+    private readonly intent;
+    constructor();
+    /**
+     * Turns preloading on and starts listening for links the reader is about to open. Called by
+     * `NgDocPreloadingStrategy` when the router creates it; does nothing on the server.
+     * @internal
+     */
+    enable(): void;
+    /**
+     * Preloads the code and the content of the page at a URL of the application. A page is
+     * preloaded once; the current page is not preloaded.
+     * @param url - The URL, relative to the application's base, for example `/docs/get-started`.
+     * @returns Whether a preload started.
+     */
+    preload(url: string | UrlTree): boolean;
+    /**
+     * Preloads pages once the browser is idle. A later call replaces the pages of an earlier one
+     * that has not run yet.
+     * @param urls - The URLs of the pages; missing ones are skipped.
+     */
+    preloadWhenIdle(urls: ReadonlyArray<string | undefined>): void;
+    /**
+     * Whether the router should load a lazy route now: the route leads to a page that is being
+     * preloaded.
+     * @param route - A lazy route that the router has not loaded yet.
+     * @returns Whether to load it.
+     * @internal
+     */
+    shouldPreload(route: Route): boolean;
+    private loaded;
+    private active;
+    private currentUrl;
+    /**
+     * Returns the application URL of a link, or `undefined` for a link that leaves the
+     * application, opens elsewhere, downloads a file or points into the current page.
+     * @param anchor - The link.
+     * @returns The URL relative to the application's base, with its query.
+     */
+    private linkUrl;
+    /** The base path of the application, ending with a slash. */
+    private basePath;
+    private destroy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocRoutePreloader, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+export { NgDocPreloadingStrategy, NgDocRoutePreloader };

package/types/ng-doc-app-services-shortcuts.d.ts

@@ -0,0 +1,96 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
+
+/**
+ * A keyboard shortcut registered with the NgDocShortcutsService.
+ */
+interface NgDocShortcut {
+    /**
+     * The key that runs the shortcut, compared with the key of the keyboard event without regard to
+     * case, for example '/', '[' or 'f'.
+     */
+    key: string;
+    /**
+     * Whether the shortcut is a chord with the Command key (macOS) or the Control key (elsewhere).
+     * Chords always work: in text fields too, and when single-key shortcuts are turned off. Other
+     * shortcuts are single keys: they run only while single-key shortcuts are on, never while the
+     * reader types in a field, and never with Command, Control or Alt held.
+     */
+    chord?: boolean;
+    /**
+     * Runs the shortcut. The default action of the keyboard event is prevented before it runs. The
+     * event is missing when the shortcut runs from the search palette.
+     */
+    handler: (event?: KeyboardEvent) => void;
+}
+/**
+ * Whether single-key shortcuts are on for readers who have not turned them on or off themselves.
+ * The default is true. Set it with the shortcuts option of provideNgDocApp.
+ */
+declare const NG_DOC_SHORTCUTS: InjectionToken<boolean>;
+/**
+ * The local storage key that keeps a reader's choice to turn single-key shortcuts on ("1") or off
+ * ("0").
+ */
+declare const NG_DOC_STORE_SHORTCUTS_KEY: string;
+
+/**
+ * Keyboard shortcuts of the documentation.
+ *
+ * Single-key shortcuts (slash opens the search, the square brackets open the previous and next
+ * page, F focuses the filter of the page, L copies the link to the page and T switches between
+ * the light and the dark theme) are on by default. Readers turn them all off with one switch, and
+ * the choice is saved in the browser. A site turns them off by default with the shortcuts option
+ * of provideNgDocApp. They never run while the reader types in a field or holds Command, Control
+ * or Alt. Chords such as Command+K (Control+K) always work.
+ */
+declare class NgDocShortcutsService {
+    private readonly document;
+    private readonly injector;
+    private readonly ngZone;
+    private readonly browser;
+    private readonly appDefault;
+    private readonly userChoice;
+    private readonly shortcuts;
+    private themeToggle?;
+    /**
+     * Whether single-key shortcuts are on: the reader's saved choice, or the site's default.
+     * Components hide the hints of single-key shortcuts while it is false.
+     */
+    readonly enabled: Signal<boolean>;
+    constructor();
+    /**
+     * Turns single-key shortcuts on or off for this reader and saves the choice in the browser.
+     * @param enabled - Whether single-key shortcuts should run.
+     */
+    setEnabled(enabled: boolean): void;
+    /** Turns single-key shortcuts off when they are on, and on when they are off. */
+    toggle(): void;
+    /**
+     * Registers a shortcut. When several shortcuts use the same key, the one registered last runs,
+     * so a page can take over a key while it is shown and give it back when it is destroyed.
+     * @param shortcut - The shortcut to register.
+     * @returns A function that removes the shortcut.
+     */
+    register(shortcut: NgDocShortcut): () => void;
+    /**
+     * Runs the single-key shortcut registered for a key, as if the reader pressed it, even while
+     * single-key shortcuts are off. The search palette uses it for its actions.
+     * @param key - The key of the shortcut, for example 't'.
+     * @returns Whether a shortcut is registered for the key.
+     */
+    run(key: string): boolean;
+    private onKeydown;
+    private find;
+    private acceptsSingleKey;
+    private readChoice;
+    private registerDefaults;
+    private toggleDarkTheme;
+    private copyLink;
+    private click;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocShortcutsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+export { NG_DOC_SHORTCUTS, NG_DOC_STORE_SHORTCUTS_KEY, NgDocShortcutsService };
+export type { NgDocShortcut };

package/types/ng-doc-app-services-sidebar.d.ts

@@ -1,21 +1,40 @@
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
 import { Router } from '@angular/router';
 import { NgDocScrollService } from '@ng-doc/ui-kit/services/scroll';
 import { BehaviorSubject, Observable } from 'rxjs';
-import * as i0 from '@angular/core';
 
+/**
+ * The widest viewport, in CSS pixels, at which the sidebar is an overlay that the navbar's menu
+ * button opens. It matches the `max-width: 900px` media query of `ng-doc-sidenav`.
+ */
+declare const NG_DOC_SIDEBAR_COLLAPSE_WIDTH = 900;
 /**
  * Service for sidebar, it can be used to hide/show sidebar or to check if sidebar is collapsable.
+ *
+ * On wide screens the sidebar is always shown. At `NG_DOC_SIDEBAR_COLLAPSE_WIDTH` and below it is
+ * an overlay: `show()` opens it and blocks page scrolling, `hide()` closes it, and a navigation
+ * or a resize to a wide screen ends the overlay.
  */
 declare class NgDocSidebarService {
-    protected readonly expanded: BehaviorSubject<boolean>;
     protected readonly document: Document;
     protected readonly window: Window;
     protected readonly router: Router;
     protected readonly scroll: NgDocScrollService;
+    protected readonly expanded: BehaviorSubject<boolean>;
+    /**
+     * Whether the sidebar is shown, as a signal. It follows the same state as `isExpanded()`.
+     */
+    readonly expandedState: Signal<boolean>;
+    private readonly ngZone;
     constructor();
+    /**
+     * Whether the viewport is narrow enough for the sidebar to be an overlay.
+     */
     get isMobile(): boolean;
     /**
      * Indicates if sidebar is visible, based on the show/hide methods.
+     * Read `expandedState` for the same value as a signal.
      */
     isExpanded(): Observable<boolean>;
     /**
@@ -30,8 +49,9 @@ declare class NgDocSidebarService {
      * Toggle sidebar visibility.
      */
     toggle(): void;
+    private syncWithViewport;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocSidebarService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgDocSidebarService>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
-export { NgDocSidebarService };
+export { NG_DOC_SIDEBAR_COLLAPSE_WIDTH, NgDocSidebarService };

package/types/ng-doc-app-services-store.d.ts

@@ -1,13 +1,36 @@
 import * as i0 from '@angular/core';
 
+/**
+ * Reads and writes NgDoc settings (for example the theme) in the browser's local storage.
+ */
 declare class NgDocStoreService {
     protected readonly localStorage: Storage;
+    /**
+     * Stores a string value.
+     * @param key - Storage key.
+     * @param data - The value to store.
+     */
     set(key: string, data: string): void;
+    /**
+     * Stores a value after serializing it.
+     * @param key - Storage key.
+     * @param data - The value to store.
+     * @param serialize - Converts the value to a string.
+     */
     set<T>(key: string, data: T, serialize: (v: T) => string): void;
+    /**
+     * Returns the stored string, or `null` when the key is not set.
+     * @param key - Storage key.
+     */
     get(key: string): string | null;
+    /**
+     * Returns the stored value, deserialized.
+     * @param key - Storage key.
+     * @param deserialize - Converts the stored string (or `null`) to the value.
+     */
     get<T>(key: string, deserialize: (v: string | null) => T): T;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocStoreService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgDocStoreService>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 export { NgDocStoreService };

package/types/ng-doc-app-services-theme.d.ts

@@ -1,27 +1,43 @@
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
 import { NgDocStoreService } from '@ng-doc/app/services/store';
 import { Subject, Observable } from 'rxjs';
-import * as i0 from '@angular/core';
 
 /**
  * Service for managing themes.
+ *
+ * The theme is the `data-theme` attribute of the document element: `auto`, `dark`, the id of a
+ * custom theme, or no attribute for the light theme.
  */
 declare class NgDocThemeService {
     protected readonly document: Document;
     protected readonly store: NgDocStoreService;
     protected readonly change$: Subject<string | null>;
     protected readonly documentElement: HTMLElement;
+    private readonly themeState;
+    /**
+     * The current theme as a signal: the theme id, or `null` for the light theme.
+     *
+     * It starts with the document's `data-theme` attribute and follows every `set()` call.
+     */
+    readonly theme: Signal<string | null>;
     /**
-     * Returns the current theme.
+     * Returns the current theme: the document's `data-theme` attribute, or `null` without one.
      */
     get currentTheme(): string | null;
+    /**
+     * Emits the theme after every `set()` call. Read `theme` for the current value as a
+     * signal.
+     */
     themeChanges(): Observable<string | null>;
     /**
      * Sets the theme by id.
      * @param id - Theme id. If not provided, the theme will be removed.
      */
     set(id?: string): void;
+    private readTheme;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocThemeService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgDocThemeService>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 export { NgDocThemeService };

package/types/ng-doc-app-services.d.ts

@@ -1,3 +1,80 @@
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { NgDocApiList } from '@ng-doc/core/interfaces';
+export * from '@ng-doc/app/services/content-scroll-intent';
+export * from '@ng-doc/app/services/content-state';
+export * from '@ng-doc/app/services/fullscreen-route';
 export * from '@ng-doc/app/services/highlighter';
+export * from '@ng-doc/app/services/route-preloader';
+export * from '@ng-doc/app/services/shortcuts';
 export * from '@ng-doc/app/services/sidebar';
 export * from '@ng-doc/app/services/store';
+export * from '@ng-doc/app/services/theme';
+
+/**
+ * A declaration of an API list, with the scope it belongs to.
+ */
+interface NgDocApiListDeclaration {
+    /** The name of the declaration. */
+    name: string;
+    /** The kind of the declaration, for example Class or Function. */
+    kind: string;
+    /** The scope of the declaration, for example the package name. */
+    scope: string;
+    /** The route of the declaration page, without the leading slash. */
+    route: string;
+    /** A one-line description, when the API list data carries one. */
+    description?: string;
+    /** The declaration header, when the API list data carries it. */
+    signature?: string;
+}
+/**
+ * The route data key that names the segment of an API entry's list data
+ * (assets/ng-doc/SEGMENT/api-list.json). An empty string is the root list.
+ */
+declare const NG_DOC_API_LIST_SEGMENT_DATA: string;
+/**
+ * Loads the API lists of every API entry once, for the search palette. The data file of an entry
+ * is assets/ng-doc/SEGMENT/api-list.json, where the segment is the route of the entry in its API
+ * configuration, or the root when it has none.
+ *
+ * The new engine lists every segment in the generated context (`NgDocContext.apiLists`), so
+ * exactly those files are requested, and none when the site has no API entry. Otherwise the
+ * entries are found in the router configuration: a route that carries the route data key
+ * NG_DOC_API_LIST_SEGMENT_DATA names its segment, and a route that declaration pages live under
+ * (ENTRY/classes/SCOPE/NAME and so on) tries its last route segment, with the root as the
+ * fallback ("api" tries the root first, as that is the default route of an API entry). When the
+ * configuration shows no entry (lazy routes), the root list is loaded. A list that cannot be
+ * loaded is skipped quietly, and each file is requested at most once per application.
+ */
+declare class NgDocApiListIndexService {
+    private readonly http;
+    private readonly router;
+    private readonly basePath;
+    private readonly context;
+    private readonly lists;
+    private readonly requests;
+    private loading?;
+    /** Every declaration of the loaded API lists. */
+    readonly declarations: Signal<NgDocApiListDeclaration[]>;
+    /**
+     * Starts loading the API lists of every API entry, once.
+     * @returns A promise that settles when every list has loaded or failed.
+     */
+    load(): Promise<void>;
+    /**
+     * Records an API list that is already loaded (the API index page loads its own), so the
+     * palette does not request it again.
+     * @param segment - The segment of the list data, or an empty string for the root list.
+     * @param list - The list.
+     */
+    remember(segment: string, list: NgDocApiList[]): void;
+    private loadEntry;
+    private request;
+    private store;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocApiListIndexService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+export { NG_DOC_API_LIST_SEGMENT_DATA, NgDocApiListIndexService };
+export type { NgDocApiListDeclaration };

package/types/ng-doc-app-tokens.d.ts

@@ -1,7 +1,14 @@
 import { InjectionToken, Provider } from '@angular/core';
-import { NgDocContext, NgDocPageProcessor, NgDocPageSkeleton, NgDocTheme, NgDocTypeControl } from '@ng-doc/app/interfaces';
+import { NgDocContext, NgDocPageProcessor, NgDocPageSkeleton, NgDocTypeControl } from '@ng-doc/app/interfaces';
 import { Mermaid } from 'mermaid';
 
+/** Enables one delayed anchor replay after asynchronous NgDoc content is processed. */
+declare const NG_DOC_CONTENT_ANCHOR_SCROLLING: InjectionToken<boolean>;
+
+type NgDocContentScrollPositionRestoration = 'enabled' | 'top' | 'disabled';
+/** Declares whether delayed NgDoc content may replay a missed saved scroll position. */
+declare const NG_DOC_CONTENT_SCROLL_POSITION_RESTORATION: InjectionToken<NgDocContentScrollPositionRestoration>;
+
 declare const NG_DOC_CONTEXT: InjectionToken<NgDocContext>;
 
 declare const NG_DOC_MERMAID: InjectionToken<Mermaid>;
@@ -30,34 +37,7 @@ interface NgDocShikiTheme {
 }
 declare const NG_DOC_SHIKI_THEME: InjectionToken<NgDocShikiTheme>;
 
-/**
- * Token that can be used to provide custom theme.
- * You must compile your theme to CSS and add it to `assets` so that NgDoc can load it dynamically.
- *
- * You always should provide custom themes in root of your application with `multi: true` parameter.
- *
- * For example
- * ```typescript
- * @NgModule({
- *    declarations: [AppComponent],
- *    imports: [],
- *    providers: [
- *        {provide: NG_DOC_THEME, useValue: {id: 'CustomTheme', path: '/assets/themes/custom.css'}, multi: true}
- *    ],
- *    bootstrap: [AppComponent],
- * })
- * export class AppModule {}
- * ```
- */
-declare const NG_DOC_THEME: InjectionToken<NgDocTheme>;
-/**
- * Default theme for application if user didn't change it manually.
- *
- * You can provide this token in the root of you application, to set theme by default.
- */
-declare const NG_DOC_DEFAULT_THEME_ID: InjectionToken<string>;
-
 declare const NG_DOC_TYPE_CONTROL: InjectionToken<NgDocTypeControl>;
 
-export { NG_DOC_CONTEXT, NG_DOC_DEFAULT_THEME_ID, NG_DOC_MERMAID, NG_DOC_PAGE_CUSTOM_PROCESSOR, NG_DOC_PAGE_PROCESSOR, NG_DOC_PAGE_SKELETON, NG_DOC_ROUTE_PREFIX, NG_DOC_SHIKI_THEME, NG_DOC_THEME, NG_DOC_TYPE_CONTROL, provideMainPageProcessor, providePageProcessor };
-export type { NgDocShikiTheme };
+export { NG_DOC_CONTENT_ANCHOR_SCROLLING, NG_DOC_CONTENT_SCROLL_POSITION_RESTORATION, NG_DOC_CONTEXT, NG_DOC_MERMAID, NG_DOC_PAGE_CUSTOM_PROCESSOR, NG_DOC_PAGE_PROCESSOR, NG_DOC_PAGE_SKELETON, NG_DOC_ROUTE_PREFIX, NG_DOC_SHIKI_THEME, NG_DOC_TYPE_CONTROL, provideMainPageProcessor, providePageProcessor };
+export type { NgDocContentScrollPositionRestoration, NgDocShikiTheme };

package/types/ng-doc-app-type-controls-boolean-control.d.ts

@@ -1,16 +1,21 @@
+import * as _angular_core from '@angular/core';
 import { NgDocTypeControl } from '@ng-doc/app/interfaces';
 import { DIControl } from 'di-controls';
-import * as i0 from '@angular/core';
 
+/** The playground control of `boolean` inputs: a checkbox labelled with the input name. */
 declare class NgDocBooleanControlComponent extends DIControl<boolean | undefined> implements NgDocTypeControl<boolean | undefined> {
-    default?: boolean;
-    name: string;
-    description: string;
+    /** Default value of the input; `undefined` leaves the component's own default. */
+    readonly default: _angular_core.InputSignal<boolean | undefined>;
+    /** Name of the input. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Description of the input, shown in a tooltip. */
+    readonly description: _angular_core.InputSignal<string>;
     constructor();
+    /** The value an unchecked box stands for. */
     get defaultValue(): boolean | undefined;
     updateModel(obj: boolean | null | undefined): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocBooleanControlComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocBooleanControlComponent, "ng-doc-boolean-control", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocBooleanControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgDocBooleanControlComponent, "ng-doc-boolean-control", never, { "default": { "alias": "default"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocBooleanControlComponent };

package/types/ng-doc-app-type-controls-number-control.d.ts

@@ -1,13 +1,15 @@
+import * as i0 from '@angular/core';
 import { NgDocTypeControl } from '@ng-doc/app/interfaces';
 import { DIControl } from 'di-controls';
-import * as i0 from '@angular/core';
 
+/** The playground control of `number` inputs. */
 declare class NgDocNumberControlComponent extends DIControl<number> implements NgDocTypeControl<number> {
-    default?: number;
+    /** Default value of the input; clearing the field returns to it. */
+    readonly default: i0.InputSignal<number | undefined>;
     constructor();
     changeModel(value: number | null): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocNumberControlComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocNumberControlComponent, "ng-doc-number-control", never, { "default": { "alias": "default"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocNumberControlComponent, "ng-doc-number-control", never, { "default": { "alias": "default"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocNumberControlComponent };

package/types/ng-doc-app-type-controls-string-control.d.ts

@@ -1,14 +1,16 @@
+import * as i0 from '@angular/core';
 import { NgDocTypeControl } from '@ng-doc/app/interfaces';
 import { DIControl } from 'di-controls';
-import * as i0 from '@angular/core';
 
+/** The playground control of `string` inputs. */
 declare class NgDocStringControlComponent extends DIControl<string> implements NgDocTypeControl<string> {
-    default?: string;
+    /** Default value of the input; clearing the field returns to it. */
+    readonly default: i0.InputSignal<string | undefined>;
     constructor();
     changeModel(value: string | null): void;
     writeValue(value: string | null): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocStringControlComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocStringControlComponent, "ng-doc-string-control", never, { "default": { "alias": "default"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocStringControlComponent, "ng-doc-string-control", never, { "default": { "alias": "default"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocStringControlComponent };

package/types/ng-doc-app-type-controls-type-alias-control.d.ts

@@ -1,16 +1,23 @@
+import * as _angular_core from '@angular/core';
 import { NgDocTypeControl } from '@ng-doc/app/interfaces';
 import { DIControl } from 'di-controls';
-import * as i0 from '@angular/core';
 
+/**
+ * The playground control of union type aliases: a select that shows the value and whether it is
+ * the default. The inspector shows the value type under the input's name.
+ */
 declare class NgDocTypeAliasControlComponent<T> extends DIControl<T> implements NgDocTypeControl<T> {
-    default?: T;
-    options?: string[];
-    isManual?: boolean;
+    /** Default value of the input; clearing the selection returns to it. */
+    readonly default: _angular_core.InputSignal<T | undefined>;
+    /** Values the input accepts: literal source text, or plain values when `isManual` is set. */
+    readonly options: _angular_core.InputSignal<string[] | undefined>;
+    /** Whether `options` are values the user listed in the playground config. */
+    readonly isManual: _angular_core.InputSignal<boolean | undefined>;
     constructor();
     typeOf(value: unknown): string;
     changeModel(value: T | null): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTypeAliasControlComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocTypeAliasControlComponent<any>, "ng-doc-type-alias-control", never, { "default": { "alias": "default"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocTypeAliasControlComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgDocTypeAliasControlComponent<any>, "ng-doc-type-alias-control", never, { "default": { "alias": "default"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "isManual": { "alias": "isManual"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocTypeAliasControlComponent };