@graphql-markdown/nuxt-theme 0.0.0-stage → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (35) hide show
  1. package/README.md +196 -2
  2. package/app/app-config.d.ts +15 -0
  3. package/app/app.config.ts +22 -0
  4. package/app/assets/css/main.css +85 -0
  5. package/app/components/ApiCodeColumn.vue +53 -0
  6. package/app/components/ApiDocumentContent.vue +45 -0
  7. package/app/components/ApiNamespaceLanding.vue +29 -0
  8. package/app/components/ApiOverviewGrid.vue +38 -0
  9. package/app/components/ApiSinglePageEntry.vue +75 -0
  10. package/app/components/ApiSinglePageSection.vue +32 -0
  11. package/app/components/SchemaCodeCard.vue +68 -0
  12. package/app/components/SiteFooter.vue +13 -0
  13. package/app/components/SiteHeader.vue +31 -0
  14. package/app/composables/useApiCodeCards.ts +96 -0
  15. package/app/composables/useApiDocument.ts +69 -0
  16. package/app/composables/useApiNavigation.ts +212 -0
  17. package/app/composables/useApiReferencePage.ts +164 -0
  18. package/app/composables/useApiSinglePage.ts +320 -0
  19. package/app/composables/useClipboardCopy.ts +56 -0
  20. package/app/composables/useHierarchyMode.ts +48 -0
  21. package/app/layouts/reference.vue +128 -0
  22. package/app/pages/api-reference/[...slug].vue +233 -0
  23. package/app/utils/api-document.ts +329 -0
  24. package/app/utils/mdc.ts +60 -0
  25. package/app/utils/navigation-tree.ts +28 -0
  26. package/bin/swizzle.mjs +256 -0
  27. package/content.config.ts +13 -0
  28. package/formatter.ts +77 -0
  29. package/generate.ts +91 -0
  30. package/modules/generate.ts +72 -0
  31. package/modules/prerender.ts +104 -0
  32. package/nuxt.config.ts +16 -0
  33. package/package.json +81 -4
  34. package/swizzle.manifest.mjs +84 -0
  35. package/swizzle.manifest.ts +11 -0
