apisurf/lib/utilities/parseApiSurface.function.test.js

Analyze API surface changes between npm package versions to catch breaking changes

import { describe, it, expect } from '@jest/globals';
import { parseApiSurface } from './parseApiSurface.js';
describe('parseApiSurface - function signatures', () => {
    it('should capture arrow function signatures', () => {
        const source = `
export const greet = (name: string) => \`Hello \${name}!\`;
export const greetWithPrefix = (name: string, prefix?: string) => \`\${prefix || 'Hello'} \${name}!\`;
`;
        const result = parseApiSurface(source, 'test-pkg', '1.0.0');
        // Check that functions are parsed
        expect(result.namedExports.has('greet')).toBe(true);
        expect(result.namedExports.has('greetWithPrefix')).toBe(true);
        // Check that signatures are captured
        const greetDef = result.typeDefinitions?.get('greet');
        expect(greetDef).toBeDefined();
        expect(greetDef?.kind).toBe('function');
        expect(greetDef?.signature).toBe('export const greet = (name: string) => ...');
        const greetWithPrefixDef = result.typeDefinitions?.get('greetWithPrefix');
        expect(greetWithPrefixDef).toBeDefined();
        expect(greetWithPrefixDef?.signature).toBe('export const greetWithPrefix = (name: string, prefix?: string) => ...');
    });
    it('should capture function type alias signatures', () => {
        const source = `
export type EventHandler<T = any> = (event: T) => void;
export type AsyncEventHandler<T = any> = (event: T, context?: any) => Promise<void>;
`;
        const result = parseApiSurface(source, 'test-pkg', '1.0.0');
        // Check that type aliases are parsed
        expect(result.typeOnlyExports.has('EventHandler')).toBe(true);
        expect(result.typeOnlyExports.has('AsyncEventHandler')).toBe(true);
        // Check that signatures are captured
        const eventHandlerDef = result.typeDefinitions?.get('EventHandler');
        expect(eventHandlerDef).toBeDefined();
        expect(eventHandlerDef?.kind).toBe('type');
        expect(eventHandlerDef?.signature).toContain('(event: T) => void');
        const asyncEventHandlerDef = result.typeDefinitions?.get('AsyncEventHandler');
        expect(asyncEventHandlerDef).toBeDefined();
        expect(asyncEventHandlerDef?.signature).toContain('(event: T, context?: any) => Promise<void>');
    });
});