@stainless-api/docs-ui 0.1.0-beta.47 → 0.1.0-beta.49

package/dist/overview-S2hUqPXA.js

@@ -0,0 +1,139 @@
+import { a as useLanguage, l as useSpec, r as useDeclaration } from "./docs-CXqi26jB.js";
+import { n as useLanguageComponents } from "./contexts-p3rRZDlM.js";
+import { t as useComponents } from "./use-components-RWQbviGq.js";
+import { t as style_default } from "./style-gnVEeXFj.js";
+import { i as PropertyToggle } from "./properties-jlGW3USi.js";
+import { f as parseStainlessPath } from "./routing-Wbb7YECB.js";
+import { s as Markdown } from "./primitives-BIWfwN5L.js";
+import { n as getResourceFromSpec, t as flatResources } from "./utils-D_1AWSRX.js";
+import * as React$1 from "react";
+import { createElement } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ChevronRight } from "lucide-react";
+
+//#region src/components/overview.tsx
+function SDKResourceHeader({ resource, parents }) {
+	const segments = parents?.map((parent, index) => /* @__PURE__ */ jsxs("span", {
+		className: style_default.ResourceTitleSegment,
+		children: [parent.title, index < parents.length && /* @__PURE__ */ jsx(ChevronRight, {
+			size: 16,
+			className: style_default.Icon
+		})]
+	}, parent.stainlessPath));
+	if (!segments && !resource.description) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: style_default.ResourceHeader,
+		children: [segments && /* @__PURE__ */ jsxs("h4", {
+			id: resource.stainlessPath,
+			className: style_default.ResourceTitle,
+			children: [segments, /* @__PURE__ */ jsx("span", {
+				className: style_default.ResourceTitleSegment,
+				children: resource.title
+			})]
+		}), resource.description && /* @__PURE__ */ jsx("div", {
+			className: style_default.ResourceDescription,
+			children: /* @__PURE__ */ jsx(Markdown, { content: resource.description })
+		})]
+	});
+}
+function SDKMethodSummary({ method }) {
+	const Docs = useComponents();
+	const Lang = useLanguageComponents();
+	const decl = useDeclaration(method.stainlessPath, true);
+	return /* @__PURE__ */ jsx(Docs.MethodHeader, {
+		level: "h5",
+		title: /* @__PURE__ */ jsx(Docs.Link, {
+			stainlessPath: method.stainlessPath,
+			children: method.summary ?? method.title
+		}),
+		signature: /* @__PURE__ */ jsx(Lang.MethodSignature, { decl }),
+		badges: method.deprecated && /* @__PURE__ */ jsx(Docs.Badge, {
+			id: "deprecated",
+			children: "Deprecated"
+		}),
+		children: /* @__PURE__ */ jsx(Docs.MethodRoute, {
+			httpMethod: method.httpMethod,
+			endpoint: method.endpoint.split(" ", 2).at(-1)
+		})
+	});
+}
+function SDKResource({ resource, parents, showModels }) {
+	const Docs = useComponents();
+	const language = useLanguage();
+	const spec = useSpec();
+	const methods = Object.values(resource.methods).filter((method) => spec?.decls?.[language]?.[method.stainlessPath]);
+	const models = Object.values(resource.models).filter((model) => spec?.decls?.[language]?.[`${model.stainlessPath} > (schema)`]);
+	return /* @__PURE__ */ jsx("div", {
+		className: style_default.Resource,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: style_default.ResourceContent,
+			children: [
+				/* @__PURE__ */ jsx(Docs.SDKResourceHeader, {
+					resource,
+					parents
+				}),
+				methods.length > 0 && /* @__PURE__ */ jsx("div", {
+					className: style_default.ResourceContentGroup,
+					children: methods.map((method) => /* @__PURE__ */ jsx("div", {
+						className: style_default.MethodSummary,
+						children: /* @__PURE__ */ jsx(Docs.SDKMethodSummary, { method })
+					}, method.stainlessPath))
+				}),
+				showModels !== false && models.length > 0 && /* @__PURE__ */ jsxs("div", {
+					className: style_default.ResourceContentGroup,
+					"data-stldocs-property-group": "models",
+					children: [/* @__PURE__ */ jsxs("h5", {
+						className: style_default.ResourceContentGroupModelTitle,
+						children: ["Models", /* @__PURE__ */ jsx(PropertyToggle, { target: "models" })]
+					}), models.map((model) => /* @__PURE__ */ jsx(Docs.SDKModel, { model }, model.stainlessPath))]
+				})
+			]
+		})
+	});
+}
+function SDKOverview({ resource }) {
+	const { SDKResource: SDKResource$1 } = useComponents();
+	const nested = React$1.useMemo(() => flatResources(resource.subresources, [resource]), [resource]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: style_default.Overview,
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				className: style_default.OverviewHeader,
+				children: /* @__PURE__ */ jsx("h1", { children: resource.title })
+			}),
+			/* @__PURE__ */ jsx(SDKResource$1, { resource }),
+			nested.map((props, index) => /* @__PURE__ */ createElement(SDKResource$1, {
+				...props,
+				key: index
+			}))
+		]
+	});
+}
+function SDKRoot({ stainlessPath }) {
+	const spec = useSpec();
+	const Docs = useComponents();
+	const parsed = parseStainlessPath(stainlessPath);
+	const resource = spec && getResourceFromSpec(stainlessPath, spec);
+	if (!resource || !parsed) {
+		console.warn(`Could not find resource or parsed path for '${stainlessPath}'`);
+		return null;
+	}
+	if (parsed.method) {
+		const method = resource.methods[parsed.method];
+		if (!method) {
+			console.warn(`Method '${parsed.method}' not found in resource '${resource.stainlessPath}'`);
+			return null;
+		}
+		return /* @__PURE__ */ jsx("div", {
+			className: style_default.Root,
+			children: /* @__PURE__ */ jsx(Docs.SDKMethod, { method })
+		});
+	}
+	return /* @__PURE__ */ jsx("div", {
+		className: style_default.Root,
+		children: /* @__PURE__ */ jsx(Docs.SDKOverview, { resource })
+	});
+}
+
+//#endregion
+export { SDKRoot as a, SDKResourceHeader as i, SDKOverview as n, SDKResource as r, SDKMethodSummary as t };

