asyncapi-viewer 2.0.0 → 2.1.0

package/dist/types/model/types.d.ts

@@ -0,0 +1,324 @@
+/**
+ * The normalised model.
+ *
+ * One shape for AsyncAPI 2 and 3. The normalisers (model/v2.ts, model/v3.ts) are the only code
+ * that knows spec field names; the render layer, the theme and the Python search fallback all
+ * work from this model. The UI may branch on `specMajor` only where specs/viewer-spec.md 3.4
+ * allows it: parameter `schemaType` (v2), server host display, and the header badge.
+ *
+ * Conventions:
+ * - Arrays are always present (possibly empty); optional scalars are absent, never null,
+ *   with one exception: `Channel.address` is `null` when the document leaves it unset.
+ * - `id` is the key in the source document. `anchor` is the sanitised, document-unique slug used
+ *   in page anchors `#<element id>--<section>--<anchor>` (ROADMAP amendment 10). The element id is
+ *   not part of the model, so several viewers on one page can share a model.
+ * - Text marked "markdown" is rendered through markdown-it with HTML disabled. Nothing in the
+ *   model is ever inserted as HTML.
+ * - Authored examples only. Generated examples (ROADMAP amendment 9) are produced from a
+ *   `SchemaNode` at render time and never stored in the model, so snapshots stay stable.
+ */
+export type SpecMajor = 2 | 3;
+export type SectionId = 'info' | 'servers' | 'operations' | 'messages' | 'schemas' | 'problems';
+export interface Document {
+    /** Exact version string from the document, e.g. "3.0.0" or "2.6.0". */
+    specVersion: string;
+    /** The only version switch the UI may use (spec 3.4). */
+    specMajor: SpecMajor;
+    title: string;
+    version: string;
+    /** markdown */
+    description?: string;
+    termsOfService?: string;
+    contact?: Contact;
+    license?: License;
+    externalDocs?: ExternalDocs;
+    /** Document-level tags: v3 `info.tags`, v2 root `tags`. Drive `bySpecTags` grouping. */
+    tags: Tag[];
+    defaultContentType?: string;
+    servers: Server[];
+    operations: Operation[];
+    /** `components.messages`, in document order. */
+    messages: Message[];
+    /** `components.schemas`, in document order. */
+    schemas: NamedSchema[];
+    /** Anything skipped or suspicious. Rendered by the Problems section when `errors` is on. */
+    problems: Problem[];
+}
+export interface Contact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface License {
+    name: string;
+    url?: string;
+}
+export interface ExternalDocs {
+    url: string;
+    /** markdown */
+    description?: string;
+}
+export interface Tag {
+    name: string;
+    /** markdown */
+    description?: string;
+    externalDocs?: ExternalDocs;
+}
+export interface Server {
+    id: string;
+    anchor: string;
+    title?: string;
+    summary?: string;
+    /** markdown */
+    description?: string;
+    protocol: string;
+    protocolVersion?: string;
+    /** v3: `host` + `pathname`; v2: `url`. Shown as is. */
+    hostDisplay: string;
+    variables: ServerVariable[];
+    security: SecurityRequirement[];
+    tags: Tag[];
+    externalDocs?: ExternalDocs;
+    bindings: Binding[];
+}
+export interface ServerVariable {
+    name: string;
+    /** markdown */
+    description?: string;
+    enum?: string[];
+    default?: string;
+    examples?: string[];
+}
+/** The application's side of the channel. v2 `publish` normalises to `receive`, `subscribe` to `send`. */
+export type OperationAction = 'send' | 'receive';
+/** `request` and `reply` are v3 operations that carry a `reply`; the badge label follows `kind`. */
+export type OperationKind = 'send' | 'receive' | 'request' | 'reply';
+export interface Operation {
+    /** v3: the operation key. v2: `operationId`, else `<publish|subscribe>-<channel key>`. */
+    id: string;
+    anchor: string;
+    /** v3: `title`, else id; with `useChannelAddressAsIdentifier` the channel address. v2: id. */
+    heading: string;
+    action: OperationAction;
+    kind: OperationKind;
+    /** Resolved from the label options at normalisation time (e.g. "SEND", "PUB"). */
+    badgeLabel: string;
+    /** Small mono line above the heading. v3: operation key; v2: `channels › <key> › <publish|subscribe>`. */
+    locationHint: string;
+    channel: Channel;
+    summary?: string;
+    /** markdown */
+    description?: string;
+    tags: Tag[];
+    externalDocs?: ExternalDocs;
+    /** The messages this operation may carry. Several means a tab row in the UI. */
+    messages: Message[];
+    reply?: Reply;
+    security: SecurityRequirement[];
+    bindings: Binding[];
+}
+export interface Channel {
+    /** v3: the channel key. v2: the channel key, which is also the address. */
+    id: string;
+    /** `null` when the document does not set one (v3 only). UI shows "Address not specified". */
+    address: string | null;
+    title?: string;
+    summary?: string;
+    /** markdown */
+    description?: string;
+    parameters: Parameter[];
+    /** Server ids this channel is available on. Empty means all servers. */
+    servers: string[];
+    tags: Tag[];
+    externalDocs?: ExternalDocs;
+    bindings: Binding[];
+}
+export interface Parameter {
+    name: string;
+    /** markdown */
+    description?: string;
+    enum?: string[];
+    default?: string;
+    examples?: string[];
+    location?: string;
+    /** v2 only: the parameter schema's type (spec 3.4). */
+    schemaType?: string;
+}
+export interface Reply {
+    /** Static reply channel, when the document declares one. */
+    channel?: Channel;
+    /** Dynamic reply address (`address.location`), when the document declares one instead. */
+    addressLocation?: string;
+    /** markdown; description of the dynamic address */
+    addressDescription?: string;
+    /** Reply messages as compact references to their definitions. */
+    messages: MessageRef[];
+}
+export interface MessageRef {
+    id: string;
+    anchor: string;
+    name?: string;
+    title?: string;
+}
+export interface Message {
+    /** The `components.messages` key, or the channel-level message key for inline messages. */
+    id: string;
+    anchor: string;
+    name?: string;
+    title?: string;
+    summary?: string;
+    /** markdown */
+    description?: string;
+    /** Resolved: message `contentType`, else document `defaultContentType`, else "application/json". */
+    contentType: string;
+    /** Resolved: message `schemaFormat`, else the default for the spec version. */
+    schemaFormat: string;
+    payload?: Schema;
+    headers?: Schema;
+    correlationId?: CorrelationId;
+    /** Authored examples only (v2.2+ and v3). See the file comment on generated examples. */
+    examples: MessageExample[];
+    tags: Tag[];
+    externalDocs?: ExternalDocs;
+    bindings: Binding[];
+}
+export interface CorrelationId {
+    location: string;
+    /** markdown */
+    description?: string;
+}
+export interface MessageExample {
+    name?: string;
+    summary?: string;
+    /** Parsed value from the document, rendered as JSON. */
+    payload?: unknown;
+    headers?: unknown;
+}
+/** A payload or headers schema: either a tree we understand, or a raw block we only display. */
+export type Schema = SchemaNode | RawSchema;
+/** Non-JSON-Schema formats (Avro, Protobuf, RAML, ...): shown as a labelled code block. */
+export interface RawSchema {
+    kind: 'raw';
+    schemaFormat: string;
+    /** The schema exactly as written, serialised to text if it was an object. */
+    source: string;
+}
+export interface SchemaNode {
+    kind: 'node';
+    /**
+     * Property name. Root nodes use "" (payload, headers) or the schema key (components.schemas).
+     * The item schema of an array is a child named "[]".
+     */
+    name: string;
+    /**
+     * Display path, one segment per level, excluding the root and this node, so a root always has
+     * `[]`. The item node of an array has the array's name as its last segment and contributes no
+     * segment of its own: its children start with `"items[]"` instead, so a node three levels under
+     * an array reads `["items[]", "customisation", "engraving"]` (spec 4.8 path line).
+     */
+    path: string[];
+    /** JSON Schema `type` as a list: `["string"]`, `["string", "null"]`; empty when untyped. */
+    types: string[];
+    format?: string;
+    /** From the parent's `required` array. Always false on root nodes. */
+    required: boolean;
+    title?: string;
+    /** markdown */
+    description?: string;
+    enum?: unknown[];
+    const?: unknown;
+    default?: unknown;
+    examples?: unknown[];
+    deprecated?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    /** min/max, length, pattern and friends, in a stable display order. */
+    constraints: Constraint[];
+    /** Object properties, or the single "[]" item node for arrays. Empty for leaves. */
+    children: SchemaNode[];
+    /** `oneOf` / `anyOf` variants. `allOf` is merged into `children` and never appears here. */
+    composition?: Composition;
+    /** Set when this node is a `$ref` to a `components.schemas` entry; links to the Schemas section. */
+    refName?: string;
+    /**
+     * Set instead of children when the node refers back to an ancestor. Names the referenced
+     * schema; the UI renders "Circular reference to <name>" with a link.
+     */
+    circularRef?: string;
+}
+export interface Composition {
+    kind: 'oneOf' | 'anyOf';
+    variants: SchemaVariant[];
+}
+export interface SchemaVariant {
+    /** The variant schema's `title`, else "Variant N". */
+    title: string;
+    node: SchemaNode;
+}
+export type ConstraintKey = 'minimum' | 'exclusiveMinimum' | 'maximum' | 'exclusiveMaximum' | 'multipleOf' | 'minLength' | 'maxLength' | 'pattern' | 'minItems' | 'maxItems' | 'uniqueItems' | 'minProperties' | 'maxProperties';
+export interface Constraint {
+    key: ConstraintKey;
+    value: number | string | boolean;
+}
+export interface NamedSchema {
+    /** The `components.schemas` key. */
+    id: string;
+    anchor: string;
+    schema: Schema;
+}
+export type BindingScope = 'server' | 'channel' | 'operation' | 'message';
+/**
+ * One chip: `<scope>.<key> <value>`, e.g. `channel.partitions 12`. `bindingVersion` is emitted as
+ * a binding of its own so new binding fields need no code changes.
+ */
+export interface Binding {
+    scope: BindingScope;
+    protocol: string;
+    key: string;
+    value: unknown;
+}
+/** A resolved security requirement: the scheme inlined, plus the scopes requested. */
+export interface SecurityScope {
+    name: string;
+    description: string;
+}
+/** One OAuth 2 flow with the URLs a reader needs and the scopes it offers. */
+export interface SecurityFlow {
+    /** implicit, password, clientCredentials or authorizationCode. */
+    kind: string;
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: SecurityScope[];
+}
+export interface SecurityRequirement {
+    /** The `components.securitySchemes` key. */
+    id: string;
+    type: string;
+    /** markdown */
+    description?: string;
+    /** Scopes this requirement asks for (the requirement's own list). */
+    scopes: string[];
+    /** Scheme facts worth reading: apiKey `in`, httpApiKey `name` and `in`, http `scheme` and `bearerFormat`. Only when there are any. */
+    facts?: Array<{
+        label: string;
+        value: string;
+    }>;
+    /** openIdConnect: the discovery URL. */
+    openIdConnectUrl?: string;
+    /** oauth2: the flows, only when the scheme defines any. */
+    flows?: SecurityFlow[];
+    /** Specification extensions (`x-` fields) on the scheme, prefix kept, in document order. Only when there are any. */
+    extensions?: Array<{
+        key: string;
+        value: unknown;
+    }>;
+}
+export type ProblemSeverity = 'error' | 'warning';
+export interface Problem {
+    severity: ProblemSeverity;
+    /** Plain text, one sentence. */
+    message: string;
+    /** Where in the source document, as a JSON pointer such as "/channels/orders/messages/0". */
+    where: string;
+}

