@stainless-api/docs-ui 0.1.0-beta.4 → 0.1.0-beta.40

package/src/search/printer.tsx

@@ -1,86 +0,0 @@
-import * as React from 'react';
-import { renderToStaticMarkup } from 'react-dom/server';
-import type * as SDKJSON from '~/lib/json-spec-v2/types';
-import type { DocsLanguage } from '../routing';
-
-import { DocsProvider, useLanguageComponents } from '../contexts';
-
-import style from '../style';
-import { ComponentProvider } from '../contexts/component';
-
-type ProvidersProps = {
-  language: DocsLanguage;
-  children: React.ReactNode;
-};
-
-function Providers({ language, children }: ProvidersProps) {
-  return (
-    <DocsProvider spec={null} language={language}>
-      <ComponentProvider
-        components={{
-          SDKReference({ stainlessPath, children }) {
-            if (!stainlessPath) return children;
-            return <span className={style.TypeReference}>{children}</span>;
-          },
-        }}
-      >
-        {children}
-      </ComponentProvider>
-    </DocsProvider>
-  );
-}
-
-function RenderType({ type, full }: { type: SDKJSON.Type; full?: boolean }) {
-  const { Type, TypeName } = useLanguageComponents();
-  return full ? <Type type={type} /> : <TypeName type={type} />;
-}
-
-export function typeName(language: DocsLanguage, type: SDKJSON.Type) {
-  const component = (
-    <Providers language={language}>
-      <RenderType type={type} />
-    </Providers>
-  );
-
-  return renderToStaticMarkup(component);
-}
-
-export function type(language: DocsLanguage, type: SDKJSON.Type) {
-  const component = (
-    <Providers language={language}>
-      <RenderType type={type} full={true} />
-    </Providers>
-  );
-
-  return renderToStaticMarkup(component);
-}
-
-function RenderDeclaration({ decl }: { decl: SDKJSON.DeclarationNode }) {
-  const { Declaration } = useLanguageComponents();
-  return <Declaration decl={decl} />;
-}
-
-export function declaration(language: DocsLanguage, decl: SDKJSON.DeclarationNode) {
-  const component = (
-    <Providers language={language}>
-      <RenderDeclaration decl={decl} />
-    </Providers>
-  );
-
-  return renderToStaticMarkup(component);
-}
-
-function RenderMethod({ method }: { method: SDKJSON.DeclarationNode }) {
-  const { MethodSignature } = useLanguageComponents();
-  return <MethodSignature decl={method} />;
-}
-
-export function methodSignature(language: DocsLanguage, decl: SDKJSON.DeclarationNode) {
-  const component = (
-    <Providers language={language}>
-      <RenderMethod method={decl} />
-    </Providers>
-  );
-
-  return renderToStaticMarkup(component);
-}

package/src/search/providers/algolia.ts