package/dist/primitives-BIWfwN5L.js

@@ -0,0 +1,258 @@
+import { a as useLanguage, s as useSettings } from "./docs-CXqi26jB.js";
+import { n as useNavigation } from "./navigation-C5TN0SgC.js";
+import { a as useRenderMarkdown } from "./markdown-CxdeWgjV.js";
+import { t as style_default } from "./style-gnVEeXFj.js";
+import { o as generateRoute } from "./routing-Wbb7YECB.js";
+import * as React$1 from "react";
+import { Fragment, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { MinusIcon, PlusIcon } from "lucide-react";
+import clsx from "clsx";
+
+//#region src/components/primitives.tsx
+function Join({ items, limit, children }) {
+	return (limit && items.length > limit + 1 ? [...items.slice(0, limit), /* @__PURE__ */ jsxs("span", {
+		className: style_default.Truncation,
+		children: [items.length - limit, " more"]
+	}, "truncation")] : items).map((item, index) => /* @__PURE__ */ jsxs(Fragment, { children: [!!index && children, item] }, `iterator:${index}`));
+}
+function Expander({ id, open, summary, virtual, muted, children }) {
+	const virtualExpanders = useSettings()?.virtualExpanders;
+	if (virtual || virtualExpanders) return /* @__PURE__ */ jsx(VirtualExpander, {
+		summary,
+		open,
+		muted,
+		id,
+		children
+	});
+	return /* @__PURE__ */ jsxs("details", {
+		className: style_default.Expander,
+		open,
+		"data-stldocs-expander-muted": muted,
+		"data-stldocs-expander-initial-state": open,
+		children: [/* @__PURE__ */ jsxs("summary", {
+			className: style_default.ExpanderSummary,
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: style_default.ExpanderSummaryIcon,
+				children: [/* @__PURE__ */ jsx(PlusIcon, {
+					size: 16,
+					strokeWidth: 1,
+					className: style_default.Icon
+				}), /* @__PURE__ */ jsx(MinusIcon, {
+					size: 16,
+					strokeWidth: 1,
+					className: style_default.Icon
+				})]
+			}), /* @__PURE__ */ jsx("div", {
+				className: style_default.ExpanderSummaryContent,
+				children: summary
+			})]
+		}), /* @__PURE__ */ jsx("div", {
+			className: style_default.ExpanderContent,
+			id,
+			children
+		})]
+	});
+}
+function VirtualExpander({ id, open: isOpen, muted, summary, children }) {
+	const [open, setOpen] = useState(isOpen);
+	React$1.useEffect(() => {
+		if (isOpen) setOpen(true);
+	}, [isOpen]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: style_default.Expander,
+		"data-open": open,
+		"data-stldocs-expander-muted": muted,
+		"data-stldocs-expander-initial-state": open,
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: style_default.ExpanderSummary,
+			onClick: () => setOpen(!open),
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: style_default.ExpanderSummaryIcon,
+				children: [/* @__PURE__ */ jsx(PlusIcon, {
+					size: 16,
+					className: style_default.Icon
+				}), /* @__PURE__ */ jsx(MinusIcon, {
+					size: 16,
+					className: style_default.Icon
+				})]
+			}), /* @__PURE__ */ jsx("div", {
+				className: style_default.ExpanderSummaryContent,
+				children: summary
+			})]
+		}), open && /* @__PURE__ */ jsx("div", {
+			className: style_default.ExpanderContent,
+			id,
+			children
+		})]
+	});
+}
+function Markdown({ content }) {
+	const rendered = useRenderMarkdown(content);
+	return rendered && /* @__PURE__ */ jsx("div", {
+		className: clsx(style_default.Markdown, style_default.Content, "stl-ui-prose"),
+		dangerouslySetInnerHTML: { __html: rendered }
+	});
+}
+function Badge({ id, children }) {
+	return /* @__PURE__ */ jsx("span", {
+		className: style_default.Badge,
+		"data-badge-id": id,
+		children: children ?? id
+	});
+}
+const TooltipNestingContext = React$1.createContext(false);
+function Tooltip({ content, children }) {
+	if (React$1.useContext(TooltipNestingContext)) return children;
+	return /* @__PURE__ */ jsxs("span", {
+		className: style_default.Tooltip,
+		children: [/* @__PURE__ */ jsx("span", {
+			className: style_default.TooltipContent,
+			children: /* @__PURE__ */ jsx(TooltipNestingContext.Provider, {
+				value: true,
+				children: content
+			})
+		}), /* @__PURE__ */ jsx("span", {
+			className: style_default.TooltipHost,
+			children
+		})]
+	});
+}
+function Link({ stainlessPath, scroll = true, children, ...props }) {
+	const { basePath, onNavigate } = useNavigation();
+	const language = useLanguage();
+	const href = React$1.useMemo(() => {
+		if (props.href) return props.href;
+		if (stainlessPath && basePath) return generateRoute(basePath, language, stainlessPath);
+	}, [
+		basePath,
+		language,
+		stainlessPath,
+		props.href
+	]);
+	const handleClick = React$1.useCallback((e) => {
+		if (props.onClick) props.onClick(e);
+		if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+		if (href) onNavigate?.(e, {
+			href,
+			language,
+			stainlessPath,
+			scroll
+		});
+	}, [
+		href,
+		scroll,
+		onNavigate,
+		language,
+		props,
+		stainlessPath
+	]);
+	if (!href) return children;
+	return /* @__PURE__ */ jsx("a", {
+		href,
+		onClick: handleClick,
+		...props,
+		children
+	});
+}
+const Input = React$1.forwardRef(function Input$1({ left, right, ...props }, ref) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: style_default.Input,
+		children: [
+			left,
+			/* @__PURE__ */ jsx("input", {
+				...props,
+				ref,
+				className: style_default.InputTextField
+			}),
+			right
+		]
+	});
+});
+const ToggleButton = React$1.forwardRef(function ToggleButton$1({ children, selected, ...props }, ref) {
+	return /* @__PURE__ */ jsx("button", {
+		...props,
+		ref,
+		className: style_default.ToggleButton,
+		"data-stldocs-toggle-selected": selected,
+		children
+	});
+});
+function ListView({ items, itemDelegate, onSelectListItem, ...rest }) {
+	const [selectedIndex, setSelectedIndex] = React$1.useState(0);
+	const [keyboardIndex, setKeyboardIndex] = React$1.useState(0);
+	const listRef = React$1.useRef(null);
+	const itemRef = React$1.useRef(null);
+	React$1.useEffect(() => {
+		setSelectedIndex(0);
+		setKeyboardIndex(0);
+	}, [items]);
+	const handleSelect = React$1.useCallback(() => {
+		const item = items[selectedIndex];
+		if (item) onSelectListItem?.(item);
+	}, [
+		items,
+		selectedIndex,
+		onSelectListItem
+	]);
+	React$1.useEffect(() => {
+		function handleKeyPress(ev) {
+			switch (ev.key) {
+				case "ArrowUp": {
+					ev.preventDefault();
+					const value = Math.max(0, selectedIndex - 1);
+					setSelectedIndex(value);
+					setKeyboardIndex(value);
+					break;
+				}
+				case "ArrowDown": {
+					ev.preventDefault();
+					const value = Math.min(items.length, selectedIndex + 1);
+					setSelectedIndex(value);
+					setKeyboardIndex(value);
+					break;
+				}
+				case "Enter":
+					ev.preventDefault();
+					handleSelect();
+					break;
+			}
+		}
+		addEventListener("keydown", handleKeyPress);
+		return () => removeEventListener("keydown", handleKeyPress);
+	}, [
+		items,
+		selectedIndex,
+		handleSelect
+	]);
+	React$1.useEffect(() => {
+		if (!keyboardIndex || !itemRef.current || !listRef.current) {
+			listRef?.current?.scroll(0, 0);
+			return;
+		}
+		const selectedBounds = itemRef.current.getBoundingClientRect();
+		const listBounds = listRef.current.getBoundingClientRect();
+		if (selectedBounds.top < listBounds.top || selectedBounds.bottom > listBounds.bottom) itemRef.current.scrollIntoView({ block: "nearest" });
+	}, [
+		keyboardIndex,
+		items,
+		listRef
+	]);
+	return /* @__PURE__ */ jsx("div", {
+		ref: listRef,
+		className: style_default.ListView,
+		tabIndex: 0,
+		...rest,
+		children: items.map((item, index) => /* @__PURE__ */ jsx("div", {
+			ref: index === selectedIndex ? itemRef : null,
+			className: style_default.ListViewItem,
+			"data-stldocs-listview-selected": index === selectedIndex,
+			onClick: handleSelect,
+			onMouseMove: () => setSelectedIndex(index),
+			children: itemDelegate(item, index === selectedIndex)
+		}, index))
+	});
+}
+
+//#endregion
+export { Link as a, ToggleButton as c, Join as i, Tooltip as l, Expander as n, ListView as o, Input as r, Markdown as s, Badge as t, VirtualExpander as u };