package/dist/types/model/v2.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AsyncAPI 2 normaliser. Direction mapping is the rule to remember: in v2, `publish` describes
+ * what the application receives and `subscribe` what it sends. The badge keeps the raw keyword
+ * (`PUB` / `SUB` by default), the location hint keeps the channel path.
+ */
+import { Context, type Obj } from './context.js';
+import type { Document } from './types.js';
+export declare function normalizeV2(ctx: Context, root: Obj, specVersion: string): Document;

package/dist/types/model/v3.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AsyncAPI 3 normaliser. The only code that knows v3 field names for info, servers, channels,
+ * operations, messages and reply. Traits, security details and bindings edge cases are refined
+ * in chunk 1.7; this chunk establishes the shape.
+ */
+import { Context, type Obj } from './context.js';
+import type { Document } from './types.js';
+export declare function normalizeV3(ctx: Context, root: Obj, specVersion: string): Document;

package/dist/types/options.d.ts

@@ -0,0 +1,56 @@
+export type GroupServers = 'byDefault' | 'bySpecTags' | 'byServersTags';
+export type GroupOperations = 'byDefault' | 'bySpecTags' | 'byOperationsTags';
+export type ThemeMode = 'auto' | 'light' | 'dark';
+export interface Options {
+    src?: string;
+    id?: string;
+    sidebar: boolean;
+    info: boolean;
+    servers: boolean;
+    operations: boolean;
+    messages: boolean;
+    schemas: boolean;
+    errors: boolean;
+    showMessageExamples: boolean;
+    messageExamples: boolean;
+    showServers: GroupServers;
+    showOperations: GroupOperations;
+    useChannelAddressAsIdentifier: boolean;
+    publishLabel: string;
+    subscribeLabel: string;
+    sendLabel: string;
+    receiveLabel: string;
+    requestLabel: string;
+    replyLabel: string;
+    parserOptions: {
+        applyTraits: boolean;
+    };
+    theme: ThemeMode;
+    themeToggle: boolean;
+    searchKeepSections: boolean;
+}
+export type OptionType = 'string' | 'boolean' | 'enum' | 'json';
+export type OptionStatus = 'active' | 'deprecated-noop';
+export interface OptionSpec {
+    name: string;
+    type: OptionType;
+    default?: unknown;
+    required?: boolean;
+    values?: string[];
+    keys?: Record<string, 'boolean' | 'string' | 'number'>;
+    status: OptionStatus;
+    specVersions: number[];
+    description: string;
+}
+export declare const OPTION_SPECS: readonly OptionSpec[];
+/** Defaults derived from the schema; `src`, `id` and deprecated options have none. */
+export declare const DEFAULTS: Readonly<Options>;
+export declare function lookupOption(attribute: string): OptionSpec | undefined;
+/** `sendLabel` -> `send-label`: the form the Python side emits. */
+export declare function toAttributeName(option: string): string;
+export type WarnFn = (message: string) => void;
+/**
+ * Build Options from attributes. `attrs` is any iterable of `[name, value]`; a `null` value is a
+ * bare attribute. `src` and `id` pass through untouched.
+ */
+export declare function parseOptions(attrs: Iterable<readonly [string, string | null]>, warn?: WarnFn): Options;

