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

package/types/ng-doc-app-components-toc.d.ts

@@ -1,38 +1,85 @@
-import * as i0 from '@angular/core';
-import { ElementRef, OnInit, QueryList, WritableSignal, NgZone, ChangeDetectorRef, Renderer2, DestroyRef } from '@angular/core';
-import { Router } from '@angular/router';
+import * as _angular_core from '@angular/core';
+import { Signal, ElementRef } from '@angular/core';
 import { NgDocPageToc, NgDocTocItem } from '@ng-doc/app/interfaces';
 
-declare class NgDocTocElementComponent {
-    path: string;
-    hash: string;
-    selected: boolean;
-    level: number;
-    readonly elementRef: ElementRef<HTMLElement>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTocElementComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocTocElementComponent, "li[ng-doc-toc-element]", never, { "path": { "alias": "path"; "required": false; }; "hash": { "alias": "hash"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "level": { "alias": "level"; "required": false; }; }, {}, never, ["*"], true, never>;
-}
-
-declare class NgDocTocComponent implements NgDocPageToc, OnInit {
-    tableOfContent: NgDocTocItem[];
-    selection?: ElementRef<HTMLElement>;
-    elements: QueryList<NgDocTocElementComponent>;
-    activeItem: WritableSignal<NgDocTocItem | undefined>;
+/**
+ * The "On this page" rail: the headings of the page, the section the reader is in, the reading
+ * progress, and the Back to top, Copy link and Edit this page actions.
+ *
+ * The active section follows scrolling: it is the last heading above a line a little below the
+ * navbar, or the last heading once the page is scrolled to the end. A heading the reader picked
+ * (an entry clicked, or a link to its fragment) stays active until the reader scrolls again, so a
+ * section near the end of the page, which cannot scroll to the top, is still marked. A soft marker
+ * glides to the active entry. Tracking pauses while the rail is hidden.
+ *
+ * While the rail exists, the L shortcut runs its Copy link action, so the rail confirms the copy.
+ */
+declare class NgDocTocComponent implements NgDocPageToc {
+    /** The headings of the page. */
+    readonly tableOfContent: _angular_core.InputSignal<NgDocTocItem[]>;
+    /** URL where the reader can edit the page source. Without it, the rail has no Edit action. */
+    readonly editSourceFileUrl: _angular_core.InputSignal<string | undefined>;
+    /** The symbol details of an API page, shown above the headings. */
+    readonly details: _angular_core.InputSignal<Element | undefined>;
+    /** Index of the heading of the section the reader is in. */
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    /** The heading of the section the reader is in. */
+    readonly activeItem: Signal<NgDocTocItem | undefined>;
+    /** How much of the page has been scrolled, in percent. */
+    protected readonly progress: _angular_core.WritableSignal<number>;
+    /** Whether the link was just copied. */
+    protected readonly copied: _angular_core.WritableSignal<boolean>;
     protected readonly document: Document;
-    protected readonly ngZone: NgZone;
-    protected readonly changeDetectorRef: ChangeDetectorRef;
-    protected readonly renderer: Renderer2;
-    protected readonly router: Router;
-    protected readonly destroyRef: DestroyRef;
+    private readonly window;
+    private readonly location;
+    private readonly locationStrategy;
+    private readonly clipboard;
+    private readonly ngZone;
+    private readonly rail;
+    private readonly list;
+    private readonly detailsHost;
+    private readonly marker;
+    private readonly elements;
+    private readonly router;
+    private copiedTimer?;
+    private pinned;
     constructor();
-    ngOnInit(): void;
     /**
-     * Selects the item in the table of content.
-     * @param item - Item to select.
+     * Scrolls the page back to its top.
+     */
+    scrollToTop(): void;
+    /**
+     * Copies the link to the page, without its query and fragment.
      */
-    protected select(item: NgDocTocItem): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTocComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocTocComponent, "ng-doc-toc", never, { "tableOfContent": { "alias": "tableOfContent"; "required": false; }; }, {}, never, never, true, never>;
+    copyLink(): void;
+    /**
+     * Marks a heading as the active section until the reader scrolls again.
+     * @param index - Index of the heading in the table of contents.
+     */
+    pin(index: number): void;
+    private pinFragment;
+    private track;
+    private keepInView;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocTocComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgDocTocComponent, "ng-doc-toc", never, { "tableOfContent": { "alias": "tableOfContent"; "required": false; "isSignal": true; }; "editSourceFileUrl": { "alias": "editSourceFileUrl"; "required": false; "isSignal": true; }; "details": { "alias": "details"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * One entry of the table of contents: a link to a heading of the page.
+ */
+declare class NgDocTocElementComponent {
+    /** Path of the page that holds the heading. */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Id of the heading, used as the link's fragment. */
+    readonly hash: _angular_core.InputSignal<string>;
+    /** Whether the heading is the section the reader is in. */
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Depth of the heading in the table of contents, from 1. */
+    readonly level: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The list item element. */
+    readonly elementRef: ElementRef<HTMLElement>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocTocElementComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgDocTocElementComponent, "li[ng-doc-toc-element]", never, { "path": { "alias": "path"; "required": false; "isSignal": true; }; "hash": { "alias": "hash"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 export { NgDocTocComponent, NgDocTocElementComponent };

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

@@ -1,15 +1,19 @@
 export * from '@ng-doc/app/components/api-list';
 export * from '@ng-doc/app/components/breadcrumb';
 export * from '@ng-doc/app/components/code';
+export * from '@ng-doc/app/components/command-palette';
 export * from '@ng-doc/app/components/copy-button';
 export * from '@ng-doc/app/components/demo';
 export * from '@ng-doc/app/components/demo-displayer';
+export * from '@ng-doc/app/components/demo-frame';
 export * from '@ng-doc/app/components/demo-pane';
 export * from '@ng-doc/app/components/fullscreen-button';
+export * from '@ng-doc/app/components/fullscreen-toggle';
 export * from '@ng-doc/app/components/heading-anchor';
 export * from '@ng-doc/app/components/image-viewer';
 export * from '@ng-doc/app/components/kind-icon';
 export * from '@ng-doc/app/components/link';
+export * from '@ng-doc/app/components/members';
 export * from '@ng-doc/app/components/mermaid-viewer';
 export * from '@ng-doc/app/components/navbar';
 export * from '@ng-doc/app/components/page';
@@ -20,7 +24,6 @@ export * from '@ng-doc/app/components/page-wrapper';
 export * from '@ng-doc/app/components/playground';
 export * from '@ng-doc/app/components/root';
 export * from '@ng-doc/app/components/search';
-export * from '@ng-doc/app/components/search-dialog';
 export * from '@ng-doc/app/components/search-result';
 export * from '@ng-doc/app/components/sidebar';
 export * from '@ng-doc/app/components/tabs';

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

@@ -0,0 +1,89 @@
+import * as i0 from '@angular/core';
+import { Provider, EnvironmentProviders, ApplicationConfig, Type } from '@angular/core';
+import { Routes } from '@angular/router';
+import { NgDocDemoProvidersImport } from '@ng-doc/core/interfaces';
+
+/**
+ * The root of the demo application, which shows one demo per page with only Angular and that
+ * demo loaded. In an iframe it reports the height of its content to the page that embeds it (a
+ * `ResizeObserver` on its border box), and it follows the theme the reader picks on the
+ * documentation site, which stores it in `localStorage`.
+ */
+declare class NgDocDemoAppComponent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocDemoAppComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocDemoAppComponent, "ng-doc-demo-app", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * How the demo application starts.
+ * @internal
+ */
+interface ɵNgDocDemoApplicationOptions {
+    /** Change detection with zone.js, when the application's polyfills load it. */
+    readonly zone?: boolean;
+    /**
+     * Hydration of the server-rendered page: always on the server, which then writes the hydration
+     * data, and in the browser only for a page the server rendered (a page without it, such as the
+     * page of a demo that failed to prerender or the development server's, has nothing to hydrate).
+     */
+    readonly hydration?: boolean;
+    /** Providers added after the others, for example server rendering. */
+    readonly providers?: Array<Provider | EnvironmentProviders>;
+}
+/**
+ * The configuration of the demo application: change detection, the router with the demo pages
+ * (and a page for unknown demos), hydration, and the providers of `demoProviders`. The generated entries of
+ * the demo application bootstrap `NgDocDemoAppComponent` with it, in the browser and on the server.
+ * @param routes - The generated demo routes.
+ * @param demoProviders - The generated import of the `demoProviders` module, if any.
+ * @param options - How the application starts.
+ * @internal
+ */
+declare function ɵngDocDemoApplicationConfig(routes: Routes, demoProviders: NgDocDemoProvidersImport | undefined, options?: ɵNgDocDemoApplicationOptions): Promise<ApplicationConfig>;
+
+/**
+ * Shows the demo of a demo page: the component in the route's `ngDocDemo` data, with the inputs
+ * of the `inputs` query parameter (the JSON of the `inputs` option of the `demo` action).
+ *
+ * The demo application hydrates its server-rendered page, but not the demo: a demo is the user's
+ * component and need not be hydration-safe, and the server renders it without the inputs of the
+ * query, which only the browser has. So the host skips hydration, as documentation pages do for
+ * their content, and the browser renders the demo again.
+ */
+declare class NgDocDemoHostComponent {
+    private readonly route;
+    /** The demo component, or undefined on the page of a demo that does not exist. */
+    protected readonly demo: Type<unknown> | undefined;
+    /** The inputs of the demo. */
+    protected readonly inputs: Record<string, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocDemoHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocDemoHostComponent, "ng-doc-demo-host", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The `source` of every message the demo application sends to the page that embeds it.
+ * @internal
+ */
+declare const ɵNG_DOC_DEMO_MESSAGE_SOURCE = "ng-doc-demo";
+/**
+ * The message an isolated demo sends to the page that shows it in an iframe whenever the height
+ * of its content changes, so that the iframe takes that height.
+ * @internal
+ */
+interface ɵNgDocDemoSizeMessage {
+    readonly source: typeof ɵNG_DOC_DEMO_MESSAGE_SOURCE;
+    readonly version: 1;
+    readonly type: 'size';
+    /** The height of the demo's content, in CSS pixels, rounded up. */
+    readonly height: number;
+}
+/**
+ * Whether a message is a size message of the demo application.
+ * @param value - The data of a `message` event.
+ * @internal
+ */
+declare function ɵisNgDocDemoSizeMessage(value: unknown): value is ɵNgDocDemoSizeMessage;
+
+export { NgDocDemoAppComponent, NgDocDemoHostComponent, ɵNG_DOC_DEMO_MESSAGE_SOURCE, ɵisNgDocDemoSizeMessage, ɵngDocDemoApplicationConfig };
+export type { ɵNgDocDemoApplicationOptions, ɵNgDocDemoSizeMessage };

package/types/ng-doc-app-directives-code-highlighter.d.ts

@@ -1,15 +1,19 @@
 import * as i0 from '@angular/core';
 import { Signal } from '@angular/core';
-import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
 import { NgDocHighlighterService } from '@ng-doc/app/services';
 
+/**
+ * Renders the given Angular HTML code, highlighted by `NgDocHighlighterService`, into its host
+ * element.
+ */
 declare class NgDocCodeHighlighterDirective {
-    code: i0.InputSignal<string>;
-    protected readonly highlightedCode: Signal<SafeHtml>;
+    /** The code to highlight. */
+    readonly code: i0.InputSignal<string>;
     protected readonly element: any;
     protected readonly highlighter: NgDocHighlighterService;
     protected readonly sanitizer: DomSanitizer;
-    constructor();
+    protected readonly highlightedCode: Signal<SafeHtml>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocCodeHighlighterDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocCodeHighlighterDirective, "[ngDocHighlighter]", never, { "code": { "alias": "ngDocHighlighter"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/types/ng-doc-app-directives-members-filter.d.ts

@@ -0,0 +1,61 @@
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+
+/**
+ * Adds the member tabs, the name filter and the expandable method rows to the members table of
+ * an API page. The page renders every member, so the table reads well without it (on the server
+ * and before hydration); the directive only hides rows.
+ *
+ * It reads this markup inside its host: tab buttons with a data-ng-doc-members-tab attribute
+ * ("all", "inherited" or a group name, each with an optional .ng-doc-members-count), a text input
+ * with a data-ng-doc-members-filter attribute, group rows (.ng-doc-members-group with data-group)
+ * and member rows (.ng-doc-member with data-group, data-name and, for inherited members,
+ * data-inherited). A .ng-doc-member-expand button in a member row shows and hides the detail row
+ * its aria-controls names, and an optional .ng-doc-members-empty element shows when no member
+ * matches. F focuses the filter while single-key shortcuts are on.
+ *
+ * In the browser it inserts an `ng-doc-selection` as the first child of the row of tabs, the
+ * highlight that slides to the selected tab as in the code-block tabs. Until it is placed, the
+ * selected tab draws its own background, so the server-rendered page looks the same.
+ */
+declare class NgDocMembersFilterDirective {
+    private readonly host;
+    private readonly selectionInjector;
+    private readonly selection;
+    private readonly selectedTab;
+    private readonly filterQuery;
+    private ready;
+    /** The selected tab: "all", "inherited" or a group name. */
+    readonly tab: Signal<string>;
+    /** The text the member names are filtered by. */
+    readonly query: Signal<string>;
+    constructor();
+    /**
+     * Shows the members of a tab.
+     * @param tab - "all", "inherited" or a group name.
+     */
+    select(tab: string): void;
+    /**
+     * Shows the members whose name contains the text.
+     * @param query - The text; case is ignored.
+     */
+    filter(query: string): void;
+    protected onClick(event: MouseEvent): void;
+    protected onInput(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    /**
+     * Inserts the highlight of the selected tab into the row of tabs. It is the same component as in
+     * the code-block tabs, so it measures, follows resizes and animates the same way; the row is its
+     * offset parent, so it scrolls with the tabs.
+     */
+    private createHighlight;
+    private tabs;
+    private members;
+    private countTabs;
+    private apply;
+    private fade;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocMembersFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocMembersFilterDirective, "[ngDocMembersFilter]", never, {}, {}, never, never, true, never>;
+}
+
+export { NgDocMembersFilterDirective };

package/types/ng-doc-app-directives-route-active.d.ts

@@ -1,13 +1,27 @@
+import * as _angular_core from '@angular/core';
 import { IsActiveMatchOptions } from '@angular/router';
-import * as i0 from '@angular/core';
 
+/**
+ * Adds classes to its host element while the router URL matches a link.
+ *
+ * ```html
+ * <a [ngDocRouteActive]="'/docs/getting-started'" activeClass="active">Getting started</a>
+ * ```
+ */
 declare class NgDocRouteActiveDirective {
-    link: string;
-    activeClass: string | string[];
-    matchOptions: IsActiveMatchOptions;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocRouteActiveDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocRouteActiveDirective, "[ngDocRouteActive]", never, { "link": { "alias": "ngDocRouteActive"; "required": false; }; "activeClass": { "alias": "activeClass"; "required": false; }; "matchOptions": { "alias": "matchOptions"; "required": false; }; }, {}, never, never, true, never>;
+    /** The link to match against the router URL. */
+    readonly link: _angular_core.InputSignal<string>;
+    /** Class or classes to add while the link is active. */
+    readonly activeClass: _angular_core.InputSignal<string | string[]>;
+    /** How the link is matched against the router URL. */
+    readonly matchOptions: _angular_core.InputSignal<IsActiveMatchOptions>;
+    private readonly router;
+    private readonly active;
+    /** Whether the link is active. */
+    readonly isActive: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocRouteActiveDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgDocRouteActiveDirective, "[ngDocRouteActive]", never, { "link": { "alias": "ngDocRouteActive"; "required": false; "isSignal": true; }; "activeClass": { "alias": "activeClass"; "required": false; "isSignal": true; }; "matchOptions": { "alias": "matchOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocRouteActiveDirective };

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

@@ -1,2 +1,3 @@
 export * from '@ng-doc/app/directives/code-highlighter';
+export * from '@ng-doc/app/directives/members-filter';
 export * from '@ng-doc/app/directives/route-active';

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

@@ -1,6 +1,8 @@
-import { ViewContainerRef, Type } from '@angular/core';
+import { InjectionToken, ApplicationRef, ViewContainerRef, Type } from '@angular/core';
+import { Route } from '@angular/router';
+import { NgDocContentSource, NgDocContentModule, NgDocPlaygroundProperty, NgDocPlaygroundOption } from '@ng-doc/core/interfaces';
 import { NgDocTocItem } from '@ng-doc/app/interfaces';
-import { NgDocPlaygroundProperty } from '@ng-doc/core/interfaces';
+import { LocationStrategy } from '@angular/common';
 
 /**
  *
@@ -8,6 +10,69 @@ import { NgDocPlaygroundProperty } from '@ng-doc/core/interfaces';
  */
 declare function asBoolean(value: unknown): boolean;
 
+/**
+ * How long the router waits for the content of a page before it shows the page anyway, in
+ * milliseconds. A stalled load must not freeze navigation: after this, the page opens and its
+ * content renders when it arrives, as without the wait.
+ * @internal
+ */
+declare const ɵNG_DOC_CONTENT_WAIT: InjectionToken<number>;
+/**
+ * Loads a content source once and keeps its payload, so a page that renders it later shows it in
+ * its first render. A failed load is forgotten, so the next request tries again.
+ * @param source - The content source.
+ * @returns The loaded payload.
+ * @internal
+ */
+declare function ɵpreloadNgDocContent(source: NgDocContentSource): Promise<NgDocContentModule>;
+/**
+ * Returns the payload of a source that `ɵpreloadNgDocContent` has loaded, without waiting.
+ * @param source - The content source.
+ * @returns The payload, or `undefined` when the source has not finished loading.
+ * @internal
+ */
+declare function ɵpeekNgDocContent(source: NgDocContentSource): NgDocContentModule | undefined;
+/**
+ * Returns the load of a source that `ɵpreloadNgDocContent` started and that has not finished,
+ * so a page that opens before it finishes waits for the same load instead of starting another.
+ * @param source - The content source.
+ * @returns The pending load, or `undefined`.
+ * @internal
+ */
+declare function ɵpendingNgDocContent(source: NgDocContentSource): Promise<NgDocContentModule> | undefined;
+/**
+ * Drops the preloaded payload of a source, for a source that reports a new revision.
+ * @param source - The content source.
+ * @internal
+ */
+declare function ɵforgetNgDocContent(source: NgDocContentSource): void;
+/**
+ * Makes the router wait for the content of a generated page before it shows the page. Without
+ * it, the router removes the previous page as soon as the page's code has loaded, and an empty
+ * page shows until its content arrives.
+ *
+ * The resolver loads the content of every route of the navigation that has some, all at once,
+ * because the router runs the resolvers of nested routes one after another. A load that fails
+ * still lets the navigation finish: the page shows the error. A load that takes longer than
+ * `ɵNG_DOC_CONTENT_WAIT` lets it finish too: the page then renders its content when it arrives.
+ * @param route - The route of the page.
+ * @param source - The content source of the route's component.
+ * @returns A copy of the route with the resolver added.
+ * @internal
+ */
+declare function ɵwithNgDocContent(route: Route, source: NgDocContentSource): Route;
+/**
+ * Returns the content sources that `ɵwithNgDocContent` attached to a route.
+ * @param route - The route, as declared or as the router copied it.
+ * @returns The content sources of the route.
+ * @internal
+ */
+declare function ɵngDocRouteContentSources(route: Route | null | undefined): NgDocContentSource[];
+
+type NgDocBootstrap<TArguments extends unknown[], TApplication extends ApplicationRef = ApplicationRef> = (...arguments_: TArguments) => Promise<TApplication>;
+/** Waits for content loading and processing before returning an SSR application. */
+declare function withNgDocContentReady<TArguments extends unknown[], TApplication extends ApplicationRef = ApplicationRef>(bootstrap: NgDocBootstrap<TArguments, TApplication>): NgDocBootstrap<TArguments, TApplication>;
+
 /**
  *
  * @param viewContainer
@@ -29,6 +94,36 @@ declare function formatHtml(html: string): Promise<string>;
  */
 declare function generateToc(container: HTMLElement): NgDocTocItem[];
 
+/**
+ * The host attribute with which a component tells that its content loads asynchronously. The
+ * server renders it, so only such hosts are copied: a page with inline content costs nothing.
+ * @internal
+ */
+declare const ɵNG_DOC_ASYNC_CONTENT_ATTRIBUTE = "data-ng-doc-async-content";
+/**
+ * Copies the server-rendered content of the NgDoc hosts that skip hydration and load their
+ * content asynchronously.
+ *
+ * Angular empties such a host when it creates its component in the browser, and the page would
+ * stay blank until the content arrives, so the component shows this copy until its own content
+ * renders (`ɵrestoreNgDocHydrationSnapshot`). Call it in the browser before the application
+ * renders.
+ * @param document - The document that holds the server-rendered application.
+ * @internal
+ */
+declare function ɵcaptureNgDocHydrationSnapshots(document: Document): void;
+/**
+ * Shows the server-rendered copy of a host's content, taken by
+ * `ɵcaptureNgDocHydrationSnapshots`, in place of the host's own content until the returned
+ * function is called. Each copy is shown once; without one, nothing changes. The copy is inert
+ * and the host is busy while it is shown.
+ * @param host - The host element of the component.
+ * @returns A function that removes the copy and shows the host's own content; later calls do
+ * nothing.
+ * @internal
+ */
+declare function ɵrestoreNgDocHydrationSnapshot(host: Element): () => void;
+
 /**
  * Check if the OS theme is dark
  */
@@ -46,4 +141,48 @@ declare function isExternalLink(url: string): boolean;
  */
 declare function isPlaygroundProperty(obj: Record<string, any>): obj is NgDocPlaygroundProperty;
 
-export { asBoolean, createComponent, formatHtml, generateToc, isDarkOsTheme, isExternalLink, isPlaygroundProperty };
+/**
+ * Returns the current route as an absolute URL in path form: the route's path, query and fragment
+ * on the document's origin.
+ *
+ * With `PathLocationStrategy`, the default, it is the document's own URL. With
+ * `HashLocationStrategy` the route lives in the document's fragment (`/#/docs/page#section`), so
+ * `location.hash` and links resolved against `location.href` see the wrong part of the URL. This
+ * URL carries the route's own fragment, and relative links resolve against the route.
+ * @param locationStrategy - The location strategy of the application.
+ * @param documentUrl - The URL of the document, `location.href`.
+ * @returns The URL of the route.
+ * @internal
+ */
+declare function ɵngDocRouteUrl(locationStrategy: LocationStrategy, documentUrl: string): URL;
+/**
+ * Returns the absolute URL of the current page, without its query, as the reader shares it: the
+ * route in the form the location strategy shows it (`/docs/page` or `/#/docs/page`).
+ * @param locationStrategy - The location strategy of the application.
+ * @param location - The location of the document.
+ * @param fragment - The fragment to link to, without `#`.
+ * @returns The URL of the page.
+ * @internal
+ */
+declare function ɵngDocPageUrl(locationStrategy: LocationStrategy, location: Pick<Location, 'href' | 'origin' | 'pathname'>, fragment?: string): string;
+
+/** An option of a playground property, resolved to the value it sets and the text it shows. */
+interface NgDocResolvedPlaygroundOption {
+    /** The text shown for the option. */
+    label: string;
+    /** The value the option sets. */
+    value: unknown;
+}
+/**
+ * Resolves an option of a playground property. A named option (an enum member) carries its
+ * value; a plain value from the playground's `controls` is the value itself; any other option is
+ * the source text of a union member, such as `'small'`, and is evaluated; it throws when that
+ * text can't be evaluated.
+ * @param option - The option.
+ * @param isManual - Whether the options come from the playground's `controls`.
+ * @returns The value of the option and the text that shows it.
+ */
+declare function resolvePlaygroundOption(option: string | NgDocPlaygroundOption, isManual?: boolean): NgDocResolvedPlaygroundOption;
+
+export { asBoolean, createComponent, formatHtml, generateToc, isDarkOsTheme, isExternalLink, isPlaygroundProperty, resolvePlaygroundOption, withNgDocContentReady, ɵNG_DOC_ASYNC_CONTENT_ATTRIBUTE, ɵNG_DOC_CONTENT_WAIT, ɵcaptureNgDocHydrationSnapshots, ɵforgetNgDocContent, ɵngDocPageUrl, ɵngDocRouteContentSources, ɵngDocRouteUrl, ɵpeekNgDocContent, ɵpendingNgDocContent, ɵpreloadNgDocContent, ɵrestoreNgDocHydrationSnapshot, ɵwithNgDocContent };
+export type { NgDocBootstrap, NgDocResolvedPlaygroundOption };