@stainless-api/docs-ui 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/routing.js

@@ -1,180 +1,204 @@
-// src/routing.ts
-var Languages = [
-  "http",
-  "node",
-  "python",
-  "go",
-  "typescript",
-  "terraform",
-  "ruby",
-  "java",
-  "kotlin"
+import { t as __exportAll } from "./chunk-pbuEa-1d.js";
+//#region src/routing.ts
+var routing_exports = /* @__PURE__ */ __exportAll({
+	LanguageNames: () => LanguageNames,
+	Languages: () => Languages,
+	SupportedLanguageSyntaxes: () => SupportedLanguageSyntaxes,
+	expandToElement: () => expandToElement,
+	findNavigationPath: () => findNavigationPath,
+	generateMissingRouteList: () => generateMissingRouteList,
+	generateRoute: () => generateRoute,
+	generateRouteList: () => generateRouteList,
+	getLanguageSnippet: () => getLanguageSnippet,
+	getResource: () => getResource,
+	isSupportedLanguage: () => isSupportedLanguage,
+	parseRoute: () => parseRoute,
+	parseStainlessPath: () => parseStainlessPath,
+	scrollToPath: () => scrollToPath,
+	trimStainlessPath: () => trimStainlessPath,
+	updateHistory: () => updateHistory,
+	walkTree: () => walkTree
+});
+const Languages = [
+	"http",
+	"node",
+	"python",
+	"go",
+	"typescript",
+	"terraform",
+	"ruby",
+	"java",
+	"kotlin",
+	"csharp",
+	"php",
+	"cli"
 ];
-var SupportedLanguageSyntaxes = [
-  "http",
-  "javascript",
-  "python",
-  "go",
-  "typescript",
-  "terraform",
-  "ruby",
-  "java",
-  "kotlin"
+const SupportedLanguageSyntaxes = [
+	"http",
+	"javascript",
+	"python",
+	"go",
+	"typescript",
+	"terraform",
+	"ruby",
+	"java",
+	"kotlin",
+	"csharp",
+	"php",
+	"bash"
 ];
-var LanguageNames = {
-  http: "HTTP",
-  node: "TypeScript",
-  typescript: "TypeScript",
-  python: "Python",
-  go: "Go",
-  ruby: "Ruby",
-  java: "Java",
-  kotlin: "Kotlin",
-  terraform: "Terraform"
+const LanguageNames = {
+	http: "HTTP",
+	node: "TypeScript",
+	typescript: "TypeScript",
+	python: "Python",
+	go: "Go",
+	ruby: "Ruby",
+	java: "Java",
+	kotlin: "Kotlin",
+	terraform: "Terraform",
+	csharp: "C#",
+	php: "PHP",
+	cli: "CLI Tool"
 };
 function getLanguageSnippet(language) {
-  return language === "http" ? "http.curl" : `${language}.default`;
+	return language === "http" ? "http.curl" : `${language}.default`;
 }
 function isSupportedLanguage(language) {
-  return Languages.includes(language);
+	return Languages.includes(language);
 }
-var DefaultLanguage = "http";
-var StainlessPathPattern = /(\(resource\) (?<resource>[^\s]+))( > (\(method\) (?<method>[^\s]+)|\(model\) (?<model>[^\s]+))?)?/;
+const DefaultLanguage = "http";
+const StainlessPathPattern = /(\(resource\) (?<resource>[^\s]+))( > (\(method\) (?<method>[^\s]+)|\(model\) (?<model>[^\s]+))?)?/;
 function parseStainlessPath(stainlessPath) {
-  const match = stainlessPath.match(StainlessPathPattern);
-  if (!match) return null;
-  return {
-    resource: match.groups.resource.split("."),
-    method: match.groups.method ?? null,
-    model: match.groups.model ?? null,
-    routable: match.groups.model ? match[1] : match[0]
-  };
+	const match = stainlessPath.match(StainlessPathPattern);
+	if (!match?.groups) return null;
+	return {
+		resource: match.groups.resource?.split(".") ?? null,
+		method: match.groups.method ?? null,
+		model: match.groups.model ?? null,
+		routable: match.groups.model ? match[1] : match[0]
+	};
 }
 function trimStainlessPath(stainlessPath) {
-  return stainlessPath.replace(/ > \([^\s]+\)$/, "");
+	return stainlessPath.replace(/ > \([^\s]+\)$/, "");
 }
 function getResource(stainlessPath) {
-  const parsed = parseStainlessPath(stainlessPath);
-  return parsed?.resource[0];
+	return parseStainlessPath(stainlessPath)?.resource?.[0];
 }
 function parseRoute(basePath, route) {
-  if (!route.startsWith(basePath)) return { stainlessPath: "", language: DefaultLanguage };
-  if (basePath && route.startsWith(basePath)) route = route.slice(basePath.length);
-  let stainlessPath = "";
-  let elements = route.slice(1).split("/");
-  let language = DefaultLanguage;
-  if (elements[0] && Languages.includes(elements[0])) {
-    language = elements[0];
-    elements = elements.slice(1);
-  }
-  while (elements.length > 0) {
-    const element = elements.shift();
-    switch (element) {
-      case "resources":
-        stainlessPath += `(resource) ${elements.shift()}`;
-        break;
-      case "subresources":
-        stainlessPath += `.${elements.shift()}`;
-        break;
-      case "methods":
-        stainlessPath += ` > (method) ${elements.shift()}`;
-        break;
-    }
-  }
-  return { stainlessPath, language };
+	if (!route.startsWith(basePath)) return {
+		stainlessPath: "",
+		language: DefaultLanguage
+	};
+	if (basePath && route.startsWith(basePath)) route = route.slice(basePath.length);
+	let stainlessPath = "";
+	let elements = route.slice(1).split("/");
+	let language = DefaultLanguage;
+	if (elements[0] && Languages.includes(elements[0])) {
+		language = elements[0];
+		elements = elements.slice(1);
+	}
+	while (elements.length > 0) switch (elements.shift()) {
+		case "resources":
+			stainlessPath += `(resource) ${elements.shift()}`;
+			break;
+		case "subresources":
+			stainlessPath += `.${elements.shift()}`;
+			break;
+		case "methods":
+			stainlessPath += ` > (method) ${elements.shift()}`;
+			break;
+	}
+	return {
+		stainlessPath,
+		language
+	};
 }
 function generateRoute(basePath, language, stainlessPath) {
-  const parsedPath = parseStainlessPath(stainlessPath);
-  if (!parsedPath) return null;
-  const path = [basePath.endsWith("/") ? basePath.slice(0, -1) : basePath];
-  if (language && language !== DefaultLanguage) path.push(language);
-  const resources = parsedPath.resource.flatMap((name, index) => [
-    index > 0 ? "subresources" : "resources",
-    name
-  ]);
-  const resourcePath = parsedPath.model ? resources.slice(0, 2) : resources;
-  path.push(...resourcePath);
-  if (parsedPath.method) path.push("methods", parsedPath.method);
-  return stainlessPath.length > parsedPath.routable.length ? `${path.join("/")}#${encodeURIComponent(stainlessPath)}` : path.join("/");
+	const parsedPath = parseStainlessPath(stainlessPath);
+	if (!parsedPath) return null;
+	const path = [basePath.endsWith("/") ? basePath.slice(0, -1) : basePath];
+	if (language && language !== DefaultLanguage) path.push(language);
+	const resources = parsedPath.resource.flatMap((name, index) => [index > 0 ? "subresources" : "resources", name]);
+	const resourcePath = parsedPath.model ? resources.slice(0, 2) : resources;
+	path.push(...resourcePath);
+	if (parsedPath.method) path.push("methods", parsedPath.method);
+	return stainlessPath.length > parsedPath.routable.length ? `${path.join("/")}#${encodeURIComponent(stainlessPath)}` : path.join("/");
 }
 function* walkResource(resource, path, includeModels) {
-  yield { data: resource, path };
-  for (const data of Object.values(resource.methods)) {
-    yield { data, path: [...path, "methods", data.name] };
-  }
-  if (includeModels)
-    for (const data of Object.values(resource.models)) {
-      yield { data, path: [...path, "models", data.name] };
-    }
-  for (const data of Object.values(resource.subresources ?? {})) {
-    yield* walkResource(data, [...path, "subresources", data.name]);
-  }
+	yield {
+		data: resource,
+		path
+	};
+	for (const data of Object.values(resource.methods)) yield {
+		data,
+		path: [
+			...path,
+			"methods",
+			data.name
+		]
+	};
+	if (includeModels) for (const data of Object.values(resource.models)) yield {
+		data,
+		path: [
+			...path,
+			"models",
+			data.name
+		]
+	};
+	for (const data of Object.values(resource.subresources ?? {})) yield* walkResource(data, [
+		...path,
+		"subresources",
+		data.name
+	]);
 }
 function* walkTree(spec, includeModels) {
-  for (const data of Object.values(spec.resources)) {
-    yield* walkResource(data, ["resources", data.name], includeModels);
-  }
+	for (const data of Object.values(spec.resources)) yield* walkResource(data, ["resources", data.name], includeModels);
 }
-function generateRouteList({
-  spec,
-  languages,
-  excludeLanguages = []
-}) {
-  const entries = Array.from(walkTree(spec));
-  const langs = languages ?? spec.docs?.languages ?? ["http"];
-  return langs.filter((lang) => Languages.includes(lang) && lang !== "terraform").filter((lang) => !excludeLanguages?.includes(lang)).flatMap(
-    (language) => entries.map(({ path, data: { title, kind, stainlessPath } }) => ({
-      title,
-      kind,
-      language,
-      stainlessPath,
-      slug: (language === "http" ? path : [language, ...path]).join("/")
-    }))
-  );
+function generateRouteList({ spec, languages, excludeLanguages = [] }) {
+	const entries = Array.from(walkTree(spec));
+	return (languages ?? spec.docs?.languages ?? ["http"]).filter((lang) => Languages.includes(lang)).filter((lang) => !excludeLanguages?.includes(lang)).flatMap((language) => entries.map(({ path, data: { title, kind, stainlessPath } }) => ({
+		title,
+		kind,
+		language,
+		stainlessPath,
+		slug: (language === "http" ? path : [language, ...path]).join("/")
+	})));
+}
+function generateMissingRouteList({ spec, basePath }) {
+	const entries = Array.from(walkTree(spec));
+	return (spec.docs?.languages ?? ["http"]).filter((lang) => Languages.includes(lang)).flatMap((language) => entries.filter(({ data: { stainlessPath, ...rest } }) => {
+		if (spec.decls?.[language]?.[stainlessPath] === void 0) return rest.kind === "http_method";
+		return false;
+	}).map(({ path }) => `${basePath.endsWith("/") ? basePath.slice(0, -1) : basePath}/${language === "http" ? path.join("/") : [language, ...path].join("/")}`));
 }
 function findNavigationPath(items, target) {
-  for (const item of Object.values(items)) {
-    if (item.stainlessPath === target) return [item.stainlessPath];
-    if (item.kind === "http_method") continue;
-    const path = findNavigationPath(
-      [...Object.values(item.methods ?? {}), ...Object.values(item.subresources ?? {})],
-      target
-    );
-    if (path) return [item.stainlessPath, ...path];
-  }
+	for (const item of Object.values(items)) {
+		if (item.stainlessPath === target) return [item.stainlessPath];
+		if (item.kind === "http_method") continue;
+		const path = findNavigationPath([...Object.values(item.methods ?? {}), ...Object.values(item.subresources ?? {})], target);
+		if (path) return [item.stainlessPath, ...path];
+	}
 }
 function expandToElement(el) {
-  while (el) {
-    if (el.tagName === "DETAILS") el["open"] = true;
-    el = el.parentElement;
-  }
+	while (el) {
+		if (el instanceof HTMLDetailsElement) el.open = true;
+		el = el.parentElement;
+	}
 }
 function scrollToPath(stainlessPath) {
-  const el = document.getElementById(stainlessPath);
-  if (el) {
-    expandToElement(el);
-    el.scrollIntoView({ behavior: "smooth" });
-  }
+	const el = document.getElementById(stainlessPath);
+	if (el) {
+		expandToElement(el);
+		el.scrollIntoView({ behavior: "smooth" });
+	}
 }
 function updateHistory(basePath, language, stainlessPath) {
-  const path = generateRoute(basePath, language, stainlessPath);
-  window.history.pushState({ stainlessPath, language }, "", path);
+	const path = generateRoute(basePath, language, stainlessPath);
+	window.history.pushState({
+		stainlessPath,
+		language
+	}, "", path);
 }
-export {
-  LanguageNames,
-  Languages,
-  SupportedLanguageSyntaxes,
-  expandToElement,
-  findNavigationPath,
-  generateRoute,
-  generateRouteList,
-  getLanguageSnippet,
-  getResource,
-  isSupportedLanguage,
-  parseRoute,
-  parseStainlessPath,
-  scrollToPath,
-  trimStainlessPath,
-  updateHistory,
-  walkTree
-};
+//#endregion
+export { LanguageNames, Languages, SupportedLanguageSyntaxes, expandToElement, findNavigationPath, generateMissingRouteList, generateRoute, generateRouteList, getLanguageSnippet, getResource, isSupportedLanguage, parseRoute, parseStainlessPath, scrollToPath, routing_exports as t, trimStainlessPath, updateHistory, walkTree };

package/dist/sdk-BkW3MDco.d.ts

@@ -0,0 +1,128 @@
+import { _ as SnippetLanguage, c as ID, d as Method, f as Model, o as HasStainlessPath, t as BaseDeclaration } from "./index-DFr9Mesr.js";
+import { t as DocsLanguage } from "./routing-yTSG7nWM.js";
+import * as React$1 from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/components/sdk.d.ts
+type PropertyModelContextType = {
+  modelPath?: string;
+  propertyPath?: string;
+};
+declare const PropertyModelContext: React$1.Context<PropertyModelContextType>;
+declare function usePropertyModel(): PropertyModelContextType;
+type ReferenceNestingContextType = string[];
+declare const ReferenceNestingContext: React$1.Context<ReferenceNestingContextType>;
+declare function useReferenceNesting(): ReferenceNestingContextType;
+type DeclarationParentsContextType = ReadonlySet<string>;
+declare function useDeclarationParents(): DeclarationParentsContextType;
+type SDKSnippetLanguagesType = Record<SnippetLanguage, {
+  name: string;
+}>;
+declare const SDKSnippetLanguages: SDKSnippetLanguagesType;
+type TransformRequestSnippetFn = ({
+  snippet,
+  language
+}: {
+  snippet: string;
+  language: DocsLanguage;
+}) => string;
+type SDKChildrenProps = {
+  paths: ID[];
+  expand?: boolean;
+  depth?: number;
+};
+declare function SDKChildren({
+  paths,
+  expand,
+  depth
+}: SDKChildrenProps): react_jsx_runtime0.JSX.Element;
+type SDKDeclarationProps = {
+  path: string;
+  expand?: boolean;
+  depth?: number;
+};
+declare function SDKDeclaration({
+  path,
+  expand,
+  depth
+}: SDKDeclarationProps): react_jsx_runtime0.JSX.Element;
+type SDKConstraintsProps = {
+  constraints?: Record<string, unknown>;
+};
+declare function SDKConstraints({
+  constraints
+}: SDKConstraintsProps): react_jsx_runtime0.JSX.Element | undefined;
+type SDKIconProps = {
+  language: SnippetLanguage;
+  size?: number;
+};
+declare function SDKIcon({
+  language
+}: SDKIconProps): react_jsx_runtime0.JSX.Element | null;
+type SDKRequestTitleProps = {
+  snippetLanguage: SnippetLanguage;
+};
+declare function SDKRequestTitle({
+  snippetLanguage
+}: SDKRequestTitleProps): react_jsx_runtime0.JSX.Element;
+type SDKExampleProps = {
+  method: Partial<Method> & HasStainlessPath;
+  transformRequestSnippet?: TransformRequestSnippetFn;
+};
+declare function SDKExample({
+  method,
+  transformRequestSnippet
+}: SDKExampleProps): react_jsx_runtime0.JSX.Element;
+type SDKMethodProps = {
+  method: Method;
+  transformRequestSnippet?: TransformRequestSnippetFn;
+};
+declare function SDKMethodHeader({
+  method
+}: SDKMethodProps): react_jsx_runtime0.JSX.Element;
+declare function useStreamingResponse(method: BaseDeclaration): ID | undefined;
+declare function SDKMethodInfo({
+  method,
+  children
+}: SDKMethodProps & {
+  children?: React$1.ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+declare function SDKMethodNotImplemented({
+  method
+}: SDKMethodProps): react_jsx_runtime0.JSX.Element;
+declare function SDKMethodInfoContent(_props: SDKMethodProps): React$1.ReactNode;
+declare function SDKMethod({
+  method,
+  transformRequestSnippet
+}: SDKMethodProps): react_jsx_runtime0.JSX.Element;
+type SDKModelProps = {
+  model: Model;
+};
+declare function SDKModel({
+  model
+}: SDKModelProps): react_jsx_runtime0.JSX.Element | null;
+type SDKReferenceProps = {
+  stainlessPath: string;
+  children?: React$1.ReactNode;
+};
+declare function SDKReference({
+  stainlessPath,
+  children
+}: SDKReferenceProps): string | number | bigint | boolean | 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> | react_jsx_runtime0.JSX.Element | null | undefined;
+type SDKLanguageBlockProps = {
+  language: DocsLanguage;
+  version: string;
+  install: string;
+  links: {
+    repo: string;
+    docs: string;
+  };
+};
+declare function SDKLanguageBlock({
+  language,
+  version,
+  install,
+  links
+}: SDKLanguageBlockProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { useStreamingResponse as A, SDKRequestTitleProps as C, useDeclarationParents as D, TransformRequestSnippetFn as E, usePropertyModel as O, SDKRequestTitle as S, SDKSnippetLanguagesType as T, SDKMethodNotImplemented as _, ReferenceNestingContextType as a, SDKModelProps as b, SDKConstraintsProps as c, SDKIcon as d, SDKLanguageBlock as f, SDKMethodInfoContent as g, SDKMethodInfo as h, ReferenceNestingContext as i, useReferenceNesting as k, SDKDeclaration as l, SDKMethodHeader as m, PropertyModelContext as n, SDKChildren as o, SDKMethod as p, PropertyModelContextType as r, SDKConstraints as s, DeclarationParentsContextType as t, SDKExample as u, SDKMethodProps as v, SDKSnippetLanguages as w, SDKReference as x, SDKModel as y };

package/dist/sdk-sidebar-BpDlOMat.d.ts

@@ -0,0 +1,15 @@
+import { h as Resource } from "./index-DFr9Mesr.js";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/components/sdk-sidebar.d.ts
+type SDKSidebarProps = {
+  resources: Resource[];
+};
+/**
+ * Given some SDKJSON.Resources, calls into StlSidebar with the appropriate sidebar entries.
+ */
+declare function SDKSidebar({
+  resources
+}: SDKSidebarProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { SDKSidebarProps as n, SDKSidebar as t };

package/dist/spec.d.ts

@@ -0,0 +1,65 @@
+import { d as Method, f as Model, h as Resource, i as DeclarationNode, v as Spec, y as SpecLanguage } from "./index-DFr9Mesr.js";
+import { t as DocsLanguage } from "./routing-yTSG7nWM.js";
+
+//#region src/spec.d.ts
+type SecurityScheme = Spec['security_schemes'][number];
+interface SpecTransforms {
+  resource(resource: Resource): Resource;
+  method(method: Method): Method;
+  model(model: Model): Model;
+  declaration(decl: DeclarationNode, language: SpecLanguage): DeclarationNode;
+  securityScheme(scheme: SecurityScheme): SecurityScheme;
+  snippet(snippet: string, language: string): string;
+  markdown(content?: string): string | undefined;
+}
+declare function defineTransforms(transforms?: Partial<SpecTransforms>): {
+  resource: (resource: Resource) => Resource;
+  method: (method: Method) => Method;
+  model: (model: Model) => Model;
+  declaration: (decl: DeclarationNode, language: SpecLanguage) => DeclarationNode;
+  securityScheme: (scheme: SecurityScheme) => SecurityScheme;
+  snippet: (snippet: string, language: string) => string;
+  markdown: (content?: string) => string | undefined;
+};
+declare function generateNavigation(resource: Partial<Resource>): {
+  title: string | undefined;
+  name: string | undefined;
+  subresources: Record<string, Partial<Resource>> | undefined;
+  methods: Record<string, Partial<Method>> | undefined;
+  models: Record<string, Partial<Model>> | undefined;
+  stainlessPath: string | undefined;
+  terraform: {
+    Name: string;
+    QualifiedName: string;
+  } | undefined;
+};
+declare function generateSpecForResource(spec: Spec, name: string, lang: DocsLanguage, transforms: SpecTransforms): Partial<Spec>;
+declare function transform(spec: Spec, transforms: SpecTransforms): {
+  name: string;
+  lang: "http" | "node" | "python" | "go" | "typescript" | "terraform" | "ruby" | "java" | "kotlin" | "csharp" | "php" | "cli";
+  spec: Partial<Spec>;
+}[];
+declare function split(spec: Spec, transforms?: SpecTransforms): {
+  resources: ReturnType<typeof transform>;
+  navigation: {
+    languages: ("http" | "node" | "python" | "go" | "typescript" | "terraform" | "ruby" | "java" | "kotlin" | "csharp" | "php" | "cli" | "sql" | "openapi")[] | undefined;
+    resources: {
+      [k: string]: {
+        title: string | undefined;
+        name: string | undefined;
+        subresources: Record<string, Partial<Resource>> | undefined;
+        methods: Record<string, Partial<Method>> | undefined;
+        models: Record<string, Partial<Model>> | undefined;
+        stainlessPath: string | undefined;
+        terraform: {
+          Name: string;
+          QualifiedName: string;
+        } | undefined;
+      };
+    };
+  };
+};
+declare function parseSpec(content: string): Spec | undefined;
+declare function retrieve(apiKey: string, project: string, revision: string): Promise<Spec | undefined>;
+//#endregion
+export { SecurityScheme, SpecTransforms, defineTransforms, generateNavigation, generateSpecForResource, parseSpec, retrieve, split, transform };