@pattern-stack/frontend-patterns 0.1.3 → 0.2.0-alpha.0

package/cli/src/codegen/openapi/bulk-hook-generator.js

@@ -1,252 +0,0 @@
-"use strict";
-/**
- * Bulk Operations Hook Generator
- *
- * Generates specialized React hooks for bulk operations with proper typing,
- * error handling, and progress tracking.
- *
- * Part of FRO-35: Bulk Operations Hook Generation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BulkHookGenerator = void 0;
-const bulk_types_1 = require("./bulk-types");
-class BulkHookGenerator {
-    /**
-     * Generate a bulk mutation hook with progress tracking and retry logic
-     */
-    generateBulkMutationHook(endpoint, hookName, operationName) {
-        const bulkType = (0, bulk_types_1.detectBulkOperationType)(endpoint.path, endpoint.method);
-        const lines = [];
-        // Generate JSDoc
-        lines.push('/**');
-        if (endpoint.summary) {
-            lines.push(` * ${endpoint.summary}`);
-        }
-        if (endpoint.description) {
-            lines.push(` * ${endpoint.description}`);
-        }
-        lines.push(' * @param options Mutation options with bulk operation support');
-        lines.push(' */');
-        // Generate hook signature
-        const resource = endpoint.tags?.[0] || 'default';
-        lines.push(`export function ${hookName}(`);
-        lines.push(`  options?: UseMutationOptions<BulkOperationResponse, any, BulkOperationRequest> & BulkMutationOptions`);
-        lines.push(') {');
-        lines.push('  const queryClient = useQueryClient()');
-        lines.push('  ');
-        lines.push('  return useMutation({');
-        // Generate mutation function with progress tracking
-        lines.push('    mutationFn: async (request: BulkOperationRequest) => {');
-        lines.push('      // Transform request if needed');
-        lines.push('      const transformedRequest = options?.transformRequest ');
-        lines.push('        ? options.transformRequest(request) ');
-        lines.push('        : request');
-        lines.push('      ');
-        lines.push('      // Simulate progress updates for demo');
-        lines.push('      if (options?.onProgress) {');
-        lines.push('        options.onProgress({');
-        lines.push('          total: request.ids.length,');
-        lines.push('          processed: 0,');
-        lines.push('          succeeded: 0,');
-        lines.push('          failed: 0,');
-        lines.push('          percentage: 0,');
-        lines.push("          status: 'processing'");
-        lines.push('        })');
-        lines.push('      }');
-        lines.push('      ');
-        lines.push(`      const response = await apiClient.${this.camelCase(operationName)}(transformedRequest)`);
-        lines.push('      ');
-        lines.push('      // Transform response if needed');
-        lines.push('      const transformedResponse = options?.transformResponse');
-        lines.push('        ? options.transformResponse(response)');
-        lines.push('        : response');
-        lines.push('      ');
-        lines.push('      // Final progress update');
-        lines.push('      if (options?.onProgress && transformedResponse) {');
-        lines.push('        options.onProgress({');
-        lines.push('          total: transformedResponse.summary?.total || request.ids.length,');
-        lines.push('          processed: transformedResponse.summary?.total || request.ids.length,');
-        lines.push('          succeeded: transformedResponse.summary?.succeeded || 0,');
-        lines.push('          failed: transformedResponse.summary?.failed || 0,');
-        lines.push('          percentage: 100,');
-        lines.push("          status: 'completed'");
-        lines.push('        })');
-        lines.push('      }');
-        lines.push('      ');
-        lines.push('      return transformedResponse');
-        lines.push('    },');
-        // Generate optimistic updates for bulk operations
-        lines.push(this.generateBulkOptimisticUpdate(resource, bulkType));
-        // Generate cache invalidation
-        lines.push(this.generateBulkCacheInvalidation(resource));
-        // Handle partial success
-        lines.push('    onSuccess: (data, variables, context) => {');
-        lines.push('      // Handle partial success');
-        lines.push('      if (data.failed.length > 0 && options?.onPartialSuccess) {');
-        lines.push('        options.onPartialSuccess(data)');
-        lines.push('      }');
-        lines.push('      ');
-        lines.push('      // Call original onSuccess if provided');
-        lines.push('      options?.onSuccess?.(data, variables, context)');
-        lines.push('    },');
-        // Retry configuration for bulk operations
-        lines.push('    retry: (failureCount, error) => {');
-        lines.push('      // Use custom retry config if provided');
-        lines.push('      if (options?.retry?.maxAttempts !== undefined) {');
-        lines.push('        return failureCount < options.retry.maxAttempts');
-        lines.push('      }');
-        lines.push('      // Default: retry up to 3 times for bulk operations');
-        lines.push('      return failureCount < 3');
-        lines.push('    },');
-        lines.push('    retryDelay: (attemptIndex) => {');
-        lines.push('      // Use custom retry delay if provided');
-        lines.push('      if (options?.retry?.initialDelay) {');
-        lines.push('        const delay = Math.min(');
-        lines.push('          options.retry.initialDelay * Math.pow(options.retry.backoffMultiplier || 2, attemptIndex),');
-        lines.push('          options.retry.maxDelay || 30000');
-        lines.push('        )');
-        lines.push('        return delay');
-        lines.push('      }');
-        lines.push('      // Default exponential backoff: 1s, 2s, 4s...');
-        lines.push('      return Math.min(1000 * Math.pow(2, attemptIndex), 30000)');
-        lines.push('    },');
-        lines.push('    ...options');
-        lines.push('  })');
-        lines.push('}');
-        return lines.join('\n');
-    }
-    /**
-     * Generate optimistic updates for bulk operations
-     */
-    generateBulkOptimisticUpdate(resource, bulkType) {
-        switch (bulkType) {
-            case 'delete':
-                return `    onMutate: async (request: BulkOperationRequest) => {
-      // Cancel outgoing refetches
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      // Snapshot previous value
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Optimistically remove items
-      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-        if (Array.isArray(old)) {
-          return old.filter((item: any) => !request.ids.includes(item.id))
-        }
-        return old
-      })
-      
-      return { previousData }
-    },
-    onError: (err: any, request: any, context: any) => {
-      // Rollback on error
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-            case 'update':
-                return `    onMutate: async (request: BulkOperationRequest) => {
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Optimistically update items
-      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-        if (Array.isArray(old)) {
-          return old.map((item: any) => 
-            request.ids.includes(item.id) 
-              ? { ...item, ...request.data } 
-              : item
-          )
-        }
-        return old
-      })
-      
-      return { previousData }
-    },
-    onError: (err: any, request: any, context: any) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-            case 'create':
-                return `    onMutate: async (request: BulkOperationRequest) => {
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Optimistically add items (if data provided)
-      if (request.data && Array.isArray(request.data)) {
-        queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-          if (Array.isArray(old)) {
-            return [...old, ...request.data]
-          }
-          return old
-        })
-      }
-      
-      return { previousData }
-    },
-    onError: (err: any, request: any, context: any) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-            default:
-                return '';
-        }
-    }
-    /**
-     * Generate cache invalidation for bulk operations
-     */
-    generateBulkCacheInvalidation(resource) {
-        return `    onSettled: () => {
-      // Invalidate related queries after bulk operation
-      queryClient.invalidateQueries({ queryKey: queryKeys.${resource}() })
-      queryClient.invalidateQueries({ queryKey: queryKeys.all })
-    },`;
-    }
-    /**
-     * Generate bulk mutation hook name
-     */
-    generateBulkMutationHookName(endpoint, resourceName) {
-        const requestBody = endpoint.requestBody;
-        if (!(0, bulk_types_1.isBulkOperation)(endpoint.path, endpoint.method, requestBody)) {
-            return null;
-        }
-        const bulkType = (0, bulk_types_1.detectBulkOperationType)(endpoint.path, endpoint.method);
-        if (bulkType && resourceName) {
-            const bulkName = (0, bulk_types_1.generateBulkOperationName)(resourceName, bulkType);
-            return `use${this.capitalize(bulkName)}`;
-        }
-        return null;
-    }
-    /**
-     * Check if endpoint is a bulk operation
-     */
-    isBulkEndpoint(endpoint) {
-        const requestBody = endpoint.requestBody;
-        return (0, bulk_types_1.isBulkOperation)(endpoint.path, endpoint.method, requestBody);
-    }
-    /**
-     * Helper to convert to camelCase
-     */
-    camelCase(str) {
-        return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase())
-            .replace(/^./, char => char.toLowerCase());
-    }
-    /**
-     * Helper to capitalize string
-     */
-    capitalize(str) {
-        // Convert snake_case to PascalCase
-        if (str.includes('_')) {
-            return str.split('_')
-                .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
-                .join('');
-        }
-        // Simple capitalization
-        return str.charAt(0).toUpperCase() + str.slice(1);
-    }
-}
-exports.BulkHookGenerator = BulkHookGenerator;

package/cli/src/codegen/openapi/bulk-types.js

@@ -1,89 +0,0 @@
-"use strict";
-/**
- * Bulk Operations Types
- *
- * Standard types for bulk operations in generated hooks
- * Part of FRO-35: Bulk Operations Hook Generation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBulkOperation = isBulkOperation;
-exports.detectBulkOperationType = detectBulkOperationType;
-exports.generateBulkOperationName = generateBulkOperationName;
-/**
- * Type guard to check if an endpoint handles bulk operations
- */
-function isBulkOperation(path, method, requestBody) {
-    const bulkPatterns = [
-        /\/bulk[-_]?delete$/i,
-        /\/bulk[-_]?update$/i,
-        /\/bulk[-_]?create$/i,
-        /\/batch$/i,
-        /\/bulk$/i,
-        /\/multiple$/i
-    ];
-    // Check path patterns
-    if (bulkPatterns.some(pattern => pattern.test(path))) {
-        return true;
-    }
-    // Check if request body expects an array of items
-    if (requestBody && typeof requestBody === 'object') {
-        // Check for ParsedRequestBody structure
-        const body = requestBody;
-        if (body.content?.['application/json']?.schema) {
-            const schema = body.content['application/json'].schema;
-            return schema.type === 'array' && !!schema.items;
-        }
-        // Check direct schema
-        if ('type' in requestBody) {
-            const bodyType = requestBody;
-            return bodyType.type === 'array' && !!bodyType.items;
-        }
-    }
-    return false;
-}
-/**
- * Detect bulk operation type from endpoint
- */
-function detectBulkOperationType(path, method) {
-    const lowercasePath = path.toLowerCase();
-    const lowercaseMethod = method.toLowerCase();
-    if (lowercasePath.includes('delete') || lowercaseMethod === 'delete') {
-        return 'delete';
-    }
-    if (lowercasePath.includes('update') || lowercaseMethod === 'put' || lowercaseMethod === 'patch') {
-        return 'update';
-    }
-    if (lowercasePath.includes('create') || lowercaseMethod === 'post') {
-        return 'create';
-    }
-    if (lowercasePath.includes('batch') || lowercasePath.includes('bulk')) {
-        return 'mixed';
-    }
-    return null;
-}
-/**
- * Generate a descriptive bulk operation name
- */
-function generateBulkOperationName(resource, operationType) {
-    const cleanResource = resource.replace(/[^a-zA-Z0-9]/g, '');
-    const singular = cleanResource.endsWith('s') ? cleanResource.slice(0, -1) : cleanResource;
-    // Capitalize first letter of singular resource
-    const capitalizedSingular = capitalize(singular);
-    switch (operationType) {
-        case 'delete':
-            return `bulkDelete${capitalizedSingular}s`;
-        case 'update':
-            return `bulkUpdate${capitalizedSingular}s`;
-        case 'create':
-            return `bulkCreate${capitalizedSingular}s`;
-        case 'mixed':
-            return `bulk${capitalizedSingular}Operations`;
-        default:
-            return `bulk${capitalizedSingular}s`;
-    }
-}
-function capitalize(str) {
-    if (!str)
-        return '';
-    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-}

package/cli/src/codegen/openapi/confidence-scorer.js

@@ -1,204 +0,0 @@
-"use strict";
-/**
- * Confidence scoring for generated hook names
- * Helps identify names that may need human review
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfidenceScorer = void 0;
-class ConfidenceScorer {
-    /**
-     * Score a generated hook name based on various quality indicators
-     */
-    scoreHookName(generatedName, originalOperationId, path, method) {
-        const issues = [];
-        const suggestions = [];
-        let score = 100;
-        // Check for camelCase issues
-        if (!this.isProperCamelCase(generatedName)) {
-            score -= 20;
-            issues.push('Improper camelCase formatting');
-        }
-        // Check for consecutive uppercase letters (like "useAssignRolesusersUserRoles")
-        if (this.hasConsecutiveUppercase(generatedName)) {
-            score -= 30;
-            issues.push('Consecutive uppercase letters suggest concatenation issues');
-            suggestions.push(this.suggestFixForConsecutiveUppercase(generatedName));
-        }
-        // Check for overly long names
-        const nameLength = generatedName.length;
-        if (nameLength > 30) {
-            score -= 20;
-            issues.push(`Name is too long (${nameLength} chars)`);
-        }
-        // Check for repeated words
-        if (this.hasRepeatedWords(generatedName)) {
-            score -= 25;
-            issues.push('Contains repeated word segments');
-        }
-        // Check if it matches common patterns
-        if (this.matchesCommonPattern(generatedName, method)) {
-            score += 10;
-            score = Math.min(score, 100); // Cap at 100
-        }
-        // Check for word boundaries issues
-        if (this.hasWordBoundaryIssues(generatedName)) {
-            score -= 15;
-            issues.push('Potential word boundary issues');
-        }
-        // Determine confidence level
-        let confidence;
-        if (score >= 80) {
-            confidence = 'high';
-        }
-        else if (score >= 60) {
-            confidence = 'medium';
-        }
-        else {
-            confidence = 'low';
-        }
-        return {
-            name: generatedName,
-            confidence,
-            score,
-            issues,
-            suggestions: suggestions.filter(s => s !== generatedName)
-        };
-    }
-    isProperCamelCase(name) {
-        // Should start with lowercase 'use'
-        if (!name.startsWith('use'))
-            return false;
-        // Check for proper camelCase pattern
-        const afterUse = name.substring(3);
-        return /^[A-Z][a-zA-Z0-9]*$/.test(afterUse);
-    }
-    hasConsecutiveUppercase(name) {
-        // Look for patterns like "RolesUsers" which suggest poor concatenation
-        return /[A-Z]{2,}[a-z]/.test(name) || /[a-z][A-Z]{2,}/.test(name);
-    }
-    hasRepeatedWords(name) {
-        // Convert camelCase to words
-        const words = this.camelCaseToWords(name).map(w => w.toLowerCase());
-        const uniqueWords = new Set(words);
-        // If we have significantly fewer unique words, there's repetition
-        return words.length > uniqueWords.size + 1; // Allow one repeat
-    }
-    matchesCommonPattern(name, method) {
-        const commonPatterns = {
-            get: /^use[A-Z][a-zA-Z]+$/,
-            post: /^useCreate[A-Z][a-zA-Z]+$/,
-            put: /^useUpdate[A-Z][a-zA-Z]+$/,
-            patch: /^useUpdate[A-Z][a-zA-Z]+$/,
-            delete: /^useDelete[A-Z][a-zA-Z]+$/
-        };
-        const pattern = commonPatterns[method];
-        return pattern ? pattern.test(name) : false;
-    }
-    hasWordBoundaryIssues(name) {
-        // Look for lowercase letters followed by uppercase without proper boundaries
-        // Exclude common patterns like "useCreate", "useUpdate", etc.
-        const afterUse = name.substring(3);
-        const knownPrefixes = ['Create', 'Update', 'Delete', 'Get', 'List', 'Fetch', 'Assign', 'Reassign'];
-        for (const prefix of knownPrefixes) {
-            if (afterUse.startsWith(prefix)) {
-                const remaining = afterUse.substring(prefix.length);
-                // Check for patterns like "Rolesusers" or "Budgettransactions"
-                if (/[a-z]{2,}[A-Z]/.test(remaining)) {
-                    return true;
-                }
-            }
-        }
-        // Check for lowercase word running into uppercase (3+ lowercase chars)
-        if (/[a-z]{3,}[A-Z]/.test(afterUse)) {
-            return true;
-        }
-        // Check for patterns like "RolesusersUser" where we have clear word concatenation
-        if (/[A-Z][a-z]+[a-z][A-Z]/.test(afterUse)) {
-            return true;
-        }
-        return false;
-    }
-    suggestFixForConsecutiveUppercase(name) {
-        // Try to fix patterns like "useAssignRolesusersUserRoles"
-        // This is a simple heuristic - the review process will catch if it's wrong
-        let suggestion = name;
-        // Specific fixes for known patterns
-        const knownFixes = {
-            'useAssignRolesusersUserRoles': 'useAssignUserRoles',
-            'useReassignBudgettransactionsReassignBudget': 'useReassignTransactionBudget',
-            'useCategorySubcategories': 'useCreateSubcategory'
-        };
-        if (knownFixes[name]) {
-            return knownFixes[name];
-        }
-        // Fix patterns where lowercase runs into uppercase (like "Rolesusers")
-        suggestion = suggestion.replace(/([a-z]{2,})([A-Z])/g, (match, p1, p2) => {
-            // If the lowercase part is a known word ending, add proper boundary
-            if (p1.endsWith('roles') || p1.endsWith('users') || p1.endsWith('budget')) {
-                return p1 + p2;
-            }
-            return match;
-        });
-        // Try to extract the main action and resource
-        const parts = this.camelCaseToWords(suggestion);
-        if (parts.length > 4) {
-            // Likely too many parts, try to simplify
-            // Keep: use + action + main resource
-            const action = parts[1]; // After 'use'
-            const resources = parts.slice(2);
-            // Find the most significant resource (usually the last one that's not a duplicate)
-            const uniqueResources = [...new Set(resources.map(r => r.toLowerCase()))];
-            if (uniqueResources.length === 1) {
-                return `use${action}${resources[resources.length - 1]}`;
-            }
-        }
-        return suggestion;
-    }
-    camelCaseToWords(str) {
-        // Split camelCase into words
-        return str
-            .replace(/([a-z])([A-Z])/g, '$1 $2')
-            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
-            .split(' ')
-            .filter(w => w.length > 0);
-    }
-    /**
-     * Generate a confidence report for review
-     */
-    generateReport(scoredNames) {
-        const byConfidence = {
-            high: scoredNames.filter(s => s.confidence === 'high'),
-            medium: scoredNames.filter(s => s.confidence === 'medium'),
-            low: scoredNames.filter(s => s.confidence === 'low')
-        };
-        let report = '# Hook Name Generation Report\n\n';
-        report += `Generated ${scoredNames.length} hooks\n\n`;
-        report += `- High confidence: ${byConfidence.high.length}\n`;
-        report += `- Medium confidence: ${byConfidence.medium.length}\n`;
-        report += `- Low confidence: ${byConfidence.low.length}\n\n`;
-        if (byConfidence.low.length > 0) {
-            report += '## Low Confidence Names (Review Recommended)\n\n';
-            for (const scored of byConfidence.low) {
-                report += `### ${scored.name}\n`;
-                report += `- Score: ${scored.score}/100\n`;
-                report += `- Issues: ${scored.issues.join(', ')}\n`;
-                if (scored.suggestions.length > 0) {
-                    report += `- Suggestions: ${scored.suggestions.join(', ')}\n`;
-                }
-                report += '\n';
-            }
-        }
-        if (byConfidence.medium.length > 0) {
-            report += '## Medium Confidence Names (Optional Review)\n\n';
-            for (const scored of byConfidence.medium) {
-                report += `- ${scored.name} (${scored.score}/100)\n`;
-                if (scored.issues.length > 0) {
-                    report += `  Issues: ${scored.issues.join(', ')}\n`;
-                }
-            }
-            report += '\n';
-        }
-        return report;
-    }
-}
-exports.ConfidenceScorer = ConfidenceScorer;

