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

package/generator/semantic/type-text.d.ts

@@ -0,0 +1,5 @@
+import { ts } from 'ts-morph';
+/** Installs the canonical order on `checker`'s `typeToString`; later calls do nothing. */
+export declare function canonicalTypeText(checker: ts.TypeChecker): void;
+/** The members of a union in the canonical order (a copy; the union is not changed). */
+export declare function canonicalUnionMembers(members: readonly ts.Type[], print: (member: ts.Type) => string): ts.Type[];

package/generator/session/build-session.d.ts

@@ -0,0 +1,206 @@
+import type { BuildEvent, BuildResult, BuildSession, BuildSessionServices, Diagnostic, FileEventSource, WatchHandle } from '../contracts.js';
+import type { ProgressSink } from '../progress/events.js';
+export interface SessionOptions {
+    batchDelayMs?: number;
+    maxQueuedBuilds?: number;
+    /**
+     * Consecutive watch generations that native changes may abort before the next one is allowed to
+     * finish and publish. Later changes then form the following generation, so a continuous event
+     * stream delays publication by at most one generation instead of starving it. Defaults to 3.
+     */
+    maxSupersessions?: number;
+    /**
+     * Discard watched `update` events whose file bytes equal the content the last committed
+     * generation observed, while no active or queued generation has the path in its changes (see
+     * UnchangedSaves). Discarded events are reported as an `unchanged` BuildEvent. Defaults to true.
+     */
+    skipUnchangedSaves?: boolean;
+    /** Fallback for watcher/observer/teardown failures. Its own exceptions are contained. */
+    onDiagnostic?: (diagnostic: Diagnostic) => void;
+    /**
+     * Progress events of every generation, buildOnce included, and of the input check and warm-up
+     * outside generations (see `session/progress.ts`). Advisory: results are the same with and
+     * without it. A failing consumer is reported once through `onDiagnostic` as the
+     * `SESSION_PROGRESS_FAILED` warning and never stops a build or a watch.
+     */
+    onProgress?: ProgressSink;
+}
+export interface SessionState {
+    disposed: boolean;
+    generation: number;
+    watching: boolean;
+    building: boolean;
+    queuedBuilds: number;
+    pendingChanges: number;
+    /** Results waited for on the watch's pending, queued or running generation (its `initial`). */
+    pendingWatchWaiters: number;
+    lastGoodRevision?: string;
+    /**
+     * The warm-up of the compiler's long-lived runtime after a reused startup baseline (see
+     * `PrimingCompiler`): `running`, or how it ended. `primed` means the runtime retains a program
+     * for the committed snapshot; `stale` means for another revision (the next generation rebuilds).
+     */
+    priming?: 'running' | 'primed' | 'stale' | 'skipped' | 'aborted' | 'failed';
+}
+export declare class SessionLifecycleError extends Error {
+    readonly diagnostic: Diagnostic;
+    constructor(diagnostic: Diagnostic);
+}
+/** A session owns one compiler and committer. Their instances must not be shared across sessions. */
+export declare class GeneratorBuildSession implements BuildSession {
+    private readonly services;
+    private readonly options;
+    private readonly delay;
+    private readonly maxQueue;
+    private readonly maxSupersessions;
+    private readonly queue;
+    private generation;
+    private active?;
+    private watchState?;
+    private pumping?;
+    private disposing?;
+    private disposed;
+    private snapshot?;
+    private manifest?;
+    private baseline?;
+    /** Filesystem inputs observed by the generation that produced the committed snapshot. */
+    private committedInputs?;
+    /**
+     * Filesystem inputs observed by the newest generation that failed after the last commit. Its
+     * new inputs were never committed, so they are re-observed against what it read instead.
+     */
+    private failedInputs?;
+    private readonly unchanged?;
+    /** The running warm-up (see `prime`); aborted by any job, watch batch, watch stop or dispose. */
+    private priming?;
+    private primingState?;
+    private readonly progress;
+    constructor(services: BuildSessionServices, options?: SessionOptions);
+    inspect(): SessionState;
+    /**
+     * The host could not publish a generation this session committed (for example a Vite adapter
+     * that failed to install it). Until the next successful generation no watched save is
+     * discarded as unchanged, so re-saving a file retries the publication.
+     */
+    publicationFailed(): void;
+    /**
+     * Re-observes inputs that a watch host has only just begun watching: its new physical watch
+     * targets and the changes it rejected while the generation that recorded them ran. That
+     * generation may have read a path before any watch existed, so a change in between would never
+     * be reported. Each path is compared with what the newest settled generation observed (the
+     * committed one, or a newer failed one, whose inputs were never committed). Each difference is
+     * admitted as an ordinary watcher change, so it runs a `filesystem` generation, which keeps the
+     * retained program; when nothing differs no generation runs, and the published generation's
+     * reload is not held back by one. Resolves once any change is admitted, never waiting for a
+     * generation. A lossy-watcher rescan still re-observes every committed input instead.
+     */
+    reconcileInputs(paths: readonly string[]): Promise<void>;
+    /**
+     * Re-observes every input the committed generation observed, as after a lossy-watcher error:
+     * the next watch generation first compares each input with the filesystem and turns every
+     * difference into an ordinary change (see `reconcile`). With differences it is a `filesystem`
+     * generation: the compiler keeps its retained program only if the program's own sweep of what
+     * it observed still holds. Without any it is a `reconcile` generation, which discards the
+     * retained program. Either way the commit is the full one, which re-verifies every output. An
+     * active watch generation is superseded as by a watched change. Resolves once scheduled,
+     * never waiting for a generation; without an active watch there is nothing to reconcile.
+     */
+    rescan(): Promise<void>;
+    buildOnce(options?: {
+        mode?: 'development' | 'production';
+    }): Promise<BuildResult>;
+    watch(source: FileEventSource, onEvent: (event: BuildEvent) => void): Promise<WatchHandle>;
+    dispose(): Promise<void>;
+    private assertOpen;
+    private capacityError;
+    private batch;
+    /** Marks the next watch batch to re-observe every committed input first (see `reconcile`). */
+    private scheduleRescan;
+    private watchWaiters;
+    /**
+     * A queued native change supersedes a watch snapshot even before the next generation starts.
+     * Explicit buildOnce jobs remain independent; the next job still waits for this
+     * compiler/committer call to settle, so shared compiler state is never concurrent. After
+     * `maxSupersessions` consecutive aborted generations the active one is protected: it finishes
+     * and publishes, and the batch runs next, so the newest change is always eventually committed.
+     */
+    private supersede;
+    /**
+     * Screens native changes for unchanged saves. Returns the changes to batch, or `false` when every
+     * change was discarded (no generation will run for them). Deferred saves return an empty list:
+     * they are decided when the active generation settles.
+     */
+    private admit;
+    /** Normalized paths in the changes of the active job, every queued job and the pending batch. */
+    private busyPaths;
+    private releaseDeferred;
+    private schedule;
+    private flush;
+    private enqueue;
+    private pump;
+    /**
+     * Merges the changes a lossy watcher may have missed: every input observed by the committed
+     * generation is re-observed and each difference becomes an ordinary change. If re-observation
+     * itself fails, every recorded content input is treated as changed.
+     */
+    private reconcile;
+    private isCurrent;
+    private execute;
+    /**
+     * Makes a committed candidate the session's state: snapshot and manifest (a delta candidate is
+     * already private, its unchanged artifacts are the previous snapshot's) and the filesystem
+     * inputs it observed.
+     */
+    private adopt;
+    /**
+     * The committed snapshot a watch generation's commit may be a delta against: with
+     * `this.manifest`, the pair that one acknowledgement made the session's state (`adopt` sets
+     * both). The committer still checks that this is what it last published.
+     * Undefined asks for the full commit, which re-verifies every output and so repairs external
+     * edits of unchanged ones: for builds outside a watch, for reconciling
+     * generations (a watcher rescan or `rescan()`), and for a generation whose compiler
+     * found a previously published output missing on disk (`output-missing`), and for every full
+     * generation of a compiler that tells full from targeted ones (`targetedResult`): full
+     * generations repair. Such a compiler keeps reporting `output-missing` for every published
+     * output, not only the recompiled ones.
+     */
+    private commitBase;
+    /** Reports a delta candidate's outcome to the compiler. A failing hook is only reported. */
+    private acknowledge;
+    /**
+     * A development buildOnce result may replace the post-subscription generation only while it is
+     * the newest generation and no watcher event is pending. The caller checks this before and
+     * again synchronously after re-observing the inputs.
+     */
+    private startupBaseline;
+    /**
+     * Every recorded filesystem input must re-observe identically after subscription. A change
+     * before subscription is found here; a later one is reported by the watcher. A verification
+     * error keeps the ordinary generation.
+     */
+    private reobserve;
+    private failure;
+    private cancelled;
+    private cancel;
+    private stopWatch;
+    /**
+     * Warms the compiler's long-lived runtime right after a watch reused the startup baseline. The
+     * baseline was compiled by a one-shot runtime, or restored by the fast start without building a
+     * program, so without this the first edit rebuilds the whole TypeScript program. The request is
+     * the one a no-change
+     * development generation would send for the committed snapshot; the compiler is deterministic,
+     * so its candidate has the committed revision and the runtime's retained program is valid for
+     * the first edit's base. Nothing comes back: no generation number is used, and nothing is
+     * committed, published, emitted or reported (a failing hook is contained). Any job, watched
+     * change, watch stop or dispose aborts it (`stopPriming`).
+     */
+    private prime;
+    private stopPriming;
+    /** Tells the compiler that the watch started or stopped. A failing hook is only reported. */
+    private watchRuntime;
+    private emit;
+    private observerFailed;
+    private fallback;
+    private cleanup;
+}
+export declare function createBuildSession(services: BuildSessionServices, options?: SessionOptions): GeneratorBuildSession;