package/dist/types/render/details.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared detail blocks: the Parameters table, binding and security chips and the reply
+ * block (spec 4.7 items 5, 7, 8, 9). Servers reuse the chips in their split style.
+ */
+import { nothing, type TemplateResult } from 'lit';
+import type { Binding, Parameter, Reply, SecurityRequirement } from '../model/types.js';
+export declare const detailStyles: import("lit").CSSResult;
+export declare function renderParameters(parameters: Parameter[], anchor: string): TemplateResult | typeof nothing;
+export type BindingStyle = 'pill' | 'split';
+/**
+ * Nested binding objects become one chip per leaf value with a dotted key
+ * (`topicConfiguration.retention.ms 60000000`); scalar arrays are joined; schema-shaped
+ * values (Kafka groupId) stay one chip showing the schema's type and description.
+ */
+export declare function flattenBinding(b: Binding): Array<{
+    key: string;
+    value: unknown;
+}>;
+/** Chips reading `<scope>.<key> <value>`; empty when there are none. */
+export declare function renderBindings(bindings: Binding[], title?: string, style?: BindingStyle): TemplateResult | typeof nothing;
+/** Security requirements as chips (spec 4.7 item 9). `serversHref` links each scheme to the Servers section. */
+export declare function renderSecurity(security: SecurityRequirement[], style?: BindingStyle, serversHref?: string): TemplateResult | typeof nothing;
+export declare function renderReply(reply: Reply, prefix: string): TemplateResult;