package/cli/src/codegen/openapi/hook-config.js

@@ -1,66 +0,0 @@
-"use strict";
-/**
- * Hook generation configuration system
- * Stores learned patterns and manual overrides for hook name generation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HookConfigManager = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const DEFAULT_CONFIG = {
-    version: '1.0.0',
-    nameOverrides: {},
-    reviewedNames: [],
-    patterns: {
-        removeDoubleWords: true,
-        smartCasing: true,
-        deduplicateSegments: true
-    }
-};
-class HookConfigManager {
-    constructor(configPath = './hooks.config.json') {
-        this.config = DEFAULT_CONFIG;
-        this.configPath = (0, path_1.resolve)(configPath);
-    }
-    async load() {
-        try {
-            const content = await fs_1.promises.readFile(this.configPath, 'utf8');
-            this.config = { ...DEFAULT_CONFIG, ...JSON.parse(content) };
-        }
-        catch (error) {
-            // File doesn't exist, use defaults
-            this.config = DEFAULT_CONFIG;
-        }
-    }
-    async save() {
-        const content = JSON.stringify(this.config, null, 2);
-        await fs_1.promises.writeFile(this.configPath, content, 'utf8');
-    }
-    getOverride(operationId) {
-        return this.config.nameOverrides[operationId];
-    }
-    addOverride(override) {
-        this.config.nameOverrides[override.original] = override.override;
-        this.config.reviewedNames.push({
-            ...override,
-            approvedAt: new Date().toISOString()
-        });
-    }
-    getPatterns() {
-        return this.config.patterns;
-    }
-    updateStatistics(stats) {
-        this.config.statistics = {
-            ...this.config.statistics,
-            ...stats,
-            lastUpdated: new Date().toISOString()
-        };
-    }
-    getReviewedNames() {
-        return this.config.reviewedNames;
-    }
-    hasBeenReviewed(operationId) {
-        return operationId in this.config.nameOverrides;
-    }
-}
-exports.HookConfigManager = HookConfigManager;

package/dist/atoms/components/data/ActivityFeed/ActivityFeed.stories.d.ts

@@ -1,38 +0,0 @@
-import React from 'react';
-type StoryObj<T> = {
-    args?: any;
-    render?: (args: any) => React.ReactElement;
-};
-declare const meta: {
-    title: string;
-    component: React.FC<import("./types").ActivityFeedProps>;
-    parameters: {
-        layout: string;
-    };
-    tags: string[];
-    argTypes: {
-        variant: {
-            control: string;
-            options: string[];
-        };
-        maxItems: {
-            control: string;
-        };
-        showFooter: {
-            control: string;
-        };
-    };
-};
-export default meta;
-type Story = StoryObj<typeof meta>;
-export declare const Default: Story;
-export declare const Compact: Story;
-export declare const Borderless: Story;
-export declare const WithFooter: Story;
-export declare const Empty: Story;
-export declare const NoTitle: Story;
-export declare const LongMessages: Story;
-export declare const MixedTypes: Story;
-export declare const RealTimeUpdates: Story;
-export declare const CustomRenderer: Story;
-//# sourceMappingURL=ActivityFeed.stories.d.ts.map

package/dist/atoms/components/data/ActivityFeed/ActivityFeed.stories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ActivityFeed.stories.d.ts","sourceRoot":"","sources":["../../../../../src/atoms/components/data/ActivityFeed/ActivityFeed.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAa1B,KAAK,QAAQ,CAAC,CAAC,IAAI;IACjB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,KAAK,CAAC,YAAY,CAAC;CAC5C,CAAC;AAEF,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;CAmB2B,CAAC;AAEtC,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAC;AAgCnC,eAAO,MAAM,OAAO,EAAE,KAKrB,CAAC;AAGF,eAAO,MAAM,OAAO,EAAE,KAMrB,CAAC;AAGF,eAAO,MAAM,UAAU,EAAE,KAMxB,CAAC;AAGF,eAAO,MAAM,UAAU,EAAE,KAOxB,CAAC;AAGF,eAAO,MAAM,KAAK,EAAE,KAKnB,CAAC;AAGF,eAAO,MAAM,OAAO,EAAE,KAIrB,CAAC;AAGF,eAAO,MAAM,YAAY,EAAE,KA0B1B,CAAC;AAGF,eAAO,MAAM,UAAU,EAAE,KAuCxB,CAAC;AAGF,eAAO,MAAM,eAAe,EAAE,KA4B7B,CAAC;AAGF,eAAO,MAAM,cAAc,EAAE,KAkB5B,CAAC"}

package/dist/codegen/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Code Generation Utilities
- *
- * Build-time tools for generating code from specifications
- */
-export * from './openapi';
-//# sourceMappingURL=index.d.ts.map

package/dist/codegen/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/codegen/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,WAAW,CAAC"}