zudoku 0.0.0-ed94abf → 0.0.0-edf4a635

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

@@ -41,7 +41,7 @@ const PlaygroundDialog = (props: PlaygroundDialogProps) => {
         {props.children ?? (
           <button
             type="button"
-            className="flex gap-1 items-center px-2 py-1 rounded-md transition text-xs bg-primary  text-primary-foreground shadow-sm hover:bg-primary/80"
+            className="flex gap-1 items-center px-2 py-1 rounded-md transition text-xs bg-primary  text-primary-foreground shadow-xs hover:bg-primary/80"
           >
             Test
             <HeroPlayIcon size={14} />
@@ -50,8 +50,9 @@ const PlaygroundDialog = (props: PlaygroundDialogProps) => {
       </DialogTrigger>
 
       <DialogContent
-        className="max-w-screen-xl w-full h-5/6 overflow-hidden p-0"
+        className="max-w-screen-xl w-full overflow-hidden p-0"
         aria-describedby={undefined}
+        showCloseButton={true}
       >
         <VisuallyHidden>
           <DialogTitle>Playground</DialogTitle>

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

@@ -1,50 +1,85 @@
+import { PlusCircleIcon, Unlink2Icon, XIcon } from "lucide-react";
+import { useEffect } from "react";
 import {
-  Control,
+  type Control,
   Controller,
   useFieldArray,
   useFormContext,
 } from "react-hook-form";
-import { Card } from "zudoku/ui/Card.js";
+import { Button } from "zudoku/ui/Button.js";
 import { Checkbox } from "zudoku/ui/Checkbox.js";
+import { Collapsible, CollapsibleContent } from "zudoku/ui/Collapsible.js";
 import { Autocomplete } from "../../../components/Autocomplete.js";
 import { Input } from "../../../ui/Input.js";
+import {
+  CollapsibleHeader,
+  CollapsibleHeaderTrigger,
+} from "./CollapsibleHeader.js";
 import { InlineInput } from "./InlineInput.js";
 import ParamsGrid, { ParamsGridItem } from "./ParamsGrid.js";
-import { type PlaygroundForm, type QueryParam } from "./Playground.js";
+import type { PlaygroundForm, QueryParam } from "./Playground.js";
 
 export const QueryParams = ({
   control,
-  queryParams,
+  schemaQueryParams,
 }: {
   control: Control<PlaygroundForm>;
-  queryParams: QueryParam[];
+  schemaQueryParams: QueryParam[];
 }) => {
-  const { fields } = useFieldArray<PlaygroundForm, "queryParams">({
+  const { fields, remove, append } = useFieldArray<
+    PlaygroundForm,
+    "queryParams"
+  >({
     control,
     name: "queryParams",
   });
-  const form = useFormContext<PlaygroundForm>();
+  const { setValue, getValues, watch } = useFormContext<PlaygroundForm>();
+  const watchedQueryParams = watch("queryParams");
+  useEffect(() => {
+    if (watchedQueryParams.length === 0) {
+      append({ name: "", value: "", active: false }, { shouldFocus: true });
+    }
+  }, [watchedQueryParams, append]);
 
-  const requiredFields = queryParams.map((param) => Boolean(param.isRequired));
+  const requiredFields = schemaQueryParams.map((param) =>
+    Boolean(param.isRequired),
+  );
 
   return (
-    <Card className="rounded-lg">
-      <div className="w-full ">
-        <ParamsGrid>
-          {fields.map((field, i) => {
-            const currentParam = queryParams.find(
-              (param) => param.name === form.watch(`queryParams.${i}.name`),
-            );
-            return (
-              <ParamsGridItem key={field.id}>
-                <div key={field.id} className="flex items-center gap-2">
+    <Collapsible defaultOpen>
+      <CollapsibleHeaderTrigger>
+        <Unlink2Icon size={16} />
+        <CollapsibleHeader>Query Parameters</CollapsibleHeader>
+        <Button
+          onClick={() => {
+            setValue("queryParams", [
+              ...getValues("queryParams"),
+              { name: "", value: "", active: false },
+            ]);
+          }}
+          type="button"
+          size="sm"
+          variant="ghost"
+          className="hover:bg-accent hover:brightness-95 flex gap-2"
+        >
+          Add parameter <PlusCircleIcon size={16} />
+        </Button>
+      </CollapsibleHeaderTrigger>
+      <CollapsibleContent className="CollapsibleContent">
+        <div className="overflow-hidden w-full">
+          <ParamsGrid>
+            {fields.map((field, i) => {
+              const currentParam = schemaQueryParams.find(
+                (param) => param.name === watchedQueryParams.at(i)?.name,
+              );
+              return (
+                <ParamsGridItem key={field.id}>
                   <Controller
                     control={control}
                     name={`queryParams.${i}.active`}
                     render={({ field }) => (
                       <Checkbox
                         id={`queryParams.${i}.active`}
-                        className="mr-2"
                         checked={field.value}
                         onCheckedChange={field.onChange}
                       />
@@ -55,12 +90,13 @@ export const QueryParams = ({
                     render={({ field }) =>
                       !requiredFields[i] ? (
                         <Autocomplete
+                          placeholder="Name"
                           value={field.value}
-                          options={queryParams.map((param) => param.name)}
+                          options={schemaQueryParams.map((param) => param.name)}
                           onChange={(e) => {
                             field.onChange(e);
                           }}
-                          className="border-0 font-mono text-xs bg-transparent hover:bg-transparent"
+                          className="border-0 p-0 m-0 shadow-none focus-visible:ring-0 bg-transparent hover:bg-transparent text-xs font-mono"
                         />
                       ) : (
                         <InlineInput asChild>
@@ -79,50 +115,60 @@ export const QueryParams = ({
                     }
                     name={`queryParams.${i}.name`}
                   />
-                </div>
-                <div className="flex justify-between items-center">
-                  <Controller
-                    control={control}
-                    render={({ field }) => {
-                      const hasEnum =
-                        currentParam?.enum && currentParam.enum.length > 0;
+                  <div className="flex justify-between items-center">
+                    <Controller
+                      control={control}
+                      render={({ field }) => {
+                        const hasEnum =
+                          currentParam?.enum && currentParam.enum.length > 0;
+
+                        if (!hasEnum) {
+                          return (
+                            <Input
+                              {...field}
+                              onChange={(e) => {
+                                field.onChange(e.target.value);
+                                if (e.target.value.length > 0) {
+                                  setValue(`queryParams.${i}.active`, true);
+                                }
+                              }}
+                              placeholder="Value"
+                              aria-label="Query parameter value"
+                              className="w-full border-0 p-0 m-0 shadow-none focus-visible:ring-0 text-xs font-mono"
+                            />
+                          );
+                        }
 
-                      if (!hasEnum) {
                         return (
-                          <Input
-                            {...field}
+                          <Autocomplete
+                            value={field.value}
+                            options={currentParam.enum ?? []}
                             onChange={(e) => {
-                              field.onChange(e.target.value);
-                              if (e.target.value.length > 0) {
-                                form.setValue(`queryParams.${i}.active`, true);
-                              }
+                              field.onChange(e);
+                              setValue(`queryParams.${i}.active`, true);
                             }}
-                            placeholder="Enter value"
-                            className="w-full border-0 shadow-none focus-visible:ring-0 text-xs font-mono"
+                            className="border-0 shadow-none focus-visible:ring-0 bg-transparent hover:bg-transparent text-xs font-mono"
                           />
                         );
-                      }
-
-                      return (
-                        <Autocomplete
-                          value={field.value}
-                          options={currentParam.enum ?? []}
-                          onChange={(e) => {
-                            field.onChange(e);
-                            form.setValue(`queryParams.${i}.active`, true);
-                          }}
-                          className="font-mono text-xs border-0 ring-1 ring-ring"
-                        />
-                      );
-                    }}
-                    name={`queryParams.${i}.value`}
-                  />
-                </div>
-              </ParamsGridItem>
-            );
-          })}
-        </ParamsGrid>
-      </div>
-    </Card>
+                      }}
+                      name={`queryParams.${i}.value`}
+                    />
+                    <Button
+                      size="icon-xs"
+                      variant="ghost"
+                      className="text-muted-foreground opacity-0 group-hover:brightness-95 group-hover:opacity-100"
+                      onClick={() => remove(i)}
+                      type="button"
+                    >
+                      <XIcon size={16} />
+                    </Button>
+                  </div>
+                </ParamsGridItem>
+              );
+            })}
+          </ParamsGrid>
+        </div>
+      </CollapsibleContent>
+    </Collapsible>
   );
 };

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

@@ -0,0 +1,87 @@
+import { motion } from "motion/react";
+
+const ball = {
+  width: 5,
+  height: 5,
+  borderRadius: "50%",
+};
+
+const Spinner = () => {
+  return (
+    <motion.div
+      className="flex items-center gap-1"
+      initial="hidden"
+      animate="visible"
+      variants={{
+        visible: {
+          transition: {
+            staggerChildren: 0.2,
+          },
+        },
+      }}
+    >
+      <motion.div
+        className="bg-white/60"
+        variants={{
+          hidden: { opacity: 0, y: 3 },
+          visible: {
+            opacity: 1,
+            y: 0,
+            transition: {
+              y: {
+                type: "spring",
+                stiffness: 300,
+                damping: 10,
+                repeat: Infinity,
+                repeatType: "reverse",
+              },
+            },
+          },
+        }}
+        style={ball}
+      />
+      <motion.div
+        className="bg-white/60"
+        variants={{
+          hidden: { opacity: 0, y: 3 },
+          visible: {
+            opacity: 1,
+            y: 0,
+            transition: {
+              y: {
+                type: "spring",
+                stiffness: 300,
+                damping: 10,
+                repeat: Infinity,
+                repeatType: "reverse",
+              },
+            },
+          },
+        }}
+        style={ball}
+      />
+      <motion.div
+        className="bg-white/60"
+        variants={{
+          hidden: { opacity: 0, y: 3 },
+          visible: {
+            opacity: 1,
+            y: 0,
+            transition: {
+              y: {
+                type: "spring",
+                stiffness: 300,
+                damping: 10,
+                repeat: Infinity,
+                repeatType: "reverse",
+              },
+            },
+          },
+        }}
+        style={ball}
+      />
+    </motion.div>
+  );
+};
+
+export default Spinner;

package/src/lib/plugins/openapi/playground/fileUtils.ts

@@ -0,0 +1,32 @@
+export function isBinaryContentType(contentType: string) {
+  return /^(application\/octet-stream|image\/|audio\/|video\/|font\/|application\/pdf|application\/zip|application\/x-protobuf|application\/x-binary)/i.test(
+    contentType,
+  );
+}
+
+export const extractFileName = (
+  headers: Array<[string, string]>,
+  url: string,
+): string => {
+  const contentDisposition = headers.find(
+    ([key]) => key.toLowerCase() === "content-disposition",
+  )?.[1];
+
+  if (contentDisposition) {
+    const filenameMatch = contentDisposition.match(
+      /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/,
+    );
+    if (filenameMatch?.[1]) {
+      return filenameMatch[1].replace(/['"]/g, "");
+    }
+  }
+
+  // Extract filename from URL as fallback
+  try {
+    const urlPath = new URL(url).pathname;
+    const fileName = urlPath.split("/").pop() || "download";
+    return fileName.includes(".") ? fileName : "download";
+  } catch {
+    return "download";
+  }
+};

package/src/lib/plugins/openapi/playground/request-panel/UrlPath.tsx

@@ -0,0 +1,31 @@
+import { useFormContext } from "react-hook-form";
+import { PathRenderer } from "../../../../components/PathRenderer.js";
+import { ColorizedParam } from "../../ColorizedParam.js";
+import type { PlaygroundForm } from "../Playground.js";
+
+export const UrlPath = ({ url }: { url: string }) => {
+  const { watch, setFocus } = useFormContext<PlaygroundForm>();
+  const [pathParams] = watch(["pathParams"]);
+
+  return (
+    <PathRenderer
+      path={url}
+      renderParam={({ name, originalValue, index }) => {
+        const formValue = pathParams.find(
+          (param) => param.name === name,
+        )?.value;
+
+        return (
+          <ColorizedParam
+            name={name}
+            backgroundOpacity="0"
+            slug={name}
+            onClick={() => setFocus(`pathParams.${index}.value`)}
+          >
+            {formValue || originalValue}
+          </ColorizedParam>
+        );
+      }}
+    />
+  );
+};

package/src/lib/plugins/openapi/playground/request-panel/UrlQueryParams.tsx

@@ -0,0 +1,25 @@
+import { Fragment } from "react";
+import { useFormContext } from "react-hook-form";
+import type { PlaygroundForm } from "../Playground.js";
+
+export const UrlQueryParams = () => {
+  const { watch } = useFormContext<PlaygroundForm>();
+  const queryParams = watch("queryParams");
+
+  const urlQueryParams = queryParams
+    .filter((p) => p.active && p.name)
+    .map((p, i, arr) => (
+      <Fragment key={p.name}>
+        {p.name}={encodeURIComponent(p.value).replaceAll("%20", "+")}
+        {i < arr.length - 1 && "&"}
+        <wbr />
+      </Fragment>
+    ));
+
+  return (
+    <>
+      {urlQueryParams.length > 0 ? `?` : ""}
+      {urlQueryParams}
+    </>
+  );
+};

package/src/lib/plugins/openapi/playground/result-panel/Highlight.tsx

@@ -0,0 +1,26 @@
+import { useZudoku } from "../../../../components/context/ZudokuContext.js";
+import { highlight } from "../../../../shiki.js";
+import invariant from "../../../../util/invariant.js";
+
+export const Highlight = ({
+  code,
+  language,
+  children,
+}:
+  | { code?: string; children?: never; language?: string }
+  | { code?: never; children: string; language: string }) => {
+  const { syntaxHighlighting } = useZudoku().options;
+
+  invariant(syntaxHighlighting?.highlighter, "Highlighter not found");
+
+  const highlightedCode = highlight(
+    syntaxHighlighting.highlighter,
+    code ?? children ?? "",
+    language,
+    syntaxHighlighting.themes,
+  );
+
+  return highlightedCode;
+};
+
+Highlight.displayName = "Highlight";

package/src/lib/plugins/openapi/playground/result-panel/ResponseStatusBar.tsx

@@ -0,0 +1,117 @@
+import { useCallback, useLayoutEffect, useRef } from "react";
+import { humanFileSize } from "../../../../util/humanFileSize.js";
+
+const ResponseCodeCircle = ({ status }: { status?: number }) => {
+  if (!status) return <div className="w-2 h-2 rounded-full bg-gray-500" />;
+
+  switch (Number(status.toString().slice(0, 1))) {
+    case 2:
+      return <div className="w-2 h-2 rounded-full bg-green-500" />;
+    case 4:
+      return <div className="w-2 h-2 rounded-full bg-yellow-400" />;
+    case 5:
+      return <div className="w-2 h-2 rounded-full bg-red-500" />;
+    default:
+      return <div className="w-2 h-2 rounded-full bg-gray-500" />;
+  }
+};
+
+const RealTimeCounter = () => {
+  const spanRef = useRef<HTMLSpanElement>(null);
+  const textRef = useRef<Text | null>(null);
+  const startTimeRef = useRef<number>(Date.now());
+  const animationFrameRef = useRef<number>(null);
+
+  const updateTime = useCallback(() => {
+    if (textRef.current) {
+      const elapsed = Date.now() - startTimeRef.current;
+      textRef.current.nodeValue = elapsed.toFixed();
+    }
+    animationFrameRef.current = requestAnimationFrame(updateTime);
+  }, []);
+
+  useLayoutEffect(() => {
+    const currentSpanRef = spanRef.current;
+    if (!currentSpanRef) return;
+
+    // Create a text node and attach it to the span
+    const textNode = document.createTextNode("0");
+
+    currentSpanRef.appendChild(textNode);
+    textRef.current = textNode;
+
+    // Start the real-time counter
+    startTimeRef.current = Date.now();
+    animationFrameRef.current = requestAnimationFrame(updateTime);
+
+    return () => {
+      if (animationFrameRef.current) {
+        cancelAnimationFrame(animationFrameRef.current);
+      }
+      if (textRef.current && currentSpanRef.contains(textNode)) {
+        currentSpanRef.removeChild(textNode);
+      }
+    };
+  }, [updateTime]);
+
+  return <span className="inline-block text-end w-[3ch]" ref={spanRef} />;
+};
+
+export const ResponseStatusBar = ({
+  status,
+  time,
+  size,
+  isFinished,
+  progress,
+}: {
+  status?: number;
+  time?: number;
+  size?: number;
+  isFinished: boolean;
+  progress: number;
+}) => {
+  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",
+  };
+
+  return (
+    <div className="relative flex h-10 text-xs gap-4 px-4 items-center justify-between font-mono border-b">
+      <div className="flex items-center gap-2">
+        <ResponseCodeCircle status={status} /> {status ?? "Sending Request..."}
+        {status ? ` ${statusCodeMap[status]}` : ""}
+      </div>
+      <div className="flex gap-2">
+        <div>
+          <span className="text-muted-foreground">Size</span>{" "}
+          <span className="inline-block text-end min-w-[5ch]">
+            {size ? humanFileSize(size) : "- B"}
+          </span>
+        </div>
+
+        <div>
+          <span className="text-muted-foreground">Time</span>{" "}
+          {time !== undefined ? `${time.toFixed(0)}` : <RealTimeCounter />}
+          ms
+        </div>
+      </div>
+      <div
+        className="h-full bg-neutral-500/10 absolute left-0 -bottom-0 z-10 transition-all duration-200 ease-in-out"
+        style={{
+          opacity: isFinished ? 0 : 1,
+          width: isFinished ? 0 : `${progress * 100}%`,
+        }}
+      />
+    </div>
+  );
+};
+
+export default ResponseStatusBar;