package/dist/types/render/example.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The example panel (spec 4.7): a dark column beside the operation content with the message
+ * name, Payload and Headers tabs, a Copy button that announces through a live region,
+ * line-numbered highlighted JSON, a select when there are several examples, and the correlation
+ * id location. When `messageExamples` is off the panel starts collapsed to a "Show example" bar.
+ * Messages without an authored example get one generated from the schema (amendment 9).
+ */
+import { nothing, type TemplateResult } from 'lit';
+import type { Message } from '../model/types.js';
+export declare const exampleStyles: import("lit").CSSResult;
+export interface ExamplePanelState {
+    tab: 'payload' | 'headers';
+    index: number;
+    open: boolean | undefined;
+    copied: 'copied' | 'failed' | undefined;
+}
+export interface ExampleContext {
+    state: ExamplePanelState;
+    /** Whether panels start open (`messageExamples` option). */
+    defaultOpen: boolean;
+    onChange: () => void;
+}
+export interface ResolvedExample {
+    label: string;
+    payload: unknown;
+    headers: unknown;
+    generated: boolean;
+}
+/** Authored examples, or one generated from the schemas. */
+export declare function examplesFor(message: Message): ResolvedExample[];
+export declare function isPanelOpen(ctx: ExampleContext): boolean;
+/** The slim bar shown in the content column while the panel is collapsed. */
+export declare function renderShowExample(ctx: ExampleContext): TemplateResult;
+export declare function renderExamplePanel(message: Message, examples: ResolvedExample[], ctx: ExampleContext, panelId: string): TemplateResult | typeof nothing;
+/** Tokenise pretty-printed JSON into spans, one grid row per line for the line numbers. */
+export declare function highlight(text: string): TemplateResult[];