package/dist/primitives-CbqXZ-5f.d.ts

@@ -0,0 +1,97 @@
+import * as React$1 from "react";
+import { ReactNode } from "react";
+import * as react_jsx_runtime18 from "react/jsx-runtime";
+
+//#region src/components/primitives.d.ts
+type JoinProps = {
+  items: ReactNode[];
+  limit?: number;
+  children: ReactNode;
+};
+declare function Join({
+  items,
+  limit,
+  children
+}: JoinProps): react_jsx_runtime18.JSX.Element[];
+type ExpanderProps = {
+  id?: string;
+  open?: boolean;
+  summary: ReactNode;
+  virtual?: boolean;
+  muted?: boolean;
+  children?: ReactNode;
+};
+declare function Expander({
+  id,
+  open,
+  summary,
+  virtual,
+  muted,
+  children
+}: ExpanderProps): react_jsx_runtime18.JSX.Element;
+declare function VirtualExpander({
+  id,
+  open: isOpen,
+  muted,
+  summary,
+  children
+}: Omit<ExpanderProps, 'virtual'>): react_jsx_runtime18.JSX.Element;
+declare function Markdown({
+  content
+}: {
+  content: string;
+}): "" | react_jsx_runtime18.JSX.Element | undefined;
+type BadgeProps = {
+  id: string;
+  children?: ReactNode;
+};
+declare function Badge({
+  id,
+  children
+}: BadgeProps): react_jsx_runtime18.JSX.Element;
+type TooltipProps = {
+  content: ReactNode;
+  children: ReactNode;
+};
+declare function Tooltip({
+  content,
+  children
+}: TooltipProps): string | number | bigint | boolean | react_jsx_runtime18.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;
+type LinkProps = {
+  stainlessPath: string;
+  scroll?: boolean;
+  children?: ReactNode;
+} & React$1.HTMLProps<HTMLAnchorElement>;
+declare function Link({
+  stainlessPath,
+  scroll,
+  children,
+  ...props
+}: LinkProps): string | number | bigint | boolean | react_jsx_runtime18.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;
+type InputProps = {
+  left?: ReactNode;
+  right?: ReactNode;
+  ref?: React$1.Ref<HTMLInputElement>;
+} & React$1.InputHTMLAttributes<HTMLInputElement>;
+declare const Input: React$1.ForwardRefExoticComponent<Omit<InputProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+type ToggleButtonProps = {
+  children?: ReactNode;
+  selected?: boolean;
+} & React$1.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const ToggleButton: React$1.ForwardRefExoticComponent<{
+  children?: ReactNode;
+  selected?: boolean;
+} & React$1.ButtonHTMLAttributes<HTMLButtonElement> & React$1.RefAttributes<HTMLButtonElement>>;
+type ListViewProps<TItem> = {
+  items: Array<TItem>;
+  itemDelegate: (item: TItem, selected: boolean) => React$1.ReactNode;
+  onSelectListItem?: (item: TItem) => void;
+} & React$1.HTMLAttributes<HTMLDivElement>;
+declare function ListView<TItem>({
+  items,
+  itemDelegate,
+  onSelectListItem,
+  ...rest
+}: ListViewProps<TItem>): react_jsx_runtime18.JSX.Element;
+//#endregion
+export { Join as a, ListViewProps as c, ToggleButtonProps as d, Tooltip as f, InputProps as i, Markdown as l, Expander as n, Link as o, VirtualExpander as p, Input as r, ListView as s, Badge as t, ToggleButton as u };