package/generator/session/input-verification.d.ts

@@ -0,0 +1,38 @@
+import type { Dependency, FileChange } from '../contracts.js';
+export type PhysicalInput = Extract<Dependency, {
+    kind: 'content' | 'existence' | 'glob';
+}>;
+/** The filesystem observations of a compilation; semantic and keyword digests derive from them. */
+export declare function physicalInputs(dependencies: readonly Dependency[]): PhysicalInput[];
+/**
+ * Re-observes every recorded filesystem input with the compiler's own dependency refresher.
+ *
+ * Content and existence observations must match exactly, including observations below the
+ * generator-owned roots: a compilation that read its own previous outputs is only current while
+ * those bytes are unchanged. Glob membership is compared without owned-root members because
+ * semantic source membership excludes generated output by construction and watchers never report
+ * owned-root changes. Any read failure or difference reports a change.
+ */
+export declare function inputsUnchanged(inputs: readonly PhysicalInput[], ownedRoots: readonly string[]): Promise<boolean>;
+/**
+ * Re-observes recorded filesystem inputs and reports each difference as the file event a watcher
+ * would have delivered: a changed digest is an update, a vanished file a delete, an existence
+ * flip a create or delete, and glob membership differences creates and deletes. Paths below the
+ * generator-owned roots are never reported, exactly as watchers ignore them. A glob that cannot be
+ * scanned reports nothing: its members are still individually observed as content inputs.
+ */
+export declare function changedInputs(inputs: readonly PhysicalInput[], ownedRoots: readonly string[]): Promise<FileChange[]>;
+/**
+ * Re-observes only the recorded inputs at the given paths. A watch host passes the targets it has
+ * just begun watching and the changes it rejected while the generation that recorded them ran:
+ * that generation may have read them before any watch could report a change. Differences are
+ * reported exactly as `changedInputs` reports them.
+ *
+ * A path selects every content or existence observation at or below it, and every glob whose root
+ * is at, below or above it, so that a membership change is found. A glob records membership only,
+ * never content: it vouches for a directory (a glob base), but a file is compared only through its
+ * own content or existence observation. A path without one has nothing to compare with (for
+ * example a file the generation read but never recorded), so it is reported as changed: an
+ * `update` while it exists, otherwise a `delete`. Paths below the owned roots are never reported.
+ */
+export declare function reobservedChanges(inputs: readonly PhysicalInput[], ownedRoots: readonly string[], paths: readonly string[]): Promise<FileChange[]>;

