@hubspot/ui-extensions-sdk-api-metadata 0.11.6 → 0.12.0

package/dist/__tests__/component-props-docs.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/component-props-docs.spec.js

@@ -0,0 +1,14 @@
+import path from 'node:path';
+import { ComponentName, getComponentPropsDocumentation } from "../index.js";
+const snapshotsDir = path.join(__dirname, '__snapshots__');
+const runComponentPropsSnapshotTest = (componentName) => {
+    const propsDocumentation = getComponentPropsDocumentation(componentName);
+    expect(`${JSON.stringify(propsDocumentation, null, 2)}\n`).toMatchFileSnapshot(path.join(snapshotsDir, `${componentName}.snapshot.json`));
+};
+describe('getComponentPropsDocumentation', () => {
+    it('should return the correct component prop documentation for the Accordion component', () => {
+        runComponentPropsSnapshotTest(ComponentName.Accordion);
+    });
+    // NOTE: We will continue to add more snapshot tests for each component so that we can verify that
+    // we are producing the correct documentation for each component.
+});

package/dist/component-props-docs.d.ts

@@ -0,0 +1,8 @@
+import { ComponentName, ComponentPropDocumentation } from './types.ts';
+/**
+ * Gets the documentation for the props of a component.
+ *
+ * @param componentName - The name of the component to get the props for
+ * @returns The documentation for the props of the component
+ */
+export declare const getComponentPropsDocumentation: (componentName: ComponentName) => ComponentPropDocumentation[];

package/dist/component-props-docs.js