package/dist/types/render/format.d.ts

@@ -0,0 +1,2 @@
+/** Short labels for schema formats, for the "contentType · format" line (design: "JSON Schema"). */
+export declare function schemaFormatLabel(schemaFormat: string): string;

package/dist/types/render/header.d.ts

@@ -0,0 +1,19 @@
+import { nothing, type TemplateResult } from 'lit';
+import type { Document } from '../model/types.js';
+export interface HeaderInput {
+    doc: Document;
+    /** The original document URL. */
+    src: string | undefined;
+    /** Object URL holding the document exactly as fetched, for "Download spec". */
+    downloadHref: string | undefined;
+    hasLogo: boolean;
+    themeToggle: boolean;
+    resolvedTheme: 'light' | 'dark';
+    onToggleTheme: () => void;
+    /** Rendered into the right-hand group (server selector, chunk 1.14). */
+    extra?: TemplateResult | typeof nothing;
+    /** Rendered first: the drawer menu button on narrow containers with the sidebar on. */
+    menu?: TemplateResult | typeof nothing;
+}
+export declare const headerStyles: import("lit").CSSResult;
+export declare function renderHeader(input: HeaderInput): TemplateResult;

package/dist/types/render/info.d.ts

@@ -0,0 +1,4 @@
+import { type TemplateResult } from 'lit';
+import type { Document } from '../model/types.js';
+export declare const infoStyles: import("lit").CSSResult;
+export declare function renderInfo(doc: Document, anchorId: string): TemplateResult;

package/dist/types/render/markdown.d.ts

@@ -0,0 +1,4 @@
+import { nothing, type TemplateResult } from 'lit';
+export declare function renderMarkdown(text: string | undefined, className?: string): TemplateResult | typeof nothing;
+/** Inline markdown (no wrapping paragraph), for summaries and short descriptions. */
+export declare function renderInline(text: string | undefined): TemplateResult | typeof nothing;

package/dist/types/render/nav.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The sidebar's data (ROADMAP amendment 11): one generic list of nav items built once per
+ * render, which the sidebar renders and the search filters. Sections and operations today;
+ * messages and schemas can join later without touching search, grouping or highlighting.
+ */
+import type { Document, Operation, OperationAction } from '../model/types.js';
+import type { GroupOperations, GroupServers } from '../options.js';
+export type NavKind = 'section' | 'server' | 'operation' | 'message' | 'schema';
+export interface NavItem {
+    kind: NavKind;
+    label: string;
+    /** Full page anchor id (element id, section, item). */
+    anchor: string;
+    /** Group heading; items without one are listed flat. */
+    group?: string;
+    badge?: {
+        label: string;
+        action: OperationAction;
+    };
+    /** Second line, e.g. the channel address. */
+    sub?: string;
+    /** Right-hand count, for the Messages and Schemas links. */
+    count?: number;
+    /** Lower-cased strings the search matches against. */
+    search: string[];
+    /** Operations: the tag names they carry, for the Tags facet. */
+    tags?: string[];
+}
+/** One entry of the sidebar's Tags block: a tag and how many operations carry it. */
+export interface TagFacet {
+    name: string;
+    description?: string;
+    count: number;
+}
+export interface NavOptions {
+    info: boolean;
+    servers: boolean;
+    messages: boolean;
+    schemas: boolean;
+    showServers: GroupServers;
+    showOperations: GroupOperations;
+}
+export declare function buildNavItems(doc: Document, operations: Operation[], prefix: string, options: NavOptions): NavItem[];
+/**
+ * The Tags block's entries (amendment 17): the document's declared tags first, in their order,
+ * then any other tag an operation carries, in first-seen order. Tags no operation carries are
+ * left out, since selecting them could only empty the list.
+ */
+export declare function tagFacets(doc: Document, operations: Operation[]): TagFacet[];
+/** Every space-separated term must match one of the item's search strings. */
+export declare function matches(item: NavItem, query: string): boolean;
+export interface FilteredNav {
+    items: NavItem[];
+    /** Operations shown and total, for the live region. */
+    shown: number;
+    total: number;
+    active: boolean;
+}
+/**
+ * The search query and the selected tags together: an operation stays when every term matches
+ * and, if any tags are selected, it carries at least one of them. Section links hide while a
+ * query is typed unless `keepSections`; a tag selection alone keeps them.
+ */
+export declare function filterNav(items: NavItem[], query: string, keepSections: boolean, selectedTags?: ReadonlySet<string>): FilteredNav;
+/** Consecutive items with the same group form one block; `undefined` groups are flat. */
+export declare function groupNav(items: NavItem[]): Array<{
+    group: string | undefined;
+    items: NavItem[];
+}>;