package/generator/session/parcel-event-source.d.ts

@@ -0,0 +1,22 @@
+import * as parcel from '@parcel/watcher';
+import type { FileEventSource } from '../contracts.js';
+/**
+ * IDE and OS metadata that is never a generator input but is rewritten constantly: the watched
+ * root's JetBrains `.idea/` directory and macOS Finder `.DS_Store` files. Recorded inputs are
+ * TypeScript sources, `ng-doc.{page,category,api}.ts` descriptions and the files they include.
+ * `.vscode/` is not ignored: VS Code keeps its frequently written state outside the workspace.
+ */
+export declare const METADATA_IGNORE: readonly string[];
+/**
+ * The backend a subscription names when its options name none. Without a name, @parcel/watcher on
+ * Linux first probes for Watchman: it runs `watchman get-sockname` through `popen`, and when
+ * Watchman is missing the reply fails to parse before `pclose`, so the probe's shell is never
+ * reaped. The host then keeps a zombie child in its process group until it exits, and a
+ * supervisor that waits for that group to empty after `dispose` finds it there. Naming inotify,
+ * the backend the probe falls back to, skips the probe. macOS selects FSEvents before any probe.
+ * @param platform The platform to choose for.
+ * @returns The backend to name, or `undefined` to keep @parcel/watcher's choice.
+ */
+export declare function nativeWatcherBackend(platform?: NodeJS.Platform): parcel.BackendType | undefined;
+/** Each subscription owns a native watcher. The adapter must ignore its generated output roots. */
+export declare function createParcelEventSource(root: string, options?: parcel.Options, subscribe?: typeof parcel.subscribe): FileEventSource;

