@pattern-stack/frontend-patterns 0.0.5 → 0.1.0

package/cli/src/codegen/openapi/parser.js

@@ -0,0 +1,279 @@
+"use strict";
+/**
+ * OpenAPI Parser Implementation
+ *
+ * Core parser that reads OpenAPI 3.0 specifications and converts them
+ * into an intermediate representation for code generation.
+ *
+ * Part of FRO-11: OpenAPI Parser Implementation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPIParser = void 0;
+exports.parseOpenAPI = parseOpenAPI;
+exports.loadOpenAPISpec = loadOpenAPISpec;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// Main parser class
+class OpenAPIParser {
+    constructor(spec) {
+        this.refs = new Map();
+        this.spec = spec;
+        this.buildRefsMap();
+    }
+    /**
+     * Parse the OpenAPI specification into our intermediate representation
+     */
+    parse() {
+        return {
+            info: this.parseInfo(),
+            servers: this.parseServers(),
+            endpoints: this.parseEndpoints(),
+            schemas: this.parseSchemas(),
+            security: this.parseSecurity()
+        };
+    }
+    parseInfo() {
+        return {
+            title: this.spec.info.title,
+            version: this.spec.info.version,
+            description: this.spec.info.description
+        };
+    }
+    parseServers() {
+        if (!this.spec.servers)
+            return [];
+        return this.spec.servers.map(server => ({
+            url: server.url,
+            description: server.description,
+            variables: server.variables ?
+                Object.fromEntries(Object.entries(server.variables).map(([key, variable]) => [
+                    key,
+                    variable.default || ''
+                ])) : undefined
+        }));
+    }
+    parseEndpoints() {
+        const endpoints = [];
+        for (const [path, pathItem] of Object.entries(this.spec.paths || {})) {
+            if (!pathItem)
+                continue;
+            const methods = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
+            for (const method of methods) {
+                const operation = pathItem[method];
+                if (!operation)
+                    continue;
+                endpoints.push({
+                    path,
+                    method,
+                    operationId: operation.operationId,
+                    summary: operation.summary,
+                    description: operation.description,
+                    tags: operation.tags,
+                    parameters: this.parseParameters(operation.parameters),
+                    requestBody: operation.requestBody ? this.parseRequestBody(operation.requestBody) : undefined,
+                    responses: this.parseResponses(operation.responses),
+                    security: operation.security ? this.parseOperationSecurity(operation.security) : undefined
+                });
+            }
+        }
+        return endpoints;
+    }
+    parseParameters(parameters) {
+        if (!parameters)
+            return [];
+        return parameters.map(param => {
+            const resolved = this.resolveRef(param);
+            return {
+                name: resolved.name,
+                in: resolved.in,
+                required: resolved.required || false,
+                schema: this.parseSchema(resolved.schema),
+                description: resolved.description
+            };
+        });
+    }
+    parseRequestBody(requestBody) {
+        const resolved = this.resolveRef(requestBody);
+        return {
+            required: resolved.required || false,
+            description: resolved.description,
+            content: Object.fromEntries(Object.entries(resolved.content || {}).map(([mediaType, mediaTypeObj]) => [
+                mediaType,
+                { schema: this.parseSchema(mediaTypeObj.schema) }
+            ]))
+        };
+    }
+    parseResponses(responses) {
+        return Object.entries(responses).map(([statusCode, response]) => {
+            const resolved = this.resolveRef(response);
+            return {
+                statusCode,
+                description: resolved.description,
+                content: resolved.content ?
+                    Object.fromEntries(Object.entries(resolved.content).map(([mediaType, mediaTypeObj]) => [
+                        mediaType,
+                        { schema: this.parseSchema(mediaTypeObj.schema) }
+                    ])) : undefined,
+                headers: resolved.headers ?
+                    Object.fromEntries(Object.entries(resolved.headers).map(([headerName, header]) => [
+                        headerName,
+                        this.parseSchema(this.resolveRef(header).schema)
+                    ])) : undefined
+            };
+        });
+    }
+    parseSchema(schema) {
+        if (!schema) {
+            return { type: 'any' };
+        }
+        // Handle $ref
+        if ('$ref' in schema) {
+            return {
+                type: 'any', // Will be resolved later
+                ref: schema.$ref,
+                originalRef: schema.$ref
+            };
+        }
+        const resolved = schema;
+        // Handle array type
+        if (resolved.type === 'array') {
+            return {
+                type: 'array',
+                items: this.parseSchema(resolved.items),
+                description: resolved.description,
+                nullable: resolved.nullable
+            };
+        }
+        // Handle object type
+        if (resolved.type === 'object' || resolved.properties) {
+            return {
+                type: 'object',
+                properties: resolved.properties ?
+                    Object.fromEntries(Object.entries(resolved.properties).map(([propName, propSchema]) => [
+                        propName,
+                        this.parseSchema(propSchema)
+                    ])) : undefined,
+                required: resolved.required,
+                description: resolved.description,
+                nullable: resolved.nullable
+            };
+        }
+        // Handle primitive types
+        const type = this.mapOpenAPIType(resolved.type);
+        return {
+            type,
+            format: resolved.format,
+            enum: resolved.enum,
+            description: resolved.description,
+            example: resolved.example,
+            nullable: resolved.nullable
+        };
+    }
+    parseSchemas() {
+        if (!this.spec.components?.schemas)
+            return [];
+        return Object.entries(this.spec.components.schemas).map(([name, schema]) => ({
+            ...this.parseSchema(schema),
+            ref: `#/components/schemas/${name}`
+        }));
+    }
+    parseSecurity() {
+        if (!this.spec.components?.securitySchemes)
+            return [];
+        return Object.entries(this.spec.components.securitySchemes).map(([_name, scheme]) => {
+            const resolved = this.resolveRef(scheme);
+            return {
+                type: resolved.type,
+                scheme: 'scheme' in resolved ? resolved.scheme : undefined,
+                bearerFormat: 'bearerFormat' in resolved ? resolved.bearerFormat : undefined,
+                in: 'in' in resolved ? resolved.in : undefined,
+                name: 'name' in resolved ? resolved.name : undefined,
+                flows: 'flows' in resolved ? resolved.flows : undefined,
+                openIdConnectUrl: 'openIdConnectUrl' in resolved ? resolved.openIdConnectUrl : undefined
+            };
+        });
+    }
+    parseOperationSecurity(_security) {
+        // Simplified - would need to match with security schemes
+        return [];
+    }
+    mapOpenAPIType(type) {
+        switch (type) {
+            case 'string': return 'string';
+            case 'number': return 'number';
+            case 'integer': return 'integer';
+            case 'boolean': return 'boolean';
+            case 'array': return 'array';
+            case 'object': return 'object';
+            case 'null': return 'null';
+            default: return 'any';
+        }
+    }
+    buildRefsMap() {
+        // Build a map of all $ref targets for quick resolution
+        this.traverseAndMapRefs(this.spec, '');
+    }
+    traverseAndMapRefs(obj, currentPath) {
+        if (typeof obj !== 'object' || obj === null)
+            return;
+        for (const [key, value] of Object.entries(obj)) {
+            const path = currentPath ? `${currentPath}/${key}` : key;
+            if (key === '$ref' && typeof value === 'string') {
+                // Don't store the ref itself, we'll resolve it when needed
+                continue;
+            }
+            if (typeof value === 'object') {
+                // Store objects that could be referenced
+                if (currentPath.includes('/components/')) {
+                    this.refs.set(`#/${path}`, value);
+                }
+                this.traverseAndMapRefs(value, path);
+            }
+        }
+    }
+    resolveRef(item) {
+        if (typeof item === 'object' && item !== null && '$ref' in item) {
+            const ref = item.$ref;
+            const resolved = this.refs.get(ref);
+            if (!resolved) {
+                throw new Error(`Could not resolve reference: ${ref}`);
+            }
+            return resolved;
+        }
+        return item;
+    }
+}
+exports.OpenAPIParser = OpenAPIParser;
+// Factory function for easy usage
+async function parseOpenAPI(spec) {
+    const parser = new OpenAPIParser(spec);
+    return parser.parse();
+}
+// Utility function to load OpenAPI from URL or file
+async function loadOpenAPISpec(source) {
+    if (source.startsWith('http://') || source.startsWith('https://')) {
+        // Load from URL
+        const response = await fetch(source);
+        if (!response.ok) {
+            throw new Error(`Failed to load OpenAPI spec from ${source}: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    else {
+        // Try to parse as JSON string first
+        try {
+            return JSON.parse(source);
+        }
+        catch {
+            // If JSON parse fails, try to read as file
+            try {
+                const absolutePath = (0, path_1.resolve)(source);
+                const content = await fs_1.promises.readFile(absolutePath, 'utf8');
+                return JSON.parse(content);
+            }
+            catch (fileError) {
+                throw new Error(`Failed to load OpenAPI spec: Not a valid URL, JSON string, or file path. ${fileError}`);
+            }
+        }
+    }
+}

package/cli/src/codegen/openapi/type-generator.js

@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * TypeScript Type Generator
+ *
+ * Creates TypeScript interfaces and types from parsed OpenAPI schemas
+ * with proper naming conventions and structure.
+ *
+ * Part of FRO-10: TypeScript Type Generator
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptGenerator = void 0;
+exports.generateTypes = generateTypes;
+class TypeScriptGenerator {
+    constructor(options = {}) {
+        this.generatedTypes = new Set();
+        this.refMap = new Map();
+        this.options = {
+            prefix: options.prefix || '',
+            suffix: options.suffix || '',
+            enumStyle: options.enumStyle || 'union',
+            nullableStyle: options.nullableStyle || 'undefined',
+            includeJSDoc: options.includeJSDoc !== false,
+            includeExamples: options.includeExamples !== false
+        };
+    }
+    generate(parsedAPI) {
+        // Reset state
+        this.generatedTypes.clear();
+        this.refMap.clear();
+        // Build reference map first
+        this.buildRefMap(parsedAPI);
+        return {
+            schemas: this.generateSchemas(parsedAPI.schemas),
+            endpoints: this.generateEndpointTypes(parsedAPI.endpoints),
+            parameters: this.generateParameterTypes(parsedAPI.endpoints),
+            responses: this.generateResponseTypes(parsedAPI.endpoints),
+            index: this.generateIndexFile()
+        };
+    }
+    buildRefMap(parsedAPI) {
+        // Build map of ref -> TypeScript type name
+        parsedAPI.schemas.forEach(schema => {
+            if (schema.ref) {
+                const typeName = this.extractTypeNameFromRef(schema.ref);
+                this.refMap.set(schema.ref, typeName);
+            }
+        });
+    }
+    generateSchemas(schemas) {
+        const types = [];
+        // Add file header
+        types.push(this.generateFileHeader('Schema Types'));
+        for (const schema of schemas) {
+            if (!schema.ref)
+                continue;
+            const typeName = this.refMap.get(schema.ref);
+            if (!typeName || this.generatedTypes.has(typeName))
+                continue;
+            const typeDefinition = this.generateSchemaType(schema, typeName);
+            types.push(typeDefinition);
+            this.generatedTypes.add(typeName);
+        }
+        return types.join('\n\n');
+    }
+    generateSchemaType(schema, typeName) {
+        const lines = [];
+        // Add JSDoc comment
+        if (this.options.includeJSDoc && schema.description) {
+            lines.push(`/**`);
+            lines.push(` * ${schema.description}`);
+            if (this.options.includeExamples && schema.example) {
+                lines.push(` * @example ${JSON.stringify(schema.example)}`);
+            }
+            lines.push(` */`);
+        }
+        // Generate the type
+        const typeContent = this.generateTypeContent(schema);
+        // Use 'type' for primitive types and unions, 'interface' for objects
+        if (schema.type === 'object' && !schema.enum) {
+            lines.push(`export interface ${typeName} ${typeContent}`);
+        }
+        else {
+            lines.push(`export type ${typeName} = ${typeContent}`);
+        }
+        return lines.join('\n');
+    }
+    generateTypeContent(schema) {
+        switch (schema.type) {
+            case 'object':
+                return this.generateObjectType(schema);
+            case 'array':
+                return `${this.generateTypeContent(schema.items)}[]`;
+            case 'string':
+                if (schema.enum) {
+                    return this.generateEnumType(schema.enum);
+                }
+                return this.addNullable('string', schema.nullable);
+            case 'number':
+            case 'integer':
+                return this.addNullable('number', schema.nullable);
+            case 'boolean':
+                return this.addNullable('boolean', schema.nullable);
+            case 'null':
+                return 'null';
+            case 'any':
+                if (schema.ref) {
+                    const refType = this.refMap.get(schema.ref);
+                    return refType || 'unknown';
+                }
+                return 'unknown';
+            default:
+                return 'unknown';
+        }
+    }
+    generateObjectType(schema) {
+        if (!schema.properties) {
+            return '{ [key: string]: unknown }';
+        }
+        const properties = [];
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+            const isRequired = schema.required?.includes(propName) || false;
+            const isOptional = !isRequired ? '?' : '';
+            const propType = this.generateTypeContent(propSchema);
+            // Add JSDoc for property if available
+            let propDoc = '';
+            if (this.options.includeJSDoc && propSchema.description) {
+                propDoc = `  /** ${propSchema.description} */\n  `;
+            }
+            properties.push(`${propDoc}${propName}${isOptional}: ${propType}`);
+        }
+        return `{\n  ${properties.join('\n  ')}\n}`;
+    }
+    generateEnumType(enumValues) {
+        if (this.options.enumStyle === 'enum') {
+            // Generate enum declaration (would need to be handled separately)
+            return enumValues.map(val => `'${val}'`).join(' | ');
+        }
+        else {
+            return enumValues.map(val => `'${val}'`).join(' | ');
+        }
+    }
+    addNullable(type, nullable) {
+        if (!nullable)
+            return type;
+        switch (this.options.nullableStyle) {
+            case 'null':
+                return `${type} | null`;
+            case 'both':
+                return `${type} | null | undefined`;
+            case 'undefined':
+            default:
+                return `${type} | undefined`;
+        }
+    }
+    generateEndpointTypes(endpoints) {
+        const types = [];
+        types.push(this.generateFileHeader('Endpoint Types'));
+        // Group endpoints by operation ID or path+method
+        const endpointTypes = new Set();
+        for (const endpoint of endpoints) {
+            const operationName = this.getOperationName(endpoint);
+            if (endpointTypes.has(operationName))
+                continue;
+            endpointTypes.add(operationName);
+            // Generate request type
+            const requestType = this.generateRequestType(endpoint, operationName);
+            if (requestType) {
+                types.push(requestType);
+            }
+            // Generate response type
+            const responseType = this.generateResponseType(endpoint, operationName);
+            if (responseType) {
+                types.push(responseType);
+            }
+        }
+        return types.join('\n\n');
+    }
+    generateRequestType(endpoint, operationName) {
+        const hasParams = endpoint.parameters.length > 0;
+        const hasBody = endpoint.requestBody !== undefined;
+        if (!hasParams && !hasBody)
+            return null;
+        const lines = [];
+        if (this.options.includeJSDoc) {
+            lines.push(`/**`);
+            lines.push(` * Request type for ${endpoint.method.toUpperCase()} ${endpoint.path}`);
+            if (endpoint.summary) {
+                lines.push(` * ${endpoint.summary}`);
+            }
+            lines.push(` */`);
+        }
+        const properties = [];
+        // Add parameters
+        if (hasParams) {
+            const paramsByType = this.groupParametersByType(endpoint.parameters);
+            for (const [paramType, params] of Object.entries(paramsByType)) {
+                if (params.length === 0)
+                    continue;
+                const paramProps = params.map(param => {
+                    const optional = param.required ? '' : '?';
+                    const type = this.generateTypeContent(param.schema);
+                    return `    ${param.name}${optional}: ${type}`;
+                });
+                properties.push(`  ${paramType}: {\n${paramProps.join('\n')}\n  }`);
+            }
+        }
+        // Add request body
+        if (hasBody && endpoint.requestBody) {
+            const bodyType = this.generateRequestBodyType(endpoint.requestBody);
+            const optional = endpoint.requestBody.required ? '' : '?';
+            properties.push(`  body${optional}: ${bodyType}`);
+        }
+        const typeName = `${this.formatTypeName(operationName)}Request`;
+        lines.push(`export interface ${typeName} {`);
+        lines.push(properties.join('\n'));
+        lines.push(`}`);
+        return lines.join('\n');
+    }
+    generateResponseType(endpoint, operationName) {
+        if (endpoint.responses.length === 0)
+            return null;
+        const lines = [];
+        if (this.options.includeJSDoc) {
+            lines.push(`/**`);
+            lines.push(` * Response type for ${endpoint.method.toUpperCase()} ${endpoint.path}`);
+            if (endpoint.summary) {
+                lines.push(` * ${endpoint.summary}`);
+            }
+            lines.push(` */`);
+        }
+        // Generate union type for all possible responses
+        const responseTypes = [];
+        for (const response of endpoint.responses) {
+            if (response.content) {
+                for (const [mediaType, content] of Object.entries(response.content)) {
+                    if (mediaType.includes('json')) {
+                        const type = this.generateTypeContent(content.schema);
+                        responseTypes.push(`{ status: ${response.statusCode}; data: ${type} }`);
+                    }
+                }
+            }
+            else {
+                responseTypes.push(`{ status: ${response.statusCode}; data: void }`);
+            }
+        }
+        const typeName = `${this.formatTypeName(operationName)}Response`;
+        const unionType = responseTypes.length > 1 ? responseTypes.join(' | ') : responseTypes[0] || 'void';
+        lines.push(`export type ${typeName} = ${unionType}`);
+        return lines.join('\n');
+    }
+    generateRequestBodyType(requestBody) {
+        // Find JSON content type
+        const jsonContent = requestBody.content['application/json'] ||
+            requestBody.content['application/vnd.api+json'] ||
+            Object.values(requestBody.content)[0];
+        if (!jsonContent)
+            return 'unknown';
+        return this.generateTypeContent(jsonContent.schema);
+    }
+    generateParameterTypes(_endpoints) {
+        const types = [];
+        types.push(this.generateFileHeader('Parameter Types'));
+        // This could be expanded to generate specific parameter types
+        // For now, we'll keep it simple
+        return types.join('\n\n');
+    }
+    generateResponseTypes(_endpoints) {
+        const types = [];
+        types.push(this.generateFileHeader('Response Types'));
+        // Additional response type utilities could go here
+        return types.join('\n\n');
+    }
+    generateIndexFile() {
+        const lines = [];
+        lines.push(this.generateFileHeader('Generated API Types'));
+        lines.push('');
+        lines.push('// Schema exports');
+        lines.push('export * from \'./schemas\'');
+        lines.push('');
+        lines.push('// Endpoint exports');
+        lines.push('export * from \'./endpoints\'');
+        lines.push('');
+        lines.push('// Parameter exports');
+        lines.push('export * from \'./parameters\'');
+        lines.push('');
+        lines.push('// Response exports');
+        lines.push('export * from \'./responses\'');
+        return lines.join('\n');
+    }
+    generateFileHeader(title) {
+        return `/**
+ * ${title}
+ * 
+ * Auto-generated from OpenAPI specification
+ * Do not edit manually - regenerate using the OpenAPI type generator
+ */`;
+    }
+    getOperationName(endpoint) {
+        if (endpoint.operationId) {
+            return endpoint.operationId;
+        }
+        // Generate from path and method
+        const pathParts = endpoint.path
+            .split('/')
+            .filter(part => part && !part.startsWith('{'))
+            .map(part => this.capitalize(part));
+        return `${endpoint.method}${pathParts.join('')}`;
+    }
+    formatTypeName(name) {
+        const formatted = this.capitalize(name);
+        return `${this.options.prefix}${formatted}${this.options.suffix}`;
+    }
+    extractTypeNameFromRef(ref) {
+        const parts = ref.split('/');
+        const name = parts[parts.length - 1];
+        return this.formatTypeName(name);
+    }
+    groupParametersByType(parameters) {
+        const grouped = {
+            path: [],
+            query: [],
+            header: [],
+            cookie: []
+        };
+        for (const param of parameters) {
+            grouped[param.in].push(param);
+        }
+        return grouped;
+    }
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+}
+exports.TypeScriptGenerator = TypeScriptGenerator;
+// Factory function for easy usage
+function generateTypes(parsedAPI, options) {
+    const generator = new TypeScriptGenerator(options);
+    return generator.generate(parsedAPI);
+}

package/dist/atoms/components/core/Avatar/Avatar.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+import { Avatar as PrimitiveAvatar } from '../../../primitives/avatar';
+export interface AvatarProps extends React.ComponentPropsWithoutRef<typeof PrimitiveAvatar> {
+    /** Image source URL */
+    src?: string;
+    /** Alt text for the image */
+    alt?: string;
+    /** Fallback text or element when image is not available */
+    fallback?: React.ReactNode;
+    /** Size variant */
+    size?: 'xs' | 'sm' | 'default' | 'lg' | 'xl';
+    /** Shape variant */
+    shape?: 'circle' | 'square';
+    /** Status indicator */
+    status?: 'online' | 'offline' | 'busy' | 'away';
+    /** Status position */
+    statusPosition?: 'top-right' | 'bottom-right' | 'top-left' | 'bottom-left';
+}
+/**
+ * Enhanced Avatar component for generic avatar needs.
+ * For user-specific avatars with initials and user data, use UserAvatar instead.
+ *
+ * @example
+ * ```tsx
+ * // Simple avatar
+ * <Avatar src="/avatar.jpg" alt="Profile" />
+ *
+ * // With fallback
+ * <Avatar src="/avatar.jpg" fallback="JD" />
+ *
+ * // With status indicator
+ * <Avatar src="/avatar.jpg" fallback="JD" status="online" />
+ *
+ * // Different size and shape
+ * <Avatar src="/avatar.jpg" size="lg" shape="square" />
+ * ```
+ */
+export declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+export declare const AvatarImage: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-avatar").AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+export declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-avatar").AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+//# sourceMappingURL=Avatar.d.ts.map

package/dist/atoms/components/core/Avatar/Avatar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Avatar.d.ts","sourceRoot":"","sources":["../../../../../src/atoms/components/core/Avatar/Avatar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EACL,MAAM,IAAI,eAAe,EAG1B,MAAM,4BAA4B,CAAC;AAGpC,MAAM,WAAW,WAAY,SAAQ,KAAK,CAAC,wBAAwB,CAAC,OAAO,eAAe,CAAC;IACzF,uBAAuB;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,mBAAmB;IACnB,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,GAAG,IAAI,CAAC;IAC7C,oBAAoB;IACpB,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,uBAAuB;IACvB,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;IAChD,sBAAsB;IACtB,cAAc,CAAC,EAAE,WAAW,GAAG,cAAc,GAAG,UAAU,GAAG,aAAa,CAAC;CAC5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,qFAyElB,CAAC;AAKF,eAAO,MAAM,WAAW,iLAAuB,CAAC;AAChD,eAAO,MAAM,cAAc,kLAA0B,CAAC"}

package/dist/atoms/components/core/Avatar/index.d.ts

@@ -0,0 +1,2 @@
+export { Avatar, AvatarImage, AvatarFallback, type AvatarProps, } from './Avatar';
+//# sourceMappingURL=index.d.ts.map

package/dist/atoms/components/core/Avatar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/atoms/components/core/Avatar/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,WAAW,EACX,cAAc,EACd,KAAK,WAAW,GACjB,MAAM,UAAU,CAAC"}