@@ -0,0 +1,115 @@
+import { isInlinedTypeReferenceNode, isObjectNode, isTypeReferenceNode, } from '@hubspot/ts-export-types-reader';
+import { componentPropsReader } from "./__generated__/component-props.js";
+import { renderPropTypeToHtml, } from "./internal/render-prop-type.js";
+import { getDefaultValueFromJsdocTags, getSeeTagsFromJsdocTags, } from "./internal/utils/jsdoc-utils.js";
+import { renderInlineMarkdownToHtml } from "./internal/utils/markdown-utils.js";
+import { getComponentTypeSource } from "./internal/get-type-source.js";
+/**
+ * Recursively resolves an API node to an ObjectNode if possible.
+ *
+ * Component props are typically defined as object types, but they may be wrapped
+ * in type references or inlined type references. This helper function traverses
+ * through these wrappers to find the underlying object type that contains the
+ * actual property definitions.
+ *
+ * @param apiNode - The API node to resolve (may be an object, type reference, or inlined reference)
+ * @returns The resolved ObjectNode if found, or null if the node doesn't represent an object type
+ *
+ * @example
+ * ```typescript
+ * // If apiNode is a TypeReferenceNode pointing to an object type, this will resolve it
+ * const propsObject = maybeGetPropsObjectHelper(typeReferenceNode);
+ * // Returns: ObjectNode with properties array
+ * ```
+ */
+const maybeGetPropsObjectHelper = (apiNode) => {
+    // If it's already an object node, return it directly
+    if (isObjectNode(apiNode)) {
+        return apiNode;
+    }
+    // If it's an inlined type reference, recursively resolve the inner type
+    if (isInlinedTypeReferenceNode(apiNode)) {
+        return maybeGetPropsObjectHelper(apiNode.type);
+    }
+    // If it's a type reference, look up the referenced type and resolve it
+    if (isTypeReferenceNode(apiNode)) {
+        const referencedNode = componentPropsReader.findReferencedTypeById(apiNode.typeId);
+        return maybeGetPropsObjectHelper(referencedNode);
+    }
+    // Not an object type or resolvable to one
+    return null;
+};
+// Matches {@link <URL> <TITLE>} or {@link <URL>}
+const embeddedLinkTagRegex = /\{@link\s+(\S+)(?:\s+([^}]+))?\s*\}/g;
+/**
+ * Renders a JSDoc @see tag's text content to HTML.
+ *
+ * Converts embedded `{@link}` tags in the see text to markdown link syntax,
+ * then renders the markdown to HTML.
+ *
+ * @param seeText - The text of the see tag
+ * @returns The see tag text rendered as HTML
+ */
+const renderSeeItemToHtml = (seeText) => {
+    // Replace all embedded {@link} tags with equivalent markdown link syntax
+    return renderInlineMarkdownToHtml(seeText.replaceAll(embeddedLinkTagRegex, (match, url, title) => {
+        return `[${title ?? url}](${url})`;
+    }));
+};
+/**
+ * Gets the documentation for the props of a component.
+ *
+ * @param componentName - The name of the component to get the props for
+ * @returns The documentation for the props of the component
+ */
+export const getComponentPropsDocumentation = (componentName) => {
+    const { exportName, exportPath } = getComponentTypeSource(componentName);
+    const typeExport = componentPropsReader.findExportByName({
+        exportName,
+        exportPath,
+    });
+    // Validate that the type export exists
+    if (!typeExport) {
+        throw new Error(`Component types not found for component "${componentName}" (${exportName} in ${exportPath})`);
+    }
+    // Resolve the type export to an object type containing the props
+    const propsObject = maybeGetPropsObjectHelper(typeExport.type);
+    if (!propsObject) {
+        throw new Error(`Props object not found for component "${componentName}" (${exportName} in ${exportPath})`);
+    }
+    // Sort properties first by required status, then alphabetically by name for consistent output
+    const props = [...propsObject.properties].sort((a, b) => {
+        const aRequired = a.isOptional !== true;
+        const bRequired = b.isOptional !== true;
+        if (aRequired !== bRequired) {
+            return aRequired ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+    });
+    return props.map((prop) => {
+        const jsdocText = prop.jsdoc?.text ?? '';
+        const jsdocTags = prop.jsdoc?.tags ?? [];
+        const renderTypeContext = {
+            typesReader: componentPropsReader,
+            foundTypeIds: new Set(),
+        };
+        const typeHtml = renderPropTypeToHtml(renderTypeContext, prop.type);
+        const descriptionHtml = renderInlineMarkdownToHtml(jsdocText);
+        // Extract default value from JSDoc tags if present
+        const defaultValue = getDefaultValueFromJsdocTags(jsdocTags);
+        const seeHtmlItems = getSeeTagsFromJsdocTags(jsdocTags).map(renderSeeItemToHtml);
+        const componentProp = {
+            name: prop.name,
+            required: prop.isOptional !== true,
+            typeJsx: `<>${typeHtml}</>`,
+            descriptionJsx: `<>${descriptionHtml}</>`,
+        };
+        if (seeHtmlItems.length > 0) {
+            componentProp.seeJsxItems = seeHtmlItems.map((seeHtmlItem) => `<>${seeHtmlItem}</>`);
+        }
+        if (defaultValue != null) {
+            componentProp.defaultValueJsx = `<>${renderInlineMarkdownToHtml(defaultValue)}</>`;
+        }
+        return componentProp;
+    });
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './component-props-docs.ts';
+export * from './types.ts';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./component-props-docs.js";
+export * from "./types.js";

package/dist/internal/get-type-source.d.ts

@@ -0,0 +1,15 @@
+import { ComponentName } from '../types.ts';
+export interface ComponentSource {
+    exportName: string;
+    exportPath: string;
+}
+/**
+ * Gets the type source for a component.
+ *
+ * The component type source is the name of the export and the path the
+ * export is exported from for the `@hubspot/ui-extensions` package.
+ *
+ * @param componentName - The name of the component to get the type source for
+ * @returns The type source for the component
+ */
+export declare const getComponentTypeSource: (componentName: ComponentName) => ComponentSource;

package/dist/internal/get-type-source.js

@@ -0,0 +1,27 @@
+/**
+ * Lookup table for component type sources.
+ *
+ * FUTURE: We should use code generation to generate this lookup table.
+ */
+const componentSourceLookup = {
+    Accordion: {
+        exportName: 'AccordionProps',
+        exportPath: '.',
+    },
+};
+/**
+ * Gets the type source for a component.
+ *
+ * The component type source is the name of the export and the path the
+ * export is exported from for the `@hubspot/ui-extensions` package.
+ *
+ * @param componentName - The name of the component to get the type source for
+ * @returns The type source for the component
+ */
+export const getComponentTypeSource = (componentName) => {
+    const componentSource = componentSourceLookup[componentName];
+    if (!componentSource) {
+        throw new Error(`Invalid component name: ${componentName}`);
+    }
+    return componentSource;
+};

package/dist/internal/render-prop-type.d.ts

@@ -0,0 +1,31 @@
+import { AnalyzeResultReader, ApiNode } from '@hubspot/ts-export-types-reader';
+/**
+ * Context object passed through the type rendering functions.
+ *
+ * This context maintains state needed for rendering types correctly:
+ * - typesReader: The reader for looking up referenced types
+ * - foundTypeIds: A set of type IDs that have already been rendered, used to
+ *                 prevent infinite recursion when rendering circular type references
+ */
+export interface RenderTypeContext {
+    typesReader: AnalyzeResultReader;
+    foundTypeIds: Set<string>;
+}
+/**
+ * Renders a prop's type as an HTML string.
+ *
+ * This function handles the special case of union types in props, which need
+ * to be rendered recursively. All types are wrapped in HTML code tags for
+ * proper HTML rendering.
+ *
+ * @param context - The rendering context containing the types reader
+ * @param propType - The API node representing the prop's type
+ * @returns An HTML string representation of the type (wrapped in code tags)
+ *
+ * @example
+ * ```typescript
+ * renderPropTypeToHtml(context, stringNode) // Returns: "<code>string</code>"
+ * renderPropTypeToHtml(context, unionNode) // Returns: "<code>boolean</code> | <code>number</code> | <code>string</code>"
+ * ```
+ */
+export declare const renderPropTypeToHtml: (context: RenderTypeContext, propType: ApiNode) => string;

package/dist/internal/render-prop-type.js

@@ -0,0 +1,213 @@
+import { isBuiltInTypeReferenceNode, isExternalTypeReferenceNode, isFunctionNode, isInlinedTypeReferenceNode, isLiteralNode, isObjectNode, isPrimitiveNode, isTypeReferenceNode, isUnionNode, } from '@hubspot/ts-export-types-reader';
+import { wrapCodeInHtmlCodeTags } from "./utils/html-utils.js";
+/**
+ * Renders an object type node as a string representation.
+ *
+ * Converts an ObjectNode into a TypeScript-like object type string, e.g.:
+ * `{ name: string, age: number }`
+ *
+ * @param context - The rendering context containing the types reader
+ * @param objectTypeNode - The object type node to render
+ * @returns A string representation of the object type
+ *
+ * @example
+ * ```typescript
+ * renderObjectType(context, objectNode)
+ * // Returns: "{ name: string, age: number }"
+ * ```
+ */
+const renderObjectType = (context, objectTypeNode) => {
+    const { properties } = objectTypeNode;
+    // Empty object types render as just {}
+    if (properties.length === 0) {
+        return `{}`;
+    }
+    // Map each property to "name: type" format and join with commas
+    const propertyParts = properties.map((property) => {
+        return `${property.name}: ${renderType(context, property.type)}`;
+    });
+    return `{ ${propertyParts.join(', ')} }`;
+};
+/**
+ * Renders a function type node as a string representation.
+ *
+ * Converts a FunctionNode into a TypeScript-like function type string, e.g.:
+ * `(param1: string, param2: number) => boolean`
+ *
+ * @param context - The rendering context containing the types reader
+ * @param functionNode - The function type node to render
+ * @returns A string representation of the function type
+ *
+ * @example
+ * ```typescript
+ * renderFunction(context, functionNode)
+ * // Returns: "(value: string) => boolean"
+ * ```
+ */
+const renderFunction = (context, functionNode) => {
+    const paramParts = [];
+    // Render each parameter as "name: type"
+    for (const param of functionNode.parameters) {
+        paramParts.push(`${param.name}: ${renderType(context, param.type)}`);
+    }
+    // Combine parameters and return type into function signature format
+    return `(${paramParts.join(', ')}) => ${renderType(context, functionNode.returnType)}`;
+};
+/**
+ * Main type rendering function that converts an API node to a string representation.
+ *
+ * This is a recursive function that handles all TypeScript type constructs:
+ * - Primitives (string, number, boolean, etc.)
+ * - Literal types (e.g., "hello" | "world")
+ * - External type references (types from other packages)
+ * - Function types
+ * - Object types
+ * - Inlined type references
+ * - Built-in generic types (Array<T>, Promise<T>, etc.)
+ * - Type references (aliases and interfaces)
+ * - Union types
+ *
+ * The function uses the context to track already-seen type IDs to prevent
+ * infinite recursion when rendering circular type references.
+ *
+ * @param context - The rendering context containing the types reader and found type IDs
+ * @param typeNode - The API node representing the type to render
+ * @returns A string representation of the type (e.g., "string", "Array<number>", "string | number")
+ */
+const renderType = (context, typeNode) => {
+    // Handle primitive types (string, number, boolean, etc.)
+    if (isPrimitiveNode(typeNode)) {
+        return typeNode.name;
+    }
+    // Handle literal types (e.g., "hello", 42, true)
+    if (isLiteralNode(typeNode)) {
+        return JSON.stringify(typeNode.value);
+    }
+    // Handle external type references (types from other packages/modules)
+    // These are rendered as-is since we don't have their definitions
+    if (isExternalTypeReferenceNode(typeNode)) {
+        return typeNode.typeString;
+    }
+    // Handle function types
+    if (isFunctionNode(typeNode)) {
+        return renderFunction(context, typeNode);
+    }
+    // Handle object types
+    if (isObjectNode(typeNode)) {
+        return renderObjectType(context, typeNode);
+    }
+    // Handle inlined type references - recursively render the inner type
+    if (isInlinedTypeReferenceNode(typeNode)) {
+        return renderType(context, typeNode.type);
+    }
+    // Handle built-in generic types (Array<T>, Promise<T>, etc.)
+    if (isBuiltInTypeReferenceNode(typeNode)) {
+        const { name, typeArguments } = typeNode;
+        // Render type arguments if present (e.g., <string, number>)
+        const renderedTypeArguments = typeArguments
+            ? `<${typeArguments
+                .map((argType) => renderType(context, argType))
+                .join(', ')}>`
+            : '';
+        return `${name}${renderedTypeArguments}`;
+    }
+    // Handle type references (aliases, interfaces, etc.)
+    if (isTypeReferenceNode(typeNode)) {
+        // Check if we've already seen this type ID to prevent infinite recursion
+        // If we have, return the type string representation instead of expanding
+        if (context.foundTypeIds.has(typeNode.typeId)) {
+            return typeNode.typeString;
+        }
+        // Mark this type as found before recursing
+        context.foundTypeIds.add(typeNode.typeId);
+        // Look up the referenced type definition and render it
+        const referencedNode = context.typesReader.findReferencedTypeById(typeNode.typeId);
+        return renderType(context, referencedNode);
+    }
+    // Handle union types (e.g., string | number | boolean)
+    if (isUnionNode(typeNode)) {
+        // Render each type in the union
+        const renderedUnionParts = typeNode.types.map((unionType) => renderType(context, unionType));
+        // Sort union parts alphabetically for consistent output
+        renderedUnionParts.sort((a, b) => a.localeCompare(b));
+        return renderedUnionParts.join(' \\| ');
+    }
+    throw new Error(`Unsupported type node: ${typeNode.kind}`);
+};
+/**
+ * Checks if a value is a non-empty array.
+ *
+ * @param array - The value to check
+ * @returns True if the value is an array with at least one element
+ */
+const isNonEmptyArray = (array) => Array.isArray(array) && array.length > 0;
+/**
+ * Checks if a type node has type arguments (generic parameters).
+ *
+ * @param typeNode - The type node to check (must be InlinedTypeReferenceNode or TypeReferenceNode)
+ * @returns True if the type node has type arguments
+ */
+const hasTypeArgs = (typeNode) => isNonEmptyArray(typeNode.typeArguments);
+/**
+ * Resolves a type node to its target type, handling type references and inlined references.
+ *
+ * For prop type rendering, we want to resolve type references to their actual definitions,
+ * but we want to preserve generic type arguments. This function:
+ * - For inlined type references: returns the node itself if it has type args, otherwise resolves to inner type
+ * - For type references: returns the node itself if it has type args, otherwise resolves to referenced type
+ * - For other nodes: returns the node as-is
+ *
+ * This ensures that generic types like `Array<string>` are preserved, while simple
+ * type aliases are resolved to their underlying types.
+ *
+ * @param context - The rendering context containing the types reader
+ * @param typeNode - The type node to resolve
+ * @returns The resolved target type node
+ */
+const getTargetTypeNode = (context, typeNode) => {
+    // For inlined type references, preserve the node if it has type args (generics)
+    // Otherwise, resolve to the inner type
+    if (isInlinedTypeReferenceNode(typeNode)) {
+        return hasTypeArgs(typeNode) ? typeNode : typeNode.type;
+    }
+    // For type references, preserve the node if it has type args (generics)
+    // Otherwise, look up and return the referenced type definition
+    if (isTypeReferenceNode(typeNode)) {
+        return hasTypeArgs(typeNode)
+            ? typeNode
+            : context.typesReader.findReferencedTypeById(typeNode.typeId);
+    }
+    // For other node types, return as-is
+    return typeNode;
+};
+/**
+ * Renders a prop's type as an HTML string.
+ *
+ * This function handles the special case of union types in props, which need
+ * to be rendered recursively. All types are wrapped in HTML code tags for
+ * proper HTML rendering.
+ *
+ * @param context - The rendering context containing the types reader
+ * @param propType - The API node representing the prop's type
+ * @returns An HTML string representation of the type (wrapped in code tags)
+ *
+ * @example
+ * ```typescript
+ * renderPropTypeToHtml(context, stringNode) // Returns: "<code>string</code>"
+ * renderPropTypeToHtml(context, unionNode) // Returns: "<code>boolean</code> | <code>number</code> | <code>string</code>"
+ * ```
+ */
+export const renderPropTypeToHtml = (context, propType) => {
+    // Resolve references to other types to the actual type node
+    // This handles type aliases and ensures generics are preserved
+    const targetPropType = getTargetTypeNode(context, propType);
+    // Special handling for union types: render each member recursively and sort
+    // This ensures nested unions are properly formatted
+    if (isUnionNode(targetPropType)) {
+        const renderedUnionTypes = targetPropType.types.map((currentType) => renderPropTypeToHtml(context, currentType));
+        // Sort union parts alphabetically for consistent output
+        renderedUnionTypes.sort((a, b) => a.localeCompare(b));
+        return renderedUnionTypes.join(' | ');
+    }
+    return wrapCodeInHtmlCodeTags(renderType(context, targetPropType));
+};

package/dist/internal/utils/html-utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Wraps code as text in HTML code tags for HTML rendering. Special HTML characters are escaped.
+ *
+ * @param value - The code as text to wrap in HTML code tags
+ * @returns The code as text wrapped in HTML code tags
+ */
+export declare const wrapCodeInHtmlCodeTags: (value: string) => string;

package/dist/internal/utils/html-utils.js

@@ -0,0 +1,18 @@
+const sanitizeHtmlText = (htmlText) => {
+    return (htmlText
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        // Use double quotes for consistency with other entity references
+        .replaceAll("'", '&#x27;'));
+};
+/**
+ * Wraps code as text in HTML code tags for HTML rendering. Special HTML characters are escaped.
+ *
+ * @param value - The code as text to wrap in HTML code tags
+ * @returns The code as text wrapped in HTML code tags
+ */
+export const wrapCodeInHtmlCodeTags = (value) => {
+    return `<code>${sanitizeHtmlText(value)}</code>`;
+};

package/dist/internal/utils/jsdoc-utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * JSDoc utilities for extracting metadata from JSDoc tags.
+ *
+ * This module provides helper functions for parsing and extracting information
+ * from JSDoc comments associated with component props, such as default values.
+ */
+import { JsdocTag } from '@hubspot/ts-export-types-reader';
+/**
+ * Extracts the default value from JSDoc tags.
+ *
+ * Searches through an array of JSDoc tags to find a tag named 'defaultValue'
+ * and returns its text content. This is used to display default values in
+ * the component props documentation tables.
+ *
+ * @param tags - An array of JSDoc tags, or undefined if no tags exist
+ * @returns The default value text if found, or null if not found or if tags is undefined
+ */
+export declare const getDefaultValueFromJsdocTags: (tags: JsdocTag[] | undefined) => string | null;
+/**
+ * Extracts see tags from JSDoc tags.
+ *
+ * Searches through an array of JSDoc tags to find tags named 'see'
+ * and returns their text content. See tags are used to reference related
+ * documentation or external resources.
+ *
+ * @param tags - An array of JSDoc tags, or undefined if no tags exist
+ * @returns An array of see tag text values, or an empty array if none found
+ */
+export declare const getSeeTagsFromJsdocTags: (tags: JsdocTag[] | undefined) => string[];

package/dist/internal/utils/jsdoc-utils.js

@@ -0,0 +1,52 @@
+/**
+ * JSDoc utilities for extracting metadata from JSDoc tags.
+ *
+ * This module provides helper functions for parsing and extracting information
+ * from JSDoc comments associated with component props, such as default values.
+ */
+/**
+ * Extracts the default value from JSDoc tags.
+ *
+ * Searches through an array of JSDoc tags to find a tag named 'defaultValue'
+ * and returns its text content. This is used to display default values in
+ * the component props documentation tables.
+ *
+ * @param tags - An array of JSDoc tags, or undefined if no tags exist
+ * @returns The default value text if found, or null if not found or if tags is undefined
+ */
+export const getDefaultValueFromJsdocTags = (tags) => {
+    // Return null if there are no tags
+    if (!tags) {
+        return null;
+    }
+    // Search through tags to find the defaultValue tag
+    for (const tag of tags) {
+        if (tag.name === 'defaultValue') {
+            // Return the tag's text, or null if text is empty/undefined
+            return tag.text || null;
+        }
+    }
+    // No defaultValue tag found
+    return null;
+};
+/**
+ * Extracts see tags from JSDoc tags.
+ *
+ * Searches through an array of JSDoc tags to find tags named 'see'
+ * and returns their text content. See tags are used to reference related
+ * documentation or external resources.
+ *
+ * @param tags - An array of JSDoc tags, or undefined if no tags exist
+ * @returns An array of see tag text values, or an empty array if none found
+ */
+export const getSeeTagsFromJsdocTags = (tags) => {
+    // Return empty array if there are no tags
+    if (!tags) {
+        return [];
+    }
+    // Search through tags to find the @see tags and extract their text
+    // Filter out any tags with empty or undefined text
+    return tags
+        .filter((tag) => tag.name === 'see' && tag.text)
+        .map((tag) => tag.text);
+};

package/dist/internal/utils/markdown-utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Renders inline markdown text to HTML.
+ *
+ * @param markdownText - The markdown text to render to HTML
+ * @returns The markdown text rendered to HTML
+ */
+export declare const renderInlineMarkdownToHtml: (markdownText: string) => string;

package/dist/internal/utils/markdown-utils.js

@@ -0,0 +1,14 @@
+import { Marked } from 'marked';
+const markedInstance = new Marked({
+    breaks: true,
+    gfm: true,
+});
+/**
+ * Renders inline markdown text to HTML.
+ *
+ * @param markdownText - The markdown text to render to HTML
+ * @returns The markdown text rendered to HTML
+ */
+export const renderInlineMarkdownToHtml = (markdownText) => {
+    return markedInstance.parseInline(markdownText).toString().trim();
+};

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Documentation for a component prop.
+ */
+export interface ComponentPropDocumentation {
+    /**
+     * The name of the prop.
+     */
+    name: string;
+    /**
+     * Whether the prop is required.
+     */
+    required: boolean;
+    /**
+     * The type of the prop as a JSX code string (e.g., `"<><code>boolean</code></>"`).
+     */
+    typeJsx: string;
+    /**
+     * The default value of the prop as a JSX code string (e.g., `"<><code>false</code></>"`).
+     */
+    defaultValueJsx?: string;
+    /**
+     * The description of the prop as a JSX code string (e.g., `"<>The description of the prop.</>"`).
+     */
+    descriptionJsx: string;
+    /**
+     * The see items of the prop as JSX code strings (e.g., `["<><a href="https://example.com">Example</a></>"]`).
+     *
+     * These are typically markup for links to other documentation related to the prop.
+     */
+    seeJsxItems?: string[];
+}
+/**
+ * The names of the components in the `@hubspot/ui-extensions` package.
+ *
+ * FUTURE: We should use code generation to generate this enum.
+ */
+export declare enum ComponentName {
+    Accordion = "Accordion"
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+/**
+ * The names of the components in the `@hubspot/ui-extensions` package.
+ *
+ * FUTURE: We should use code generation to generate this enum.
+ */
+export var ComponentName;
+(function (ComponentName) {
+    ComponentName["Accordion"] = "Accordion";
+})(ComponentName || (ComponentName = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/ui-extensions-sdk-api-metadata",
-  "version": "0.11.6",
+  "version": "0.12.0",
   "description": "UI Extensions SDK API Metadata",
   "type": "module",
   "scripts": {
@@ -9,7 +9,7 @@
     "check:tsc": "tsc",
     "generate": "npm run generate:sdk-api-metadata",
     "generate:sdk-api-metadata": "(cd ../ui-extensions-components && npm run build) && ts-export-types analyze --config ts-export-types.component-props.config.js",
-    "test": "echo 'No tests configured for @hubspot/ui-extensions-sdk-api-metadata'",
+    "test": "vitest run",
     "watch": "npm run clean && tsc --watch",
     "prepublishOnly": "npm run build",
     "lint": "echo 'No linter configured for @hubspot/ui-extensions-sdk-api-metadata'"
@@ -21,18 +21,21 @@
     "access": "public"
   },
   "exports": {
-    "./component-props": "./dist/__generated__/component-props.js"
+    ".": "./dist/index.js"
   },
   "license": "MIT",
   "dependencies": {
-    "@hubspot/ts-export-types-reader": "0.1.2"
+    "@hubspot/ts-export-types-reader": "0.1.2",
+    "marked": "17.0.1"
   },
   "devDependencies": {
     "@hubspot/ts-export-types": "0.1.2",
-    "typescript": "5.9.3"
+    "@vitest/coverage-v8": "2.1.8",
+    "typescript": "5.9.3",
+    "vitest": "2.1.9"
   },
   "engines": {
     "node": ">=16"
   },
-  "gitHead": "12a14abf6ad776b12204dc37467a7c665a806adb"
+  "gitHead": "c5b66da065a341df3afd98ce6641bb3e6317aeb4"
 }