@@ -1,88 +0,0 @@
-import { searchClient } from '@algolia/client-search';
-import { generateChatIndex, generateIndex } from '../indexer';
-import { SearchableAttributes, SearchableAttributesChat } from '../types';
-import type * as SDKJSON from '~/lib/json-spec-v2/types';
-import type { ResultRecordType, SearchSettings, SearchParams, ResultType } from '../types';
-
-export async function buildIndex(
-  appId: string,
-  indexName: string,
-  writeKey: string,
-  spec: SDKJSON.Spec,
-  renderMarkdown: (string?) => string | null,
-): Promise<void> {
-  if (!appId || !indexName || !writeKey) return;
-  const objects = Array.from(generateIndex(spec, renderMarkdown));
-  const client = searchClient(appId, writeKey);
-
-  await client.setSettings({
-    indexName,
-    indexSettings: {
-      highlightPreTag: '<mark>',
-      highlightPostTag: '</mark>',
-      customRanking: ['asc(priority)'],
-      attributesForFaceting: ['language', 'kind'],
-      searchableAttributes: SearchableAttributes,
-    },
-  });
-
-  await client.replaceAllObjects({ indexName, objects });
-}
-
-export async function buildChatIndex(
-  appId: string,
-  indexName: string,
-  writeKey: string,
-  spec: SDKJSON.Spec,
-): Promise<void> {
-  if (!appId || !indexName || !writeKey) return;
-  const objects = Array.from(generateChatIndex(spec));
-  const client = searchClient(appId, writeKey);
-
-  await client.setSettings({
-    indexName,
-    indexSettings: {
-      attributesForFaceting: ['language'],
-      attributeForDistinct: 'stainlessPath',
-      searchableAttributes: SearchableAttributesChat,
-    },
-  });
-
-  await client.replaceAllObjects({ indexName, objects });
-}
-
-export async function search({
-  settings: { appId, indexName, searchKey },
-  params: { query, language, kind },
-}: {
-  params: SearchParams;
-  settings: SearchSettings;
-}): Promise<ResultType | undefined> {
-  const client = searchClient(appId, searchKey);
-  const filters = language ? `language:${language}` : undefined;
-  const facetFilters = kind ? [`kind:${kind}`] : undefined;
-  const { results } = await client.search<ResultRecordType>({
-    requests: [
-      {
-        query,
-        indexName,
-        filters,
-        hitsPerPage: 5,
-        facets: ['kind'],
-      },
-      {
-        query,
-        indexName,
-        filters,
-        facetFilters,
-        facets: ['kind'],
-        hitsPerPage: 50,
-      },
-    ],
-  });
-
-  if ('hits' in results[0] && 'hits' in results[1]) {
-    const [{ nbHits, facets }, { hits }] = results;
-    return { hits, nbHits, facets };
-  }
-}

package/src/search/providers/fuse.ts

@@ -1,19 +0,0 @@
-import Fuse, { FuseIndex } from 'fuse.js';
-import { DocsLanguage } from '../../routing';
-import { generateIndex } from '../indexer';
-import { IndexEntry, SearchableAttributes } from '../types';
-import type * as SDKJSON from '~/lib/json-spec-v2/types';
-
-export type FuseIndexData = { content: IndexEntry[]; index: FuseIndex<IndexEntry> };
-
-export function buildIndex(spec: SDKJSON.Spec, language?: DocsLanguage): FuseIndexData {
-  const idx = Array.from(generateIndex(spec, null, false));
-  const content = language ? idx.filter((entry) => entry.language === language) : idx;
-  const index = Fuse.createIndex(SearchableAttributes, content);
-  return { content, index };
-}
-
-export function search({ content, index }: FuseIndexData, query: string, limit: number = 100) {
-  const fuse = new Fuse(content, { keys: SearchableAttributes }, index);
-  return fuse.search(query).slice(0, limit);
-}

package/src/search/providers/pagefind.ts

@@ -1,17 +0,0 @@
-import type { GuideResultType } from '../types';
-
-async function loadPagefind(path: string) {
-  const url = new URL(path, import.meta.url).href;
-  return await import(/* @vite-ignore */ url);
-}
-
-export async function guideSearch(
-  loadPath: string,
-  query: string,
-  limit?: number,
-): Promise<GuideResultType[]> {
-  const index = await loadPagefind(loadPath);
-  const response = await index.search(query);
-  const items = limit ? response.results.slice(0, limit) : response.results;
-  return Promise.all(items.map((result) => result.data().then((data) => ({ ...result, data }))));
-}

package/src/search/providers/walker.ts

