@fumadocs/api-docs 0.0.1

package/dist/components/schema/index.js

@@ -0,0 +1,276 @@
+"use client";
+import { mergeAllOf } from "../../schema/merge.js";
+import { schemaToString } from "../../schema/to-string.js";
+import { SchemaUI } from "./client.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useTranslations } from "@fuma-translate/react";
+//#region src/components/schema/index.tsx
+function Schema({ client, root, readOnly, writeOnly, resolver, showExample, renderMarkdown }) {
+	const t = useTranslations({ note: "schema UI" });
+	const generated = useMemo(() => {
+		return generateSchemaUI({
+			root,
+			resolver,
+			readOnly,
+			writeOnly,
+			showExample,
+			renderMarkdown,
+			labels: {
+				default: t("Default"),
+				match: t("Match"),
+				format: t("Format"),
+				multipleOf: t("Multiple Of"),
+				range: t("Range"),
+				length: t("Length"),
+				properties: t("Properties"),
+				items: t("Items"),
+				valueIn: t("Value in"),
+				example: t("Example")
+			}
+		});
+	}, [
+		root,
+		readOnly,
+		writeOnly,
+		resolver,
+		showExample,
+		renderMarkdown,
+		t
+	]);
+	return /* @__PURE__ */ jsx(SchemaUI, {
+		...client,
+		generated
+	});
+}
+function generateSchemaUI({ root, resolver, renderMarkdown, readOnly = false, writeOnly = false, showExample = false, labels }) {
+	const refs = {};
+	function generateInfoTags(schema) {
+		const fields = [];
+		if (schema.default !== void 0) fields.push({
+			label: labels.default,
+			value: JSON.stringify(schema.default)
+		});
+		if (schema.pattern) fields.push({
+			label: labels.match,
+			value: schema.pattern
+		});
+		if (schema.format) fields.push({
+			label: labels.format,
+			value: schema.format
+		});
+		if (schema.multipleOf) fields.push({
+			label: labels.multipleOf,
+			value: schema.multipleOf.toString()
+		});
+		let range = formatRange("value", schema.minimum, schema.exclusiveMinimum, schema.maximum, schema.exclusiveMaximum);
+		if (range) fields.push({
+			label: labels.range,
+			value: range
+		});
+		range = formatRange("length", schema.minLength, void 0, schema.maxLength, void 0);
+		if (range) fields.push({
+			label: labels.length,
+			value: range
+		});
+		range = formatRange("properties", schema.minProperties, void 0, schema.maxProperties, void 0);
+		if (range) fields.push({
+			label: labels.properties,
+			value: range
+		});
+		range = formatRange("items", schema.minItems, void 0, schema.maxItems, void 0);
+		if (range) fields.push({
+			label: labels.items,
+			value: range
+		});
+		if (schema.enum) fields.push({
+			label: labels.valueIn,
+			value: schema.enum.map((value) => JSON.stringify(value)).join(" | ")
+		});
+		if (showExample && schema.examples) for (const example of schema.examples) fields.push({
+			label: labels.example,
+			value: JSON.stringify(example, null, 2)
+		});
+		return fields;
+	}
+	let _counter = 0;
+	const autoIds = /* @__PURE__ */ new WeakMap();
+	function getSchemaId(schema) {
+		if (typeof schema === "boolean") return String(schema);
+		const rawRef = resolver(schema).$ref;
+		if (rawRef) return rawRef;
+		const prev = autoIds.get(schema);
+		if (prev) return prev;
+		const generated = `__${_counter++}`;
+		autoIds.set(schema, generated);
+		return generated;
+	}
+	function isVisible(schema) {
+		if (typeof schema === "boolean") return true;
+		if (schema.writeOnly) return writeOnly;
+		if (schema.readOnly) return readOnly;
+		return true;
+	}
+	function base(schema) {
+		if (typeof schema === "boolean") {
+			const name = schema ? "any" : "never";
+			return {
+				typeName: name,
+				aliasName: name
+			};
+		}
+		return {
+			description: schema.description ? renderMarkdown(schema.description) : void 0,
+			infoTags: generateInfoTags(schema),
+			typeName: schemaToString(schema, resolver),
+			aliasName: schemaToString(schema, resolver, 1),
+			deprecated: schema.deprecated
+		};
+	}
+	function scanRefs(id, schema) {
+		if (id in refs) return;
+		if (typeof schema === "boolean") {
+			refs[id] = {
+				type: "primitive",
+				...base(schema)
+			};
+			return;
+		}
+		if (Array.isArray(schema.type)) {
+			const out = {
+				type: "or",
+				items: [],
+				...base(schema)
+			};
+			refs[id] = out;
+			for (const type of schema.type) {
+				const key = `${id}_type:${type}`;
+				scanRefs(key, {
+					...schema,
+					type
+				});
+				out.items.push({
+					name: type,
+					$type: key
+				});
+			}
+			return;
+		}
+		if (schema.oneOf && schema.anyOf) {
+			const out = {
+				type: "and",
+				items: [],
+				...base(schema)
+			};
+			refs[id] = out;
+			for (const omit of ["anyOf", "oneOf"]) {
+				const $type = `${id}_omit:${omit}`;
+				scanRefs($type, {
+					...schema,
+					[omit]: void 0
+				});
+				out.items.push({
+					name: refs[$type].aliasName,
+					$type
+				});
+			}
+			return;
+		}
+		const union = schema.oneOf ?? schema.anyOf;
+		if (union) {
+			const out = {
+				type: "or",
+				items: [],
+				...base(schema)
+			};
+			refs[id] = out;
+			for (const item of union) {
+				if (!item || typeof item !== "object" || !isVisible(item)) continue;
+				const itemId = getSchemaId(item);
+				const key = `${id}_extends:${itemId}`;
+				scanRefs(key, {
+					...schema,
+					oneOf: void 0,
+					anyOf: void 0,
+					...item,
+					properties: {
+						...schema.properties,
+						...item.properties
+					}
+				});
+				out.items.push({
+					$type: key,
+					name: refs[itemId]?.aliasName ?? schemaToString(item, resolver, 1)
+				});
+			}
+			return;
+		}
+		if (schema.allOf) {
+			scanRefs(id, mergeAllOf(schema));
+			return;
+		}
+		if (schema.type === "object") {
+			const out = {
+				type: "object",
+				props: [],
+				...base(schema)
+			};
+			refs[id] = out;
+			const { properties = {}, patternProperties, additionalProperties } = schema;
+			const props = Object.entries(properties);
+			if (patternProperties) props.push(...Object.entries(patternProperties));
+			for (const [key, prop] of props) {
+				if (!prop || !isVisible(prop)) continue;
+				const $type = getSchemaId(prop);
+				scanRefs($type, prop);
+				out.props.push({
+					$type,
+					name: key,
+					required: schema.required?.includes(key) ?? false
+				});
+			}
+			if (additionalProperties && isVisible(additionalProperties)) {
+				const $type = getSchemaId(additionalProperties);
+				scanRefs($type, additionalProperties);
+				out.props.push({
+					$type,
+					name: "[key: string]",
+					required: false
+				});
+			}
+			return;
+		}
+		if (schema.type === "array") {
+			const items = schema.items ?? true;
+			const $type = getSchemaId(items);
+			refs[id] = {
+				type: "array",
+				item: { $type },
+				...base(schema)
+			};
+			scanRefs($type, items);
+			return;
+		}
+		refs[id] = {
+			type: "primitive",
+			...base(schema)
+		};
+	}
+	const $root = getSchemaId(root);
+	scanRefs($root, root);
+	return {
+		refs,
+		$root
+	};
+}
+function formatRange(value, min, exclusiveMin, max, exclusiveMax) {
+	const out = [];
+	if (min !== void 0) out.push(`${min} <=`);
+	else if (exclusiveMin !== void 0) out.push(`${exclusiveMin} <`);
+	out.push(value);
+	if (max !== void 0) out.push(`<= ${max}`);
+	else if (exclusiveMax !== void 0) out.push(`< ${exclusiveMax}`);
+	if (out.length > 1) return out.join(" ");
+}
+//#endregion
+export { Schema, generateSchemaUI };