package/generator/session/progress.d.ts

@@ -0,0 +1,72 @@
+import type { ArtifactSnapshot, BuildResult, CommitResult, CompilationProgressUpdate, Diagnostic, Generation } from '../contracts.js';
+import type { ProgressActivityEvent, ProgressEvent, ProgressSink, ProgressTrigger } from '../progress/events.js';
+/** What a generation reports when it starts. */
+export interface ProgressJob {
+    generation: Generation;
+    trigger: ProgressTrigger;
+    mode: 'development' | 'production';
+    /** File changes behind the generation, before a rescan adds what it found. */
+    changes: number;
+}
+type Activity = ProgressActivityEvent['activity'];
+/**
+ * The session's progress events (`SessionOptions.onProgress`). Advisory only: nothing here reads
+ * or changes what a generation compiles, commits or publishes. Without a consumer every call is a
+ * single branch. Timings come from the session's own clock, and a failing consumer is reported
+ * once as `SESSION_PROGRESS_FAILED` and never stops anything.
+ */
+export declare class SessionProgress {
+    private readonly now;
+    private readonly sink?;
+    private readonly activities;
+    constructor(sink: ProgressSink | undefined, report: (diagnostic: Diagnostic) => void, now?: () => number);
+    /**
+     * A generation started. `isCurrent` gates every later update: once the generation is aborted or
+     * superseded, only its one `progress-settled` event follows.
+     */
+    start(job: ProgressJob, isCurrent: () => boolean): GenerationProgress | undefined;
+    /**
+     * Work outside a generation: the input check after a watch starts, and the warm-up. An end may
+     * say the work `failed`, or that other work `stopped` it first.
+     */
+    activity(activity: Activity, state: 'start' | 'end', outcome?: 'failed' | 'stopped'): void;
+}
+/**
+ * One generation's events: `progress-started`, the compilation's phases (compiler and worker, see
+ * `compilation`), the session's commit, then exactly one settle.
+ */
+export declare class GenerationProgress {
+    private readonly sink;
+    private readonly job;
+    private readonly isCurrent;
+    private readonly now;
+    private seq;
+    private readonly startedAt;
+    private phases;
+    private open?;
+    private commit?;
+    private settled;
+    private pass?;
+    private reason?;
+    /** The compilation's updates, stamped and gated like the session's own (`compile` context). */
+    readonly compilation: (update: CompilationProgressUpdate) => void;
+    constructor(sink: (event: ProgressEvent) => void, job: ProgressJob, isCurrent: () => boolean, now: () => number);
+    /**
+     * The commit starts. A full commit (`full` is the candidate) compares every candidate output, so
+     * their count is the total; a delta commit writes an unknown share of them.
+     */
+    commitStarted(full?: ArtifactSnapshot): void;
+    commitEnded(result: CommitResult): void;
+    /** The generation's outcome. `previous` is the last committed snapshot, for a failure's page count. */
+    settle(result: BuildResult, previous?: ArtifactSnapshot): void;
+    /** Counts never decide an outcome: a result they cannot read is reported without them. */
+    private safeCounts;
+    /**
+     * A phase update from the compilation or the session. The session's clock times it: no clock
+     * crosses the worker boundary.
+     */
+    private update;
+    private close;
+    private counts;
+}
+export {};

