zudoku 0.0.0-ff3751f → 0.0.0-fix-display-option-navigation-items.4bdfe991

package/src/lib/plugins/openapi/playground/Playground.tsx

@@ -1,6 +1,15 @@
+import { useNProgress } from "@tanem/react-nprogress";
 import { useMutation } from "@tanstack/react-query";
-import { Fragment, useEffect, useRef, useTransition } from "react";
+import {
+  CheckIcon,
+  CopyIcon,
+  IdCardLanyardIcon,
+  ShapesIcon,
+} from "lucide-react";
+import { useEffect, useMemo, useRef, useState, useTransition } from "react";
 import { FormProvider, useForm } from "react-hook-form";
+import { Button } from "zudoku/ui/Button.js";
+import { Collapsible, CollapsibleContent } from "zudoku/ui/Collapsible.js";
 import {
   Select,
   SelectContent,
@@ -8,45 +17,53 @@ import {
   SelectTrigger,
   SelectValue,
 } from "zudoku/ui/Select.js";
-import { useSelectedServerStore } from "../../../authentication/state.js";
+import { TooltipProvider } from "zudoku/ui/Tooltip.js";
 import { useApiIdentities } from "../../../components/context/ZudokuContext.js";
-import { Spinner } from "../../../components/Spinner.js";
-import { Button } from "../../../ui/Button.js";
-import { Callout } from "../../../ui/Callout.js";
-import { Card, CardContent, CardHeader, CardTitle } from "../../../ui/Card.js";
-import { Tabs, TabsContent, TabsList, TabsTrigger } from "../../../ui/Tabs.js";
-import { ColorizedParam } from "../ColorizedParam.js";
+import { useHotkey } from "../../../hooks/useHotkey.js";
+import { cn } from "../../../util/cn.js";
+import { useCopyToClipboard } from "../../../util/useCopyToClipboard.js";
+import { useLatest } from "../../../util/useLatest.js";
+import { type Content } from "../SidecarExamples.js";
+import { useSelectedServer } from "../state.js";
+import BodyPanel from "./BodyPanel.js";
+import {
+  CollapsibleHeader,
+  CollapsibleHeaderTrigger,
+} from "./CollapsibleHeader.js";
 import { createUrl } from "./createUrl.js";
+import { extractFileName, isBinaryContentType } from "./fileUtils.js";
 import { Headers } from "./Headers.js";
+import { IdentityDialog } from "./IdentityDialog.js";
+import IdentitySelector from "./IdentitySelector.js";
 import { PathParams } from "./PathParams.js";
 import { QueryParams } from "./QueryParams.js";
-import { ResponseTab } from "./ResponseTab.js";
+import { useIdentityStore } from "./rememberedIdentity.js";
+import { UrlPath } from "./request-panel/UrlPath.js";
+import { UrlQueryParams } from "./request-panel/UrlQueryParams.js";
+import RequestLoginDialog from "./RequestLoginDialog.js";
+import { ResultPanel } from "./result-panel/ResultPanel.js";
+import { useRememberSkipLoginDialog } from "./useRememberSkipLoginDialog.js";
 
 export const NO_IDENTITY = "__none";
 
-const statusCodeMap: Record<number, string> = {
-  200: "OK",
-  201: "Created",
-  202: "Accepted",
-  204: "No Content",
-  400: "Bad Request",
-  401: "Unauthorized",
-  403: "Forbidden",
-  404: "Not Found",
-  405: "Method Not Allowed",
-  500: "Internal Server Error",
-};
-
 export type Header = {
   name: string;
   defaultValue?: string;
+  defaultActive?: boolean;
+  isRequired?: boolean;
+  enum?: string[];
+  type?: string;
 };
+
 export type QueryParam = {
   name: string;
   defaultValue?: string;
   defaultActive?: boolean;
   isRequired?: boolean;
+  enum?: string[];
+  type?: string;
 };
+
 export type PathParam = {
   name: string;
   defaultValue?: string;
@@ -55,14 +72,44 @@ export type PathParam = {
 
 export type PlaygroundForm = {
   body: string;
-  queryParams: Array<{ name: string; value: string; active: boolean }>;
-  pathParams: Array<{ name: string; value: string }>;
-  headers: Array<{ name: string; value: string }>;
+  queryParams: Array<{
+    name: string;
+    value: string;
+    active: boolean;
+    enum?: string[];
+  }>;
+  pathParams: Array<{
+    name: string;
+    value: string;
+  }>;
+  headers: Array<{
+    name: string;
+    value: string;
+    active: boolean;
+    enum?: string[];
+  }>;
   identity?: string;
 };
 
+export type PlaygroundResult = {
+  status: number;
+  headers: Array<[string, string]>;
+  size: number;
+  body: string;
+  time: number;
+  isBinary?: boolean;
+  fileName?: string;
+  blob?: Blob;
+  request: {
+    method: string;
+    url: string;
+    headers: Array<[string, string]>;
+    body?: string;
+  };
+};
+
 export type PlaygroundContentProps = {
-  server: string;
+  server?: string;
   servers?: string[];
   url: string;
   method: string;
@@ -70,90 +117,194 @@ export type PlaygroundContentProps = {
   queryParams?: QueryParam[];
   pathParams?: PathParam[];
   defaultBody?: string;
+  examples?: Content;
+  requiresLogin?: boolean;
+  onLogin?: () => void;
+  onSignUp?: () => void;
 };
 
 export const Playground = ({
   server,
-  servers,
+  servers = [],
   url,
   method,
   headers = [],
   queryParams = [],
   pathParams = [],
   defaultBody = "",
+  examples,
+  requiresLogin = false,
+  onLogin,
+  onSignUp,
 }: PlaygroundContentProps) => {
-  const { selectedServer, setSelectedServer } = useSelectedServerStore();
+  const { selectedServer, setSelectedServer } = useSelectedServer(
+    servers.map((url) => ({ url })),
+  );
+  const [showSelectIdentity, setShowSelectIdentity] = useState(false);
+  const identities = useApiIdentities();
+  const { setRememberedIdentity, getRememberedIdentity } = useIdentityStore();
   const [, startTransition] = useTransition();
+  const { skipLogin, setSkipLogin } = useRememberSkipLoginDialog();
+  const [showLongRunningWarning, setShowLongRunningWarning] = useState(false);
+  const abortControllerRef = useRef<AbortController | undefined>(undefined);
+  const latestSetRememberedIdentity = useLatest(setRememberedIdentity);
+  const formRef = useRef<HTMLFormElement>(null);
+
+  const { label: hotkeyLabel } = useHotkey("meta+enter", () => {
+    formRef.current?.requestSubmit();
+  });
+
+  const pathParamOrder =
+    url.match(/\{([^}]+)\}/g)?.map((match) => match.slice(1, -1)) ?? [];
+  const sortedPathParams = [...pathParams].sort(
+    (a, b) => pathParamOrder.indexOf(a.name) - pathParamOrder.indexOf(b.name),
+  );
+
   const { register, control, handleSubmit, watch, setValue, ...form } =
     useForm<PlaygroundForm>({
       defaultValues: {
         body: defaultBody,
-        queryParams: queryParams.map((param) => ({
+        queryParams:
+          queryParams.length > 0
+            ? queryParams.map((param) => ({
+                name: param.name,
+                value: param.defaultValue ?? "",
+                active: param.defaultActive ?? false,
+                enum: param.enum ?? [],
+              }))
+            : [
+                {
+                  name: "",
+                  value: "",
+                  active: false,
+                  enum: [],
+                },
+              ],
+        pathParams: sortedPathParams.map((param) => ({
           name: param.name,
           value: param.defaultValue ?? "",
-          active: param.defaultActive ?? false,
         })),
-        pathParams: pathParams.map((param) => ({
-          name: param.name,
-          value: param.defaultValue ?? "",
-        })),
-        headers: headers.map((header) => ({
-          name: header.name,
-          value: header.defaultValue ?? "",
-        })),
-        identity: NO_IDENTITY,
+        headers:
+          headers.length > 0
+            ? headers.map((header) => ({
+                name: header.name,
+                value: header.defaultValue ?? "",
+                active: header.defaultActive ?? false,
+              }))
+            : [
+                {
+                  name: "",
+                  value: "",
+                  active: false,
+                },
+              ],
+        identity: getRememberedIdentity([
+          NO_IDENTITY,
+          ...(identities.data?.map((i) => i.id) ?? []),
+        ]),
       },
     });
-  const formState = watch();
-  const identities = useApiIdentities();
+  const identity = watch("identity");
+
+  const authorizationFields = useMemo(
+    () => identities.data?.find((i) => i.id === identity)?.authorizationFields,
+    [identities.data, identity],
+  );
 
-  const setOnce = useRef(false);
   useEffect(() => {
-    if (setOnce.current) return;
-    const firstIdentity = identities.data?.at(0);
-    if (firstIdentity) {
-      setValue("identity", firstIdentity.id);
-      setOnce.current = true;
+    if (identity) {
+      latestSetRememberedIdentity.current(identity);
     }
-  }, [setValue, identities.data]);
+  }, [latestSetRememberedIdentity, identity]);
 
   const queryMutation = useMutation({
+    gcTime: 0,
     mutationFn: async (data: PlaygroundForm) => {
-      const requestUrl = createUrl(selectedServer ?? server, url, data);
       const start = performance.now();
 
-      const request = new Request(requestUrl, {
-        method: method.toUpperCase(),
-        headers: Object.fromEntries(
-          data.headers
-            .filter((h) => h.name)
-            .map((header) => [header.name, header.value]),
-        ),
-        body: data.body ? data.body : undefined,
-      });
+      const headers = Object.fromEntries([
+        ...data.headers
+          .filter((h) => h.name && h.active)
+          .map((header) => [header.name, header.value]),
+      ]);
+
+      const request = new Request(
+        createUrl(server ?? selectedServer, url, data),
+        {
+          method: method.toUpperCase(),
+          headers,
+          body: data.body ? data.body : undefined,
+        },
+      );
 
       if (data.identity !== NO_IDENTITY) {
-        identities.data
+        await identities.data
           ?.find((i) => i.id === data.identity)
           ?.authorizeRequest(request);
       }
+
+      const warningTimeout = setTimeout(
+        () => setShowLongRunningWarning(true),
+        3210,
+      );
+      abortControllerRef.current = new AbortController();
+
+      abortControllerRef.current.signal.addEventListener("abort", () => {
+        clearTimeout(warningTimeout);
+      });
+
       try {
         const response = await fetch(request, {
-          signal: AbortSignal.timeout(5000),
+          cache: "no-store",
+          signal: abortControllerRef.current.signal,
         });
 
+        clearTimeout(warningTimeout);
+        setShowLongRunningWarning(false);
+
         const time = performance.now() - start;
+        const url = new URL(request.url);
+        const responseHeaders = Array.from(response.headers.entries());
+        const contentType = response.headers.get("content-type") || "";
+        const isBinary = isBinaryContentType(contentType);
+
+        let body = "";
+        let blob: Blob | undefined;
+        let fileName: string | undefined;
 
-        const body = await response.text();
+        if (isBinary) {
+          blob = await response.blob();
+          fileName = extractFileName(responseHeaders, request.url);
+          body = `Binary content (${contentType})`;
+        } else {
+          body = await response.text();
+        }
+
+        const responseSize = response.headers.get("content-length");
 
         return {
           status: response.status,
-          headers: response.headers,
-          size: body.length,
+          headers: responseHeaders,
+          size: responseSize ? parseInt(responseSize) : body.length,
           body,
           time,
-        };
+          isBinary,
+          fileName,
+          blob,
+          request: {
+            method: request.method.toUpperCase(),
+            url: request.url,
+            headers: [
+              ["Host", url.host],
+              ["User-Agent", "Zudoku Playground"],
+              ...Array.from(request.headers.entries()),
+            ],
+            body: data.body ? data.body : undefined,
+          },
+        } satisfies PlaygroundResult;
       } catch (error) {
+        clearTimeout(warningTimeout);
+        setShowLongRunningWarning(false);
         if (error instanceof TypeError) {
           throw new Error(
             "The request failed, possibly due to network issues or CORS policy.",
@@ -165,252 +316,218 @@ export const Playground = ({
     },
   });
 
-  const path = url.split("/").map((part, i, arr) => {
-    const isPathParam =
-      (part.startsWith("{") && part.endsWith("}")) || part.startsWith(":");
-    const replaced = part.replace(/[:{}]/g, "");
-    const value = formState.pathParams.find((p) => p.name === replaced)?.value;
-
-    const pathParamValue = value ? (
-      <ColorizedParam backgroundOpacity="25%" name={part} slug={part}>
-        {encodeURIComponent(value)}
-      </ColorizedParam>
-    ) : (
-      <span
-        className="underline decoration-wavy decoration-red-500"
-        title={`Missing value for path parameter \`${replaced}\``}
-      >
-        {part}
-      </span>
-    );
-
-    return (
-      // eslint-disable-next-line react/no-array-index-key
-      <Fragment key={part + i}>
-        {isPathParam ? pathParamValue : part}
-        {i < arr.length - 1 && "/"}
-        <wbr />
-      </Fragment>
-    );
-  });
+  const isRequestAnimating = queryMutation.isPending;
+  const [isAnimating, setIsAnimating] = useState(false);
 
-  const headerEntries = Array.from(queryMutation.data?.headers.entries() ?? []);
+  useEffect(() => {
+    const timer = setTimeout(() => setIsAnimating(isRequestAnimating), 100);
+    return () => clearTimeout(timer);
+  }, [isRequestAnimating]);
 
-  const urlQueryParams = formState.queryParams
-    .filter((p) => p.active)
-    .map((p, i, arr) => (
-      <Fragment key={p.name}>
-        {p.name}={encodeURIComponent(p.value).replaceAll("%20", "+")}
-        {i < arr.length - 1 && "&"}
-        <wbr />
-      </Fragment>
-    ));
+  const { isFinished, progress } = useNProgress({ isAnimating });
+
+  useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
 
   const serverSelect = (
     <div className="inline-block opacity-50 hover:opacity-100 transition">
-      {servers && servers.length > 1 ? (
-        <Select
-          onValueChange={(value) => {
-            startTransition(() => {
-              setSelectedServer(value);
-            });
-          }}
-          value={selectedServer}
-        >
-          <SelectTrigger className="p-0 border-none flex-row-reverse bg-transparent text-xs gap-0.5 h-auto">
-            <SelectValue />
-          </SelectTrigger>
-          <SelectContent>
-            {servers.map((s) => (
-              <SelectItem key={s} value={s}>
-                {s.replace(/^https?:\/\//, "")}
-              </SelectItem>
-            ))}
-          </SelectContent>
-        </Select>
+      {server ? (
+        <span>{server.replace(/^https?:\/\//, "").replace(/\/$/, "")}</span>
       ) : (
-        <span>{server.replace(/^https?:\/\//, "")}</span>
+        servers.length > 1 && (
+          <Select
+            onValueChange={(value) => {
+              startTransition(() => setSelectedServer(value));
+            }}
+            value={selectedServer}
+            defaultValue={selectedServer}
+          >
+            <SelectTrigger className="p-0 border-none flex-row-reverse bg-transparent text-xs gap-0.5 h-auto translate-y-[4px]">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              {servers.map((s) => (
+                <SelectItem key={s} value={s}>
+                  {s.replace(/^https?:\/\//, "").replace(/\/$/, "")}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        )
       )}
     </div>
   );
 
+  const showLogin = requiresLogin && !skipLogin;
+  const isBodySupported = ["POST", "PUT", "PATCH", "DELETE"].includes(
+    method.toUpperCase(),
+  );
+  const [isCopied, copyToClipboard] = useCopyToClipboard();
+
   return (
     <FormProvider
       {...{ register, control, handleSubmit, watch, setValue, ...form }}
     >
-      <form onSubmit={handleSubmit((data) => queryMutation.mutateAsync(data))}>
-        <div className="grid grid-cols-[8fr_7fr] text-sm h-full">
-          <div className="flex flex-col gap-4 p-8 bg-muted/50 after:bg-muted-foreground/20 relative after:absolute after:w-px after:inset-0 after:left-auto">
-            <div className="flex gap-2 items-stretch">
-              <div className="flex flex-1 items-center w-full border rounded-md">
-                <div className="border-r p-2 bg-muted rounded-l-md self-stretch font-semibold font-mono">
+      <TooltipProvider delayDuration={150}>
+        <form
+          ref={formRef}
+          onSubmit={handleSubmit((data) => {
+            if (identities.data?.length === 0 || data.identity) {
+              queryMutation.mutate(data);
+            } else {
+              setShowSelectIdentity(true);
+            }
+          })}
+          className="relative"
+        >
+          <IdentityDialog
+            identities={identities.data ?? []}
+            open={showSelectIdentity}
+            onOpenChange={setShowSelectIdentity}
+            onSubmit={({ rememberedIdentity, identity }) => {
+              if (rememberedIdentity) {
+                setValue("identity", identity ?? NO_IDENTITY);
+              }
+              setShowSelectIdentity(false);
+              queryMutation.mutate({ ...form.getValues(), identity });
+            }}
+          />
+          <RequestLoginDialog
+            open={showLogin}
+            setOpen={(open) => setSkipLogin(!open)}
+            onSignUp={onSignUp}
+            onLogin={onLogin}
+          />
+
+          <div className="grid grid-cols-[1fr_1px_1fr] text-sm">
+            <div className="col-span-3 p-4 border-b flex gap-2 items-stretch">
+              <div className="flex flex-1 items-center w-full border rounded-md relative overflow-hidden">
+                <div className="border-r p-2 bg-muted rounded-l-md self-stretch font-semibold font-mono flex items-center">
                   {method.toUpperCase()}
                 </div>
-                <div className="flex items-center flex-wrap p-2 font-mono text-xs">
-                  {serverSelect}
-                  {path}
-                  {urlQueryParams.length > 0 ? "?" : ""}
-                  {urlQueryParams}
+                <div className="items-center px-2 font-mono text-xs break-all leading-6 relative h-full w-full">
+                  <div className="h-full py-1.5">
+                    {serverSelect}
+                    <UrlPath url={url} />
+                    <UrlQueryParams />
+                  </div>
                 </div>
-              </div>
-              <Button type="submit" className="h-auto flex gap-1">
-                Send
-              </Button>
-            </div>
-            <Tabs
-              defaultValue={
-                queryParams.length + pathParams.length > 0
-                  ? "parameters"
-                  : "headers"
-              }
-            >
-              <div className="flex flex-wrap gap-1 justify-between">
-                <TabsList>
-                  {queryParams.length + pathParams.length > 0 && (
-                    <TabsTrigger value="parameters">Parameters</TabsTrigger>
-                  )}
-                  <TabsTrigger value="headers">
-                    Headers{" "}
-                    {formState.headers.length > 0 &&
-                      `(${formState.headers.length})`}
-                  </TabsTrigger>
-                  <TabsTrigger
-                    value="body"
-                    disabled={
-                      !["POST", "PUT", "PATCH", "DELETE"].includes(
-                        method.toUpperCase(),
-                      )
-                    }
-                  >
-                    Body
-                  </TabsTrigger>
-                </TabsList>
-                <div className="flex gap-2 items-center">
-                  Auth:
-                  <Select
-                    onValueChange={(value) => setValue("identity", value)}
-                    value={formState.identity}
-                    defaultValue={formState.identity}
+                <div className="px-1">
+                  <Button
+                    type="button"
+                    onClick={() => {
+                      copyToClipboard(
+                        createUrl(
+                          server ?? selectedServer,
+                          url,
+                          form.getValues(),
+                        ).toString(),
+                      );
+                    }}
+                    variant="ghost"
+                    size="icon-xs"
+                    className={cn(
+                      "hover:opacity-100 transition",
+                      isCopied ? "text-emerald-600 opacity-100" : "opacity-50",
+                    )}
                   >
-                    <SelectTrigger className="w-[180px] flex">
-                      {identities.isPending ? <Spinner /> : <SelectValue />}
-                    </SelectTrigger>
-                    <SelectContent align="center">
-                      <SelectItem value={NO_IDENTITY}>None</SelectItem>
-                      {identities.data?.map((identity) => (
-                        <SelectItem key={identity.id} value={identity.id}>
-                          {identity.label}
-                        </SelectItem>
-                      ))}
-                    </SelectContent>
-                  </Select>
+                    {isCopied ? (
+                      <CheckIcon className="text-green-500" size={14} />
+                    ) : (
+                      <CopyIcon size={14} />
+                    )}
+                  </Button>
                 </div>
               </div>
-              <TabsContent value="headers">
-                <Headers control={control} register={register} />
-              </TabsContent>
-              <TabsContent value="parameters">
-                {pathParams.length > 0 && (
-                  <div className="flex flex-col gap-4 my-4">
-                    <span className="font-semibold">Path Parameters</span>
-                    <PathParams control={control} />
-                  </div>
-                )}
-                {queryParams.length > 0 && (
-                  <div className="flex flex-col gap-4 my-4">
-                    <span className="font-semibold">Query Parameters</span>
-                    <QueryParams control={control} queryParams={queryParams} />
-                  </div>
-                )}
-              </TabsContent>
-              <TabsContent value="body">
-                <textarea
-                  {...register("body")}
-                  className="border w-full rounded p-2 bg-muted h-40"
-                />
-              </TabsContent>
-            </Tabs>
-          </div>
-          <div className="min-w-0 p-8 bg-muted/70">
-            {queryMutation.error ? (
-              <div className="flex flex-col gap-2">
-                {formState.pathParams.some((p) => p.value === "") && (
-                  <Callout type="caution">
-                    Some path parameters are missing values. Please fill them in
-                    to ensure the request is sent correctly.
-                  </Callout>
-                )}
-                <Card>
-                  <CardHeader>
-                    <CardTitle>Request failed</CardTitle>
-                  </CardHeader>
-                  <CardContent>
-                    Error:{" "}
-                    {queryMutation.error.message ||
-                      String(queryMutation.error) ||
-                      "Unexpected error"}
-                  </CardContent>
-                </Card>
-              </div>
-            ) : queryMutation.data ? (
-              <div className="flex flex-col gap-2">
-                <div className="flex gap-2">
-                  <div className="flex text-xs gap-6">
-                    <div>
-                      Status: {queryMutation.data.status}{" "}
-                      {statusCodeMap[queryMutation.data.status] ?? ""}
-                    </div>
-                    <div>Time: {queryMutation.data.time.toFixed(0)}ms</div>
-                    <div>Size: {queryMutation.data.size} B</div>
-                  </div>
-                </div>
-                <Tabs defaultValue="response">
-                  <TabsList>
-                    <TabsTrigger value="response">Response</TabsTrigger>
-                    <TabsTrigger value="headers">
-                      {headerEntries.length
-                        ? `Headers (${headerEntries.length})`
-                        : "No headers"}
-                    </TabsTrigger>
-                  </TabsList>
-
-                  <TabsContent value="response">
-                    <ResponseTab
-                      headers={queryMutation.data.headers}
-                      body={queryMutation.data.body}
+
+              <Button
+                type="submit"
+                variant={queryMutation.isPending ? "destructive" : "default"}
+                onClick={(e) => {
+                  if (queryMutation.isPending) {
+                    abortControllerRef.current?.abort(
+                      "Request cancelled by user",
+                    );
+                    e.preventDefault();
+                  }
+                }}
+                className="w-18"
+              >
+                {queryMutation.isPending ? "Cancel" : "Send"}
+              </Button>
+            </div>
+            <div className="relative overflow-y-auto h-[80vh]">
+              {identities.data?.length !== 0 && (
+                <Collapsible defaultOpen>
+                  <CollapsibleHeaderTrigger>
+                    <IdCardLanyardIcon size={16} />
+                    <CollapsibleHeader className="col-span-2">
+                      Authentication
+                    </CollapsibleHeader>
+                  </CollapsibleHeaderTrigger>
+                  <CollapsibleContent className="CollapsibleContent">
+                    <IdentitySelector
+                      value={identity}
+                      identities={identities.data ?? []}
+                      setValue={(value) => setValue("identity", value)}
                     />
-                  </TabsContent>
-                  <TabsContent value="headers">
-                    <Card
-                      // playground dialog has h-5/6 ≈ 83.333vh
-                      className="max-h-[calc(83.333vh-140px)] overflow-y-auto grid grid-cols-2 w-full gap-2.5 font-mono text-xs shadow-none p-4"
-                    >
-                      <div className="font-semibold">Key</div>
-                      <div className="font-semibold">Value</div>
-                      {headerEntries.map(([key, value]) => (
-                        <Fragment key={key}>
-                          <div>{key}</div>
-                          <div className="break-words">{value}</div>
-                        </Fragment>
-                      ))}
-                    </Card>
-                  </TabsContent>
-                </Tabs>
-              </div>
-            ) : (
-              <div className="grid place-items-center h-full">
-                <span className="text-[16px] font-semibold text-muted-foreground">
-                  {queryMutation.isPending ? (
-                    <Spinner />
-                  ) : (
-                    "Send a request first to see the response here"
-                  )}
-                </span>
-              </div>
-            )}
+                  </CollapsibleContent>
+                </Collapsible>
+              )}
+
+              {sortedPathParams.length > 0 && (
+                <Collapsible defaultOpen>
+                  <CollapsibleHeaderTrigger>
+                    <ShapesIcon size={16} />
+                    <CollapsibleHeader className="col-span-2">
+                      Path Parameters
+                    </CollapsibleHeader>
+                  </CollapsibleHeaderTrigger>
+                  <CollapsibleContent className="CollapsibleContent">
+                    <PathParams url={url} control={control} />
+                  </CollapsibleContent>
+                </Collapsible>
+              )}
+
+              <QueryParams control={control} schemaQueryParams={queryParams} />
+
+              <Headers
+                control={control}
+                schemaHeaders={headers}
+                lockedHeaders={authorizationFields?.headers}
+              />
+              {isBodySupported && <BodyPanel content={examples} />}
+            </div>
+            <div className="w-full bg-muted-foreground/20" />
+            <ResultPanel
+              queryMutation={queryMutation}
+              showLongRunningWarning={showLongRunningWarning}
+              isFinished={isFinished}
+              progress={progress}
+              tip={
+                <div className="text-xs w-full">
+                  <span className="text-muted-foreground">
+                    Press{" "}
+                    <kbd className="text-foreground border rounded m-0.5 px-1 py-0.5 capitalize">
+                      {hotkeyLabel.join(" + ")}
+                    </kbd>{" "}
+                    to send a request
+                  </span>
+                </div>
+              }
+              onCancel={() => {
+                abortControllerRef.current?.abort(
+                  "Request cancelled by the user",
+                );
+                setShowLongRunningWarning(false);
+              }}
+            />
           </div>
-        </div>
-      </form>
+        </form>
+      </TooltipProvider>
     </FormProvider>
   );
 };