@@ -1,30 +0,0 @@
-import { DocsLanguage } from '../../routing';
-import { generateIndex } from '../indexer';
-import { IndexEntry, SearchableAttributes } from '../types';
-import type * as SDKJSON from '~/lib/json-spec-v2/types';
-
-export function buildIndex(spec: SDKJSON.Spec) {
-  return generateIndex(spec, null, false);
-}
-
-function* findEntryInIndex(index: Generator<IndexEntry>, language: string, query: string) {
-  for (const entry of index) {
-    if (entry.language !== language) continue;
-    for (const attr of SearchableAttributes) {
-      if (entry[attr] && typeof entry[attr] === 'string' && entry[attr].includes(query)) yield entry;
-    }
-  }
-}
-
-export function search(
-  index: Generator<IndexEntry>,
-  language: DocsLanguage,
-  query: string,
-  limit: number = 100,
-) {
-  const results = findEntryInIndex(index, language, query);
-  const sorted = Array.from(results)
-    .sort((a, b) => a.priority - b.priority)
-    .slice(0, limit);
-  return sorted;
-}

package/src/search/results.tsx

@@ -1,181 +0,0 @@
-import { Folder, Box, Code, Wrench, BookOpenText, Search } from 'lucide-react';
-import { useLanguage } from '../contexts';
-import { useComponents } from '../contexts/use-components';
-import { GuideResultType, QueryKindsType, ResultRecordType, SearchAttributeNames } from './types';
-
-import style from '../style';
-
-export const QueryKindDisplay: Record<QueryKindsType, { name: string; icon: typeof Folder }> = {
-  all: { name: 'Results', icon: Search },
-  resource: { name: 'Resources', icon: Folder },
-  http_method: { name: 'Methods', icon: Box },
-  model: { name: 'Types', icon: Code },
-  property: { name: 'Properties', icon: Wrench },
-  guide: { name: 'Guide', icon: BookOpenText },
-};
-
-export type HighlightProps = {
-  result: ResultRecordType;
-  name: SearchAttributeNames;
-};
-
-export function Highlight({ result, name }: HighlightProps) {
-  const value = result._highlightResult[name]?.value;
-  if (value) return <span dangerouslySetInnerHTML={{ __html: value }} />;
-}
-
-export type SearchResultProps = {
-  result: ResultRecordType;
-};
-
-export function SearchResultBreadcrumb({ result }: SearchResultProps) {
-  const Docs = useComponents();
-  const Icon = QueryKindDisplay[result.kind].icon;
-  const items = result.crumbs?.map((crumb) => (
-    <span key={crumb} className={style.SearchBreadcrumbItem}>
-      {crumb}
-    </span>
-  ));
-
-  return (
-    <div className={style.SearchBreadcrumb}>
-      <Icon className={style.Icon} size={14} />
-      {Array.isArray(result.crumbs) && (
-        <Docs.Join items={items}>
-          <span className={style.SearchBreadcrumbDivider}>{'›'}</span>
-        </Docs.Join>
-      )}
-    </div>
-  );
-}
-
-export function SearchResult({ result }: SearchResultProps) {
-  return (
-    <div className={style.SearchResult} data-stldocs-search-result={result.kind}>
-      <SearchResultBreadcrumb result={result} />
-      <SearchResultContent result={result} />
-    </div>
-  );
-}
-
-export type GuideResultProps = {
-  result: GuideResultType;
-};
-
-export function GuideResult({ result }: GuideResultProps) {
-  const Docs = useComponents();
-  const Icon = QueryKindDisplay['guide'].icon;
-  const path = result.data.url
-    .slice(1, -1)
-    .split('/')
-    .map((crumb) => (
-      <span className={style.SearchBreadcrumbItem} key={crumb}>
-        {crumb}
-      </span>
-    ));
-
-  const crumbs =
-    path.length > 1
-      ? path
-      : [
-          <span className={style.SearchBreadcrumbItem} key="overview">
-            Overview
-          </span>,
-        ];
-
-  return (
-    <div className={style.SearchResult} data-stldocs-search-result="guide">
-      <div className={style.SearchBreadcrumb}>
-        <Icon className={style.Icon} size={14} />
-        <Docs.Join items={crumbs}>
-          <span className={style.SearchBreadcrumbDivider}>{'›'}</span>
-        </Docs.Join>
-      </div>
-      <h3 className={style.SearchResultGuideTitle}>{result.data.meta.title}</h3>
-      <div
-        className={style.SearchResultGuideExcerpt}
-        dangerouslySetInnerHTML={{ __html: result.data.excerpt }}
-      />
-    </div>
-  );
-}
-
-export function SearchResultContent({ result }: SearchResultProps) {
-  const Docs = useComponents();
-  const language = useLanguage();
-
-  switch (result.kind) {
-    case 'http_method':
-      return (
-        <>
-          <Docs.MethodHeader
-            title={<Highlight result={result} name={result.summary ? 'summary' : 'title'} />}
-            signature={result['qualified'] && <Highlight result={result} name={'qualified'} />}
-          >
-            <Docs.MethodRoute
-              httpMethod={result.httpMethod}
-              endpoint={<Highlight result={result} name="endpoint" />}
-            />
-          </Docs.MethodHeader>
-          <div className={style.MethodDescription}>
-            <Highlight result={result} name="description" />
-          </div>
-        </>
-      );
-
-    case 'model': {
-      const properties = result.children.map((child, index) => (
-        <span key={index} className={style.TextIdentifier}>
-          {child}
-        </span>
-      ));
-
-      return (
-        <div className={style.Property} data-stldocs-language={language}>
-          <div className={style.PropertyHeader}>
-            <span className={style.PropertyName}>
-              <Highlight result={result} name={result.title ? 'title' : 'name'} />
-            </span>
-          </div>
-          <span className={style.PropertyDeclaration}>
-            <Highlight result={result} name="ident" />:{' '}
-            <Docs.Join items={properties} limit={3}>
-              <span className={style.TextPunctuation}>, </span>
-            </Docs.Join>
-          </span>
-        </div>
-      );
-    }
-
-    case 'resource':
-      return (
-        <div className={style.SearchResultResourceInfo}>
-          <span className={style.SearchResultResourceTitle}>
-            <Highlight result={result} name="title" />
-          </span>
-          <span className={style.SearchResultResourcePath}>
-            <Highlight result={result} name="QualifiedName" />
-          </span>
-        </div>
-      );
-
-    case 'property':
-      return (
-        <div className={style.Property} data-stldocs-language={language}>
-          <div className={style.PropertyHeader}>
-            <span className={style.PropertyName}>
-              <Highlight result={result} name="name" />
-            </span>
-            <span className={style.PropertyTypeName}>
-              <span dangerouslySetInnerHTML={{ __html: result.type }} />
-            </span>
-          </div>
-          {result.docstring && (
-            <span className={style.PropertyDescription}>
-              <Highlight result={result} name="docstring" />
-            </span>
-          )}
-        </div>
-      );
-  }
-}