package/generator/session/unchanged-saves.d.ts

@@ -0,0 +1,63 @@
+import type { FileChange } from '../contracts.js';
+import type { PhysicalInput } from './input-verification.js';
+/**
+ * Bounds on the synchronous reads made to recognise unchanged saves. A file above `maxFileBytes`,
+ * and every candidate after a delivered event batch has used up its file or byte budget, is
+ * admitted unchecked, exactly as without the filter.
+ */
+export interface UnchangedSaveLimits {
+    maxFileBytes: number;
+    maxFilesPerBatch: number;
+    maxBytesPerBatch: number;
+}
+export declare const UNCHANGED_SAVE_LIMITS: Readonly<UnchangedSaveLimits>;
+export interface ScreenContext {
+    /** A generation is running; it may read a path after the committed observation. */
+    active: boolean;
+    /** The path (normalized) is in the changes of the active, a queued or the pending batch. */
+    busy(path: string): boolean;
+}
+export interface ScreenResult {
+    passed: FileChange[];
+    dropped: FileChange[];
+    deferred: number;
+}
+/**
+ * Recognises watched saves that change nothing: an `update` whose file bytes equal the content the
+ * last committed generation observed for that path, while no active or queued generation has the
+ * path in its changes. Such an event would only rerun a full
+ * generation (and supersede one in flight) to publish identical output.
+ *
+ * Exactness:
+ * - Creates, deletes and paths without a recorded content digest are always admitted.
+ * - Nothing is dropped unless the newest settled (non-cancelled) generation succeeded, so a revert
+ *   to the committed bytes after a failed generation still regenerates and clears the failure.
+ * - A path in the changes of the active, a queued or the pending batch is admitted: an active
+ *   generation may already have read newer bytes (a revert during a generation still runs).
+ * - While any generation is active, a matching save is deferred, not dropped: that generation may
+ *   read the path after the committed observation (for example during a coalesced A→B→A write).
+ *   When it settles, deferred saves are screened again against the digests it committed.
+ */
+export declare class UnchangedSaves {
+    private readonly limits;
+    private readonly digestOf;
+    private digests;
+    private healthy;
+    private readonly waiting;
+    constructor(limits?: Readonly<UnchangedSaveLimits>, digestOf?: (file: string, maxBytes: number) => {
+        digest: string;
+        bytes: number;
+    } | undefined);
+    /** Records the content observations of a committed generation. */
+    committed(inputs: readonly PhysicalInput[]): void;
+    /** A non-cancelled generation settled. Only a success keeps unchanged saves droppable. */
+    settled(status: 'success' | 'failure'): void;
+    /** Recorded digest of a path, for diagnostics and tests. */
+    recorded(file: string): string | undefined;
+    deferredCount(): number;
+    /** Deferred saves, removed from the filter, in arrival order. */
+    takeDeferred(): FileChange[];
+    clearDeferred(): void;
+    reset(): void;
+    screen(events: readonly FileChange[], context: ScreenContext): ScreenResult;
+}

package/generator/session/watch-inputs.d.ts

@@ -0,0 +1,6 @@
+import type { WatchInputs } from '../contracts.js';
+/**
+ * Projects a complete compiler dependency DTO into host-facing filesystem inputs.
+ * It is intentionally pure: session ownership ends at observation, not watching.
+ */
+export declare function projectWatchInputs(dependencies: unknown): WatchInputs;

package/generator/session/watch-signals.d.ts

@@ -0,0 +1,10 @@
+import type { Diagnostic } from '../contracts.js';
+/**
+ * A file event source reports this warning when its native watcher may have lost events (for
+ * example an FSEvents queue overflow: "Events were dropped ... File system must be re-scanned").
+ * The watch itself stays alive. The session answers it with a reconciling generation whose
+ * changes are re-observed from the inputs of the last committed generation, instead of treating
+ * the signal as a fatal watcher error.
+ */
+export declare const WATCHER_RESCAN = "WATCHER_RESCAN";
+export declare function isRescanSignal(diagnostic: Diagnostic): boolean;

