@lynx-js/genui 0.0.1-rc.0

package/a2ui-catalog-extractor/dist/index.js

@@ -0,0 +1,755 @@
+// Copyright 2026 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Application, OptionDefaults, ReflectionKind } from 'typedoc';
+const supportedSourceExtensions = new Set([
+    '.cts',
+    '.js',
+    '.jsx',
+    '.mts',
+    '.ts',
+    '.tsx',
+]);
+export function findCatalogSourceFiles(inputPath) {
+    const absoluteInputPath = path.resolve(inputPath);
+    if (!fs.existsSync(absoluteInputPath)) {
+        return [];
+    }
+    const stat = fs.statSync(absoluteInputPath);
+    if (stat.isFile()) {
+        return isSupportedSourceFile(absoluteInputPath) ? [absoluteInputPath] : [];
+    }
+    const files = [];
+    collectSourceFiles(absoluteInputPath, files);
+    return files.sort((left, right) => left.localeCompare(right));
+}
+export async function extractCatalogComponents(options) {
+    const project = await createTypeDocProject(options);
+    return extractCatalogComponentsFromTypeDocProject(project, options.cwd ? { cwd: options.cwd } : {});
+}
+export function extractCatalogComponentsFromTypeDocProject(project, options = {}) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const components = [];
+    for (const reflection of walkReflections(project)) {
+        if (!isInterfaceReflection(reflection)) {
+            continue;
+        }
+        const parsedDoc = parseComment(reflection.comment);
+        if (parsedDoc.a2uiCatalogName === undefined) {
+            continue;
+        }
+        components.push({
+            filePath: getReflectionFilePath(reflection, cwd),
+            interfaceName: reflection.name,
+            name: parsedDoc.a2uiCatalogName || inferCatalogName(reflection.name),
+            schema: createComponentSchema(reflection, parsedDoc),
+        });
+    }
+    return components;
+}
+export function extractCatalogComponentsFromTypeDocJson(project, options = {}) {
+    return extractCatalogComponentsFromTypeDocProject(project, options);
+}
+export async function extractCatalogFunctions(options) {
+    const project = await createTypeDocProject(options);
+    return extractCatalogFunctionsFromTypeDocProject(project, options.cwd ? { cwd: options.cwd } : {});
+}
+export function extractCatalogFunctionsFromTypeDocProject(project, options = {}) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const functions = [];
+    for (const reflection of walkReflections(project)) {
+        const parsedDoc = parseComment(reflection.comment);
+        let docWithSignature = parsedDoc;
+        let signature = pickFunctionSignature(reflection);
+        if (signature && !docWithSignature.a2uiFunctionName) {
+            docWithSignature = parseComment(signature.comment);
+        }
+        if (docWithSignature.a2uiFunctionName === undefined) {
+            continue;
+        }
+        signature ??= pickFunctionSignature(reflection);
+        if (!signature) {
+            throw createReflectionError(reflection, `\`@a2uiFunction\` requires a function signature on "${reflection.name}".`);
+        }
+        functions.push({
+            filePath: getReflectionFilePath(reflection, cwd),
+            name: docWithSignature.a2uiFunctionName || reflection.name,
+            ...(docWithSignature.description
+                ? { description: docWithSignature.description }
+                : {}),
+            parameters: createFunctionParametersSchema(signature, reflection),
+            returnType: resolveReturnType(signature, reflection),
+        });
+    }
+    return functions;
+}
+export function extractCatalogFunctionsFromTypeDocJson(project, options = {}) {
+    return extractCatalogFunctionsFromTypeDocProject(project, options);
+}
+export async function writeComponentCatalogs(options) {
+    const components = await extractCatalogComponents(options);
+    writeCatalogComponents(components, options);
+    return components;
+}
+export function writeCatalogComponents(components, options) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const outDir = path.resolve(cwd, options.outDir);
+    for (const component of components) {
+        const componentOutDir = path.join(outDir, component.name);
+        fs.mkdirSync(componentOutDir, { recursive: true });
+        fs.writeFileSync(path.join(componentOutDir, 'catalog.json'), `${JSON.stringify({ [component.name]: component.schema }, null, 2)}\n`);
+    }
+}
+export async function writeCatalogFunctionDefinitions(options) {
+    const functions = await extractCatalogFunctions(options);
+    writeCatalogFunctions(functions, options);
+    return functions;
+}
+/**
+ * Bootstrap TypeDoc once and emit both component and function catalog files.
+ * Preferred entry point for the CLI — running the conversion twice doubles
+ * cold-start latency on large catalogs.
+ */
+export async function writeCatalogArtifacts(options) {
+    const project = await createTypeDocProject(options);
+    const cwdOptions = options.cwd ? { cwd: options.cwd } : {};
+    const components = extractCatalogComponentsFromTypeDocProject(project, cwdOptions);
+    const functions = extractCatalogFunctionsFromTypeDocProject(project, cwdOptions);
+    writeCatalogComponents(components, options);
+    writeCatalogFunctions(functions, options);
+    return { components, functions };
+}
+// Function names must be valid JavaScript identifiers so they're safe to
+// (a) use as filesystem paths without escaping `..` or path separators and
+// (b) survive A2UI 0.9's wire format (`FunctionCall.call` is a bare name).
+const FUNCTION_NAME_RE = /^[a-z_$][\w$]*$/i;
+export function writeCatalogFunctions(functions, options) {
+    if (functions.length === 0)
+        return;
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const functionsDir = path.join(path.resolve(cwd, options.outDir), 'functions');
+    fs.mkdirSync(functionsDir, { recursive: true });
+    for (const fn of functions) {
+        if (!FUNCTION_NAME_RE.test(fn.name)) {
+            throw new Error(`[a2ui-catalog-extractor] Invalid function name "${fn.name}". `
+                + 'Names must match /^[A-Za-z_$][A-Za-z0-9_$]*$/ so they can be '
+                + 'used as filenames and as FunctionCall.call identifiers.');
+        }
+        const { filePath: _filePath, ...definition } = fn;
+        fs.writeFileSync(path.join(functionsDir, `${fn.name}.json`), `${JSON.stringify({ [fn.name]: definition }, null, 2)}\n`);
+    }
+}
+export function createA2UICatalog(options) {
+    const catalogComponents = Array.isArray(options.components)
+        ? Object.fromEntries(options.components.map(component => [component.name, component.schema]))
+        : options.components;
+    return {
+        catalogId: options.catalogId,
+        components: catalogComponents,
+        ...(options.functions ? { functions: options.functions } : {}),
+        ...(options.theme ? { theme: options.theme } : {}),
+    };
+}
+async function createTypeDocProject(options) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    // TypeDoc treats `entryPoints` as glob patterns and rejects Windows
+    // backslashes ("escapes a non-special character"). Force POSIX
+    // separators so the same paths work on Windows and *nix.
+    const sourceFiles = options.sourceFiles.map(sourceFile => path.resolve(cwd, sourceFile).replace(/\\/g, '/'));
+    if (sourceFiles.length === 0) {
+        throw new Error('No TypeDoc entry points were provided.');
+    }
+    const tsconfigPath = getTsconfigPath(cwd, options.tsconfig);
+    const bootstrapOptions = {
+        blockTags: [
+            ...OptionDefaults.blockTags,
+            '@a2uiCatalog',
+            '@a2uiFunction',
+        ],
+        entryPoints: sourceFiles,
+        excludePrivate: false,
+        excludeProtected: false,
+        readme: 'none',
+        skipErrorChecking: true,
+        sort: ['source-order'],
+        sortEntryPoints: false,
+    };
+    if (tsconfigPath) {
+        bootstrapOptions.tsconfig = tsconfigPath;
+    }
+    const app = await Application.bootstrap(bootstrapOptions);
+    const project = await app.convert();
+    if (!project) {
+        throw new Error('TypeDoc did not produce a project reflection.');
+    }
+    return project;
+}
+function collectSourceFiles(dir, files) {
+    for (const dirent of fs.readdirSync(dir, { withFileTypes: true })) {
+        const nextPath = path.join(dir, dirent.name);
+        if (dirent.isDirectory()) {
+            if (dirent.name === 'node_modules' || dirent.name === 'dist'
+                || dirent.name === '.turbo') {
+                continue;
+            }
+            collectSourceFiles(nextPath, files);
+        }
+        else if (dirent.isFile() && isSupportedSourceFile(nextPath)) {
+            files.push(nextPath);
+        }
+    }
+}
+function isSupportedSourceFile(filePath) {
+    if (filePath.endsWith('.d.ts')) {
+        return false;
+    }
+    return supportedSourceExtensions.has(path.extname(filePath));
+}
+function* walkReflections(reflection) {
+    for (const child of reflection.children ?? []) {
+        yield child;
+        yield* walkReflections(child);
+    }
+}
+function isInterfaceReflection(reflection) {
+    return reflection.kind === ReflectionKind.Interface
+        || reflection.kindString === 'Interface';
+}
+function pickFunctionSignature(reflection) {
+    if (reflection.signatures && reflection.signatures.length > 0) {
+        return reflection.signatures[0];
+    }
+    // Type alias / function-typed variable: `type x = (a: string) => boolean`.
+    const declarationSignatures = reflection.type?.declaration?.signatures;
+    if (declarationSignatures && declarationSignatures.length > 0) {
+        return declarationSignatures[0];
+    }
+    return undefined;
+}
+function createFunctionParametersSchema(signature, owner) {
+    const parameters = signature.parameters ?? [];
+    // A2UI 0.9 function calls carry `args: Record<string, any>`. The natural
+    // TypeScript convention is `function fn(args: { name: T1, ... }): R`. When
+    // we see exactly one inline-object parameter, unwrap it so the emitted
+    // schema describes the args record directly rather than nesting it under
+    // a synthetic `args` property.
+    if (parameters.length === 1) {
+        const only = parameters[0];
+        if (only.type?.type === 'reflection' && only.type.declaration) {
+            return parseFunctionObjectReflection(only.type.declaration, owner);
+        }
+    }
+    const schema = {
+        type: 'object',
+        properties: {},
+        required: [],
+        additionalProperties: false,
+    };
+    for (const parameter of parameters) {
+        if (!parameter.type) {
+            throw createReflectionError(owner, `Missing type for function parameter "${parameter.name}".`);
+        }
+        const propertySchema = parseFunctionParamType(parameter.type, parameter);
+        applyDocToSchema(propertySchema, parseComment(parameter.comment));
+        schema.properties[parameter.name] = propertySchema;
+        if (!isOptionalProperty(parameter)) {
+            schema.required.push(parameter.name);
+        }
+    }
+    return schema;
+}
+/**
+ * A relaxed sibling of `parseObjectReflection` used for function-arg shapes.
+ * Permits `any`/`unknown` so validators like `required(value)` and
+ * formatters like `formatString({ options })` can accept arbitrary inputs
+ * — the agent receives `{}` (no `type`) which is JSON-Schema-equivalent to
+ * "any value".
+ */
+function parseFunctionObjectReflection(declaration, owner) {
+    if (declaration.children === undefined) {
+        throw createReflectionError(owner, `Missing object declaration for "${owner.name}".`);
+    }
+    const schema = {
+        type: 'object',
+        properties: {},
+        required: [],
+        additionalProperties: false,
+    };
+    for (const child of declaration.children) {
+        if (!isPropertyReflection(child)) {
+            continue;
+        }
+        if (!child.type) {
+            throw createReflectionError(child, `Missing type for "${child.name}".`);
+        }
+        const propertySchema = parseFunctionParamType(child.type, child);
+        applyDocToSchema(propertySchema, parseComment(child.comment));
+        schema.properties[child.name] = propertySchema;
+        if (!isOptionalProperty(child)) {
+            schema.required.push(child.name);
+        }
+    }
+    return schema;
+}
+function parseFunctionParamType(type, owner) {
+    if (type.type === 'intrinsic') {
+        const name = type.name ?? '';
+        if (name === 'unknown' || name === 'any') {
+            // JSON Schema for "any value" — drop the type constraint.
+            return {};
+        }
+    }
+    if (type.type === 'reflection' && type.declaration) {
+        return parseFunctionObjectReflection(type.declaration, owner);
+    }
+    if (type.type === 'array' && type.elementType) {
+        return {
+            type: 'array',
+            items: parseFunctionParamType(type.elementType, owner),
+        };
+    }
+    if (type.type === 'union' && type.types) {
+        const actualTypes = type.types.filter(t => !isUndefinedType(t));
+        if (actualTypes.length === 1) {
+            return parseFunctionParamType(actualTypes[0], owner);
+        }
+        if (actualTypes.some(t => t.type === 'intrinsic'
+            && (t.name === 'unknown' || t.name === 'any'))) {
+            return {};
+        }
+    }
+    if (type.type === 'reference') {
+        const referenceName = String(type.name ?? type.qualifiedName ?? '');
+        if (referenceName === 'Record' && type.typeArguments?.length === 2) {
+            return {
+                type: 'object',
+                additionalProperties: parseFunctionParamType(type.typeArguments[1], owner),
+            };
+        }
+    }
+    return parseTypeDocType(type, owner);
+}
+function resolveReturnType(signature, owner) {
+    const type = signature.type;
+    if (!type) {
+        return 'void';
+    }
+    return mapTypeToReturnType(type, owner);
+}
+function mapTypeToReturnType(type, owner) {
+    switch (type.type) {
+        case 'intrinsic': {
+            const name = type.name ?? '';
+            if (name === 'string' || name === 'number' || name === 'boolean'
+                || name === 'void' || name === 'any') {
+                return name;
+            }
+            throw createReflectionError(owner, `Unsupported function return type "${name}" for "${owner.name}". `
+                + `Expected string, number, boolean, array, object, any, or void.`);
+        }
+        case 'array':
+            return 'array';
+        case 'reflection':
+        case 'reference': {
+            const referenceName = String(type.name ?? type.qualifiedName ?? '');
+            if (referenceName === 'Promise') {
+                throw createReflectionError(owner, `Async functions are not supported by A2UI 0.9; "${owner.name}" `
+                    + `must return a synchronous value.`);
+            }
+            if (referenceName === 'Array' || referenceName === 'ReadonlyArray') {
+                return 'array';
+            }
+            if (referenceName === 'Record' || type.type === 'reflection') {
+                return 'object';
+            }
+            return 'object';
+        }
+        case 'union': {
+            const actualTypes = (type.types ?? []).filter(candidate => !isUndefinedType(candidate));
+            if (actualTypes.length === 1) {
+                return mapTypeToReturnType(actualTypes[0], owner);
+            }
+            const mapped = actualTypes.map(candidate => mapTypeToReturnType(candidate, owner));
+            if (mapped.every(value => value === mapped[0])) {
+                return mapped[0];
+            }
+            return 'any';
+        }
+        case 'literal': {
+            switch (typeof type.value) {
+                case 'string':
+                    return 'string';
+                case 'number':
+                    return 'number';
+                case 'boolean':
+                    return 'boolean';
+                default:
+                    return 'any';
+            }
+        }
+        default:
+            return 'any';
+    }
+}
+function isPropertyReflection(reflection) {
+    return reflection.kind === ReflectionKind.Property
+        || reflection.kindString === 'Property';
+}
+function createComponentSchema(reflection, parsedDoc) {
+    if (reflection.children === undefined) {
+        throw createReflectionError(reflection, `Missing interface member declarations for "${reflection.name}".`);
+    }
+    const schema = { properties: {}, required: [] };
+    applyDocToSchema(schema, parsedDoc);
+    for (const child of reflection.children) {
+        if (child.inheritedFrom) {
+            continue;
+        }
+        if (!isPropertyReflection(child)) {
+            continue;
+        }
+        if (!child.type) {
+            throw createReflectionError(child, `Missing type for "${child.name}".`);
+        }
+        const propertySchema = parseTypeDocType(child.type, child);
+        applyDocToSchema(propertySchema, parseComment(child.comment));
+        schema.properties[child.name] = propertySchema;
+        if (!isOptionalProperty(child)) {
+            schema.required.push(child.name);
+        }
+    }
+    return schema;
+}
+function parseTypeDocType(type, owner) {
+    switch (type.type) {
+        case 'intrinsic':
+            return parseIntrinsicType(type.name ?? '', owner);
+        case 'literal':
+            return parseLiteralType(type.value, owner);
+        case 'union':
+            if (!type.types) {
+                throw createReflectionError(owner, `Missing union members for "${owner.name}".`);
+            }
+            return parseUnionType(type.types, owner);
+        case 'array':
+            if (!type.elementType) {
+                throw createReflectionError(owner, `Missing array element type for "${owner.name}".`);
+            }
+            return {
+                type: 'array',
+                items: parseTypeDocType(type.elementType, owner),
+            };
+        case 'reflection':
+            if (!type.declaration) {
+                throw createReflectionError(owner, `Missing reflection declaration for "${owner.name}".`);
+            }
+            return parseObjectReflection(type.declaration, owner);
+        case 'reference':
+            return parseReferenceType(type, owner);
+        case 'typeOperator':
+            if (!type.target) {
+                throw createReflectionError(owner, `Missing type operator target for "${owner.name}".`);
+            }
+            return parseTypeDocType(type.target, owner);
+        default:
+            if (type.elementType) {
+                return parseTypeDocType(type.elementType, owner);
+            }
+            throw createReflectionError(owner, `Unsupported TypeDoc type "${type.type}" for "${owner.name}".`);
+    }
+}
+function parseIntrinsicType(name, owner) {
+    switch (name) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+            return { type: name };
+        case 'any':
+        case 'unknown':
+        case 'undefined':
+        case 'null':
+        case 'never':
+        case 'void':
+            throw createReflectionError(owner, `Unsupported ambiguous intrinsic TypeDoc type "${name}" for "${owner.name}".`);
+        default:
+            throw createReflectionError(owner, `Unsupported intrinsic TypeDoc type "${name}" for "${owner.name}".`);
+    }
+}
+function parseLiteralType(value, owner) {
+    switch (typeof value) {
+        case 'string':
+            return { type: 'string', enum: [value] };
+        case 'number':
+            return { type: 'number', enum: [value] };
+        case 'bigint':
+            throw createReflectionError(owner, `Unsupported bigint literal for "${owner.name}".`);
+        case 'boolean':
+            return { type: 'boolean', enum: [value] };
+        default:
+            throw createReflectionError(owner, `Unsupported nullish literal for "${owner.name}".`);
+    }
+}
+function parseUnionType(types, owner) {
+    if (types.length === 0) {
+        throw createReflectionError(owner, `Missing union members for "${owner.name}".`);
+    }
+    if (types.some(type => isNullType(type))) {
+        throw createReflectionError(owner, `Unsupported nullable union for "${owner.name}".`);
+    }
+    const actualTypes = types.filter(type => !isUndefinedType(type));
+    if (actualTypes.length === 0) {
+        throw createReflectionError(owner, `Unsupported undefined-only union for "${owner.name}".`);
+    }
+    if (actualTypes.length === 1) {
+        return parseTypeDocType(actualTypes[0], owner);
+    }
+    const stringLiteralValues = actualTypes.map(type => getStringLiteralValue(type));
+    if (stringLiteralValues.every(value => value !== undefined)) {
+        return { type: 'string', enum: stringLiteralValues };
+    }
+    if (actualTypes.length === 2
+        && actualTypes.every(type => type.type === 'literal' && typeof type.value === 'boolean')) {
+        return { type: 'boolean' };
+    }
+    const oneOf = [];
+    for (const childType of actualTypes) {
+        const schema = parseTypeDocType(childType, owner);
+        if (!oneOf.some(existing => schemasEqual(existing, schema))) {
+            oneOf.push(schema);
+        }
+    }
+    return oneOf.length === 1 ? oneOf[0] : { oneOf };
+}
+function parseObjectReflection(declaration, owner) {
+    if (declaration.children === undefined) {
+        throw createReflectionError(owner, `Missing object declaration for "${owner.name}".`);
+    }
+    const schema = {
+        type: 'object',
+        properties: {},
+        required: [],
+        additionalProperties: false,
+    };
+    for (const child of declaration.children) {
+        if (!isPropertyReflection(child)) {
+            continue;
+        }
+        if (!child.type) {
+            throw createReflectionError(child, `Missing type for "${child.name}".`);
+        }
+        const propertySchema = parseTypeDocType(child.type, child);
+        applyDocToSchema(propertySchema, parseComment(child.comment));
+        schema.properties[child.name] = propertySchema;
+        if (!isOptionalProperty(child)) {
+            schema.required.push(child.name);
+        }
+    }
+    return schema;
+}
+function parseReferenceType(type, owner) {
+    const typeName = String(type.name ?? type.qualifiedName ?? '');
+    const typeArguments = type.typeArguments ?? [];
+    if ((typeName === 'Array' || typeName === 'ReadonlyArray')
+        && typeArguments.length === 1) {
+        return {
+            type: 'array',
+            items: parseTypeDocType(typeArguments[0], owner),
+        };
+    }
+    if (typeName === 'Record' && typeArguments.length === 2) {
+        const keyType = typeArguments[0];
+        if (!isStringKeyType(keyType)) {
+            throw createReflectionError(owner, 'A2UI catalog Record keys must be string-compatible.');
+        }
+        const valueType = typeArguments[1];
+        if (isAmbiguousIntrinsicType(valueType)) {
+            return {
+                type: 'object',
+                additionalProperties: true,
+            };
+        }
+        return {
+            type: 'object',
+            additionalProperties: parseTypeDocType(valueType, owner),
+        };
+    }
+    throw createReflectionError(owner, `Unsupported TypeDoc reference "${typeName}" for "${owner.name}". Use an inline type literal, array, union, or Record<string, T>.`);
+}
+function parseComment(comment) {
+    if (!comment) {
+        return {};
+    }
+    const parsedDoc = {};
+    const summary = normalizeDescription(renderCommentParts(comment.summary));
+    if (summary) {
+        parsedDoc.description = summary;
+    }
+    if (hasModifierTag(comment, '@deprecated')) {
+        parsedDoc.deprecated = true;
+    }
+    for (const block of comment.blockTags ?? []) {
+        const content = normalizeDescription(renderCommentParts(block.content));
+        switch (block.tag) {
+            case '@a2uiCatalog':
+                parsedDoc.a2uiCatalogName = content;
+                break;
+            case '@a2uiFunction':
+                parsedDoc.a2uiFunctionName = content;
+                break;
+            case '@remarks':
+                if (content) {
+                    parsedDoc.description = parsedDoc.description
+                        ? `${parsedDoc.description}\n\n${content}`
+                        : content;
+                }
+                break;
+            case '@default':
+            case '@defaultValue':
+                if (content) {
+                    parsedDoc.defaultValue = parseDefaultValue(content);
+                }
+                break;
+            case '@deprecated':
+                parsedDoc.deprecated = true;
+                break;
+            default:
+                break;
+        }
+    }
+    return parsedDoc;
+}
+function applyDocToSchema(schema, parsedDoc) {
+    if (parsedDoc.description) {
+        schema.description = parsedDoc.description;
+    }
+    if (parsedDoc.defaultValue !== undefined) {
+        schema.default = parsedDoc.defaultValue;
+    }
+    if (parsedDoc.deprecated) {
+        schema.deprecated = true;
+    }
+}
+function renderCommentParts(parts) {
+    return (parts ?? []).map(part => renderCommentPart(part)).join('');
+}
+function renderCommentPart(part) {
+    if (part.text !== undefined) {
+        return part.text;
+    }
+    if (part.code !== undefined) {
+        return `\`${part.code}\``;
+    }
+    if (part.content) {
+        return renderCommentParts(part.content);
+    }
+    if (part.kind === 'softBreak') {
+        return ' ';
+    }
+    return '';
+}
+function normalizeDescription(text) {
+    return text.replace(/[ \t\r\n]+/g, ' ').trim();
+}
+function parseDefaultValue(text) {
+    const trimmed = unwrapCodeSpan(text.trim());
+    if (trimmed === 'undefined') {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function unwrapCodeSpan(text) {
+    if (text.startsWith('`') && text.endsWith('`') && text.length >= 2) {
+        return text.slice(1, -1);
+    }
+    return text;
+}
+function hasModifierTag(comment, tag) {
+    const modifierTags = comment.modifierTags;
+    if (!modifierTags) {
+        return false;
+    }
+    if (typeof modifierTags.has === 'function') {
+        return modifierTags.has(tag);
+    }
+    return Boolean(modifierTags[tag]);
+}
+function isOptionalProperty(reflection) {
+    return reflection.flags?.isOptional === true
+        || (reflection.type ? typeIncludesUndefined(reflection.type) : false);
+}
+function typeIncludesUndefined(type) {
+    if (type.type !== 'union') {
+        return false;
+    }
+    return (type.types ?? []).some(childType => isUndefinedType(childType));
+}
+function isUndefinedType(type) {
+    return type.type === 'intrinsic' && type.name === 'undefined';
+}
+function isNullType(type) {
+    return (type.type === 'intrinsic' && type.name === 'null')
+        || (type.type === 'literal' && type.value === null);
+}
+function isAmbiguousIntrinsicType(type) {
+    return type.type === 'intrinsic'
+        && (type.name === 'unknown' || type.name === 'any');
+}
+function getStringLiteralValue(type) {
+    if (type.type === 'literal' && typeof type.value === 'string') {
+        return type.value;
+    }
+    return undefined;
+}
+function isStringKeyType(type) {
+    if (type.type === 'intrinsic' && type.name === 'string') {
+        return true;
+    }
+    if (type.type === 'union') {
+        return (type.types ?? []).every(childType => childType.type === 'literal' && typeof childType.value === 'string');
+    }
+    return false;
+}
+function getReflectionFilePath(reflection, cwd) {
+    const source = reflection.sources?.[0];
+    if (!source) {
+        return '';
+    }
+    if (source.fullFileName) {
+        return path.resolve(source.fullFileName);
+    }
+    if (source.fileName) {
+        return path.resolve(cwd, source.fileName);
+    }
+    return '';
+}
+function createReflectionError(reflection, message) {
+    const source = reflection.sources?.[0];
+    if (!source) {
+        return new Error(message);
+    }
+    const fileName = source.fullFileName ?? source.fileName ?? '';
+    const line = source.line ? `:${source.line}` : '';
+    const character = source.character ? `:${source.character}` : '';
+    return new Error(`${fileName}${line}${character} ${message}`.trim());
+}
+function inferCatalogName(interfaceName) {
+    return interfaceName.replace(/(?:Component)?Props$/, '');
+}
+function schemasEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function getTsconfigPath(cwd, tsconfig) {
+    if (tsconfig) {
+        return path.resolve(cwd, tsconfig);
+    }
+    const defaultTsconfig = path.join(cwd, 'tsconfig.json');
+    return fs.existsSync(defaultTsconfig) ? defaultTsconfig : undefined;
+}
+//# sourceMappingURL=index.js.map