package/src/search/state.ts

@@ -1,64 +0,0 @@
-import { useReducer } from 'react';
-import { QueryKindsType, ResultRecordType } from './types';
-
-export type SearchReducerState = {
-  results: ResultRecordType[];
-  resultsCount: number;
-  filterKind?: QueryKindsType;
-  filterKindCount?: Record<QueryKindsType, number>;
-  keyboardSelection?: number;
-  selectedIndex: number;
-  searchQuery: string;
-};
-
-export type SearchReducerAction =
-  | { action: 'DecrementSelection' }
-  | { action: 'IncrementSelection' }
-  | { action: 'SetSelectedIndex'; selectedIndex: number }
-  | { action: 'SetFilterKind'; filterKind: QueryKindsType }
-  | { action: 'UpdateQuery'; searchQuery: string }
-  | ({ action: 'UpdateResults' } & Pick<SearchReducerState, 'results' | 'resultsCount' | 'filterKindCount'>);
-
-export const SearchReducerDefaults: SearchReducerState = {
-  results: [],
-  resultsCount: 0,
-  selectedIndex: 0,
-  searchQuery: '',
-};
-
-export function searchReducer(state: SearchReducerState, op: SearchReducerAction): SearchReducerState {
-  switch (op.action) {
-    case 'IncrementSelection': {
-      const value = Math.min(state.resultsCount, state.selectedIndex + 1);
-      return { ...state, selectedIndex: value, keyboardSelection: value };
-    }
-
-    case 'DecrementSelection': {
-      const value = Math.max(0, state.selectedIndex - 1);
-      return { ...state, selectedIndex: value, keyboardSelection: value };
-    }
-
-    case 'SetSelectedIndex':
-      return { ...state, selectedIndex: op.selectedIndex };
-
-    case 'SetFilterKind':
-      return { ...state, filterKind: op.filterKind };
-
-    case 'UpdateQuery':
-      return { ...state, searchQuery: op.searchQuery };
-
-    case 'UpdateResults':
-      return {
-        ...state,
-        results: op.results,
-        resultsCount: op.resultsCount,
-        filterKindCount: op.filterKindCount,
-        keyboardSelection: undefined,
-        selectedIndex: 0,
-      };
-  }
-}
-
-export function useSearchReducer() {
-  return useReducer(searchReducer, SearchReducerDefaults);
-}