package/dist/printer-DBw4S_Jn.d.ts

@@ -0,0 +1,13 @@
+import { t as DocsLanguage } from "./routing-CMqh1cTZ.js";
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/markdown/printer.d.ts
+declare namespace printer_d_exports {
+  export { declaration, methodSignature, type, typeName };
+}
+declare function typeName(language: DocsLanguage, type: SDKJSON.Type): string;
+declare function type(language: DocsLanguage, type: SDKJSON.Type): string;
+declare function declaration(language: DocsLanguage, decl: SDKJSON.DeclarationNode): string;
+declare function methodSignature(language: DocsLanguage, decl: SDKJSON.DeclarationNode): string;
+//#endregion
+export { typeName as a, type as i, methodSignature as n, printer_d_exports as r, declaration as t };

package/dist/printer-DVZVkqAr.d.ts

@@ -0,0 +1,13 @@
+import { t as DocsLanguage } from "./routing-Dhmv52Fd.js";
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/markdown/printer.d.ts
+declare namespace printer_d_exports {
+  export { declaration, methodSignature, type, typeName };
+}
+declare function typeName(language: DocsLanguage, type: SDKJSON.Type): string;
+declare function type(language: DocsLanguage, type: SDKJSON.Type): string;
+declare function declaration(language: DocsLanguage, decl: SDKJSON.DeclarationNode): string;
+declare function methodSignature(language: DocsLanguage, decl: SDKJSON.DeclarationNode): string;
+//#endregion
+export { typeName as a, type as i, methodSignature as n, printer_d_exports as r, declaration as t };

