@lukoweb/apitogo 0.1.23 → 0.1.37

package/src/lib/plugins/openapi/util/getRoutes.tsx

@@ -1,265 +1,265 @@
-import { useSuspenseQuery } from "@tanstack/react-query";
-import {
-  generatePath,
-  Navigate,
-  redirect,
-  type RouteObject,
-  useLocation,
-  useParams,
-} from "react-router";
-import { joinUrl } from "../../../util/joinUrl.js";
-import type { GraphQLClient } from "../client/GraphQLClient.js";
-import { useCreateQuery } from "../client/useCreateQuery.js";
-import { useOasConfig } from "../context.js";
-import {
-  GetNavigationOperationsQuery,
-  type OpenApiPluginOptions,
-  UNTAGGED_PATH,
-} from "../index.js";
-import type { OasPluginConfig, VersionEntry } from "../interfaces.js";
-
-const createOasProvider = (opts: {
-  routePath: string;
-  basePath: string;
-  version?: string;
-  routes: RouteObject[];
-  client: GraphQLClient;
-  config: OpenApiPluginOptions;
-}): RouteObject => ({
-  path: opts.routePath,
-  async lazy() {
-    const { OasProvider } = await import("../OasProvider.js");
-    return {
-      element: (
-        <OasProvider
-          basePath={opts.basePath}
-          version={opts.version}
-          client={opts.client}
-          config={opts.config}
-        />
-      ),
-    };
-  },
-  children: opts.routes,
-});
-
-const createRoute = ({
-  path,
-  tag,
-  untagged,
-}: {
-  path: string;
-  tag?: string;
-  untagged?: boolean;
-}): RouteObject => ({
-  path,
-  async lazy() {
-    const { OperationList } = await import("../OperationList.js");
-    return { element: <OperationList tag={tag} untagged={untagged} /> };
-  },
-});
-
-// Used when tagPages is not configured (e.g. URL schemas). Resolves tags at
-// runtime via GraphQL and redirects to the first available tag.
-const NonTagPagesOperationList = ({
-  render,
-  path,
-}: {
-  render: (tag: string) => React.ReactNode;
-  path: string;
-}) => {
-  const { type, input } = useOasConfig();
-  const { tag: currentTag } = useParams();
-  const location = useLocation();
-  const query = useCreateQuery(GetNavigationOperationsQuery, { type, input });
-  const {
-    data: { schema },
-  } = useSuspenseQuery(query);
-
-  const firstTag = schema.tags.at(0);
-
-  if (!currentTag && firstTag?.slug) {
-    return (
-      <Navigate
-        to={{
-          pathname: generatePath(path, { tag: firstTag.slug }),
-          search: location.search,
-        }}
-      />
-    );
-  }
-
-  if (currentTag && schema.tags.some((t) => t.slug === currentTag)) {
-    return render(currentTag);
-  }
-
-  return null;
-};
-
-const createNonTagPagesRoute = ({ path }: { path: string }): RouteObject => ({
-  path,
-  async lazy() {
-    const { OperationList } = await import("../OperationList.js");
-    return {
-      element: (
-        <NonTagPagesOperationList
-          path={path}
-          render={(tag) => <OperationList tag={tag} />}
-        />
-      ),
-    };
-  },
-});
-
-const createAdditionalRoutes = ({
-  basePath,
-  hasUntaggedOperations = true,
-}: {
-  basePath: string;
-  hasUntaggedOperations?: boolean;
-}) => [
-  ...(hasUntaggedOperations
-    ? [
-        createRoute({
-          path: joinUrl(basePath, UNTAGGED_PATH),
-          untagged: true,
-        }),
-      ]
-    : []),
-  {
-    path: joinUrl(basePath, "~schemas"),
-    lazy: async () => {
-      const { SchemaList } = await import("../SchemaList.js");
-      return { element: <SchemaList /> };
-    },
-  },
-];
-
-const createVersionRoutes = ({
-  versionPath,
-  tagPages,
-  hasUntaggedOperations = true,
-  showInfoPage = true,
-}: {
-  versionPath: string;
-  tagPages: string[];
-  hasUntaggedOperations?: boolean;
-  showInfoPage?: boolean;
-}): RouteObject[] => {
-  const firstTag =
-    tagPages.at(0) ?? (hasUntaggedOperations ? UNTAGGED_PATH : undefined);
-
-  const indexRoute: RouteObject = showInfoPage
-    ? {
-        index: true,
-        path: versionPath,
-        lazy: async () => {
-          const { SchemaInfo } = await import("../SchemaInfo.js");
-          return { element: <SchemaInfo /> };
-        },
-      }
-    : firstTag
-      ? { index: true, loader: () => redirect(joinUrl(versionPath, firstTag)) }
-      : createRoute({ path: versionPath });
-
-  return [
-    indexRoute,
-    ...tagPages.map((tag) =>
-      createRoute({ path: joinUrl(versionPath, tag), tag }),
-    ),
-    ...createAdditionalRoutes({ basePath: versionPath, hasUntaggedOperations }),
-  ];
-};
-
-export const getVersionMetadata = (config: OasPluginConfig) => {
-  if (config.type === "raw" || !Array.isArray(config.input)) {
-    return {
-      versions: [] as string[],
-      versionMap: {} as Record<
-        string,
-        { label: string; downloadUrl?: string; tagPages?: string[] }
-      >,
-    };
-  }
-
-  return {
-    versions: config.input.map((v) => v.path),
-    versionMap: Object.fromEntries(
-      config.input.map((v) => [
-        v.path,
-        {
-          label: v.label ?? v.path,
-          downloadUrl: v.downloadUrl,
-          tagPages: v.tagPages,
-        },
-      ]),
-    ),
-  };
-};
-
-/**
- * Build the target URL when switching versions. Preserves the current tag
- * if it exists in the target version, otherwise navigates to the version
- * root (which redirects to its first tag).
- */
-export const buildVersionSwitchUrl = (
-  target: VersionEntry,
-  currentTag: string | undefined,
-) => {
-  const tagExistsInTarget =
-    currentTag && (!target.tagPages || target.tagPages.includes(currentTag));
-
-  if (!tagExistsInTarget) return target.path;
-
-  return joinUrl(target.path, currentTag);
-};
-
-export const getRoutes = ({
-  basePath,
-  config,
-  client,
-}: {
-  client: GraphQLClient;
-  config: OpenApiPluginOptions;
-  basePath: string;
-}): RouteObject[] => {
-  const tagPages = config.tagPages;
-  const { versions } = getVersionMetadata(config);
-  const inputArray = Array.isArray(config.input) ? config.input : undefined;
-
-  // undefined entry = index path that serves the latest version
-  const versionsInPath =
-    versions.length > 1 ? [undefined, ...versions] : [undefined];
-
-  return versionsInPath.map((version) => {
-    const versionPath = joinUrl(basePath, version);
-    const versionInput = version
-      ? inputArray?.find((v) => v.path === version)
-      : inputArray?.[0];
-    const hasUntaggedOperations = versionInput?.hasUntaggedOperations ?? true;
-
-    const versionTagPages = versionInput?.tagPages ?? tagPages;
-
-    return createOasProvider({
-      basePath,
-      version,
-      routePath: versionPath,
-      routes: versionTagPages
-        ? createVersionRoutes({
-            versionPath,
-            tagPages: versionTagPages,
-            hasUntaggedOperations,
-            showInfoPage: config.options?.showInfoPage !== false,
-          })
-        : [
-            createNonTagPagesRoute({ path: `${versionPath}/:tag?` }),
-            ...createAdditionalRoutes({
-              basePath: versionPath,
-              hasUntaggedOperations,
-            }),
-          ],
-      client,
-      config,
-    });
-  });
-};
+import { useSuspenseQuery } from "@tanstack/react-query";
+import {
+  generatePath,
+  Navigate,
+  redirect,
+  type RouteObject,
+  useLocation,
+  useParams,
+} from "react-router";
+import { joinUrl } from "../../../util/joinUrl.js";
+import type { GraphQLClient } from "../client/GraphQLClient.js";
+import { useCreateQuery } from "../client/useCreateQuery.js";
+import { useOasConfig } from "../context.js";
+import {
+  GetNavigationOperationsQuery,
+  type OpenApiPluginOptions,
+  UNTAGGED_PATH,
+} from "../index.js";
+import type { OasPluginConfig, VersionEntry } from "../interfaces.js";
+
+const createOasProvider = (opts: {
+  routePath: string;
+  basePath: string;
+  version?: string;
+  routes: RouteObject[];
+  client: GraphQLClient;
+  config: OpenApiPluginOptions;
+}): RouteObject => ({
+  path: opts.routePath,
+  async lazy() {
+    const { OasProvider } = await import("../OasProvider.js");
+    return {
+      element: (
+        <OasProvider
+          basePath={opts.basePath}
+          version={opts.version}
+          client={opts.client}
+          config={opts.config}
+        />
+      ),
+    };
+  },
+  children: opts.routes,
+});
+
+const createRoute = ({
+  path,
+  tag,
+  untagged,
+}: {
+  path: string;
+  tag?: string;
+  untagged?: boolean;
+}): RouteObject => ({
+  path,
+  async lazy() {
+    const { OperationList } = await import("../OperationList.js");
+    return { element: <OperationList tag={tag} untagged={untagged} /> };
+  },
+});
+
+// Used when tagPages is not configured (e.g. URL schemas). Resolves tags at
+// runtime via GraphQL and redirects to the first available tag.
+const NonTagPagesOperationList = ({
+  render,
+  path,
+}: {
+  render: (tag: string) => React.ReactNode;
+  path: string;
+}) => {
+  const { type, input } = useOasConfig();
+  const { tag: currentTag } = useParams();
+  const location = useLocation();
+  const query = useCreateQuery(GetNavigationOperationsQuery, { type, input });
+  const {
+    data: { schema },
+  } = useSuspenseQuery(query);
+
+  const firstTag = schema.tags.at(0);
+
+  if (!currentTag && firstTag?.slug) {
+    return (
+      <Navigate
+        to={{
+          pathname: generatePath(path, { tag: firstTag.slug }),
+          search: location.search,
+        }}
+      />
+    );
+  }
+
+  if (currentTag && schema.tags.some((t) => t.slug === currentTag)) {
+    return render(currentTag);
+  }
+
+  return null;
+};
+
+const createNonTagPagesRoute = ({ path }: { path: string }): RouteObject => ({
+  path,
+  async lazy() {
+    const { OperationList } = await import("../OperationList.js");
+    return {
+      element: (
+        <NonTagPagesOperationList
+          path={path}
+          render={(tag) => <OperationList tag={tag} />}
+        />
+      ),
+    };
+  },
+});
+
+const createAdditionalRoutes = ({
+  basePath,
+  hasUntaggedOperations = true,
+}: {
+  basePath: string;
+  hasUntaggedOperations?: boolean;
+}) => [
+  ...(hasUntaggedOperations
+    ? [
+        createRoute({
+          path: joinUrl(basePath, UNTAGGED_PATH),
+          untagged: true,
+        }),
+      ]
+    : []),
+  {
+    path: joinUrl(basePath, "~schemas"),
+    lazy: async () => {
+      const { SchemaList } = await import("../SchemaList.js");
+      return { element: <SchemaList /> };
+    },
+  },
+];
+
+const createVersionRoutes = ({
+  versionPath,
+  tagPages,
+  hasUntaggedOperations = true,
+  showInfoPage = true,
+}: {
+  versionPath: string;
+  tagPages: string[];
+  hasUntaggedOperations?: boolean;
+  showInfoPage?: boolean;
+}): RouteObject[] => {
+  const firstTag =
+    tagPages.at(0) ?? (hasUntaggedOperations ? UNTAGGED_PATH : undefined);
+
+  const indexRoute: RouteObject = showInfoPage
+    ? {
+        index: true,
+        path: versionPath,
+        lazy: async () => {
+          const { SchemaInfo } = await import("../SchemaInfo.js");
+          return { element: <SchemaInfo /> };
+        },
+      }
+    : firstTag
+      ? { index: true, loader: () => redirect(joinUrl(versionPath, firstTag)) }
+      : createRoute({ path: versionPath });
+
+  return [
+    indexRoute,
+    ...tagPages.map((tag) =>
+      createRoute({ path: joinUrl(versionPath, tag), tag }),
+    ),
+    ...createAdditionalRoutes({ basePath: versionPath, hasUntaggedOperations }),
+  ];
+};
+
+export const getVersionMetadata = (config: OasPluginConfig) => {
+  if (config.type === "raw" || !Array.isArray(config.input)) {
+    return {
+      versions: [] as string[],
+      versionMap: {} as Record<
+        string,
+        { label: string; downloadUrl?: string; tagPages?: string[] }
+      >,
+    };
+  }
+
+  return {
+    versions: config.input.map((v) => v.path),
+    versionMap: Object.fromEntries(
+      config.input.map((v) => [
+        v.path,
+        {
+          label: v.label ?? v.path,
+          downloadUrl: v.downloadUrl,
+          tagPages: v.tagPages,
+        },
+      ]),
+    ),
+  };
+};
+
+/**
+ * Build the target URL when switching versions. Preserves the current tag
+ * if it exists in the target version, otherwise navigates to the version
+ * root (which redirects to its first tag).
+ */
+export const buildVersionSwitchUrl = (
+  target: VersionEntry,
+  currentTag: string | undefined,
+) => {
+  const tagExistsInTarget =
+    currentTag && (!target.tagPages || target.tagPages.includes(currentTag));
+
+  if (!tagExistsInTarget) return target.path;
+
+  return joinUrl(target.path, currentTag);
+};
+
+export const getRoutes = ({
+  basePath,
+  config,
+  client,
+}: {
+  client: GraphQLClient;
+  config: OpenApiPluginOptions;
+  basePath: string;
+}): RouteObject[] => {
+  const tagPages = config.tagPages;
+  const { versions } = getVersionMetadata(config);
+  const inputArray = Array.isArray(config.input) ? config.input : undefined;
+
+  // undefined entry = index path that serves the latest version
+  const versionsInPath =
+    versions.length > 1 ? [undefined, ...versions] : [undefined];
+
+  return versionsInPath.map((version) => {
+    const versionPath = joinUrl(basePath, version);
+    const versionInput = version
+      ? inputArray?.find((v) => v.path === version)
+      : inputArray?.[0];
+    const hasUntaggedOperations = versionInput?.hasUntaggedOperations ?? true;
+
+    const versionTagPages = versionInput?.tagPages ?? tagPages;
+
+    return createOasProvider({
+      basePath,
+      version,
+      routePath: versionPath,
+      routes: versionTagPages
+        ? createVersionRoutes({
+            versionPath,
+            tagPages: versionTagPages,
+            hasUntaggedOperations,
+            showInfoPage: config.options?.showInfoPage !== false,
+          })
+        : [
+            createNonTagPagesRoute({ path: `${versionPath}/:tag?` }),
+            ...createAdditionalRoutes({
+              basePath: versionPath,
+              hasUntaggedOperations,
+            }),
+          ],
+      client,
+      config,
+    });
+  });
+};

