nuxt-openapi-hyperfetch 0.1.0-alpha.1

package/dist/generators/use-fetch/parser.js

@@ -0,0 +1,282 @@
+import { Project, SyntaxKind } from 'ts-morph';
+import * as path from 'path';
+import { existsSync, readdirSync } from 'node:fs';
+import { pascalCase } from 'change-case';
+import { p } from '../../cli/logger.js';
+/**
+ * Get all API files from the input directory
+ */
+export function getApiFiles(inputDir) {
+    const apisDir = path.join(inputDir, 'apis');
+    if (!existsSync(apisDir)) {
+        throw new Error(`APIs directory not found: ${apisDir}`);
+    }
+    const files = readdirSync(apisDir);
+    return files
+        .filter((file) => file.endsWith('.ts') && file !== 'index.ts')
+        .map((file) => path.join(apisDir, file));
+}
+/**
+ * Parse an API file and extract all methods
+ */
+export function parseApiFile(filePath) {
+    const project = new Project();
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    // Find the API class (e.g., PetApi, StoreApi)
+    const classes = sourceFile.getClasses();
+    if (classes.length === 0) {
+        throw new Error(`No class found in ${filePath}`);
+    }
+    const apiClass = classes[0];
+    const className = apiClass.getName() || '';
+    // Get all public methods (excluding Raw and RequestOpts)
+    const methods = getPublicMethods(apiClass.getMethods());
+    const methodInfos = [];
+    for (const method of methods) {
+        try {
+            const methodInfo = extractMethodInfo(method, sourceFile);
+            if (methodInfo) {
+                methodInfos.push(methodInfo);
+            }
+        }
+        catch (error) {
+            p.log.warn(`Could not parse method ${method.getName()}: ${String(error)}`);
+        }
+    }
+    return {
+        className,
+        methods: methodInfos,
+    };
+}
+/**
+ * Filter to get only public methods (not Raw, not RequestOpts)
+ */
+function getPublicMethods(methods) {
+    return methods.filter((method) => {
+        const name = method.getName();
+        const isAsync = method.isAsync();
+        const isPublic = !method.hasModifier(SyntaxKind.PrivateKeyword) &&
+            !method.hasModifier(SyntaxKind.ProtectedKeyword);
+        return isPublic && isAsync && !name.endsWith('Raw') && !name.endsWith('RequestOpts');
+    });
+}
+/**
+ * Extract method information
+ */
+function extractMethodInfo(method, sourceFile) {
+    const methodName = method.getName();
+    const composableName = `useFetch${pascalCase(methodName)}`;
+    // Get parameters
+    const params = method.getParameters();
+    let requestType = params.length > 0 ? params[0].getType().getText() : undefined;
+    // Clean up type text: remove import() expressions and fix formatting
+    if (requestType) {
+        // Remove all import("path") expressions
+        requestType = requestType.replace(/import\([^)]+\)\./g, '');
+        // If it's the default RequestInit | InitOverrideFunction, treat as no params
+        if (requestType === 'RequestInit | InitOverrideFunction') {
+            requestType = undefined;
+        }
+    }
+    // Get return type
+    const returnType = method.getReturnType();
+    const responseType = extractResponseType(returnType.getText());
+    // Find corresponding RequestOpts method
+    const requestOptsMethodName = `${methodName}RequestOpts`;
+    const requestOptsMethod = sourceFile.getClasses()[0].getMethod(requestOptsMethodName);
+    if (!requestOptsMethod) {
+        p.log.warn(`Could not find ${requestOptsMethodName} method`);
+        return null;
+    }
+    // Parse request options
+    const requestOpts = parseRequestOptions(requestOptsMethod);
+    // Get description from JSDoc
+    const jsDocs = method.getJsDocs();
+    const description = jsDocs.length > 0 ? jsDocs[0].getDescription().trim() : undefined;
+    // Detect if Raw method exists
+    const rawMethodName = `${methodName}Raw`;
+    const classDeclaration = sourceFile.getClasses()[0];
+    const hasRawMethod = classDeclaration.getMethod(rawMethodName) !== undefined;
+    return {
+        name: methodName,
+        composableName,
+        requestType,
+        responseType,
+        httpMethod: requestOpts.method,
+        path: requestOpts.path,
+        hasBody: requestOpts.hasBody,
+        bodyField: requestOpts.bodyField,
+        hasQueryParams: requestOpts.queryParams.length > 0,
+        queryParams: requestOpts.queryParams,
+        pathParams: extractPathParams(requestOpts.path),
+        headers: requestOpts.headers,
+        description,
+        hasRawMethod,
+        rawMethodName: hasRawMethod ? rawMethodName : undefined,
+    };
+}
+/**
+ * Extract response type from Promise<Type>
+ */
+function extractResponseType(returnTypeText) {
+    // Match Promise<Type>
+    const match = returnTypeText.match(/Promise<(.+)>$/);
+    if (match) {
+        // Remove all import("path") expressions
+        return match[1].replace(/import\([^)]+\)\./g, '');
+    }
+    return 'void';
+}
+/**
+ * Parse the RequestOpts method to extract request details
+ */
+function parseRequestOptions(method) {
+    const result = {
+        path: '',
+        method: 'GET',
+        headers: {},
+        hasBody: false,
+        bodyField: undefined,
+        queryParams: [],
+    };
+    // Find the return statement
+    const returnStatements = method.getDescendantsOfKind(SyntaxKind.ReturnStatement);
+    if (returnStatements.length === 0) {
+        return result;
+    }
+    const returnStmt = returnStatements[0];
+    const objectLiteral = returnStmt.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression);
+    if (!objectLiteral) {
+        return result;
+    }
+    // Parse each property
+    for (const prop of objectLiteral.getProperties()) {
+        if (prop.getKind() !== SyntaxKind.PropertyAssignment) {
+            continue;
+        }
+        const propAssignment = prop.asKind(SyntaxKind.PropertyAssignment);
+        if (!propAssignment) {
+            continue;
+        }
+        const propName = propAssignment.getName();
+        const initializer = propAssignment.getInitializer();
+        if (!initializer) {
+            continue;
+        }
+        switch (propName) {
+            case 'path': {
+                // Extract path from variable assignment
+                const pathValue = extractStringValue(initializer, method);
+                if (pathValue) {
+                    result.path = pathValue;
+                }
+                break;
+            }
+            case 'method': {
+                const methodValue = extractStringValue(initializer, method);
+                if (methodValue) {
+                    result.method = methodValue;
+                }
+                break;
+            }
+            case 'body': {
+                result.hasBody = true;
+                // Try to extract body field (e.g., params['pet'] or params.pet)
+                const bodyText = initializer.getText();
+                const bodyMatch = bodyText.match(/requestParameters(?:\['(\w+)'\]|\.(\w+))/);
+                if (bodyMatch) {
+                    result.bodyField = bodyMatch[1] || bodyMatch[2];
+                }
+                break;
+            }
+            case 'headers': {
+                // Extract headers if it's an object literal
+                if (initializer.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                    const headersObj = initializer.asKind(SyntaxKind.ObjectLiteralExpression);
+                    if (headersObj) {
+                        for (const headerProp of headersObj.getProperties()) {
+                            if (headerProp.getKind() === SyntaxKind.PropertyAssignment) {
+                                const headerAssignment = headerProp.asKind(SyntaxKind.PropertyAssignment);
+                                if (headerAssignment) {
+                                    const headerName = headerAssignment.getName();
+                                    const headerValue = headerAssignment.getInitializer();
+                                    if (headerValue && headerValue.getKind() === SyntaxKind.StringLiteral) {
+                                        result.headers[headerName] = headerValue.getText().slice(1, -1);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+        }
+    }
+    // Extract query parameters from the method body
+    result.queryParams = extractQueryParams(method);
+    return result;
+}
+/**
+ * Extract string value from expression
+ */
+function extractStringValue(node, method) {
+    // Direct string literal
+    if (node.getKind() === SyntaxKind.StringLiteral) {
+        return node.getText().slice(1, -1); // Remove quotes
+    }
+    // Template literal
+    if (node.getKind() === SyntaxKind.TemplateExpression ||
+        node.getKind() === SyntaxKind.NoSubstitutionTemplateLiteral) {
+        return node.getText().slice(1, -1); // Remove backticks
+    }
+    // Variable reference - try to find its value
+    if (node.getKind() === SyntaxKind.Identifier) {
+        const varName = node.getText();
+        // Find variable declarations in the method body
+        const varDeclarations = method.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+        for (const varDecl of varDeclarations) {
+            if (varDecl.getName() === varName) {
+                const initializer = varDecl.getInitializer();
+                if (initializer) {
+                    if (initializer.getKind() === SyntaxKind.StringLiteral) {
+                        return initializer.getText().slice(1, -1);
+                    }
+                    if (initializer.getKind() === SyntaxKind.TemplateExpression ||
+                        initializer.getKind() === SyntaxKind.NoSubstitutionTemplateLiteral) {
+                        return initializer.getText().slice(1, -1);
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extract query parameters from method body
+ */
+function extractQueryParams(method) {
+    const params = [];
+    const methodText = method.getText();
+    // Look for queryParameters['paramName'] or queryParameters.paramName
+    const regex = /queryParameters(?:\['(\w+)'\]|\.(\w+))/g;
+    let match;
+    while ((match = regex.exec(methodText)) !== null) {
+        const paramName = match[1] || match[2];
+        if (paramName && !params.includes(paramName)) {
+            params.push(paramName);
+        }
+    }
+    return params;
+}
+/**
+ * Extract path parameters from path string (e.g., /pet/{petId} -> ['petId'])
+ */
+function extractPathParams(path) {
+    const regex = /\{(\w+)\}/g;
+    const params = [];
+    let match;
+    while ((match = regex.exec(path)) !== null) {
+        params.push(match[1]);
+    }
+    return params;
+}

package/dist/generators/use-fetch/runtime/useApiRequest.d.ts

@@ -0,0 +1,46 @@
+import { type ApiRequestOptions as BaseApiRequestOptions } from '../../shared/runtime/apiHelpers.js';
+/**
+ * Options for useFetch API requests with lifecycle callbacks
+ * Extends base options with useFetch-specific options
+ */
+export interface ApiRequestOptions<T = any> extends BaseApiRequestOptions<T> {
+    /** All standard useFetch options */
+    [key: string]: any;
+}
+/**
+ * Enhanced useFetch wrapper with lifecycle callbacks and request interception
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const { data, error } = useApiRequest<Pet>('/api/pets', {
+ *   method: 'POST',
+ *   body: { name: 'Max' },
+ * });
+ *
+ * // With transform (type is inferred!)
+ * const { data } = useApiRequest<Pet>('/api/pets/1', {
+ *   transform: (pet) => ({ displayName: pet.name, available: pet.status === 'available' })
+ * });
+ * // data is Ref<{ displayName: string, available: boolean }>
+ *
+ * // With pick (simple fields)
+ * const { data } = useApiRequest<Pet>('/api/pets/1', {
+ *   pick: ['id', 'name'] as const
+ * });
+ *
+ * // With pick (nested dot notation)
+ * const { data } = useApiRequest('/api/user', {
+ *   pick: ['person.name', 'person.email', 'status']
+ * });
+ * // Result: { person: { name: '...', email: '...' }, status: '...' }
+ *
+ * // With callbacks
+ * const { data } = useApiRequest<Pet>('/api/pets', {
+ *   onRequest: (ctx) => ({ headers: { 'Authorization': `Bearer ${token}` } }),
+ *   onSuccess: (pet) => console.log('Got pet:', pet),
+ *   onError: (err) => console.error('Failed:', err),
+ * });
+ * ```
+ */
+export declare function useApiRequest<T = any, Options extends ApiRequestOptions<T> = ApiRequestOptions<T>>(url: string | (() => string), options?: Options): any;

package/dist/generators/use-fetch/runtime/useApiRequest.js

@@ -0,0 +1,158 @@
+// @ts-nocheck
+/**
+ * Nuxt Runtime Helper - This file is copied to the generated output
+ * It requires Nuxt 3 to be installed in the target project
+ */
+import { watch } from 'vue';
+import { getGlobalHeaders, applyPick, applyRequestModifications, mergeCallbacks, } from '../../shared/runtime/apiHelpers.js';
+/**
+ * Enhanced useFetch wrapper with lifecycle callbacks and request interception
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const { data, error } = useApiRequest<Pet>('/api/pets', {
+ *   method: 'POST',
+ *   body: { name: 'Max' },
+ * });
+ *
+ * // With transform (type is inferred!)
+ * const { data } = useApiRequest<Pet>('/api/pets/1', {
+ *   transform: (pet) => ({ displayName: pet.name, available: pet.status === 'available' })
+ * });
+ * // data is Ref<{ displayName: string, available: boolean }>
+ *
+ * // With pick (simple fields)
+ * const { data } = useApiRequest<Pet>('/api/pets/1', {
+ *   pick: ['id', 'name'] as const
+ * });
+ *
+ * // With pick (nested dot notation)
+ * const { data } = useApiRequest('/api/user', {
+ *   pick: ['person.name', 'person.email', 'status']
+ * });
+ * // Result: { person: { name: '...', email: '...' }, status: '...' }
+ *
+ * // With callbacks
+ * const { data } = useApiRequest<Pet>('/api/pets', {
+ *   onRequest: (ctx) => ({ headers: { 'Authorization': `Bearer ${token}` } }),
+ *   onSuccess: (pet) => console.log('Got pet:', pet),
+ *   onError: (err) => console.error('Failed:', err),
+ * });
+ * ```
+ */
+export function useApiRequest(url, options) {
+    const { onRequest, onSuccess, onError, onFinish, skipGlobalCallbacks, transform, pick, ...fetchOptions } = options || {};
+    // Prepare request context for onRequest interceptor
+    const urlValue = typeof url === 'function' ? url() : url;
+    const requestContext = {
+        url: urlValue,
+        method: fetchOptions.method || 'GET',
+        body: fetchOptions.body,
+        headers: fetchOptions.headers,
+        query: fetchOptions.query,
+    };
+    // Merge local and global callbacks
+    const mergedCallbacks = mergeCallbacks(urlValue, { onRequest, onSuccess, onError, onFinish }, skipGlobalCallbacks);
+    // Apply global headers configuration (from composable or plugin)
+    const modifiedOptions = { ...fetchOptions };
+    const globalHeaders = getGlobalHeaders();
+    if (Object.keys(globalHeaders).length > 0) {
+        modifiedOptions.headers = {
+            ...globalHeaders,
+            ...modifiedOptions.headers, // User headers override global headers
+        };
+    }
+    // Execute merged onRequest interceptor and apply modifications
+    if (mergedCallbacks.onRequest) {
+        try {
+            const result = mergedCallbacks.onRequest(requestContext);
+            // Handle async onRequest
+            if (result && typeof result === 'object' && 'then' in result) {
+                result
+                    .then((modifications) => {
+                    if (modifications) {
+                        applyRequestModifications(modifiedOptions, modifications);
+                    }
+                })
+                    .catch((error) => {
+                    console.error('Error in merged onRequest callback:', error);
+                });
+            }
+            // Handle sync onRequest with return value
+            else if (result && typeof result === 'object') {
+                applyRequestModifications(modifiedOptions, result);
+            }
+        }
+        catch (error) {
+            console.error('Error in merged onRequest callback:', error);
+        }
+    }
+    // Make the actual request using Nuxt's useFetch
+    const result = useFetch(url, modifiedOptions);
+    const transformedData = ref(null);
+    // Track if callbacks have been executed to avoid duplicates
+    let successExecuted = false;
+    let errorExecuted = false;
+    // Watch for changes in data, error, and pending states
+    watch(() => [result.data.value, result.error.value, result.pending.value], async ([data, error, pending], [prevData, prevError, prevPending]) => {
+        // Apply transformations when data arrives
+        if (data && data !== prevData) {
+            let processedData = data;
+            // Step 1: Apply pick if specified
+            if (pick) {
+                processedData = applyPick(processedData, pick);
+            }
+            // Step 2: Apply transform if specified
+            if (transform) {
+                try {
+                    processedData = transform(processedData);
+                }
+                catch (err) {
+                    console.error('Error in transform function:', err);
+                }
+            }
+            // Update transformed data ref
+            transformedData.value = processedData;
+            // onSuccess - when data arrives and no error (using merged callback)
+            if (!error && !successExecuted && mergedCallbacks.onSuccess) {
+                successExecuted = true;
+                try {
+                    await mergedCallbacks.onSuccess(processedData);
+                }
+                catch (err) {
+                    console.error('Error in merged onSuccess callback:', err);
+                }
+            }
+        }
+        // onError - when an error occurs (using merged callback)
+        if (error && error !== prevError && !errorExecuted && mergedCallbacks.onError) {
+            errorExecuted = true;
+            try {
+                await mergedCallbacks.onError(error);
+            }
+            catch (err) {
+                console.error('Error in merged onError callback:', err);
+            }
+        }
+        // onFinish - when request completes (was pending, now not) (using merged callback)
+        if (prevPending && !pending && mergedCallbacks.onFinish) {
+            const finishContext = {
+                data: transformedData.value || undefined,
+                error: error || undefined,
+                success: !!transformedData.value && !error,
+            };
+            try {
+                await mergedCallbacks.onFinish(finishContext);
+            }
+            catch (err) {
+                console.error('Error in merged onFinish callback:', err);
+            }
+        }
+    }, { immediate: true });
+    // Return result with transformed data
+    return {
+        ...result,
+        data: transformedData,
+    };
+}

package/dist/generators/use-fetch/templates.d.ts

@@ -0,0 +1,16 @@
+import type { MethodInfo } from './types.js';
+/**
+ * Options for code generation
+ */
+export interface GenerateOptions {
+    baseUrl?: string;
+    backend?: string;
+}
+/**
+ * Generate a useFetch composable function
+ */
+export declare function generateComposableFile(method: MethodInfo, apiImportPath: string, options?: GenerateOptions): string;
+/**
+ * Generate index.ts that exports all composables
+ */
+export declare function generateIndexFile(composableNames: string[]): string;

package/dist/generators/use-fetch/templates.js

@@ -0,0 +1,169 @@
+/**
+ * Generate file header with auto-generation warning
+ */
+function generateFileHeader() {
+    return `/**
+ * ⚠️ AUTO-GENERATED FILE - DO NOT EDIT MANUALLY
+ *
+ * This file was automatically generated by nuxt-openapi-generator.
+ * Any manual changes will be overwritten on the next generation.
+ *
+ * @generated by nuxt-openapi-generator
+ * @see https://github.com/dmartindiaz/nuxt-openapi-hyperfetch
+ */
+
+/* eslint-disable */
+// @ts-nocheck
+`;
+}
+/**
+ * Generate a useFetch composable function
+ */
+export function generateComposableFile(method, apiImportPath, options) {
+    const header = generateFileHeader();
+    const imports = generateImports(method, apiImportPath);
+    const functionBody = generateFunctionBody(method, options);
+    return `${header}${imports}\n\n${functionBody}\n`;
+}
+/**
+ * Extract base type names from a type string
+ * Examples:
+ *   Pet[] -> Pet
+ *   Array<Pet> -> Pet
+ *   Pet -> Pet
+ *   { [key: string]: Pet } -> (empty, it's anonymous)
+ */
+function extractBaseTypes(type) {
+    if (!type) {
+        return [];
+    }
+    // Handle array syntax: Pet[]
+    const arrayMatch = type.match(/^(\w+)\[\]$/);
+    if (arrayMatch) {
+        return [arrayMatch[1]];
+    }
+    // Handle Array generic: Array<Pet>
+    const arrayGenericMatch = type.match(/^Array<(\w+)>$/);
+    if (arrayGenericMatch) {
+        return [arrayGenericMatch[1]];
+    }
+    // If it's a simple named type (single word, PascalCase), include it
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(type)) {
+        return [type];
+    }
+    // For complex types, don't extract anything
+    return [];
+}
+/**
+ * Generate import statements
+ */
+function generateImports(method, apiImportPath) {
+    const typeNames = new Set();
+    // Extract base types from request type
+    if (method.requestType) {
+        const extracted = extractBaseTypes(method.requestType);
+        extracted.forEach((t) => typeNames.add(t));
+    }
+    // Extract base types from response type
+    if (method.responseType && method.responseType !== 'void') {
+        const extracted = extractBaseTypes(method.responseType);
+        extracted.forEach((t) => typeNames.add(t));
+    }
+    let imports = '';
+    // Import types from API (only if we have named types to import)
+    if (typeNames.size > 0) {
+        imports += `import type { ${Array.from(typeNames).join(', ')} } from '${apiImportPath}';\n`;
+    }
+    // Import runtime helper
+    imports += `import { useApiRequest, type ApiRequestOptions } from '../runtime/useApiRequest';`;
+    return imports;
+}
+/**
+}
+
+/**
+ * Generate the composable function body
+ */
+function generateFunctionBody(method, options) {
+    const hasParams = !!method.requestType;
+    const paramsArg = hasParams ? `params: MaybeRef<${method.requestType}>` : '';
+    const optionsType = `ApiRequestOptions<${method.responseType}>`;
+    const optionsArg = `options?: ${optionsType}`;
+    const args = hasParams ? `${paramsArg}, ${optionsArg}` : optionsArg;
+    const responseTypeGeneric = method.responseType !== 'void' ? `<${method.responseType}>` : '';
+    const url = generateUrl(method);
+    const fetchOptions = generateFetchOptions(method, options);
+    const description = method.description ? `/**\n * ${method.description}\n */\n` : '';
+    const pInit = hasParams ? `\n  const p = isRef(params) ? params : shallowRef(params)` : '';
+    return `${description}export const ${method.composableName} = (${args}) => {${pInit}
+  return useApiRequest${responseTypeGeneric}(${url}, ${fetchOptions})
+}`;
+}
+/**
+ * Generate URL (with path params if needed)
+ */
+function generateUrl(method) {
+    if (method.pathParams.length === 0) {
+        return `'${method.path}'`;
+    }
+    let url = method.path;
+    for (const param of method.pathParams) {
+        const accessor = method.paramsShape === 'nested' ? `p.value.path.${param}` : `p.value.${param}`;
+        url = url.replace(`{${param}}`, `\${${accessor}}`);
+    }
+    return `() => \`${url}\``;
+}
+/**
+ * Generate fetch options object
+ */
+function generateFetchOptions(method, generateOptions) {
+    const options = [];
+    // Method
+    options.push(`method: '${method.httpMethod}'`);
+    // Base URL (if provided in config)
+    if (generateOptions?.baseUrl) {
+        options.push(`baseURL: '${generateOptions.baseUrl}'`);
+    }
+    // Body
+    if (method.hasBody) {
+        if (method.paramsShape === 'nested') {
+            options.push(`body: computed(() => p.value.body)`);
+        }
+        else if (method.bodyField) {
+            options.push(`body: computed(() => p.value.${method.bodyField})`);
+        }
+    }
+    // Query params
+    if (method.hasQueryParams) {
+        if (method.paramsShape === 'nested') {
+            options.push(`query: computed(() => p.value.query)`);
+        }
+        else if (method.queryParams.length > 0) {
+            const queryObj = method.queryParams
+                .map((param) => `${param}: p.value.${param}`)
+                .join(',\n      ');
+            options.push(`query: computed(() => ({\n      ${queryObj}\n    }))`);
+        }
+    }
+    // Headers
+    if (Object.keys(method.headers).length > 0) {
+        const headersEntries = Object.entries(method.headers)
+            .map(([key, value]) => `'${key}': '${value}'`)
+            .join(',\n      ');
+        options.push(`headers: {\n      ${headersEntries},\n      ...options?.headers\n    }`);
+    }
+    // Spread options
+    options.push('...options');
+    const optionsStr = options.join(',\n    ');
+    return `{\n    ${optionsStr}\n  }`;
+}
+/**
+ * Generate index.ts that exports all composables
+ */
+export function generateIndexFile(composableNames) {
+    const header = generateFileHeader();
+    const exports = composableNames
+        .map((name) => `export { ${name} } from './composables/${name}'`)
+        .join('\n');
+    return `${header}${exports}\n`;
+}

package/dist/generators/use-fetch/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-export shared types
+ * This allows use-fetch generator to use the same types as other generators
+ */
+export * from '../shared/types.js';

package/dist/generators/use-fetch/types.js

@@ -0,0 +1,5 @@
+/**
+ * Re-export shared types
+ * This allows use-fetch generator to use the same types as other generators
+ */
+export * from '../shared/types.js';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};