apiuikit 0.2.1 → 0.5.0

package/dist/components/tests/Authorization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/tests/RenderExtensions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/config.d.ts

@@ -11,11 +11,14 @@ export interface ShowConfig {
     sidebar?: boolean;
     info?: boolean;
     servers?: boolean;
+    search?: boolean;
     operations?: boolean;
     messages?: boolean;
     messageExamples?: boolean;
     schemas?: boolean;
     errors?: boolean;
+    /** Whether to render known x-* spec extensions (see the `x-tensions` catalog). Defaults to true. */
+    extensions?: boolean;
 }
 export interface ExpandConfig {
     messageExamples?: boolean;

package/dist/containers/AsyncAPI/AsyncAPI.d.ts

@@ -1,12 +1,18 @@
 import { ConfigInterface } from '../../config';
 import { AsyncAPIDocumentData } from '../../types/schema';
-export type IAsyncAPIProps = {
+export interface IAsyncAPIProps {
+    /** A pre-resolved AsyncAPI 3.0 document object, or one that still contains `$ref`s. */
     asyncapi: AsyncAPIDocumentData;
+    /** UI configuration: theme, which sections to show, sidebar options, and more. */
     config?: ConfigInterface;
-} | {
-    kind: "resolved";
-    asyncapi: AsyncAPIDocumentData;
-    config?: ConfigInterface;
-};
+    /** Informational hint that `asyncapi` has already been fully dereferenced upstream, not a contract: `$ref`s left in place are still resolved either way. */
+    kind?: "resolved";
+}
+/**
+ * Renders a full AsyncAPI documentation page: sidebar navigation, search,
+ * servers, operations, messages, and schemas. Pass a pre-resolved (or
+ * `$ref`-carrying) document object; for raw YAML/JSON strings, use
+ * `AsyncAPIRenderer` instead, which parses first.
+ */
 declare const AsyncAPI: (props: IAsyncAPIProps) => import("react").JSX.Element;
 export default AsyncAPI;

package/dist/containers/AsyncAPI/AsyncAPIDocumentProvider.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { ConfigInterface } from '../../config';
+import { AsyncAPIDocumentData } from '../../types/schema';
+export interface AsyncAPIDocumentProviderProps {
+    document: AsyncAPIDocumentData;
+    config?: ConfigInterface;
+    /** Extra classes merged onto the root surface (e.g. Layout's sidebar `pt-14`). */
+    className?: string;
+    children: ReactNode;
+}
+export declare function AsyncAPIDocumentProvider({ document: asyncapi, config, className, children, }: AsyncAPIDocumentProviderProps): import("react").JSX.Element;
+export default AsyncAPIDocumentProvider;

package/dist/containers/AsyncAPI/AsyncAPIRenderer.d.ts

@@ -1,8 +1,17 @@
 import { ConfigInterface } from '../../config/config';
 interface AsyncAPIRendererProps {
+    /** Raw AsyncAPI document as a YAML or JSON string, parsed and validated internally via `@asyncapi/parser`. */
     raw: string;
+    /** UI configuration: theme, which sections to show, sidebar options, and more. */
     config?: ConfigInterface;
+    /** Called with the parser's diagnostics (errors/warnings) after each parse attempt. */
     onDiagnostics?: (diagnostics: unknown[]) => void;
 }
+/**
+ * Parses a raw AsyncAPI YAML/JSON string (via `@asyncapi/parser`) and renders
+ * the same full documentation page as `AsyncAPI`. Use this when you have a
+ * document as text rather than a pre-parsed object, e.g. user-entered or
+ * loaded from a file at runtime.
+ */
 export declare function AsyncAPIRenderer({ raw, config, onDiagnostics }: AsyncAPIRendererProps): import("react").JSX.Element | null;
 export {};

package/dist/containers/AsyncAPI/tests/searchHighlight.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/containers/Messages/MessageDetails.d.ts

@@ -4,6 +4,8 @@ interface MessageDetailsProps {
     expanded: boolean;
     onToggleExpanded: () => void;
     paddingX?: string;
+    /** "payload" | "headers" when search navigated here for that schema specifically. */
+    focusSection?: string | null;
 }
-export declare function MessageDetails({ message, expanded, onToggleExpanded, paddingX, }: MessageDetailsProps): import("react").JSX.Element;
+export declare function MessageDetails({ message, expanded, onToggleExpanded, paddingX, focusSection, }: MessageDetailsProps): import("react").JSX.Element;
 export {};

package/dist/containers/Messages/Messages.d.ts

@@ -2,6 +2,8 @@ import { MessageObject } from '../../types/asyncapi/MessageObject';
 interface MessagesProps {
     messages: Record<string, MessageObject>;
     selectedKey?: string | null;
+    /** Which collapsed section ("payload" | "headers") search navigated to. */
+    focusSection?: string | null;
 }
-export default function Messages({ messages, selectedKey }: MessagesProps): import("react").JSX.Element;
+export default function Messages({ messages, selectedKey, focusSection }: MessagesProps): import("react").JSX.Element;
 export {};

package/dist/containers/Operation/Operation.d.ts

@@ -2,6 +2,8 @@ import { Operation as OperationInterface } from '../../types/asyncapi/Operation'
 interface OperationProps {
     op: OperationInterface;
     id: string | null;
+    /** Which collapsed section search navigated to, e.g. `binding:kafka`. */
+    focusSection?: string | null;
 }
-export default function Operation({ op, id }: OperationProps): import("react").JSX.Element;
+export default function Operation({ op, id, focusSection }: OperationProps): import("react").JSX.Element;
 export {};

package/dist/containers/Operation/Operations.d.ts

@@ -3,6 +3,8 @@ interface OperationsProps {
     operations: Record<string, OperationType>;
     selectedKey?: string | null;
     onSelectKey?: (key: string | null) => void;
+    /** Which collapsed section of the selected operation search navigated to. */
+    focusSection?: string | null;
 }
-export default function Operations({ operations, selectedKey, onSelectKey }: OperationsProps): import("react").JSX.Element | null;
+export default function Operations({ operations, selectedKey, onSelectKey, focusSection }: OperationsProps): import("react").JSX.Element | null;
 export {};

package/dist/containers/Schema/Schemas.d.ts

@@ -2,6 +2,11 @@ import { SchemaNodeData } from '../../types/schema';
 interface SchemasProps {
     schemas: Record<string, SchemaNodeData>;
     selectedKey?: string | null;
+    /** The precisely-matched nested node search navigated to, if any — see Layout.tsx. */
+    focusTarget?: {
+        tokens: string[];
+        id: string;
+    } | null;
 }
-export default function Schemas({ schemas, selectedKey }: SchemasProps): import("react").JSX.Element;
+export default function Schemas({ schemas, selectedKey, focusTarget }: SchemasProps): import("react").JSX.Element;
 export {};

package/dist/containers/Server/Server.d.ts

@@ -1,2 +1,9 @@
 import { Server as ServerInterface } from '../../types/asyncapi/Server';
-export default function Server({ host, protocol, description, tags, variables, security, bindings, }: ServerInterface): import("react").JSX.Element;
+interface ServerProps extends ServerInterface {
+    /** The server's own key/name, needed to build ids for its sub-sections. */
+    serverKey?: string;
+    /** Which collapsed section (if any) search navigated to, e.g. `binding:kafka`. */
+    focusSection?: string | null;
+}
+export default function Server({ host, protocol, description, tags, variables, security, bindings, serverKey, focusSection, }: ServerProps): import("react").JSX.Element;
+export {};

package/dist/containers/Server/Servers.d.ts

@@ -1,6 +1,10 @@
 import { Server as ServerInterface } from '../../types/asyncapi/Server';
-interface ServersInterface {
-    [key: string]: Record<string, ServerInterface>;
+interface ServersProps {
+    servers: Record<string, ServerInterface>;
+    selectedServer?: string | null;
+    onSelectServer?: (serverName: string) => void;
+    /** Which collapsed section of the selected server search navigated to. */
+    focusSection?: string | null;
 }
-export default function Servers({ servers }: ServersInterface): import("react").JSX.Element;
+export default function Servers({ servers, selectedServer, onSelectServer, focusSection }: ServersProps): import("react").JSX.Element;
 export {};

package/dist/contexts/useSpec.d.ts

@@ -10,6 +10,8 @@ interface AsyncAPIContextValue {
     defaultSchemaExpanded?: boolean;
     /** Resolved schema tree depth-line colors (config-provided or default), cycled by nesting depth. */
     depthColors: string[];
+    /** Whether to render known x-* spec extensions (see the `x-tensions` catalog). Defaults to true. */
+    showExtensions: boolean;
 }
 export declare const AsyncAPIDocumentContext: import('react').Context<AsyncAPIContextValue | null>;
 export declare const useAsyncAPIDocument: () => AsyncAPIContextValue;

package/dist/helpers/protobuf/lazyProtoToJsonSchema.d.ts

@@ -0,0 +1,14 @@
+import { protoToJsonSchema as ProtoToJsonSchemaFn } from './protoToJsonSchema';
+/** Returns the converter if already loaded; otherwise kicks off the
+ * (idempotent) background import and returns null. Pair with
+ * useProtobufConverterReady() so callers re-resolve once it's ready. */
+export declare function getProtoToJsonSchema(): typeof ProtoToJsonSchemaFn | null;
+/** Resolves once the converter has finished loading (kicking off the load
+ * if needed) — for tests and other non-React callers that need to wait
+ * rather than subscribe via useProtobufConverterReady(). */
+export declare function waitForProtobufConverter(): Promise<void>;
+/** True once the Protobuf converter has finished loading. Include in a
+ * useMemo's dependencies wherever resolveSchemaInput might return a pending
+ * Protobuf conversion, so it re-resolves (synchronously, from then on) the
+ * moment loading completes. */
+export declare function useProtobufConverterReady(): boolean;

package/dist/helpers/schemaFormat.d.ts

@@ -17,6 +17,9 @@ export interface ResolvedSchemaInput {
      * back to one carried on the multi-format wrapper (not spec-defined there,
      * but tolerated — the parser passes it through untouched). */
     description?: string;
+    /** True while a Protobuf schema's converter is still being lazy-loaded —
+     * `schema` is a placeholder until then. See lazyProtoToJsonSchema.ts. */
+    pendingConversion?: boolean;
 }
 export declare function isAvroSchemaFormat(format: unknown): boolean;
 export declare function isProtobufSchemaFormat(format: unknown): boolean;

package/dist/helpers/searchIndex.d.ts

@@ -0,0 +1,18 @@
+import { AsyncAPIDocumentData } from '../types/schema';
+export type SearchTab = "operations" | "messages" | "schemas" | "info" | "servers";
+export type SearchType = "operation" | "message" | "schema" | "info" | "server";
+export interface SearchEntry {
+    id: string;
+    targetId: string;
+    type: SearchType;
+    tab: SearchTab;
+    key: string;
+    name: string;
+    path: string;
+    location: string;
+    subtitle?: string;
+    text: string;
+    focusSection?: string;
+    schemaFocusTokens?: string[];
+}
+export declare function buildSearchIndex(asyncapi: AsyncAPIDocumentData): SearchEntry[];

package/dist/helpers/textHighlight.d.ts

@@ -0,0 +1,2 @@
+export declare function highlightSearchMatch(root: Element, query: string): void;
+export declare function clearSearchHighlight(): void;

package/dist/hooks/useSpecSearch.d.ts

@@ -0,0 +1,13 @@
+import { AsyncAPIDocumentData } from '../types/schema';
+export interface UseSpecSearchOptions {
+    threshold?: number;
+    limit?: number;
+    /** Delay before a query change triggers a search, in ms. Defaults to 150. */
+    debounceMs?: number;
+}
+export declare function useSpecSearch(asyncapi: AsyncAPIDocumentData, options?: UseSpecSearchOptions): {
+    query: string;
+    setQuery: import('react').Dispatch<import('react').SetStateAction<string>>;
+    results: import('../helpers/searchIndex').SearchEntry[];
+    searchIndex: import('../helpers/searchIndex').SearchEntry[];
+};

package/dist/icons/Search.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const SearchIcon: React.FC<React.SVGProps<SVGSVGElement>>;
+export default SearchIcon;

package/dist/icons/Server.d.ts

@@ -1,4 +1,5 @@
-import { IconWrapperProps } from './IconWrapper';
-type IconServerProps = IconWrapperProps;
-export default function IconServer(props: IconServerProps): import("react").JSX.Element;
+interface IconServerProps {
+    className?: string;
+}
+export default function IconServer({ className }: IconServerProps): import("react").JSX.Element;
 export {};