package/dist/printer-bNxiG6UB.js

@@ -0,0 +1,74 @@
+import { t as __export } from "./chunk-DRcLgZ1e.js";
+import { t as DocsProvider } from "./docs-CXqi26jB.js";
+import { n as useLanguageComponents } from "./contexts-p3rRZDlM.js";
+import { t as style_default } from "./style-gnVEeXFj.js";
+import { t as ComponentProvider } from "./component-DRO8kQSp.js";
+import "react";
+import { jsx } from "react/jsx-runtime";
+import { renderToStaticMarkup } from "react-dom/server";
+
+//#region src/markdown/printer.tsx
+var printer_exports = /* @__PURE__ */ __export({
+	declaration: () => declaration,
+	methodSignature: () => methodSignature,
+	type: () => type,
+	typeName: () => typeName
+});
+function Providers({ language, children }) {
+	return /* @__PURE__ */ jsx(DocsProvider, {
+		spec: null,
+		language,
+		children: /* @__PURE__ */ jsx(ComponentProvider, {
+			components: { SDKReference({ stainlessPath, children: children$1 }) {
+				if (!stainlessPath) return children$1;
+				return /* @__PURE__ */ jsx("span", {
+					className: style_default.TypeReference,
+					children: children$1
+				});
+			} },
+			children
+		})
+	});
+}
+function RenderType({ type: type$1, full }) {
+	const { Type, TypeName } = useLanguageComponents();
+	return full ? /* @__PURE__ */ jsx(Type, { type: type$1 }) : /* @__PURE__ */ jsx(TypeName, { type: type$1 });
+}
+function typeName(language, type$1) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderType, { type: type$1 })
+	}));
+}
+function type(language, type$1) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderType, {
+			type: type$1,
+			full: true
+		})
+	}));
+}
+function RenderDeclaration({ decl }) {
+	const { Declaration } = useLanguageComponents();
+	return /* @__PURE__ */ jsx(Declaration, { decl });
+}
+function declaration(language, decl) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderDeclaration, { decl })
+	}));
+}
+function RenderMethod({ method }) {
+	const { MethodSignature } = useLanguageComponents();
+	return /* @__PURE__ */ jsx(MethodSignature, { decl: method });
+}
+function methodSignature(language, decl) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderMethod, { method: decl })
+	}));
+}
+
+//#endregion
+export { typeName as a, type as i, methodSignature as n, printer_exports as r, declaration as t };