package/dist/components/select-tab.d.ts

@@ -0,0 +1,33 @@
+import { SelectTrigger } from "./select.js";
+import { ComponentProps, ReactNode } from "react";
+
+//#region src/components/select-tab.d.ts
+declare function SelectTabs({
+  defaultValue,
+  children
+}: {
+  defaultValue?: string;
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function SelectTab({
+  value,
+  anchorSegments,
+  ...props
+}: ComponentProps<'div'> & {
+  value: string; /** define the tab as an anchor section */
+  anchorSegments?: string[];
+}): import("react").JSX.Element | undefined;
+declare function SelectTabTrigger({
+  items,
+  className,
+  placeholder,
+  ...props
+}: ComponentProps<typeof SelectTrigger> & {
+  placeholder?: ReactNode;
+  items: {
+    label: ReactNode;
+    value: string;
+  }[];
+}): import("react").JSX.Element;
+//#endregion
+export { SelectTab, SelectTabTrigger, SelectTabs };

package/dist/components/select-tab.js

@@ -0,0 +1,56 @@
+"use client";
+import { anchorIdStartsWith } from "../auto-anchor/index.js";
+import { AnchorSection, useAnchorId } from "../auto-anchor/client.js";
+import { cn } from "../utils/cn.js";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "./select.js";
+import { createContext, use, useEffect, useMemo, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/select-tab.tsx
+const Context = createContext(null);
+function SelectTabs({ defaultValue, children }) {
+	const [value, setValue] = useState(defaultValue ?? null);
+	return /* @__PURE__ */ jsx(Context, {
+		value: useMemo(() => ({
+			value,
+			setValue
+		}), [value]),
+		children
+	});
+}
+function SelectTab({ value, anchorSegments, ...props }) {
+	const { value: currentValue, setValue } = use(Context);
+	const id = useAnchorId(anchorSegments ?? false);
+	useEffect(() => {
+		if (id && anchorIdStartsWith(window.location.hash.slice(1), id)) setValue(value);
+	}, [
+		id,
+		value,
+		setValue
+	]);
+	if (value !== currentValue) return;
+	const content = /* @__PURE__ */ jsx("div", { ...props });
+	return anchorSegments ? /* @__PURE__ */ jsx(AnchorSection, {
+		segments: anchorSegments,
+		children: content
+	}) : content;
+}
+function SelectTabTrigger({ items, className, placeholder, ...props }) {
+	const { value, setValue } = use(Context);
+	return /* @__PURE__ */ jsxs(Select, {
+		value: value ?? "",
+		onValueChange: setValue,
+		children: [/* @__PURE__ */ jsx(SelectTrigger, {
+			className: cn("not-prose w-fit min-w-0 *:min-w-0", className),
+			...props,
+			children: /* @__PURE__ */ jsx(SelectValue, {
+				placeholder,
+				children: value && items.find((item) => item.value === value)?.label
+			})
+		}), /* @__PURE__ */ jsx(SelectContent, { children: items.map(({ label, value }) => /* @__PURE__ */ jsx(SelectItem, {
+			value,
+			children: label
+		}, value)) })]
+	});
+}
+//#endregion
+export { SelectTab, SelectTabTrigger, SelectTabs };

package/dist/components/select.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+
+//#region src/components/select.d.ts
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue };

package/dist/components/select.js

@@ -0,0 +1,72 @@
+import { cn } from "../utils/cn.js";
+import { forwardRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Check, ChevronDown, ChevronUp } from "lucide-react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+//#region src/components/select.tsx
+const Select = SelectPrimitive.Root;
+const SelectGroup = SelectPrimitive.Group;
+const SelectValue = SelectPrimitive.Value;
+const SelectTrigger = forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(SelectPrimitive.Trigger, {
+	ref,
+	className: cn("flex items-center w-full rounded-md border p-2 gap-2 text-start text-sm text-fd-secondary-foreground bg-fd-secondary hover:bg-fd-accent focus:outline-none focus:ring focus:ring-fd-ring disabled:cursor-not-allowed disabled:opacity-50 data-placeholder:text-fd-muted-foreground", className),
+	...props,
+	children: [children, /* @__PURE__ */ jsx(SelectPrimitive.Icon, {
+		asChild: true,
+		children: /* @__PURE__ */ jsx(ChevronDown, { className: "ms-auto size-3.5 text-fd-muted-foreground shrink-0" })
+	})]
+}));
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
+const SelectScrollUpButton = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.ScrollUpButton, {
+	ref,
+	className: cn("flex items-center justify-center py-1", className),
+	...props,
+	children: /* @__PURE__ */ jsx(ChevronUp, { className: "size-4" })
+}));
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
+const SelectScrollDownButton = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.ScrollDownButton, {
+	ref,
+	className: cn("flex items-center justify-center py-1", className),
+	...props,
+	children: /* @__PURE__ */ jsx(ChevronDown, { className: "size-4" })
+}));
+SelectScrollDownButton.displayName = SelectPrimitive.ScrollDownButton.displayName;
+const SelectContent = forwardRef(({ className, children, position, ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.Portal, { children: /* @__PURE__ */ jsxs(SelectPrimitive.Content, {
+	ref,
+	className: cn("z-50 overflow-hidden rounded-lg border bg-fd-popover text-fd-popover-foreground shadow-md", className),
+	position,
+	...props,
+	children: [
+		/* @__PURE__ */ jsx(SelectScrollUpButton, {}),
+		/* @__PURE__ */ jsx(SelectPrimitive.Viewport, {
+			className: "p-1",
+			children
+		}),
+		/* @__PURE__ */ jsx(SelectScrollDownButton, {})
+	]
+}) }));
+SelectContent.displayName = SelectPrimitive.Content.displayName;
+const SelectLabel = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.Label, {
+	ref,
+	className: cn("py-1.5 pe-2 ps-6 text-sm font-semibold", className),
+	...props
+}));
+SelectLabel.displayName = SelectPrimitive.Label.displayName;
+const SelectItem = forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(SelectPrimitive.Item, {
+	ref,
+	className: cn("flex select-none flex-row items-center rounded-md py-1.5 px-2 text-sm outline-none focus:bg-fd-accent focus:text-fd-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className),
+	...props,
+	children: [/* @__PURE__ */ jsx(SelectPrimitive.ItemText, { children }), /* @__PURE__ */ jsx(SelectPrimitive.ItemIndicator, {
+		className: "ms-auto",
+		children: /* @__PURE__ */ jsx(Check, { className: "size-3.5 text-fd-primary" })
+	})]
+}));
+SelectItem.displayName = SelectPrimitive.Item.displayName;
+const SelectSeparator = forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.Separator, {
+	ref,
+	className: cn("my-1 h-px bg-fd-muted", className),
+	...props
+}));
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName;
+//#endregion
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue };

package/dist/components/spinner.d.ts

@@ -0,0 +1,7 @@
+//#region src/components/spinner.d.ts
+declare function Spinner({
+  className,
+  ...props
+}: React.ComponentProps<'svg'>): import("react").JSX.Element;
+//#endregion
+export { Spinner };

package/dist/components/spinner.js

@@ -0,0 +1,14 @@
+import { cn } from "../utils/cn.js";
+import { jsx } from "react/jsx-runtime";
+import { Loader2Icon } from "lucide-react";
+//#region src/components/spinner.tsx
+function Spinner({ className, ...props }) {
+	return /* @__PURE__ */ jsx(Loader2Icon, {
+		role: "status",
+		"aria-label": "Loading",
+		className: cn("size-4 animate-spin", className),
+		...props
+	});
+}
+//#endregion
+export { Spinner };

package/dist/i18n.d.ts

@@ -0,0 +1,7 @@
+import { Translations } from "./.translations/index.js";
+import { TranslationExtension } from "fumadocs-core/i18n";
+
+//#region src/i18n.d.ts
+declare function apiDocsTranslations(): TranslationExtension<keyof Translations>;
+//#endregion
+export { type Translations, apiDocsTranslations };

package/dist/i18n.js

@@ -0,0 +1,7 @@
+import keys_default from "./.translations/keys.js";
+//#region src/i18n.ts
+function apiDocsTranslations() {
+	return { keys: keys_default };
+}
+//#endregion
+export { apiDocsTranslations };