zudoku 0.0.0-f3f6db5 → 0.0.0-f471fb8

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

@@ -1,19 +1,18 @@
 import { XIcon } from "lucide-react";
-import { useRef } from "react";
+import { useCallback, useEffect, useRef } from "react";
 import {
   Control,
   Controller,
   useFieldArray,
   useFormContext,
-  UseFormRegister,
 } from "react-hook-form";
 import { Card } from "zudoku/ui/Card.js";
 import { Checkbox } from "zudoku/ui/Checkbox.js";
 import { Autocomplete } from "../../../components/Autocomplete.js";
 import { Button } from "../../../ui/Button.js";
 import { Input } from "../../../ui/Input.js";
-import ParamsGrid from "./ParamsGrid.js";
-import { type PlaygroundForm } from "./Playground.js";
+import ParamsGrid, { ParamsGridItem } from "./ParamsGrid.js";
+import { Header, type PlaygroundForm } from "./Playground.js";
 
 const headerOptions = Object.freeze([
   "Accept",
@@ -46,26 +45,29 @@ const headerOptions = Object.freeze([
 
 export const Headers = ({
   control,
-  register,
+  headers: schemaHeaders,
 }: {
-  register: UseFormRegister<PlaygroundForm>;
   control: Control<PlaygroundForm>;
+  headers: Header[];
 }) => {
-  const { fields, append, remove } = useFieldArray<PlaygroundForm>({
+  const { fields, append, remove } = useFieldArray<PlaygroundForm, "headers">({
     control,
     name: "headers",
   });
-  const { setValue } = useFormContext<PlaygroundForm>();
+  const { setValue, watch } = useFormContext<PlaygroundForm>();
   const valueRefs = useRef<Array<HTMLInputElement | null>>([]);
   const nameRefs = useRef<Array<HTMLInputElement | null>>([]);
+  const watchedHeaders = watch("headers");
 
-  const addNewHeader = () => {
-    append({
-      name: "",
-      value: "",
-      active: false,
-    } as PlaygroundForm["headers"][number]);
-  };
+  const addNewHeader = useCallback(() => {
+    append({ name: "", value: "", active: false });
+  }, [append]);
+
+  useEffect(() => {
+    if (watchedHeaders.length === 0) {
+      addNewHeader();
+    }
+  }, [watchedHeaders, addNewHeader]);
 
   const handleHeaderEnter = (index: number) => {
     valueRefs.current[index]?.focus();
@@ -76,83 +78,112 @@ export const Headers = ({
     requestAnimationFrame(() => nameRefs.current[index + 1]?.focus());
   };
 
+  const missingHeaders = schemaHeaders
+    .filter((h) => !watchedHeaders.some((f) => f.name === h.name))
+    .map(({ name }) => name);
+
   return (
     <div className="flex flex-col gap-2">
       <Card className="overflow-hidden">
         <ParamsGrid>
-          {fields.map((header, i) => (
-            <div key={i} className="group grid col-span-full grid-cols-subgrid">
-              <div className="flex items-center gap-2 ">
-                <Controller
-                  control={control}
-                  name={`headers.${i}.active`}
-                  render={({ field }) => (
-                    <Checkbox
-                      variant="outline"
-                      id={`headers.${i}.active`}
-                      checked={field.value}
-                      onCheckedChange={(checked) => {
-                        field.onChange(checked);
-                      }}
-                    />
-                  )}
-                />
-                <Controller
-                  control={control}
-                  name={`headers.${i}.name`}
-                  render={({ field }) => (
-                    <Autocomplete
-                      {...field}
-                      placeholder="Name"
-                      className="border-0 shadow-none bg-transparent text-xs font-mono"
-                      options={headerOptions}
-                      onEnterPress={() => handleHeaderEnter(i)}
-                      onChange={(e) => {
-                        field.onChange(e);
-                        setValue(`headers.${i}.active`, true);
-                      }}
-                      ref={(el) => {
-                        nameRefs.current[i] = el;
-                      }}
-                    />
-                  )}
-                />
-              </div>
-              <div className="flex items-center gap-2">
-                <Controller
-                  control={control}
-                  name={`headers.${i}.value`}
-                  render={({ field }) => (
-                    <Input
-                      placeholder="Value"
-                      className="w-full border-0 shadow-none text-xs font-mono focus-visible:ring-0"
-                      {...field}
-                      ref={(el) => {
-                        valueRefs.current[i] = el;
-                      }}
-                      onKeyDown={(e) => {
-                        if (e.key === "Enter" && e.currentTarget.value.trim()) {
-                          handleValueEnter(i);
-                        }
-                      }}
-                      autoComplete="off"
-                    />
-                  )}
-                />
-                <Button
-                  size="icon"
-                  variant="ghost"
-                  className="text-muted-foreground opacity-0 group-hover:opacity-100 rounded-full w-8 h-7"
-                  onClick={() => {
-                    remove(i);
-                  }}
-                  type="button"
-                >
-                  <XIcon size={16} />
-                </Button>
-              </div>
-            </div>
-          ))}
+          {fields.map((field, i) => {
+            const currentHeader = schemaHeaders.find(
+              (h) => h.name === watch(`headers.${i}.name`),
+            );
+            return (
+              <ParamsGridItem key={field.id}>
+                <div className="flex items-center gap-2 ">
+                  <Controller
+                    control={control}
+                    name={`headers.${i}.active`}
+                    render={({ field }) => (
+                      <Checkbox
+                        id={`headers.${i}.active`}
+                        checked={field.value}
+                        onCheckedChange={(checked) => {
+                          field.onChange(checked);
+                        }}
+                      />
+                    )}
+                  />
+                  <Controller
+                    control={control}
+                    name={`headers.${i}.name`}
+                    render={({ field }) => (
+                      <Autocomplete
+                        {...field}
+                        placeholder="Name"
+                        className="border-0 shadow-none bg-transparent text-xs font-mono"
+                        options={[...missingHeaders, ...headerOptions]}
+                        onEnterPress={() => handleHeaderEnter(i)}
+                        onChange={(e) => {
+                          field.onChange(e);
+                          setValue(`headers.${i}.active`, true);
+                        }}
+                        ref={(el) => {
+                          nameRefs.current[i] = el;
+                        }}
+                      />
+                    )}
+                  />
+                </div>
+                <div className="flex items-center gap-2">
+                  <Controller
+                    control={control}
+                    name={`headers.${i}.value`}
+                    render={({ field }) => {
+                      const hasEnum =
+                        currentHeader?.enum && currentHeader.enum.length > 0;
+
+                      if (!hasEnum) {
+                        return (
+                          <Input
+                            placeholder="Value"
+                            className="w-full border-0 shadow-none text-xs font-mono focus-visible:ring-0"
+                            {...field}
+                            ref={(el) => {
+                              valueRefs.current[i] = el;
+                            }}
+                            onKeyDown={(e) => {
+                              if (
+                                e.key === "Enter" &&
+                                e.currentTarget.value.trim()
+                              ) {
+                                handleValueEnter(i);
+                              }
+                            }}
+                            autoComplete="off"
+                          />
+                        );
+                      }
+
+                      return (
+                        <Autocomplete
+                          shouldFilter={false}
+                          value={field.value}
+                          options={currentHeader.enum ?? []}
+                          onChange={(e) => {
+                            field.onChange(e);
+                            setValue(`headers.${i}.active`, true);
+                          }}
+                          className="font-mono text-xs border-0"
+                        />
+                      );
+                    }}
+                  />
+                  <Button
+                    size="icon"
+                    variant="ghost"
+                    className="text-muted-foreground opacity-0 group-hover:opacity-100 rounded-full w-8 h-7"
+                    onClick={() => remove(i)}
+                    type="button"
+                  >
+                    <XIcon size={16} />
+                  </Button>
+                </div>
+              </ParamsGridItem>
+            );
+          })}
         </ParamsGrid>
       </Card>
       <div className="text-end">

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

@@ -0,0 +1,74 @@
+import { useState } from "react";
+import { Button } from "zudoku/ui/Button.js";
+import { Checkbox } from "zudoku/ui/Checkbox.js";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogTitle,
+} from "zudoku/ui/Dialog.js";
+import { Label } from "zudoku/ui/Label.js";
+import { type ApiIdentity } from "../../../core/ZudokuContext.js";
+import IdentitySelector from "./IdentitySelector.js";
+
+const IdentityDialog = ({
+  onSubmit,
+  identities,
+  open,
+  onOpenChange,
+}: {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onSubmit: ({
+    rememberedIdentity,
+    identity,
+  }: {
+    rememberedIdentity: boolean;
+    identity?: string;
+  }) => void;
+  identities: ApiIdentity[];
+}) => {
+  const [identity, setIdentity] = useState<string | undefined>(undefined);
+  const [rememberedIdentity, setRememberedIdentity] = useState<boolean>(false);
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent>
+        <DialogTitle>Select an auth identity</DialogTitle>
+        <DialogDescription>
+          Please select an identity for this request.
+        </DialogDescription>
+        <div className="max-h-80 overflow-auto">
+          <IdentitySelector
+            identities={identities}
+            setValue={setIdentity}
+            value={identity}
+          />
+        </div>
+        <DialogFooter className="flex flex-col gap-2">
+          <div className="flex items-center gap-2">
+            <Checkbox
+              id="remember"
+              checked={rememberedIdentity}
+              onCheckedChange={(checked) =>
+                setRememberedIdentity(
+                  checked === "indeterminate" ? false : !!checked,
+                )
+              }
+            />
+            <Label htmlFor="remember">Remember my choice</Label>
+          </div>
+
+          <Button
+            onClick={() => onSubmit({ identity: identity, rememberedIdentity })}
+          >
+            Send
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+};
+
+export { IdentityDialog };

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

@@ -0,0 +1,54 @@
+import { Card } from "zudoku/ui/Card.js";
+import { Label } from "zudoku/ui/Label.js";
+import { RadioGroup, RadioGroupItem } from "zudoku/ui/RadioGroup.js";
+import { type ApiIdentity } from "../../../core/ZudokuContext.js";
+import { NO_IDENTITY } from "./Playground.js";
+
+const IdentitySelector = ({
+  identities,
+  setValue,
+  value,
+}: {
+  identities?: ApiIdentity[];
+  setValue: (value: string) => void;
+  value?: string;
+}) => {
+  return (
+    <Card className="w-full overflow-hidden">
+      <RadioGroup
+        onValueChange={(value) => setValue(value)}
+        value={value}
+        defaultValue={NO_IDENTITY}
+        className="gap-0"
+        disabled={identities?.length === 0}
+      >
+        <Label
+          className="h-12 border-b items-center flex p-4 cursor-pointer hover:bg-accent"
+          htmlFor="none"
+        >
+          <RadioGroupItem value={NO_IDENTITY} id="none">
+            None
+          </RadioGroupItem>
+          <Label htmlFor="none" className="ml-2">
+            None
+          </Label>
+        </Label>
+        {identities?.map((identity) => (
+          <Label
+            key={identity.id}
+            className="h-12 border-b items-center flex p-4 cursor-pointer hover:bg-accent"
+          >
+            <RadioGroupItem value={identity.id} id={identity.id}>
+              {identity.label}
+            </RadioGroupItem>
+            <Label htmlFor={identity.id} className="ml-2">
+              {identity.label}
+            </Label>
+          </Label>
+        ))}
+      </RadioGroup>
+    </Card>
+  );
+};
+
+export default IdentitySelector;

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

@@ -2,7 +2,12 @@ import createVariantComponent from "../../../util/createVariantComponent.js";
 
 const ParamsGrid = createVariantComponent(
   "div",
-  "hover:bg-accent/40 grid grid-cols-[2fr_3fr] gap-2 items-center px-3",
+  "grid grid-cols-[2fr_3fr] gap-2 items-center",
+);
+
+export const ParamsGridItem = createVariantComponent(
+  "div",
+  "group hover:bg-accent px-3 grid col-span-full grid-cols-subgrid",
 );
 
 export default ParamsGrid;

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

@@ -1,33 +1,39 @@
-import { Control, Controller, useFieldArray } from "react-hook-form";
+import { type Control, Controller, useFieldArray } from "react-hook-form";
 import { Card } from "zudoku/ui/Card.js";
 import { Input } from "../../../ui/Input.js";
 import { ColorizedParam } from "../ColorizedParam.js";
-import ParamsGrid from "./ParamsGrid.js";
+import ParamsGrid, { ParamsGridItem } from "./ParamsGrid.js";
 import type { PlaygroundForm } from "./Playground.js";
 
 export const PathParams = ({
   control,
+  url,
 }: {
   control: Control<PlaygroundForm>;
+  url: string;
 }) => {
-  const { fields } = useFieldArray<PlaygroundForm>({
+  const { fields } = useFieldArray<PlaygroundForm, "pathParams">({
     control,
     name: "pathParams",
   });
 
+  const sortedFields = [...fields].sort(
+    (a, b) => url.indexOf(`{${a.name}}`) - url.indexOf(`{${b.name}}`),
+  );
+
   return (
     <Card className="rounded-lg">
       <ParamsGrid>
-        {fields.map((part, i) => (
-          <>
+        {sortedFields.map((field, i) => (
+          <ParamsGridItem key={field.id}>
             <Controller
               control={control}
               name={`pathParams.${i}.name`}
               render={() => (
-                <div>
+                <div className="flex items-center">
                   <ColorizedParam
-                    slug={part.name}
-                    name={part.name}
+                    slug={field.name}
+                    name={field.name}
                     className="font-mono text-xs px-2"
                   />
                 </div>
@@ -43,12 +49,12 @@ export const PathParams = ({
                     {...field}
                     required
                     placeholder="Enter value"
-                    className="w-full border-0 shadow-none text-xs font-mono hover:bg-accent"
+                    className="w-full border-0 shadow-none text-xs font-mono focus-visible:ring-0"
                   />
                 )}
               />
             </div>
-          </>
+          </ParamsGridItem>
         ))}
       </ParamsGrid>
     </Card>