package/src/lib/plugins/openapi/util/methodColorMap.tsx

@@ -1,11 +1,11 @@
-import type { ColorMap } from "../../../components/navigation/NavigationBadge.js";
-
-export const MethodColorMap: Record<string, keyof typeof ColorMap> = {
-  get: "green",
-  post: "blue",
-  put: "yellow",
-  delete: "red",
-  patch: "purple",
-  options: "gray",
-  head: "gray",
-};
+import type { ColorMap } from "../../../components/navigation/NavigationBadge.js";
+
+export const MethodColorMap: Record<string, keyof typeof ColorMap> = {
+  get: "green",
+  post: "blue",
+  put: "yellow",
+  delete: "red",
+  patch: "purple",
+  options: "gray",
+  head: "gray",
+};

package/src/lib/plugins/openapi/util/methodToColor.ts

@@ -1,27 +1,27 @@
-export const TextColorMap = {
-  green: "text-green-600",
-  blue: "text-sky-600",
-  yellow: "text-yellow-600",
-  red: "text-red-600",
-  purple: "text-purple-600",
-  indigo: "text-indigo-600",
-  gray: "text-gray-600",
-};
-
-export const methodToColor = {
-  get: TextColorMap.green,
-  post: TextColorMap.blue,
-  put: TextColorMap.yellow,
-  delete: TextColorMap.red,
-  patch: TextColorMap.purple,
-  options: TextColorMap.indigo,
-  head: TextColorMap.gray,
-  trace: TextColorMap.gray,
-};
-
-export const methodForColor = (method: string) => {
-  return (
-    methodToColor[method.toLocaleLowerCase() as keyof typeof methodToColor] ??
-    TextColorMap.gray
-  );
-};
+export const TextColorMap = {
+  green: "text-green-600",
+  blue: "text-sky-600",
+  yellow: "text-yellow-600",
+  red: "text-red-600",
+  purple: "text-purple-600",
+  indigo: "text-indigo-600",
+  gray: "text-gray-600",
+};
+
+export const methodToColor = {
+  get: TextColorMap.green,
+  post: TextColorMap.blue,
+  put: TextColorMap.yellow,
+  delete: TextColorMap.red,
+  patch: TextColorMap.purple,
+  options: TextColorMap.indigo,
+  head: TextColorMap.gray,
+  trace: TextColorMap.gray,
+};
+
+export const methodForColor = (method: string) => {
+  return (
+    methodToColor[method.toLocaleLowerCase() as keyof typeof methodToColor] ??
+    TextColorMap.gray
+  );
+};