package/dist/types/render/operation.d.ts

@@ -0,0 +1,18 @@
+import { nothing, type TemplateResult } from 'lit';
+import type { Document, Operation } from '../model/types.js';
+import { type ExampleContext } from './example.js';
+import { type TreeState } from './tree.js';
+export interface OperationContext {
+    prefix: string;
+    tree: (key: string) => TreeState;
+    example: (key: string) => ExampleContext;
+    /** Selected message index per operation anchor. */
+    messageIndex: (anchor: string) => number;
+    selectMessage: (anchor: string, index: number) => void;
+}
+export declare const operationStyles: import("lit").CSSResult;
+export declare function operationAnchor(prefix: string, op: Operation): string;
+/** The address; `{parameters}` are set off in the accent colour, without links. */
+export declare function renderAddress(op: Operation): TemplateResult;
+export declare function renderOperation(op: Operation, ctx: OperationContext): TemplateResult;
+export declare function renderOperations(doc: Document, ctx: OperationContext): TemplateResult | typeof nothing;

package/dist/types/render/sections.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Servers, Messages, Schemas and Problems sections (spec 4.10) and the server selector (4.6).
+ */
+import { nothing, type TemplateResult } from 'lit';
+import type { Document, Problem } from '../model/types.js';
+import { type ExampleContext } from './example.js';
+import { type TreeState } from './tree.js';
+export declare const sectionStyles: import("lit").CSSResult;
+export interface SectionContext {
+    prefix: string;
+    tree: (key: string) => TreeState;
+    example: (key: string) => ExampleContext;
+}
+export declare function renderServers(doc: Document, prefix: string): TemplateResult | typeof nothing;
+export declare function renderMessages(doc: Document, ctx: SectionContext, showExamples: boolean): TemplateResult | typeof nothing;
+export declare function renderSchemas(doc: Document, ctx: SectionContext): TemplateResult | typeof nothing;
+export declare function renderProblems(problems: readonly Problem[], prefix: string): TemplateResult | typeof nothing;

package/dist/types/render/sidebar.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The sidebar (spec 4.9 and amendment 11): search, then the nav items grouped as configured,
+ * with the current item highlighted. On narrow containers it is a drawer behind a menu button.
+ */
+import { type TemplateResult } from 'lit';
+import { type NavItem, type TagFacet } from './nav.js';
+export declare const sidebarStyles: import("lit").CSSResult;
+export interface SidebarInput {
+    items: NavItem[];
+    /** The Tags block's entries; empty hides the block. */
+    tags: TagFacet[];
+    selectedTags: ReadonlySet<string>;
+    /** Whether the Tags block is expanded; kept by the element so a re-render never collapses it. */
+    tagsOpen: boolean;
+    onTagsToggle: (open: boolean) => void;
+    onToggleTag: (name: string) => void;
+    onClearTags: () => void;
+    query: string;
+    keepSections: boolean;
+    current: string | undefined;
+    open: boolean;
+    liveText: string;
+    onQuery: (query: string) => void;
+    onEscape: () => void;
+    onChoose: () => void;
+    onClose: () => void;
+    id: string;
+}
+export declare function renderSidebar(input: SidebarInput): TemplateResult;
+export declare const menuIcon: TemplateResult<1>;

package/dist/types/render/tag.d.ts

@@ -0,0 +1,7 @@
+import { type TemplateResult } from 'lit';
+import type { Tag } from '../model/types.js';
+/**
+ * A tag chip. With a description it is focusable and shows it as a tooltip on hover and focus
+ * (`.chip--tip`, pure CSS); the description is also in visually hidden text for screen readers.
+ */
+export declare function tagChip(tag: Tag): TemplateResult;