zudoku 0.0.0-f01b653 → 0.0.0-f0602bf

package/dist/lib/plugins/openapi/graphql/graphql.d.ts

@@ -52,6 +52,15 @@ export type Scalars = {
         input: any;
         output: any;
     };
+    /** OpenAPI schema scalar type that handles circular references */
+    JSONSchema: {
+        input: any;
+        output: any;
+    };
+};
+export type Components = {
+    __typename?: "Components";
+    schemas?: Maybe<Array<SchemaItem>>;
 };
 export type EncodingItem = {
     __typename?: "EncodingItem";
@@ -75,13 +84,14 @@ export type MediaTypeObject = {
     encoding?: Maybe<Array<EncodingItem>>;
     examples?: Maybe<Array<ExampleItem>>;
     mediaType: Scalars["String"]["output"];
-    schema?: Maybe<Scalars["JSON"]["output"]>;
+    schema?: Maybe<Scalars["JSONSchema"]["output"]>;
 };
 export type OperationItem = {
     __typename?: "OperationItem";
     contentTypes: Array<Scalars["String"]["output"]>;
     deprecated?: Maybe<Scalars["Boolean"]["output"]>;
     description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
     method: Scalars["String"]["output"];
     operationId?: Maybe<Scalars["String"]["output"]>;
     parameters?: Maybe<Array<ParameterItem>>;
@@ -101,10 +111,11 @@ export type ParameterItem = {
     description?: Maybe<Scalars["String"]["output"]>;
     examples?: Maybe<Array<ExampleItem>>;
     explode?: Maybe<Scalars["Boolean"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
     in: ParameterIn;
     name: Scalars["String"]["output"];
     required?: Maybe<Scalars["Boolean"]["output"]>;
-    schema?: Maybe<Scalars["JSON"]["output"]>;
+    schema?: Maybe<Scalars["JSONSchema"]["output"]>;
     style?: Maybe<Scalars["String"]["output"]>;
 };
 export type PathItem = {
@@ -130,37 +141,55 @@ export type ResponseItem = {
     __typename?: "ResponseItem";
     content?: Maybe<Array<MediaTypeObject>>;
     description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
     headers?: Maybe<Scalars["JSON"]["output"]>;
     links?: Maybe<Scalars["JSON"]["output"]>;
     statusCode: Scalars["String"]["output"];
 };
 export type Schema = {
     __typename?: "Schema";
+    components?: Maybe<Components>;
     description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
     openapi: Scalars["String"]["output"];
     operations: Array<OperationItem>;
     paths: Array<PathItem>;
     servers: Array<Server>;
+    summary?: Maybe<Scalars["String"]["output"]>;
+    tag?: Maybe<SchemaTag>;
     tags: Array<SchemaTag>;
     title: Scalars["String"]["output"];
-    url: Scalars["String"]["output"];
+    url?: Maybe<Scalars["String"]["output"]>;
     version: Scalars["String"]["output"];
-    summary?: Maybe<Scalars["String"]["output"]>;
 };
 export type SchemaOperationsArgs = {
     method?: InputMaybe<Scalars["String"]["input"]>;
     operationId?: InputMaybe<Scalars["String"]["input"]>;
     path?: InputMaybe<Scalars["String"]["input"]>;
     tag?: InputMaybe<Scalars["String"]["input"]>;
+    untagged?: InputMaybe<Scalars["Boolean"]["input"]>;
 };
-export type SchemaTagsArgs = {
+export type SchemaTagArgs = {
     name?: InputMaybe<Scalars["String"]["input"]>;
+    slug?: InputMaybe<Scalars["String"]["input"]>;
+    untagged?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+export type SchemaItem = {
+    __typename?: "SchemaItem";
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
+    name: Scalars["String"]["output"];
+    schema: Scalars["JSONSchema"]["output"];
 };
 export type SchemaTag = {
     __typename?: "SchemaTag";
     description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
+    isUntagged: Scalars["Boolean"]["output"];
     name?: Maybe<Scalars["String"]["output"]>;
+    next?: Maybe<SchemaTag>;
     operations: Array<OperationItem>;
+    prev?: Maybe<SchemaTag>;
+    slug?: Maybe<Scalars["String"]["output"]>;
 };
 export type SchemaType = "file" | "raw" | "url";
 export type Server = {
@@ -171,6 +200,7 @@ export type Server = {
 export type TagItem = {
     __typename?: "TagItem";
     description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
     name: Scalars["String"]["output"];
 };
 export type ServersQueryQueryVariables = Exact<{
@@ -181,7 +211,7 @@ export type ServersQueryQuery = {
     __typename?: "Query";
     schema: {
         __typename?: "Schema";
-        url: string;
+        url?: string | null;
         servers: Array<{
             __typename?: "Server";
             url: string;
@@ -197,6 +227,8 @@ export type OperationsFragmentFragment = {
     operationId?: string | null;
     contentTypes: Array<string>;
     path: string;
+    deprecated?: boolean | null;
+    extensions?: any | null;
     parameters?: Array<{
         __typename?: "ParameterItem";
         name: string;
@@ -205,6 +237,7 @@ export type OperationsFragmentFragment = {
         required?: boolean | null;
         schema?: any | null;
         style?: string | null;
+        explode?: boolean | null;
         examples?: Array<{
             __typename?: "ExampleItem";
             name: string;
@@ -262,20 +295,37 @@ export type OperationsFragmentFragment = {
 } & {
     " $fragmentName"?: "OperationsFragmentFragment";
 };
-export type AllOperationsQueryVariables = Exact<{
+export type SchemaWarmupQueryVariables = Exact<{
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+}>;
+export type SchemaWarmupQuery = {
+    __typename?: "Query";
+    schema: {
+        __typename?: "Schema";
+        openapi: string;
+    };
+};
+export type OperationsForTagQueryVariables = Exact<{
     input: Scalars["JSON"]["input"];
     type: SchemaType;
+    tag?: InputMaybe<Scalars["String"]["input"]>;
+    untagged?: InputMaybe<Scalars["Boolean"]["input"]>;
 }>;
-export type AllOperationsQuery = {
+export type OperationsForTagQuery = {
     __typename?: "Query";
     schema: {
         __typename?: "Schema";
         description?: string | null;
         summary?: string | null;
         title: string;
-        url: string;
+        url?: string | null;
         version: string;
-        tags: Array<{
+        servers: Array<{
+            __typename?: "Server";
+            url: string;
+        }>;
+        tag?: {
             __typename?: "SchemaTag";
             name?: string | null;
             description?: string | null;
@@ -287,7 +337,39 @@ export type AllOperationsQuery = {
                     OperationsFragmentFragment: OperationsFragmentFragment;
                 };
             }>;
-        }>;
+            next?: {
+                __typename?: "SchemaTag";
+                name?: string | null;
+                slug?: string | null;
+            } | null;
+            prev?: {
+                __typename?: "SchemaTag";
+                name?: string | null;
+                slug?: string | null;
+            } | null;
+        } | null;
+    };
+};
+export type GetSchemasQueryVariables = Exact<{
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+}>;
+export type GetSchemasQuery = {
+    __typename?: "Query";
+    schema: {
+        __typename?: "Schema";
+        title: string;
+        description?: string | null;
+        summary?: string | null;
+        components?: {
+            __typename?: "Components";
+            schemas?: Array<{
+                __typename?: "SchemaItem";
+                name: string;
+                schema: any;
+                extensions?: any | null;
+            }> | null;
+        } | null;
     };
 };
 export type GetServerQueryQueryVariables = Exact<{
@@ -298,46 +380,54 @@ export type GetServerQueryQuery = {
     __typename?: "Query";
     schema: {
         __typename?: "Schema";
-        url: string;
+        url?: string | null;
         servers: Array<{
             __typename?: "Server";
             url: string;
         }>;
     };
 };
-export type GetCategoriesQueryVariables = Exact<{
+export type GetSidebarOperationsQueryVariables = Exact<{
     input: Scalars["JSON"]["input"];
     type: SchemaType;
 }>;
-export type GetCategoriesQuery = {
+export type GetSidebarOperationsQuery = {
     __typename?: "Query";
     schema: {
         __typename?: "Schema";
-        url: string;
         tags: Array<{
-            __typename: "SchemaTag";
+            __typename?: "SchemaTag";
+            slug?: string | null;
             name?: string | null;
+            extensions?: any | null;
             operations: Array<{
-                __typename: "OperationItem";
+                __typename?: "OperationItem";
+                summary?: string | null;
                 slug: string;
-                deprecated?: boolean | null;
                 method: string;
-                summary?: string | null;
                 operationId?: string | null;
                 path: string;
             }>;
         }>;
+        components?: {
+            __typename?: "Components";
+            schemas?: Array<{
+                __typename: "SchemaItem";
+            }> | null;
+        } | null;
     };
 };
 export declare class TypedDocumentString<TResult, TVariables> extends String implements DocumentTypeDecoration<TResult, TVariables> {
+    __apiType?: DocumentTypeDecoration<TResult, TVariables>["__apiType"];
     private value;
     __meta__?: Record<string, any> | undefined;
-    __apiType?: DocumentTypeDecoration<TResult, TVariables>["__apiType"];
     constructor(value: string, __meta__?: Record<string, any> | undefined);
     toString(): string & DocumentTypeDecoration<TResult, TVariables>;
 }
 export declare const OperationsFragmentFragmentDoc: TypedDocumentString<OperationsFragmentFragment, unknown>;
 export declare const ServersQueryDocument: TypedDocumentString<ServersQueryQuery, ServersQueryQueryVariables>;
-export declare const AllOperationsDocument: TypedDocumentString<AllOperationsQuery, AllOperationsQueryVariables>;
+export declare const SchemaWarmupDocument: TypedDocumentString<SchemaWarmupQuery, SchemaWarmupQueryVariables>;
+export declare const OperationsForTagDocument: TypedDocumentString<OperationsForTagQuery, OperationsForTagQueryVariables>;
+export declare const GetSchemasDocument: TypedDocumentString<GetSchemasQuery, GetSchemasQueryVariables>;
 export declare const GetServerQueryDocument: TypedDocumentString<GetServerQueryQuery, GetServerQueryQueryVariables>;
-export declare const GetCategoriesDocument: TypedDocumentString<GetCategoriesQuery, GetCategoriesQueryVariables>;
+export declare const GetSidebarOperationsDocument: TypedDocumentString<GetSidebarOperationsQuery, GetSidebarOperationsQueryVariables>;

package/dist/lib/plugins/openapi/graphql/graphql.js

@@ -1,7 +1,7 @@
 export class TypedDocumentString extends String {
+    __apiType;
     value;
     __meta__;
-    __apiType;
     constructor(value, __meta__) {
         super(value);
         this.value = value;
@@ -20,6 +20,8 @@ export const OperationsFragmentFragmentDoc = new TypedDocumentString(`
   operationId
   contentTypes
   path
+  deprecated
+  extensions
   parameters {
     name
     in
@@ -27,6 +29,7 @@ export const OperationsFragmentFragmentDoc = new TypedDocumentString(`
     required
     schema
     style
+    explode
     examples {
       name
       description
@@ -84,21 +87,39 @@ export const ServersQueryDocument = new TypedDocumentString(`
   }
 }
     `);
-export const AllOperationsDocument = new TypedDocumentString(`
-    query AllOperations($input: JSON!, $type: SchemaType!) {
+export const SchemaWarmupDocument = new TypedDocumentString(`
+    query SchemaWarmup($input: JSON!, $type: SchemaType!) {
   schema(input: $input, type: $type) {
+    openapi
+  }
+}
+    `);
+export const OperationsForTagDocument = new TypedDocumentString(`
+    query OperationsForTag($input: JSON!, $type: SchemaType!, $tag: String, $untagged: Boolean) {
+  schema(input: $input, type: $type) {
+    servers {
+      url
+    }
     description
     summary
     title
     url
     version
-    tags {
+    tag(slug: $tag, untagged: $untagged) {
       name
       description
       operations {
         slug
         ...OperationsFragment
       }
+      next {
+        name
+        slug
+      }
+      prev {
+        name
+        slug
+      }
     }
   }
 }
@@ -110,6 +131,8 @@ export const AllOperationsDocument = new TypedDocumentString(`
   operationId
   contentTypes
   path
+  deprecated
+  extensions
   parameters {
     name
     in
@@ -117,6 +140,7 @@ export const AllOperationsDocument = new TypedDocumentString(`
     required
     schema
     style
+    explode
     examples {
       name
       description
@@ -163,6 +187,22 @@ export const AllOperationsDocument = new TypedDocumentString(`
     }
   }
 }`);
+export const GetSchemasDocument = new TypedDocumentString(`
+    query GetSchemas($input: JSON!, $type: SchemaType!) {
+  schema(input: $input, type: $type) {
+    title
+    description
+    summary
+    components {
+      schemas {
+        name
+        schema
+        extensions
+      }
+    }
+  }
+}
+    `);
 export const GetServerQueryDocument = new TypedDocumentString(`
     query getServerQuery($input: JSON!, $type: SchemaType!) {
   schema(input: $input, type: $type) {
@@ -173,23 +213,26 @@ export const GetServerQueryDocument = new TypedDocumentString(`
   }
 }
     `);
-export const GetCategoriesDocument = new TypedDocumentString(`
-    query GetCategories($input: JSON!, $type: SchemaType!) {
+export const GetSidebarOperationsDocument = new TypedDocumentString(`
+    query GetSidebarOperations($input: JSON!, $type: SchemaType!) {
   schema(input: $input, type: $type) {
-    url
     tags {
-      __typename
+      slug
       name
+      extensions
       operations {
-        __typename
+        summary
         slug
-        deprecated
         method
-        summary
         operationId
         path
       }
     }
+    components {
+      schemas {
+        __typename
+      }
+    }
   }
 }
     `);

package/dist/lib/plugins/openapi/graphql/graphql.js.map

@@ -1 +1 @@
-{"version":3,"file":"graphql.js","sourceRoot":"","sources":["../../../../../src/lib/plugins/openapi/graphql/graphql.ts"],"names":[],"mappings":"AAmUA,MAAM,OAAO,mBACX,SAAQ,MAAM;IAMJ;IACD;IAJT,SAAS,CAA4D;IAErE,YACU,KAAa,EACd,QAA0C;QAEjD,KAAK,CAAC,KAAK,CAAC,CAAC;QAHL,UAAK,GAAL,KAAK,CAAQ;QACd,aAAQ,GAAR,QAAQ,CAAkC;IAGnD,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;CACF;AACD,MAAM,CAAC,MAAM,6BAA6B,GAAG,IAAI,mBAAmB,CAClE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8DG,EACH,EAAE,YAAY,EAAE,oBAAoB,EAAE,CACgC,CAAC;AACzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,mBAAmB,CAAC;;;;;;;;;KASvD,CAGJ,CAAC;AACF,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8E3D,CAGD,CAAC;AACF,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,mBAAmB,CAAC;;;;;;;;;KASzD,CAGJ,CAAC;AACF,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;KAmBxD,CAGJ,CAAC"}
+{"version":3,"file":"graphql.js","sourceRoot":"","sources":["../../../../../src/lib/plugins/openapi/graphql/graphql.ts"],"names":[],"mappings":"AAsZA,MAAM,OAAO,mBACX,SAAQ,MAAM;IAGd,SAAS,CAA4D;IAC7D,KAAK,CAAS;IACf,QAAQ,CAAmC;IAElD,YAAY,KAAa,EAAE,QAA0C;QACnE,KAAK,CAAC,KAAK,CAAC,CAAC;QACb,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;CACF;AACD,MAAM,CAAC,MAAM,6BAA6B,GAAG,IAAI,mBAAmB,CAClE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiEG,EACH,EAAE,YAAY,EAAE,oBAAoB,EAAE,CACgC,CAAC;AACzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,mBAAmB,CAAC;;;;;;;;;KASvD,CAGJ,CAAC;AACF,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,mBAAmB,CAAC;;;;;;KAMvD,CAGJ,CAAC;AACF,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4F9D,CAGD,CAAC;AACF,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,mBAAmB,CAAC;;;;;;;;;;;;;;;KAerD,CAGJ,CAAC;AACF,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,mBAAmB,CAAC;;;;;;;;;KASzD,CAGJ,CAAC;AACF,MAAM,CAAC,MAAM,4BAA4B,GAAG,IAAI,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;;;;KAsB/D,CAGJ,CAAC"}

package/dist/lib/plugins/openapi/index.d.ts

@@ -1,8 +1,11 @@
 import { type ZudokuPlugin } from "../../core/plugins.js";
-import { OasPluginConfig } from "./interfaces.js";
-type InternalOasPluginConfig = {
-    inMemory?: boolean;
-};
-export type OpenApiPluginOptions = OasPluginConfig & InternalOasPluginConfig;
-export declare const openApiPlugin: (config: OpenApiPluginOptions) => ZudokuPlugin;
-export {};
+import type { GetSidebarOperationsQuery as GetSidebarOperationsQueryResult } from "./graphql/graphql.js";
+import { type OasPluginConfig } from "./interfaces.js";
+export declare const GetSidebarOperationsQuery: import("./graphql/graphql.js").TypedDocumentString<GetSidebarOperationsQueryResult, import("./graphql/graphql.js").Exact<{
+    input: import("./graphql/graphql.js").Scalars["JSON"]["input"];
+    type: import("./graphql/graphql.js").SchemaType;
+}>>;
+export type OperationResult = GetSidebarOperationsQueryResult["schema"]["tags"][number]["operations"][number];
+export type OpenApiPluginOptions = OasPluginConfig;
+export declare const UNTAGGED_PATH = "~endpoints";
+export declare const openApiPlugin: (config: OasPluginConfig) => ZudokuPlugin;

package/dist/lib/plugins/openapi/index.js

@@ -1,44 +1,41 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { matchPath } from "react-router";
-import { graphql } from "./graphql/index.js";
-import { useQuery } from "@tanstack/react-query";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { CirclePlayIcon, LogInIcon } from "lucide-react";
+import { matchPath } from "react-router";
 import { useAuth } from "../../authentication/hook.js";
 import { Button } from "../../ui/Button.js";
-import { joinPath } from "../../util/joinPath.js";
+import { joinUrl } from "../../util/joinUrl.js";
 import { GraphQLClient } from "./client/GraphQLClient.js";
+import { createQuery } from "./client/useCreateQuery.js";
+import { graphql } from "./graphql/index.js";
 import { PlaygroundDialog } from "./playground/PlaygroundDialog.js";
-const GetCategoriesQuery = graphql(`
-  query GetCategories($input: JSON!, $type: SchemaType!) {
+import { createSidebarCategory } from "./util/createSidebarCategory.js";
+import { getRoutes, getVersions } from "./util/getRoutes.js";
+export const GetSidebarOperationsQuery = graphql(`
+  query GetSidebarOperations($input: JSON!, $type: SchemaType!) {
     schema(input: $input, type: $type) {
-      url
       tags {
-        __typename
+        slug
         name
+        extensions
         operations {
-          __typename
+          summary
           slug
-          deprecated
           method
-          summary
           operationId
           path
         }
       }
+      components {
+        schemas {
+          __typename
+        }
+      }
     }
   }
 `);
-const MethodColorMap = {
-    get: "green",
-    post: "blue",
-    put: "yellow",
-    delete: "red",
-    patch: "purple",
-    options: "gray",
-    head: "gray",
-};
+export const UNTAGGED_PATH = "~endpoints";
 export const openApiPlugin = (config) => {
-    const basePath = joinPath(config.navigationId ?? "/reference");
+    const basePath = joinUrl(config.navigationId ?? "/reference");
     const client = new GraphQLClient(config);
     return {
         getHead: () => {
@@ -50,84 +47,70 @@ export const openApiPlugin = (config) => {
             }
         },
         getMdxComponents: () => ({
-            OpenPlaygroundButton: ({ requireAuth, server, method, url, ...props }) => {
+            OpenPlaygroundButton: ({ requireAuth, server, method, url, children, ...props }) => {
                 const auth = useAuth();
-                // We don't have the GraphQL context here
-                const serverQuery = useQuery({
-                    queryFn: () => client.fetch(GetCategoriesQuery, {
-                        type: config.type,
-                        input: config.input,
-                    }),
-                    enabled: !server,
-                    queryKey: ["playground-server"],
-                });
+                if (!server) {
+                    throw new Error("Server is required");
+                }
                 if (requireAuth && !auth.isAuthenticated) {
                     return (_jsxs(Button, { className: "gap-2 items-center", variant: "outline", onClick: auth.login, children: ["Login to open in Playground ", _jsx(LogInIcon, { size: 16 })] }));
                 }
-                return (_jsx(PlaygroundDialog, { url: url ?? "/", method: method ?? "get", server: server ?? serverQuery.data?.schema.url ?? "https://example.com", ...props, children: _jsxs(Button, { className: "gap-2 items-center", variant: "outline", children: ["Open in Playground ", _jsx(CirclePlayIcon, { size: 16 })] }) }));
+                return (_jsx(PlaygroundDialog, { url: url ?? "/", method: method ?? "get", server: server, ...props, children: _jsx(Button, { className: "gap-2 items-center", variant: "outline", children: children ?? (_jsxs(_Fragment, { children: ["Open in Playground ", _jsx(CirclePlayIcon, { size: 16 })] })) }) }));
             },
         }),
-        getSidebar: async (path) => {
+        getSidebar: async (path, context) => {
             if (!matchPath({ path: basePath, end: false }, path)) {
                 return [];
             }
+            const match = matchPath({ path: `${basePath}/:version?/:tag`, end: true }, path);
             try {
-                const data = await client.fetch(GetCategoriesQuery, {
-                    type: config.type,
-                    input: config.input,
+                const versionParam = match?.params.version;
+                const version = versionParam ?? getVersions(config).at(0);
+                const { type } = config;
+                const input = type === "file" ? config.input[version] : config.input;
+                const query = createQuery(client, GetSidebarOperationsQuery, {
+                    type,
+                    input,
                 });
-                const categories = data.schema.tags
-                    .filter((tag) => tag.operations.length > 0)
-                    .map((tag) => ({
-                    type: "category",
-                    label: tag.name || "Other endpoints",
-                    collapsible: true,
-                    collapsed: false,
-                    items: tag.operations.map((operation) => ({
-                        type: "link",
-                        label: operation.summary ?? operation.path,
-                        href: `#${operation.slug}`,
-                        badge: {
-                            label: operation.method,
-                            color: MethodColorMap[operation.method.toLowerCase()],
-                        },
-                    })),
-                }));
-                categories.unshift({
-                    type: "link",
-                    label: "Overview",
-                    href: "#description",
+                const data = await context.queryClient.ensureQueryData(query);
+                const categories = data.schema.tags.flatMap((tag) => {
+                    if (!tag.name || tag.operations.length === 0)
+                        return [];
+                    const categoryPath = joinUrl(basePath, versionParam, tag.slug);
+                    const isCollapsed = tag.extensions?.["x-zudoku-collapsed"] ??
+                        !config.options?.expandAllTags;
+                    const isCollapsible = tag.extensions?.["x-zudoku-collapsible"] ?? true;
+                    return createSidebarCategory({
+                        label: tag.name,
+                        path: categoryPath,
+                        operations: tag.operations,
+                        collapsed: isCollapsed,
+                        collapsible: isCollapsible,
+                    });
                 });
+                const untaggedOperations = data.schema.tags.find((tag) => !tag.name)?.operations;
+                if (untaggedOperations) {
+                    categories.push(createSidebarCategory({
+                        label: "Other endpoints",
+                        path: joinUrl(basePath, versionParam, UNTAGGED_PATH),
+                        operations: untaggedOperations,
+                        collapsed: !config.options?.expandAllTags,
+                    }));
+                }
+                if (data.schema.components?.schemas?.length) {
+                    categories.push({
+                        type: "link",
+                        label: "Schemas",
+                        href: joinUrl(basePath, versionParam, "~schemas"),
+                    });
+                }
                 return categories;
             }
             catch {
                 return [];
             }
         },
-        getRoutes: () => [
-            {
-                async lazy() {
-                    const { OpenApiRoute } = await import("./Route.js");
-                    return {
-                        element: _jsx(OpenApiRoute, { client: client, config: config }),
-                    };
-                },
-                children: [
-                    {
-                        path: basePath,
-                        children: [
-                            {
-                                index: true,
-                                async lazy() {
-                                    const { OperationList } = await import("./OperationList.js");
-                                    return { element: _jsx(OperationList, {}) };
-                                },
-                            },
-                        ],
-                    },
-                ],
-            },
-        ],
+        getRoutes: () => getRoutes({ basePath, config, client }),
     };
 };
 //# sourceMappingURL=index.js.map