package/src/search/types.ts

@@ -1,116 +0,0 @@
-import type * as SDKJSON from '~/lib/json-spec-v2/types';
-import { DocsLanguage } from '../routing';
-
-export type SearchSettings = {
-  appId: string;
-  searchKey: string;
-  indexName: string;
-  assistant?: string;
-};
-
-export type SearchParams = {
-  query: string;
-  language?: DocsLanguage | null;
-  kind?: QueryKindsType | null;
-};
-
-export const QueryKinds = ['all', 'resource', 'http_method', 'model', 'property', 'guide'] as const;
-
-export type QueryKindsType = (typeof QueryKinds)[number];
-
-export type IndexModel = {
-  kind: 'model';
-  title: string;
-  children?: string[];
-  ident?: string;
-};
-
-export type IndexProperty = {
-  kind: 'property';
-  docstring?: string;
-  type?: string;
-};
-
-export type IndexResource = {
-  kind: 'resource';
-  title: string;
-  Name: string;
-  QualifiedName: string;
-};
-
-export type IndexMethod = Pick<
-  SDKJSON.Method,
-  'kind' | 'summary' | 'description' | 'endpoint' | 'httpMethod'
-> & {
-  title: string;
-  qualified?: string;
-  ident?: string;
-};
-
-export const SearchableAttributes = [
-  'name',
-  'title',
-  'ident',
-  'Name',
-  'qualified',
-  'QualifiedName',
-  'endpoint',
-  'summary',
-  'description',
-  'docstring',
-];
-
-export const SearchableAttributesChat = [
-  'title',
-  'name',
-  'endpoint',
-  'summary',
-  'description',
-  'qualified',
-  'ident',
-  'content',
-];
-
-export type SearchAttributeNames = (typeof SearchableAttributes)[number];
-
-export type RoutableJsonNode = SDKJSON.Method | SDKJSON.Model | SDKJSON.Resource;
-
-export type IndexEntry = Pick<RoutableJsonNode, 'name' | 'stainlessPath'> &
-  (IndexProperty | IndexModel | IndexResource | IndexMethod) & {
-    language: DocsLanguage;
-    priority: number;
-    crumbs: string[];
-  };
-
-export type ResultRecordType = IndexEntry & {
-  objectID: string;
-  _highlightResult: Record<SearchAttributeNames, { value: string }>;
-};
-
-export type ResultType = {
-  hits: ResultRecordType[];
-  facets?: Record<string, Record<string, number>>;
-  nbHits: number;
-};
-
-export type GuideResultType = {
-  id: string;
-  score: number;
-  words: number[];
-  data: {
-    excerpt: string;
-    url: string;
-    word_count: number;
-    meta: { title: string };
-    sub_results: {
-      url: string;
-      title: string;
-      excerpt: string;
-    }[];
-  };
-};
-
-export type ResultData = {
-  items: Array<ResultRecordType | GuideResultType>;
-  counts: Partial<Record<QueryKindsType, number>>;
-};