zudoku 0.0.0-eb4182d → 0.0.0-eeace45

package/src/lib/plugins/openapi/schema/SchemaView.tsx

@@ -67,10 +67,13 @@ export const SchemaView = ({
       }
     }
 
-    if (schema.type === "object" && !schema.properties) {
+    if (
+      schema.type === "object" &&
+      (!schema.properties || Object.keys(schema.properties).length === 0)
+    ) {
       return (
         <Card className="p-4 flex gap-2 items-center">
-          {"name" in schema && <>{schema.name}</>}
+          {"name" in schema && <>{schema.name as string}</>}
           <span className="text-sm text-muted-foreground">object</span>
           {schema.description && (
             <Markdown

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

@@ -1,72 +1,58 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { type SchemaObject } from "../../../oas/graphql/index.js";
 
-export const isObject = (value: unknown): boolean =>
-  typeof value === "object" && value !== null && !Array.isArray(value);
-
 export const generateSchemaExample = (
   schema: SchemaObject,
   name?: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): any => {
   // Directly return the example or default if they exist
   if (schema.example !== undefined) {
     return schema.example;
+  } else if (schema.examples) {
+    return Object.values(schema.examples)[0];
   } else if (schema.default !== undefined) {
     return schema.default;
   }
 
-  // Process examples object
-  if (schema.examples && isObject(schema.examples)) {
-    return Object.values(schema.examples)[0];
-  }
-
-  // Recursively process objects and arrays
-  return processComplexTypes(schema, name);
-};
+  if (schema.properties || schema.type === "object") {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const example: any = {};
 
-function processComplexTypes(schema: SchemaObject, name?: string): any {
-  const properties = Object.entries(schema.properties ?? {}).concat(
-    Object.entries(schema.additionalProperties ?? {}),
-  );
-  if (schema.type === "object" && properties.length > 0) {
-    const obj: { [key: string]: any } = {};
-    properties.forEach(([key, propSchema]) => {
-      const value = generateSchemaExample(propSchema, key);
-      if (value !== undefined) {
-        obj[key] = value;
+    if (schema.properties) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        example[key] = generateSchemaExample(propSchema as SchemaObject, key);
       }
-    });
-    return obj;
-  } else if (schema.type === "array" && schema.items) {
-    const value = generateSchemaExample(schema.items, name);
-    if (value !== undefined) {
-      return [value];
+    }
+    return example;
+  }
+
+  if (schema.type === "array") {
+    if (Array.isArray(schema.items)) {
+      return schema.items.map((itemSchema) =>
+        generateSchemaExample(itemSchema as SchemaObject),
+      );
+    } else if (schema.items) {
+      return [generateSchemaExample(schema.items as SchemaObject)];
     }
     return [];
   }
-  // Fallback for missing or undefined types
-  return undefined; //getDefaultForType(schema.type);
-}
 
-function getDefaultForType(type?: string | string[]): any {
-  if (Array.isArray(type)) {
-    return getDefaultForSingleType(type[0]);
+  if (schema.enum) {
+    return schema.enum[0];
   }
-  return getDefaultForSingleType(type);
-}
 
-function getDefaultForSingleType(type?: string): any {
-  switch (type) {
+  switch (schema.type) {
     case "string":
-      return "";
+      return name || "string";
     case "number":
     case "integer":
       return 0;
     case "boolean":
-      return false;
+      return true;
     case "null":
       return null;
+    case undefined:
     default:
-      return "undefined";
+      return {};
   }
-}
+};

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

@@ -0,0 +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
+  );
+};

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

@@ -0,0 +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;")
+  );
+}

package/src/lib/plugins/openapi-worker.ts

@@ -1 +1,11 @@
-export { createClient } from "./openapi/client/createWorkerClient.js";
+export const initializeWorker = () => {
+  const worker = new SharedWorker(
+    new URL("./openapi/client/worker.ts", import.meta.url),
+    { type: "module" },
+  );
+  // eslint-disable-next-line no-console
+  worker.onerror = (e) => console.error(e);
+  worker.port.start();
+
+  return worker;
+};

package/src/lib/plugins/redirect/index.tsx

@@ -1,19 +1,15 @@
-import { redirect } from "react-router-dom";
-import type { DevPortalPlugin } from "../../core/plugins.js";
-
-export type Redirect = {
-  from: string;
-  to: string;
-};
+import { redirect } from "react-router";
+import { ZudokuRedirect } from "../../../config/validators/common.js";
+import type { ZudokuPlugin } from "../../core/plugins.js";
 
 export const redirectPlugin = (options: {
-  redirects: Redirect[];
-}): DevPortalPlugin => {
+  redirects: ZudokuRedirect[];
+}): ZudokuPlugin => {
   return {
     getRoutes: () =>
       options.redirects.map(({ from, to }) => ({
         path: from,
-        loader: () => redirect(to),
+        loader: () => redirect(to, 301),
       })),
   };
 };

package/src/lib/plugins/search-inkeep/index.tsx

@@ -1,22 +1,31 @@
-import type { InkeepWidgetBaseSettings } from "@inkeep/widgets";
-import { lazy } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { ClientOnly } from "../../components/ClientOnly.js";
-import type { DevPortalPlugin } from "../../core/plugins.js";
+import type { ZudokuPlugin } from "../../core/plugins.js";
 import { aiChatSettings, baseSettings } from "./inkeep.js";
 
-type PickedPluginInkeepBaseSettings =
-  | "apiKey"
-  | "integrationId"
-  | "organizationId"
-  | "primaryBrandColor"
-  | "organizationDisplayName";
+interface PluginInkeepBaseSettings {
+  apiKey?: string;
+  integrationId: string;
+  organizationId: string;
+  organizationDisplayName?: string;
+  primaryBrandColor: string;
+}
 
-type PluginInkeepBaseSettings = Pick<
-  InkeepWidgetBaseSettings,
-  PickedPluginInkeepBaseSettings
->;
+interface InkeepEmbedConfig {
+  componentType: string;
+  targetElement: HTMLElement;
+  properties: unknown;
+}
 
-const Inkeep = lazy(() => import("./InkeepCustomTrigger.js"));
+interface InkeepWidget {
+  render: (config: InkeepEmbedConfig & { isOpen: boolean }) => void;
+}
+
+declare global {
+  let Inkeep: () => {
+    embed: (config: InkeepEmbedConfig) => InkeepWidget;
+  };
+}
 
 const InkeepSearch = ({
   prefilledQuery,
@@ -29,23 +38,69 @@ const InkeepSearch = ({
   prefilledQuery?: string | null;
   settings: PluginInkeepBaseSettings;
 }) => {
-  return (
-    <Inkeep
-      isOpen={isOpen}
-      onClose={onClose}
-      baseSettings={{ ...baseSettings, ...settings }}
-      aiChatSettings={aiChatSettings}
-      searchSettings={{
-        prefilledQuery: prefilledQuery || undefined,
-      }}
-    />
+  const ref = useRef<HTMLDivElement>(null);
+  const widgetRef = useRef<InkeepWidget | null>(null);
+  const [isInkeepAvailable, setIsInkeepAvailable] = useState(
+    typeof Inkeep !== "undefined",
+  );
+
+  const config: InkeepEmbedConfig = useMemo(
+    () => ({
+      componentType: "CustomTrigger",
+      targetElement: ref.current!,
+      properties: {
+        isOpen,
+        onClose,
+        onOpen: undefined,
+        baseSettings: { ...baseSettings, ...settings },
+        searchSettings: {
+          prefilledQuery: prefilledQuery || undefined,
+        },
+        aiChatSettings,
+      },
+    }),
+    [isOpen, onClose, prefilledQuery, settings, ref],
   );
+
+  useEffect(() => {
+    if (isInkeepAvailable) return;
+
+    const checkInkeep = setInterval(() => {
+      if (typeof Inkeep !== "undefined") {
+        setIsInkeepAvailable(true);
+        clearInterval(checkInkeep);
+      }
+    }, 100);
+
+    return () => clearInterval(checkInkeep);
+  }, [isInkeepAvailable]);
+
+  useEffect(() => {
+    if (!isInkeepAvailable || widgetRef.current) return;
+
+    widgetRef.current = Inkeep().embed(config);
+  }, [config, isInkeepAvailable]);
+
+  useEffect(() => {
+    widgetRef.current?.render({ ...config, isOpen });
+  }, [config, isOpen]);
+
+  return <div ref={ref} />;
 };
 
 export const inkeepSearchPlugin = (
   settings: PluginInkeepBaseSettings,
-): DevPortalPlugin => {
+): ZudokuPlugin => {
   return {
+    getHead: () => {
+      return (
+        <script
+          type="module"
+          src="https://unpkg.com/@inkeep/uikit-js@0.3.19/dist/embed.js"
+          defer
+        />
+      );
+    },
     renderSearch: ({
       isOpen,
       onClose,

package/src/lib/plugins/search-inkeep/inkeep.ts

@@ -1,9 +1,3 @@
-import {
-  InkeepAIChatSettings,
-  InkeepModalSettings,
-  InkeepSearchSettings,
-} from "@inkeep/widgets";
-
 const baseSettings = {
   theme: {
     components: {
@@ -23,10 +17,10 @@ const baseSettings = {
   },
 } as const;
 
-const modalSettings: InkeepModalSettings = {};
+const modalSettings = {};
 
-const searchSettings: InkeepSearchSettings = {};
+const searchSettings = {};
 
-const aiChatSettings: InkeepAIChatSettings = {};
+const aiChatSettings = {};
 
 export { aiChatSettings, baseSettings, modalSettings, searchSettings };

package/src/lib/ui/Accordion.tsx

@@ -0,0 +1,56 @@
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+import { ChevronDown } from "lucide-react";
+import * as React from "react";
+
+import { cn } from "../util/cn.js";
+
+const Accordion = AccordionPrimitive.Root;
+
+const AccordionItem = React.forwardRef<
+  React.ElementRef<typeof AccordionPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item>
+>(({ className, ...props }, ref) => (
+  <AccordionPrimitive.Item
+    ref={ref}
+    className={cn("border-b", className)}
+    {...props}
+  />
+));
+AccordionItem.displayName = "AccordionItem";
+
+const AccordionTrigger = React.forwardRef<
+  React.ElementRef<typeof AccordionPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger>
+>(({ className, children, ...props }, ref) => (
+  <AccordionPrimitive.Header className="flex">
+    <AccordionPrimitive.Trigger
+      ref={ref}
+      className={cn(
+        "flex flex-1 items-center justify-between py-4 font-medium transition-all hover:underline [&[data-state=open]>svg]:rotate-180",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <ChevronDown className="h-4 w-4 shrink-0 transition-transform duration-200" />
+    </AccordionPrimitive.Trigger>
+  </AccordionPrimitive.Header>
+));
+AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName;
+
+const AccordionContent = React.forwardRef<
+  React.ElementRef<typeof AccordionPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content>
+>(({ className, children, ...props }, ref) => (
+  <AccordionPrimitive.Content
+    ref={ref}
+    className="overflow-hidden text-sm transition-all data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down"
+    {...props}
+  >
+    <div className={cn("pb-4 pt-0", className)}>{children}</div>
+  </AccordionPrimitive.Content>
+));
+
+AccordionContent.displayName = AccordionPrimitive.Content.displayName;
+
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger };

package/src/lib/ui/ActionButton.tsx

@@ -0,0 +1,28 @@
+import { forwardRef } from "react";
+import { Button, type ButtonProps } from "zudoku/ui/Button.js";
+import { Spinner } from "../components/Spinner.js";
+import { cn } from "../util/cn.js";
+
+type ActionButtonProps = ButtonProps & { isPending?: boolean };
+
+export const ActionButton = forwardRef<HTMLButtonElement, ActionButtonProps>(
+  ({ isPending, children, className, ...props }: ActionButtonProps, ref) => {
+    return (
+      <Button
+        ref={ref}
+        disabled={isPending}
+        {...props}
+        className={cn("relative", className)}
+      >
+        {isPending && (
+          <div className="absolute inset-0 grid place-items-center">
+            <Spinner />
+          </div>
+        )}
+        <div className={cn(isPending && "invisible")}>{children}</div>
+      </Button>
+    );
+  },
+);
+
+ActionButton.displayName = "ActionButton";

package/src/lib/ui/{Note.tsx → Alert.tsx}

@@ -1,8 +1,9 @@
 import { cva, type VariantProps } from "class-variance-authority";
 import * as React from "react";
+
 import { cn } from "../util/cn.js";
 
-const noteVariants = cva(
+const alertVariants = cva(
   "relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground",
   {
     variants: {
@@ -18,20 +19,20 @@ const noteVariants = cva(
   },
 );
 
-const Note = React.forwardRef<
+const Alert = React.forwardRef<
   HTMLDivElement,
-  React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof noteVariants>
+  React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>
 >(({ className, variant, ...props }, ref) => (
   <div
     ref={ref}
     role="alert"
-    className={cn(noteVariants({ variant }), className)}
+    className={cn(alertVariants({ variant }), className)}
     {...props}
   />
 ));
-Note.displayName = "Alert";
+Alert.displayName = "Alert";
 
-const NoteTitle = React.forwardRef<
+const AlertTitle = React.forwardRef<
   HTMLParagraphElement,
   React.HTMLAttributes<HTMLHeadingElement>
 >(({ className, ...props }, ref) => (
@@ -41,9 +42,9 @@ const NoteTitle = React.forwardRef<
     {...props}
   />
 ));
-NoteTitle.displayName = "AlertTitle";
+AlertTitle.displayName = "AlertTitle";
 
-const NoteDescription = React.forwardRef<
+const AlertDescription = React.forwardRef<
   HTMLParagraphElement,
   React.HTMLAttributes<HTMLParagraphElement>
 >(({ className, ...props }, ref) => (
@@ -53,6 +54,6 @@ const NoteDescription = React.forwardRef<
     {...props}
   />
 ));
-NoteDescription.displayName = "AlertDescription";
+AlertDescription.displayName = "AlertDescription";
 
-export { Note, NoteDescription, NoteTitle };
+export { Alert, AlertDescription, AlertTitle };

package/src/lib/ui/AlertDialog.tsx

@@ -0,0 +1,139 @@
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+import * as React from "react";
+
+import { cn } from "../util/cn.js";
+import { buttonVariants } from "./Button.js";
+
+const AlertDialog = AlertDialogPrimitive.Root;
+
+const AlertDialogTrigger = AlertDialogPrimitive.Trigger;
+
+const AlertDialogPortal = AlertDialogPrimitive.Portal;
+
+const AlertDialogOverlay = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Overlay>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Overlay>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Overlay
+    className={cn(
+      "fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      className,
+    )}
+    {...props}
+    ref={ref}
+  />
+));
+AlertDialogOverlay.displayName = AlertDialogPrimitive.Overlay.displayName;
+
+const AlertDialogContent = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Content>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPortal>
+    <AlertDialogOverlay />
+    <AlertDialogPrimitive.Content
+      ref={ref}
+      className={cn(
+        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+        className,
+      )}
+      {...props}
+    />
+  </AlertDialogPortal>
+));
+AlertDialogContent.displayName = AlertDialogPrimitive.Content.displayName;
+
+const AlertDialogHeader = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      "flex flex-col space-y-2 text-center sm:text-left",
+      className,
+    )}
+    {...props}
+  />
+);
+AlertDialogHeader.displayName = "AlertDialogHeader";
+
+const AlertDialogFooter = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
+      className,
+    )}
+    {...props}
+  />
+);
+AlertDialogFooter.displayName = "AlertDialogFooter";
+
+const AlertDialogTitle = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Title>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Title>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Title
+    ref={ref}
+    className={cn("text-lg font-semibold", className)}
+    {...props}
+  />
+));
+AlertDialogTitle.displayName = AlertDialogPrimitive.Title.displayName;
+
+const AlertDialogDescription = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Description>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Description>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Description
+    ref={ref}
+    className={cn("text-sm text-muted-foreground", className)}
+    {...props}
+  />
+));
+AlertDialogDescription.displayName =
+  AlertDialogPrimitive.Description.displayName;
+
+const AlertDialogAction = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Action>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Action>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Action
+    ref={ref}
+    className={cn(buttonVariants(), className)}
+    {...props}
+  />
+));
+AlertDialogAction.displayName = AlertDialogPrimitive.Action.displayName;
+
+const AlertDialogCancel = React.forwardRef<
+  React.ElementRef<typeof AlertDialogPrimitive.Cancel>,
+  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Cancel>
+>(({ className, ...props }, ref) => (
+  <AlertDialogPrimitive.Cancel
+    ref={ref}
+    className={cn(
+      buttonVariants({ variant: "outline" }),
+      "mt-2 sm:mt-0",
+      className,
+    )}
+    {...props}
+  />
+));
+AlertDialogCancel.displayName = AlertDialogPrimitive.Cancel.displayName;
+
+export {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogOverlay,
+  AlertDialogPortal,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+};

package/src/lib/ui/AspectRatio.tsx

@@ -0,0 +1,5 @@
+import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio";
+
+const AspectRatio = AspectRatioPrimitive.Root;
+
+export { AspectRatio };