package/generator/templates/api/base.html.nunj

@@ -0,0 +1,26 @@
+{% import "helpers/declaration-modifiers.html.nunj" as tagsMacro %}
+{% import "helpers/no-content.html.nunj" as noContentMacro %}
+
+{% if not hideDescription %}
+    {% set description = docNode | getJsDocDescription %}
+
+    {{ description if description else noContentMacro.render('No documentation has been provided.') }}
+{% endif %}
+
+{% if not hideRemarks %}
+    {% include "parts/remarks.html.nunj" %}
+{% endif %}
+
+{% if not hideSeeAlso %}
+    {% include "parts/see-also.html.nunj" %}
+{% endif %}
+
+{% block overview %}{% endblock %}
+
+{% if not hideExamples %}
+    {% include "parts/examples.html.nunj" %}
+{% endif %}
+
+{% if not hideUsageNotes %}
+    {% include "parts/usage-notes.html.nunj" %}
+{% endif %}

package/generator/templates/api/class-declaration.html.nunj

@@ -0,0 +1,59 @@
+{% extends "api/base.html.nunj" %}
+
+{% import "helpers/constructor.html.nunj" as constructorMacro %}
+{% import "helpers/methods.html.nunj" as methodsMacro %}
+{% import "helpers/properties.html.nunj" as propertiesMacro %}
+{% import "helpers/accessors.html.nunj" as accessorsMacro %}
+{% import "helpers/modifier.html.nunj" as modifierMacro %}
+
+{% block overview %}
+    {#- The new engine sets `hideProtectedMembers` for `api.protectedMembers: false`; the legacy engine never does. #}
+    {%- set memberScopes = ["public"] if hideProtectedMembers else ["public", "protected"] -%}
+    {%- set constructors = declaration.getConstructors() | filterByScope("public") | excludeByJsDocTags('internal') -%}
+    {%- set allProperties = declaration | getClassProperties | excludeByJsDocTags('internal') | filterByScope(memberScopes) | filterUselessMembers | sortByNodesName -%}
+    {%- set allMethods = declaration | getClassMethods | excludeByJsDocTags('internal') | filterByScope(memberScopes) | filterUselessMembers | sortByNodesName -%}
+    {%- set allAccessors = declaration | getClassAccessors | excludeByJsDocTags('internal') | filterByScope(memberScopes) | filterUselessMembers | sortByNodesName -%}
+
+    {%- set staticProperties = allProperties | filterByStatic(true) -%}
+    {%- set staticAccessors = allAccessors | filterByStatic(true) -%}
+    {%- set staticMethods = allMethods | filterByStatic(true) -%}
+    {%- set properties = allProperties | filterByStatic(false) -%}
+    {%- set accessors = allAccessors | filterByStatic(false) -%}
+    {%- set getAccessors = declaration.getGetAccessors() | filterByStatic(false) -%}
+    {%- set methods = allMethods | filterByStatic(false) -%}
+
+    {% if constructors.length -%}
+        <h2>Constructor</h2>
+        {{ constructorMacro.render(constructors[0]) }}
+    {%- endif %}
+
+    {% if staticProperties.length -%}
+        <h2>Static Properties</h2>
+        {{ propertiesMacro.render(staticProperties, declaration) }}
+    {%- endif %}
+
+    {% if properties.length -%}
+        <h2>Properties</h2>
+        {{ propertiesMacro.render(properties, declaration) }}
+    {%- endif %}
+
+    {% if staticAccessors.length -%}
+        <h2>Static Accessors</h2>
+        {{ accessorsMacro.render(staticAccessors, declaration) }}
+    {%- endif %}
+
+    {% if accessors.length -%}
+        <h2>Accessors</h2>
+        {{ accessorsMacro.render(accessors, declaration) }}
+    {%- endif %}
+
+    {% if staticMethods.length -%}
+        <h2>Static Methods</h2>
+        {{ methodsMacro.render(staticMethods, declaration) }}
+    {%- endif %}
+
+    {% if methods.length -%}
+        <h2>Methods</h2>
+        {{ methodsMacro.render(methods, declaration) }}
+    {%- endif %}
+{% endblock %}

package/generator/templates/api/details/class-declaration.html.nunj

@@ -0,0 +1,47 @@
+{% import "helpers/type.html.nunj" as typeMacro %}
+
+{% set typeParameters %}
+    {% include "api/details/helpers/type-parameters.html.nunj" %}
+{% endset %}
+{% set hasTypeParameters = typeParameters | trim | length %}
+
+{% set decorators %}
+    {% include "api/details/helpers/decorators.html.nunj" %}
+{% endset %}
+{% set hasDecorators = decorators | trim | length %}
+
+{% set selectors %}
+    {% include "api/details/helpers/selectors.html.nunj" %}
+{% endset %}
+{% set hasSelectors = selectors | trim | length %}
+
+{% set extends = declaration.getExtends() %}
+{% set implements = declaration.getImplements() %}
+
+{% if hasTypeParameters or hasDecorators or hasSelectors or extends or implements.length %}
+    <table class="ng-doc-api-table no-padding no-full-width">
+        <tbody>
+        {{ decorators }}
+        {{ typeParameters }}
+        {{ selectors }}
+
+        {% if extends %}
+            <tr>
+                <td indexable="false">Extends:</td>
+                <td>{{ typeMacro.type(extends) }}</td>
+            </tr>
+        {%- endif %}
+
+        {% if implements.length %}
+            <tr>
+                <td indexable="false">Implements:</td>
+                <td>
+                    {%- for i in implements -%}
+                        {{ typeMacro.type(i) }}
+                    {%- endfor %}
+                </td>
+            </tr>
+        {%- endif %}
+        </tbody>
+    </table>
+{% endif %}

package/generator/templates/api/details/function-declaration.html.nunj

@@ -0,0 +1,14 @@
+{% import "helpers/type.html.nunj" as typeMacro %}
+
+{% set typeParameters %}
+    {% include "api/details/helpers/type-parameters.html.nunj" %}
+{% endset %}
+{% set hasTypeParameters = typeParameters | trim | length %}
+
+{% if hasTypeParameters %}
+    <table class="ng-doc-api-table no-padding no-full-width">
+        <tbody>
+        {{ typeParameters }}
+        </tbody>
+    </table>
+{% endif %}

package/generator/templates/api/details/helpers/decorators.html.nunj

@@ -0,0 +1,14 @@
+{% import "helpers/type.html.nunj" as typeMacro %}
+
+{% set decorators = declaration.getDecorators() %}
+
+{% if decorators.length %}
+    <tr>
+        <td indexable="false">Decorators:</td>
+        <td indexable="false">
+            {% for decorator in decorators %}
+                {{ typeMacro.render( '@' + decorator.getName()) }}
+            {%- endfor %}
+        </td>
+    </tr>
+{% endif %}

package/generator/templates/api/details/helpers/extends.html.nunj

@@ -0,0 +1,6 @@
+{% if extends %}
+    <tr>
+        <td indexable="false">Extends:</td>
+        <td>{{ typeMacro.type(extends) }}</td>
+    </tr>
+{%- endif %}

package/generator/templates/api/details/helpers/selectors.html.nunj

@@ -0,0 +1,12 @@
+{% set selectors = declaration | extractSelectors %}
+
+{% if selectors.length %}
+    <tr>
+        <td indexable="false">Selectors:</td>
+        <td>
+            {% for selector in selectors %}
+                <code>{{ selector }}</code>
+            {%- endfor %}
+        </td>
+    </tr>
+{% endif %}

package/generator/templates/api/details/helpers/type-parameters.html.nunj

@@ -0,0 +1,14 @@
+{% import "helpers/type.html.nunj" as typeMacro %}
+
+{% set typeParameters = declaration.getTypeParameters() %}
+
+{% if typeParameters.length %}
+    <tr>
+        <td indexable="false">Generic types:</td>
+        <td>
+            {% for typeParameter in typeParameters %}
+                {{ typeMacro.type(typeParameter) }}
+            {%- endfor %}
+        </td>
+    </tr>
+{% endif %}