@@ -0,0 +1,13 @@
1
+ <template>
2
+ <UFooter
3
+ :ui="{ root: 'border-t border-default bg-muted', container: 'py-6' }"
4
+ >
5
+ <ULink
6
+ to="https://graphql-markdown.dev/"
7
+ target="_blank"
8
+ class="text-sm text-dimmed transition hover:text-primary"
9
+ >
10
+ Built with GraphQL-Markdown
11
+ </ULink>
12
+ </UFooter>
13
+ </template>
@@ -0,0 +1,31 @@
1
+ <template>
2
+ <UHeader
3
+ to="/"
4
+ :toggle="false"
5
+ :ui="{ root: 'bg-muted', container: containerClass }"
6
+ >
7
+ <template #left>
8
+ <slot name="leading" />
9
+
10
+ <ULink to="/" class="text-2xl font-bold tracking-normal text-highlighted">
11
+ {{ config.gqlmd.siteTitle }}
12
+ </ULink>
13
+ </template>
14
+
15
+ <template #right>
16
+ <slot name="right" />
17
+
18
+ <UColorModeButton variant="outline" />
19
+ </template>
20
+ </UHeader>
21
+ </template>
22
+
23
+ <script setup lang="ts">
24
+ // The reference layout is full-bleed so the header lines up with the fixed
25
+ // sidebar; the landing page centres its content and passes its own width.
26
+ withDefaults(defineProps<{ containerClass?: string }>(), {
27
+ containerClass: "max-w-none px-4 md:px-8",
28
+ });
29
+
30
+ const config = useAppConfig();
31
+ </script>
@@ -0,0 +1,96 @@
1
+ import { codeToHtml } from "shiki";
2
+ import type { Ref } from "vue";
3
+ import {
4
+ CODE_COLUMN_SECTIONS,
5
+ definitionCode,
6
+ sectionCode,
7
+ } from "~/utils/api-document";
8
+ import type { MdcNode } from "~/utils/mdc";
9
+
10
+ /**
11
+ * Object and input examples are JSON payloads, operation examples and every
12
+ * definition are GraphQL. Highlighting JSON with the GraphQL grammar drops
13
+ * every key and string into the theme's comment colour, which is barely
14
+ * legible on the dark card. Exported for `useApiSinglePage`, which highlights
15
+ * the same kind of snippets across every generated page in one pass.
16
+ */
17
+ export const detectLanguage = (code: string): "graphql" | "json" => {
18
+ try {
19
+ JSON.parse(code);
20
+ return "json";
21
+ } catch {
22
+ return "graphql";
23
+ }
24
+ };
25
+
26
+ /**
27
+ * Highlights the code column's cards, dropping any the page carries no snippet
28
+ * for: the landing page has no definition, and most types define no example.
29
+ */
30
+ const toCards = async (
31
+ cards: { label: string; kind: string; code?: string }[],
32
+ shikiTheme: string,
33
+ ): Promise<{ label: string; kind: string; code: string; html: string }[]> => {
34
+ return Promise.all(
35
+ cards
36
+ .filter((card): card is typeof card & { code: string } => {
37
+ return Boolean(card.code);
38
+ })
39
+ .map(async (card) => {
40
+ return {
41
+ ...card,
42
+ html: await codeToHtml(card.code, {
43
+ lang: detectLanguage(card.code),
44
+ theme: shikiTheme,
45
+ }),
46
+ };
47
+ }),
48
+ );
49
+ };
50
+
51
+ /**
52
+ * Builds the code column's highlighted cards: the page's own definition (if
53
+ * any) plus any `CODE_COLUMN_SECTIONS` examples the schema defines. Called
54
+ * once with a top-level `await`, not reactively — matches the page's own
55
+ * one-shot data-fetch pattern, since Shiki highlighting isn't cheap enough to
56
+ * redo on every keystroke-level reactivity change.
57
+ */
58
+ export const useApiCodeCards = async (
59
+ documentBody: Ref<MdcNode[]>,
60
+ schemaKind: Ref<string>,
61
+ isOperation: Ref<boolean>,
62
+ shikiTheme: string,
63
+ ): Promise<{
64
+ definitionCard:
65
+ | { label: string; kind: string; code: string; html: string }
66
+ | undefined;
67
+ exampleCards: { label: string; kind: string; code: string; html: string }[];
68
+ }> => {
69
+ const [definitionCard] = await toCards(
70
+ [
71
+ {
72
+ label: "SDL",
73
+ kind: schemaKind.value,
74
+ code: definitionCode(documentBody.value),
75
+ },
76
+ ],
77
+ shikiTheme,
78
+ );
79
+
80
+ const filteredSections = CODE_COLUMN_SECTIONS.filter((section) => {
81
+ return !section.operationOnly || isOperation.value;
82
+ });
83
+
84
+ const exampleCards = await toCards(
85
+ filteredSections.map(({ title, label, kind }) => {
86
+ return {
87
+ label: label ?? title,
88
+ kind: kind ?? schemaKind.value,
89
+ code: sectionCode(documentBody.value, title),
90
+ };
91
+ }),
92
+ shikiTheme,
93
+ );
94
+
95
+ return { definitionCard, exampleCards };
96
+ };
@@ -0,0 +1,69 @@
1
+ import type { Ref } from "vue";
2
+
3
+ /**
4
+ * Splits a queried content document's body into the always-visible lead
5
+ * (everything before the first `h3`) and the collapsible sections after each
6
+ * `h3` — the shape `[...slug].vue`'s template renders as a `ContentRenderer`
7
+ * lead plus one `UCollapsible` per section.
8
+ */
9
+ export const useApiDocument = (
10
+ page: Ref<Record<string, any> | null | undefined>,
11
+ ): {
12
+ documentBody: ComputedRef<MdcNode[]>;
13
+ deprecationReason: ComputedRef<ReturnType<typeof findDeprecationNotice>>;
14
+ document: ComputedRef<{
15
+ lead: Record<string, any> | undefined;
16
+ sections: { id: string; title: string; document: Record<string, any> }[];
17
+ }>;
18
+ } => {
19
+ const documentBody = computed<MdcNode[]>(() => {
20
+ return page.value?.body?.value ?? [];
21
+ });
22
+
23
+ const deprecationReason = computed(() => {
24
+ return findDeprecationNotice(page.value?.body);
25
+ });
26
+
27
+ /**
28
+ * The prose column: generated markup fixed up for Nuxt UI, minus everything
29
+ * already shown by the code column and the deprecation alert.
30
+ */
31
+ const documentNodes = computed(() => {
32
+ const inCodeColumn = codeColumnNodeIndexes(documentBody.value);
33
+
34
+ return withoutDeprecationNotice(
35
+ documentBody.value.filter((_, index) => {
36
+ return !inCodeColumn.has(index);
37
+ }),
38
+ deprecationReason.value,
39
+ ).map(toRenderableNode);
40
+ });
41
+
42
+ const asDocument = (nodes: MdcNode[]): Record<string, any> => {
43
+ return {
44
+ ...page.value,
45
+ body: { ...page.value?.body, value: nodes },
46
+ };
47
+ };
48
+
49
+ /**
50
+ * The document is split at its `h3` boundaries so each schema section
51
+ * ("Arguments", "Fields", …) can collapse behind its own heading. The nodes
52
+ * before the first heading are the type description and stay always visible.
53
+ */
54
+ const document = computed(() => {
55
+ const { lead, sections } = splitDocumentSections(documentNodes.value);
56
+
57
+ return {
58
+ lead: lead.length ? asDocument(lead) : undefined,
59
+ sections: sections.map(({ nodes, ...section }) => {
60
+ return {
61
+ ...section,
62
+ document: asDocument(nodes),
63
+ };
64
+ }),
65
+ };
66
+ });
67
+
68
+ return { documentBody, deprecationReason, document };
69
+ };
@@ -0,0 +1,212 @@
1
+ import { findDeprecationNotice, titleCase } from "~/utils/api-document";
2
+
3
+ export interface ApiNavigationLeaf {
4
+ title: string;
5
+ path: string;
6
+ isDeprecated: boolean;
7
+ ui?: Record<string, unknown>;
8
+ badge?: { label: string; color: "error"; variant: "subtle" };
9
+ }
10
+
11
+ export interface ApiNavigationBranch {
12
+ title: string;
13
+ children: ApiNavigationNode[];
14
+ }
15
+
16
+ export type ApiNavigationNode = ApiNavigationBranch | ApiNavigationLeaf;
17
+
18
+ interface RawPage {
19
+ path: string;
20
+ title: string;
21
+ isDeprecated: boolean;
22
+ /** The GraphQL entity kind (`objects`, `scalars`, `queries`, …) stamped by `formatter.ts`'s `formatMDXFrontmatter`. */
23
+ kind?: string;
24
+ }
25
+
26
+ /** True for a namespace/schema's own generated landing doc, never a real nav entry. */
27
+ const isLandingDoc = (path: string): boolean => {
28
+ return path.endsWith("/generated");
29
+ };
30
+
31
+ interface Branch {
32
+ children: Map<string, Branch>;
33
+ leaves: ApiNavigationLeaf[];
34
+ }
35
+
36
+ /**
37
+ * Groups `items` into a tree keyed by their path segments, skipping the
38
+ * leading `rootDepth` segments (the shared baseURL prefix, e.g.
39
+ * "api-reference" -\> 1 segment) and the item's own trailing slug segment
40
+ * (its leaf identity, not a category). Works for any remaining depth: 0
41
+ * extra segments (a page directly under the root) up to arbitrarily many
42
+ * (multi-schema namespaces stacked above section/group). This is the fix
43
+ * for the old hardcoded-exactly-2-levels behavior.
44
+ */
45
+ const buildTree = (
46
+ items: RawPage[],
47
+ rootDepth: number,
48
+ ): ApiNavigationNode[] => {
49
+ const root: Branch = { children: new Map(), leaves: [] };
50
+
51
+ for (const item of items) {
52
+ const segments = item.path.split("/").filter(Boolean);
53
+ const pathCategory = segments.slice(rootDepth, -1);
54
+ // Falls back to the page's `kind` frontmatter (see RawPage) when there
55
+ // are no folder segments left to group by — i.e. `hierarchy: "flat"`,
56
+ // which otherwise has nothing else to group the sidebar/landing grid on.
57
+ let categoryPath: string[] = pathCategory;
58
+ if (pathCategory.length === 0) {
59
+ categoryPath = item.kind ? [item.kind] : [];
60
+ }
61
+ let node = root;
62
+ for (const segment of categoryPath) {
63
+ let child = node.children.get(segment);
64
+ if (!child) {
65
+ child = { children: new Map(), leaves: [] };
66
+ node.children.set(segment, child);
67
+ }
68
+ node = child;
69
+ }
70
+ node.leaves.push({
71
+ title: item.title,
72
+ path: item.path,
73
+ isDeprecated: item.isDeprecated,
74
+ ui: { linkTitle: "font-mono text-[small]" },
75
+ badge: item.isDeprecated
76
+ ? {
77
+ label: "deprecated",
78
+ color: "error" as const,
79
+ variant: "subtle" as const,
80
+ }
81
+ : undefined,
82
+ });
83
+ }
84
+
85
+ const byTitle = <T extends { title: string }>(a: T, b: T): number => {
86
+ return a.title.localeCompare(b.title);
87
+ };
88
+
89
+ const toNodes = (branch: Branch): ApiNavigationNode[] => {
90
+ return [
91
+ ...[...branch.children.entries()]
92
+ .map(([name, child]) => {
93
+ return {
94
+ title: titleCase(name),
95
+ children: toNodes(child),
96
+ };
97
+ })
98
+ .sort(byTitle),
99
+ ...[...branch.leaves].sort(byTitle),
100
+ ];
101
+ };
102
+
103
+ return toNodes(root);
104
+ };
105
+
106
+ /**
107
+ * The navigation tree, derived from the content paths themselves and however
108
+ * many path segments each page actually has after the shared `baseURL`
109
+ * prefix (`app.config.ts`'s `gqlmd.baseURL`) — no assumption about exact
110
+ * depth, so it serves both the default single-schema case (section/group
111
+ * levels) and multi-schema setups (an extra namespace level above
112
+ * section/group) with the same code.
113
+ *
114
+ * The shape is the one `UContentNavigation` and `UContentSearch` both
115
+ * expect — nodes with a `title` and either `children` or a `path` — so the
116
+ * sidebar and the search palette read the same tree.
117
+ */
118
+ export const useApiNavigation = async (): Promise<{
119
+ sections: ComputedRef<ApiNavigationNode[]>;
120
+ overviewGroupsFor: (landingPath: string) => (ApiNavigationNode & {
121
+ sectionTitle: string;
122
+ })[];
123
+ }> => {
124
+ // Read app config BEFORE the first `await` below. Nuxt's async-instance
125
+ // context (how `useAppConfig`/`useAsyncData`/etc. find "the current app"
126
+ // at all) only survives automatically across `<script setup>`'s own
127
+ // compiler-injected `await`s — a nested async function's OWN internal
128
+ // await does not get that same restoration, so any Nuxt-instance-dependent
129
+ // composable called after `await useAsyncData(...)` below throws
130
+ // NUXT_E1001 ("called outside of a plugin, Nuxt hook, Nuxt middleware, or
131
+ // Vue setup function") — confirmed by actually reproducing it against a
132
+ // real dev server and reading the thrown error's stack trace, not assumed.
133
+ const config = useAppConfig();
134
+ const rootDepth = computed(() => {
135
+ return (config.gqlmd.baseURL as string).split("/").filter(Boolean).length;
136
+ });
137
+
138
+ const { data: pages } = await useAsyncData(
139
+ "api-reference-navigation",
140
+ async () => {
141
+ return queryCollection("content")
142
+ .order("path", "ASC")
143
+ .select("path", "title", "body", "meta")
144
+ .all()
145
+ .then((items) => {
146
+ return items
147
+ .filter((item) => {
148
+ return !isLandingDoc(item.path);
149
+ })
150
+ .map<RawPage>((item) => {
151
+ return {
152
+ path: item.path,
153
+ title: item.title,
154
+ isDeprecated: Boolean(findDeprecationNotice(item.body)),
155
+ // `kind` (see RawPage) is undeclared custom frontmatter, so
156
+ // Nuxt Content surfaces it under `meta`, not as a top-level field.
157
+ // Nuxt Content's generated query type claims `meta` is always
158
+ // present, but real content items (and this file's own test
159
+ // mocks) can omit it — the optional chain here is load-bearing.
160
+ kind:
161
+ // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
162
+ typeof item.meta?.kind === "string"
163
+ ? item.meta.kind
164
+ : undefined,
165
+ };
166
+ });
167
+ });
168
+ },
169
+ );
170
+
171
+ const sections = computed(() => {
172
+ return buildTree(pages.value ?? [], rootDepth.value);
173
+ });
174
+
175
+ /**
176
+ * Card-grid data for a landing page at `landingPath` (e.g. `/api-reference`
177
+ * or, for a multi-schema namespace, `/api-reference/schema-a`). Scopes to
178
+ * that landing page's own subtree and flattens exactly one extra level
179
+ * (its direct branch children) into `{ ...leaf-or-branch, sectionTitle }`
180
+ * pairs for the 2-tier card layout — a fixed "take 2 levels for the card
181
+ * grid" projection, independent of how deep the underlying tree actually
182
+ * goes below that.
183
+ */
184
+ const overviewGroupsFor = (
185
+ landingPath: string,
186
+ ): (ApiNavigationNode & { sectionTitle: string })[] => {
187
+ const scopeDepth = landingPath.split("/").filter(Boolean).length;
188
+ const prefix = landingPath.replace(/\/$/, "") + "/";
189
+ const scoped = (pages.value ?? []).filter((item) => {
190
+ return item.path.startsWith(prefix);
191
+ });
192
+ const scopedTree = buildTree(scoped, scopeDepth);
193
+
194
+ return scopedTree.flatMap((node) => {
195
+ return "children" in node
196
+ ? node.children.map((item) => {
197
+ return { ...item, sectionTitle: node.title };
198
+ })
199
+ : [];
200
+ });
201
+ };
202
+
203
+ return { sections, overviewGroupsFor };
204
+ };
205
+
206
+ /** The absolute path for the shared `gqlmd.baseURL` prefix (e.g. `/api-reference`), used by every file that needs to link to or detect the reference root. */
207
+ export const useApiBaseURL = (): ComputedRef<string> => {
208
+ const config = useAppConfig();
209
+ return computed(() => {
210
+ return `/${config.gqlmd.baseURL}`;
211
+ });
212
+ };
@@ -0,0 +1,164 @@
1
+ import type { ComputedRef, Ref } from "vue";
2
+ import { anchorIdFor } from "~/composables/useApiSinglePage";
3
+
4
+ type Page = Record<string, any> | null | undefined;
5
+ type Resolved<T extends (...args: any[]) => any> = Awaited<ReturnType<T>>;
6
+
7
+ export interface ApiReferencePage {
8
+ route: ReturnType<typeof useRoute>;
9
+ baseURLPath: Ref<string>;
10
+ page: Ref<Page>;
11
+ isLandingPage: ComputedRef<boolean>;
12
+ isNamespaceChooser: ComputedRef<boolean>;
13
+ isFlat: Ref<boolean>;
14
+ buckets: Resolved<typeof useApiSinglePage>["buckets"];
15
+ sections: Resolved<typeof useApiNavigation>["sections"];
16
+ overviewGroups: ComputedRef<
17
+ ReturnType<Resolved<typeof useApiNavigation>["overviewGroupsFor"]>
18
+ >;
19
+ breadcrumbs: ComputedRef<ReturnType<typeof buildBreadcrumbs>>;
20
+ deprecationReason: ReturnType<typeof useApiDocument>["deprecationReason"];
21
+ document: ReturnType<typeof useApiDocument>["document"];
22
+ definitionCard: Resolved<typeof useApiCodeCards>["definitionCard"];
23
+ exampleCards: Resolved<typeof useApiCodeCards>["exampleCards"];
24
+ }
25
+
26
+ /**
27
+ * Everything the catch-all API reference page binds to: the queried content
28
+ * page, its derived schema kind, navigation, code-column cards, the flat-mode
29
+ * redirect and SEO metadata. Kept out of `[...slug].vue` so the page stays a
30
+ * thin template.
31
+ */
32
+ export const useApiReferencePage = async (): Promise<ApiReferencePage> => {
33
+ // Unlike `<script setup>`, a plain composable gets no compiler-inserted
34
+ // context restoration after an `await`, so Nuxt-context composables called
35
+ // past the first one must be wrapped (otherwise: NUXT_E1001).
36
+ const nuxtApp = useNuxtApp();
37
+ const route = useRoute();
38
+ const config = useAppConfig();
39
+ const baseURLPath = useApiBaseURL();
40
+
41
+ const pathSegments = computed(() => {
42
+ return route.path.split("/").filter(Boolean);
43
+ });
44
+
45
+ /** `/api-reference/types/objects/user` → `OBJECT`, for the code-column badge. */
46
+ const schemaKind = computed(() => {
47
+ return schemaKindLabel(pathSegments.value.at(-2));
48
+ });
49
+
50
+ const isOperation = computed(() => {
51
+ return isOperationCategory(pathSegments.value.at(-2));
52
+ });
53
+
54
+ const { data } = await useAsyncData(route.path, async () => {
55
+ const exact = await queryCollection("content").path(route.path).first();
56
+ if (exact) return exact;
57
+ return queryCollection("content")
58
+ .path(`${route.path.replace(/\/$/, "")}/generated`)
59
+ .first();
60
+ });
61
+
62
+ const page = data as Ref<Page>;
63
+
64
+ const isLandingPage = computed(() => {
65
+ return page.value?.path?.endsWith("/generated") ?? false;
66
+ });
67
+
68
+ const { sections, overviewGroupsFor } = await nuxtApp.runWithContext(
69
+ async () => {
70
+ return useApiNavigation();
71
+ },
72
+ );
73
+ const { isFlat } = await nuxtApp.runWithContext(async () => {
74
+ return useHierarchyMode();
75
+ });
76
+ const { buckets } = await nuxtApp.runWithContext(async () => {
77
+ return useApiSinglePage(isFlat.value);
78
+ });
79
+ const overviewGroups = computed(() => {
80
+ return isLandingPage.value ? overviewGroupsFor(route.path) : [];
81
+ });
82
+
83
+ // Nothing generated at this path — and not the shared base route of a
84
+ // multi-schema site, which renders the namespace chooser instead — so it's
85
+ // a stale or mistyped link: surface a real 404 (which also fails prerender
86
+ // crawls) rather than leaving the page stuck on its loading placeholder.
87
+ const isNamespaceChooser = computed(() => {
88
+ return (
89
+ !page.value &&
90
+ route.path.replace(/\/$/, "") === baseURLPath.value &&
91
+ sections.value.length > 0
92
+ );
93
+ });
94
+ if (!page.value && !isNamespaceChooser.value) {
95
+ throw createError({
96
+ statusCode: 404,
97
+ statusMessage: `No API reference page at ${route.path}`,
98
+ fatal: true,
99
+ });
100
+ }
101
+
102
+ if (isFlat.value && page.value && !isLandingPage.value) {
103
+ const anchorId = anchorIdFor({
104
+ path: page.value.path,
105
+ kind:
106
+ typeof page.value.meta?.kind === "string"
107
+ ? page.value.meta.kind
108
+ : undefined,
109
+ });
110
+ await nuxtApp.runWithContext(async () => {
111
+ return navigateTo(`${baseURLPath.value}#${anchorId}`, {
112
+ redirectCode: 301,
113
+ });
114
+ });
115
+ }
116
+
117
+ const breadcrumbs = computed(() => {
118
+ return buildBreadcrumbs(
119
+ pathSegments.value,
120
+ // Empty titles fall back to the path-derived label, hence `||`.
121
+ // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
122
+ page.value?.title || undefined,
123
+ baseURLPath.value,
124
+ );
125
+ });
126
+
127
+ const { documentBody, deprecationReason, document } = useApiDocument(page);
128
+
129
+ const { definitionCard, exampleCards } = await useApiCodeCards(
130
+ documentBody,
131
+ schemaKind,
132
+ isOperation,
133
+ config.gqlmd.shikiTheme,
134
+ );
135
+
136
+ if (page.value) {
137
+ const current = page.value;
138
+ await nuxtApp.runWithContext(() => {
139
+ useSeoMeta({
140
+ title: isLandingPage.value
141
+ ? current.title
142
+ : `API Reference | ${current.title}`,
143
+ description: current.description,
144
+ });
145
+ });
146
+ }
147
+
148
+ return {
149
+ route,
150
+ baseURLPath,
151
+ page,
152
+ isLandingPage,
153
+ isNamespaceChooser,
154
+ isFlat,
155
+ buckets,
156
+ sections,
157
+ overviewGroups,
158
+ breadcrumbs,
159
+ deprecationReason,
160
+ document,
161
+ definitionCard,
162
+ exampleCards,
163
+ };
164
+ };