package/src/lib/plugins/openapi/util/sanitizeMarkdownForMetatag.tsx

@@ -1,32 +1,32 @@
-export function sanitizeMarkdownForMetatag(
-  description: string,
-  maxLength: number = 160,
-): string {
-  if (!description) {
-    return "";
-  }
-
-  return (
-    description
-      // Replace Markdown links [text](url) with just "text"
-      .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
-      // Remove Markdown image syntax: ![alt](url)
-      .replace(/!\[.*?\]\(.*?\)/g, "")
-      // Remove other Markdown syntax (e.g., **bold**, _italic_, `code`)
-      .replace(/[_*`~]/g, "")
-      // Remove headings (# Heading), blockquotes (> Quote), and horizontal rules (--- or ***)
-      .replace(/^(?:>|\s*#+|-{3,}|\*{3,})/gm, "")
-      // Remove any remaining formatting characters
-      .replace(/[|>{}[\]]/g, "")
-      // Collapse multiple spaces and trim the text
-      .replace(/\s+/g, " ")
-      .trim()
-      // Limit to the specified maximum length
-      .substring(0, maxLength)
-      .replace(/&/g, "&")
-      .replace(/</g, "&lt;")
-      .replace(/>/g, "&gt;")
-      .replace(/"/g, "&quot;")
-      .replace(/'/g, "&#039;")
-  );
-}
+export function sanitizeMarkdownForMetatag(
+  description: string,
+  maxLength: number = 160,
+): string {
+  if (!description) {
+    return "";
+  }
+
+  return (
+    description
+      // Replace Markdown links [text](url) with just "text"
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+      // Remove Markdown image syntax: ![alt](url)
+      .replace(/!\[.*?\]\(.*?\)/g, "")
+      // Remove other Markdown syntax (e.g., **bold**, _italic_, `code`)
+      .replace(/[_*`~]/g, "")
+      // Remove headings (# Heading), blockquotes (> Quote), and horizontal rules (--- or ***)
+      .replace(/^(?:>|\s*#+|-{3,}|\*{3,})/gm, "")
+      // Remove any remaining formatting characters
+      .replace(/[|>{}[\]]/g, "")
+      // Collapse multiple spaces and trim the text
+      .replace(/\s+/g, " ")
+      .trim()
+      // Limit to the specified maximum length
+      .substring(0, maxLength)
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#039;")
+  );
+}