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

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

@@ -0,0 +1,48 @@
+/**
+ * Hook Configuration Manager (Stub)
+ *
+ * Provides name overrides and pattern configuration for hook generation.
+ * This is a minimal stub to unblock the hook generator.
+ */
+
+export class HookConfigManager {
+  constructor(configPath) {
+    this.configPath = configPath;
+    this.overrides = {};
+    this.patterns = {
+      deduplicateSegments: true
+    };
+    this.reviewedNames = [];
+    this.statistics = {};
+  }
+
+  async load() {
+    // No-op for stub - would load from config file
+    return;
+  }
+
+  async save() {
+    // No-op for stub - would save to config file
+    return;
+  }
+
+  getOverride(operationId) {
+    return this.overrides[operationId] || null;
+  }
+
+  getPatterns() {
+    return this.patterns;
+  }
+
+  getReviewedNames() {
+    return this.reviewedNames;
+  }
+
+  updateStatistics(stats) {
+    this.statistics = { ...this.statistics, ...stats };
+  }
+
+  setOverride(operationId, hookName) {
+    this.overrides[operationId] = hookName;
+  }
+}

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

@@ -6,8 +6,10 @@
  *
  * Part of FRO-3: React Hook Generator
  */
-import { HookConfigManager } from './hook-config';
-import { ConfidenceScorer } from './confidence-scorer';
+import { HookConfigManager } from './hook-config.js';
+import { ConfidenceScorer } from './confidence-scorer.js';
+import { singularize, pluralize, isPlural } from './naming-utils.js';
+import { AUTH_ACTIONS, HEALTH_ENDPOINTS, USER_PROFILE_ENDPOINTS, SINGLETON_RESOURCES, COLLECTION_ACTIONS, SPECIAL_ACTIONS } from './naming-constants.js';
 export class ReactHookGenerator {
     options;
     configManager;
@@ -203,13 +205,13 @@ export class ReactHookGenerator {
                 return `    onMutate: async (newData) => {
       // Cancel outgoing refetches
       await queryClient.cancelQueries({ queryKey: queryKeys.all })
-      
+
       // Snapshot previous value
       const previousData = queryClient.getQueryData(queryKeys.all)
-      
+
       // Optimistically update cache
       queryClient.setQueryData(queryKeys.all, (old: any) => [...(old || []), newData])
-      
+
       return { previousData }
     },
     onError: (err, newData, context) => {
@@ -220,14 +222,14 @@ export class ReactHookGenerator {
             case 'patch':
                 return `    onMutate: async (updatedData) => {
       await queryClient.cancelQueries({ queryKey: queryKeys.all })
-      
+
       const previousData = queryClient.getQueryData(queryKeys.all)
-      
+
       // Update specific item in cache
-      queryClient.setQueryData(queryKeys.all, (old: any) => 
+      queryClient.setQueryData(queryKeys.all, (old: any) =>
         old?.map((item: any) => item.id === updatedData.id ? { ...item, ...updatedData } : item)
       )
-      
+
       return { previousData }
     },
     onError: (err, updatedData, context) => {
@@ -236,14 +238,14 @@ export class ReactHookGenerator {
             case 'delete':
                 return `    onMutate: async (id) => {
       await queryClient.cancelQueries({ queryKey: queryKeys.all })
-      
+
       const previousData = queryClient.getQueryData(queryKeys.all)
-      
+
       // Remove item from cache
-      queryClient.setQueryData(queryKeys.all, (old: any) => 
+      queryClient.setQueryData(queryKeys.all, (old: any) =>
         old?.filter((item: any) => item.id !== id)
       )
-      
+
       return { previousData }
     },
     onError: (err, id, context) => {
@@ -275,18 +277,36 @@ export class ReactHookGenerator {
         // Group endpoints by resource/tag
         const groupedEndpoints = this.groupEndpointsByResource(endpoints);
         for (const [resource, resourceEndpoints] of Object.entries(groupedEndpoints)) {
+            // Sanitize resource name to be a valid JS identifier
+            const sanitizedResource = this.sanitizeIdentifier(resource);
+            console.log(`DEBUG: resource="${resource}" -> sanitizedResource="${sanitizedResource}"`);
             keys.push(`  // ${resource} keys`);
-            keys.push(`  ${resource}: () => [...queryKeys.all, '${resource}'] as const,`);
+            keys.push(`  ${sanitizedResource}: () => [...queryKeys.all, '${sanitizedResource}'] as const,`);
+            const usedKeys = new Set([sanitizedResource]); // Track used keys to avoid duplicates
             for (const endpoint of resourceEndpoints) {
                 if (endpoint.method !== 'get')
                     continue;
                 const operationName = this.getOperationName(endpoint);
-                const keyName = this.camelCase(operationName.replace(/^get/, ''));
+                let keyName = this.camelCase(operationName.replace(/^get/, ''));
+                // Skip if keyName matches sanitizedResource (base key already handles this)
+                if (keyName === sanitizedResource) {
+                    continue;
+                }
+                // If keyName already used, add suffix to disambiguate
+                if (usedKeys.has(keyName)) {
+                    const isList = !endpoint.path.includes('{');
+                    keyName = isList ? `${keyName}List` : `${keyName}Detail`;
+                }
+                // Still duplicate after suffix? Skip to avoid compilation error
+                if (usedKeys.has(keyName)) {
+                    continue;
+                }
+                usedKeys.add(keyName);
                 if (this.hasRequiredParams(endpoint)) {
-                    keys.push(`  ${keyName}: (params: any) => [...queryKeys.${resource}(), '${keyName}', params] as const,`);
+                    keys.push(`  ${keyName}: (params: Record<string, unknown>) => [...queryKeys.${sanitizedResource}(), '${keyName}', params] as const,`);
                 }
                 else {
-                    keys.push(`  ${keyName}: () => [...queryKeys.${resource}(), '${keyName}'] as const,`);
+                    keys.push(`  ${keyName}: () => [...queryKeys.${sanitizedResource}(), '${keyName}'] as const,`);
                 }
             }
             keys.push('');
@@ -336,7 +356,7 @@ export class ReactHookGenerator {
     generateFileHeader(title) {
         return `/**
  * ${title}
- * 
+ *
  * Auto-generated React hooks from OpenAPI specification
  * Do not edit manually - regenerate using the hook generator
  */`;
@@ -422,6 +442,8 @@ export class ReactHookGenerator {
             /^(?<action>\w+?)_api_v\d+_(?<path>.+?)_(?<method>get|post|put|patch|delete)$/i,
             // Pattern: action_resource_path_method
             /^(?<action>\w+?)_(?<resource>\w+?)_(?<path>.+?)_(?<method>get|post|put|patch|delete)$/i,
+            // Pattern: simple action_action_method (e.g., ready_ready_get, health_health_get)
+            /^(?<action>\w+?)_\1_(?<method>get|post|put|patch|delete)$/i,
             // Pattern: simple action_resource
             /^(?<action>\w+?)_(?<resource>\w+?)$/i,
         ];
@@ -439,7 +461,12 @@ export class ReactHookGenerator {
         // Check if it's a custom action
         const urlSegments = endpoint.path.split('/');
         const lastSegment = urlSegments[urlSegments.length - 1];
-        const isCustomAction = !lastSegment.startsWith('{') && urlSegments[urlSegments.length - 2]?.startsWith('{');
+        const prevSegment = urlSegments[urlSegments.length - 2];
+        // Custom action: either after a path param (e.g., /accounts/{id}/archive)
+        // or a known action verb on a collection (e.g., /activities/search)
+        const isResourceAction = !lastSegment.startsWith('{') && prevSegment?.startsWith('{');
+        const isCollectionAction = !lastSegment.startsWith('{') && !prevSegment?.startsWith('{') && COLLECTION_ACTIONS.includes(lastSegment);
+        const isCustomAction = isResourceAction || isCollectionAction;
         // Extract or infer the action verb
         const actionVerb = this.extractActionVerb(components.action || operationId, endpoint.method);
         // Extract or infer the resource
@@ -449,7 +476,7 @@ export class ReactHookGenerator {
             'resource';
         return {
             action: actionVerb,
-            resource: resource,
+            resource: isCollectionAction ? prevSegment : resource,
             path: components.path || '',
             method: endpoint.method,
             isCustomAction,
@@ -463,10 +490,10 @@ export class ReactHookGenerator {
     extractActionVerb(actionPart, method) {
         // Common action verbs to recognize
         const actionVerbs = [
-            'login', 'logout', 'register', 'signup', 'signin',
-            'health', 'status', 'check',
+            ...AUTH_ACTIONS,
+            ...HEALTH_ENDPOINTS,
             'list', 'get', 'create', 'update', 'delete',
-            'reassign', 'assign', 'settle', 'reconcile',
+            ...COLLECTION_ACTIONS,
             'approve', 'reject', 'archive', 'restore',
             'sync', 'refresh', 'reset', 'verify', 'validate'
         ];
@@ -501,11 +528,7 @@ export class ReactHookGenerator {
      * Check if this is a special endpoint that should keep its action verb
      */
     isSpecialEndpoint(parsed) {
-        const specialActions = [
-            'login', 'logout', 'register', 'signup', 'signin',
-            'health', 'status', 'check', 'verify', 'validate'
-        ];
-        return specialActions.includes(parsed.action);
+        return SPECIAL_ACTIONS.includes(parsed.action);
     }
     /**
      * Format name for custom action endpoints
@@ -519,17 +542,18 @@ export class ReactHookGenerator {
                 return customActionName;
             }
             // Otherwise combine resource and action
-            return `${this.singularize(resource)}_${customActionName}`;
+            return `${singularize(resource)}_${customActionName}`;
         }
-        return `${action}_${this.singularize(resource)}`;
+        return `${action}_${singularize(resource)}`;
     }
     /**
      * Format name for special endpoints (login, health, etc.)
      */
     formatSpecialEndpointName(parsed) {
         const { action, resource } = parsed;
-        // For endpoints like "login", "health", just return the action
-        if (['login', 'logout', 'health', 'status'].includes(action)) {
+        // For simple singleton endpoints, just return the action
+        const simpleActions = [...AUTH_ACTIONS.filter(a => ['login', 'logout'].includes(a)), ...HEALTH_ENDPOINTS.filter(h => ['health', 'ready', 'status'].includes(h)), ...USER_PROFILE_ENDPOINTS];
+        if (simpleActions.includes(action)) {
             return action;
         }
         // For other special endpoints, combine with resource if meaningful
@@ -544,19 +568,19 @@ export class ReactHookGenerator {
     formatStandardOperationName(parsed, endpoint) {
         const { resource } = parsed;
         // Determine if it's a list or single resource operation
-        const isList = endpoint.method === 'get' && !endpoint.path.includes('{');
+        const isList = endpoint.method === 'get' && !endpoint.path.includes('{') && !this.isSingletonEndpoint(resource, endpoint.path);
         switch (endpoint.method) {
             case 'get':
-                return isList ? this.pluralize(resource) : this.singularize(resource);
+                return isList ? pluralize(resource) : singularize(resource);
             case 'post':
-                return `create_${this.singularize(resource)}`;
+                return `create_${singularize(resource)}`;
             case 'put':
             case 'patch':
-                return `update_${this.singularize(resource)}`;
+                return `update_${singularize(resource)}`;
             case 'delete':
-                return `delete_${this.singularize(resource)}`;
+                return `delete_${singularize(resource)}`;
             default:
-                return this.singularize(resource);
+                return singularize(resource);
         }
     }
     generateCleanName(endpoint) {
@@ -578,7 +602,7 @@ export class ReactHookGenerator {
             const action = lastSegment.replace(/-/g, '_');
             return `${mainResource}_${action}`;
         }
-        // For nested resources (e.g., /categories/{id}/subcategories), 
+        // For nested resources (e.g., /categories/{id}/subcategories),
         // just use the last resource name
         if (pathParts.length > 2 && segments.some(s => s.startsWith('{'))) {
             // This is a nested resource, just use the last part
@@ -591,7 +615,7 @@ export class ReactHookGenerator {
                 const isList = !endpoint.path.includes('{');
                 // Only pluralize if it's a list and not already plural
                 if (isList && !cleanResource.endsWith('s') && !cleanResource.endsWith('ies')) {
-                    return this.pluralize(cleanResource);
+                    return pluralize(cleanResource);
                 }
                 return cleanResource;
             case 'post':
@@ -605,28 +629,22 @@ export class ReactHookGenerator {
                 return `${endpoint.method}_${cleanResource}`;
         }
     }
-    pluralize(word) {
-        // Simple pluralization rules
-        if (word.endsWith('y') && !['ay', 'ey', 'iy', 'oy', 'uy'].includes(word.slice(-2))) {
-            return word.slice(0, -1) + 'ies';
+    isSingletonEndpoint(resource, path) {
+        // Check if resource matches singleton pattern
+        const lowerResource = resource.toLowerCase().replace(/_/g, '');
+        if (SINGLETON_RESOURCES.some(s => lowerResource === s || lowerResource.endsWith(s))) {
+            return true;
         }
-        if (word.endsWith('s') || word.endsWith('x') || word.endsWith('ch') || word.endsWith('sh')) {
-            return word + 'es';
+
+        // Check path patterns for common singletons
+        const pathSegments = path.split('/').filter(s => s && !s.startsWith('{'));
+        const lastSegment = pathSegments[pathSegments.length - 1]?.toLowerCase();
+
+        if (SINGLETON_RESOURCES.includes(lastSegment)) {
+            return true;
         }
-        return word + 's';
-    }
-    singularize(word) {
-        // Simple singularization rules
-        if (word.endsWith('ies')) {
-            return word.slice(0, -3) + 'y';
-        }
-        if (word.endsWith('ses') || word.endsWith('xes') || word.endsWith('ches') || word.endsWith('shes')) {
-            return word.slice(0, -2);
-        }
-        if (word.endsWith('s') && !word.endsWith('ss')) {
-            return word.slice(0, -1);
-        }
-        return word;
+
+        return false;
     }
     hasRequiredParams(endpoint) {
         return endpoint.parameters.some(p => p.required) ||
@@ -663,6 +681,15 @@ export class ReactHookGenerator {
         }
     }
     isListEndpoint(endpoint) {
+        // Extract resource for singleton check
+        const pathSegments = endpoint.path.split('/').filter(s => s && !s.startsWith('{'));
+        const resource = pathSegments[pathSegments.length - 1]?.replace(/-/g, '_') || '';
+
+        // Singleton endpoints are never list endpoints
+        if (this.isSingletonEndpoint(resource, endpoint.path)) {
+            return false;
+        }
+
         return endpoint.path.includes('list') ||
             !endpoint.path.includes('{') ||
             (endpoint.summary?.toLowerCase().includes('list') ?? false) ||
@@ -671,7 +698,9 @@ export class ReactHookGenerator {
     groupEndpointsByResource(endpoints) {
         const groups = {};
         for (const endpoint of endpoints) {
-            const resource = endpoint.tags?.[0] || 'default';
+            const tag = endpoint.tags?.[0] || 'default';
+            // Sanitize tag to be a valid JS identifier (camelCase, no spaces)
+            const resource = this.sanitizeIdentifier(tag);
             if (!groups[resource]) {
                 groups[resource] = [];
             }
@@ -679,8 +708,17 @@ export class ReactHookGenerator {
         }
         return groups;
     }
+    sanitizeIdentifier(str) {
+        // Convert to camelCase and remove invalid characters
+        return str
+            .replace(/[^a-zA-Z0-9\s]/g, '') // Remove special chars except spaces
+            .split(/\s+/) // Split on whitespace
+            .map((word, i) => i === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
     getRelatedQueryTags(endpoint) {
-        const resource = endpoint.tags?.[0] || 'default';
+        const tag = endpoint.tags?.[0] || 'default';
+        const resource = this.sanitizeIdentifier(tag);
         return [resource, 'all'];
     }
     camelCase(str) {

package/cli/src/codegen/openapi/naming-constants.js

@@ -0,0 +1,98 @@
+/**
+ * Naming Constants
+ *
+ * Shared constants for magic strings used across hook and client generators.
+ * These constants help identify special endpoints that get unique naming treatment.
+ */
+
+/**
+ * Authentication action endpoints
+ * These endpoints are named directly without CRUD prefixes (e.g., 'login' not 'createLogin')
+ */
+export const AUTH_ACTIONS = [
+  'login',
+  'logout',
+  'register',
+  'signup',
+  'signin',
+  'refresh'
+];
+
+/**
+ * Health/status check endpoints
+ * These are singleton endpoints that return system status
+ */
+export const HEALTH_ENDPOINTS = [
+  'health',
+  'ready',
+  'status',
+  'info',
+  'version'
+];
+
+/**
+ * User profile endpoints
+ * These endpoints reference the current/authenticated user
+ */
+export const USER_PROFILE_ENDPOINTS = [
+  'me',
+  'self',
+  'profile',
+  'current'
+];
+
+/**
+ * Singleton resources
+ * Resources that return a single item, not a collection
+ * Includes all auth, health, and user profile endpoints plus common singleton patterns
+ */
+export const SINGLETON_RESOURCES = [
+  'me',
+  'self',
+  'current',
+  'profile',
+  'health',
+  'ready',
+  'status',
+  'info',
+  'version',
+  'metadata',
+  'config',
+  'settings',
+  'preferences',
+  'summary',
+  'stats',
+  'statistics',
+  'dashboard',
+  'schema',
+  'spec',
+  'openapi'
+];
+
+/**
+ * Collection action verbs
+ * Actions that operate on collections (e.g., /activities/search)
+ */
+export const COLLECTION_ACTIONS = [
+  'search',
+  'export',
+  'import',
+  'bulk',
+  'batch',
+  'count',
+  'stats',
+  'validate'
+];
+
+/**
+ * Special actions - combination of auth, health, and user profile endpoints
+ * These endpoints get special naming treatment and keep their action verb
+ */
+export const SPECIAL_ACTIONS = [
+  ...AUTH_ACTIONS,
+  ...HEALTH_ENDPOINTS,
+  ...USER_PROFILE_ENDPOINTS,
+  'check',
+  'verify',
+  'validate'
+];

package/cli/src/codegen/openapi/naming-utils.js

@@ -0,0 +1,149 @@
+/**
+ * Shared naming utilities for OpenAPI code generation
+ * Handles singular/plural conversions with proper edge case handling
+ */
+
+/**
+ * Map of irregular plural forms
+ */
+export const IRREGULAR_PLURALS = {
+    person: 'people',
+    child: 'children',
+    data: 'data',         // already plural
+    media: 'media',       // already plural
+    metadata: 'metadata', // already plural
+    people: 'people',     // already plural
+    children: 'children', // already plural
+};
+
+/**
+ * Map of irregular singular forms (reverse lookup)
+ */
+const IRREGULAR_SINGULARS = {
+    people: 'person',
+    children: 'child',
+    data: 'data',         // already singular
+    media: 'media',       // already singular
+    metadata: 'metadata', // already singular
+    person: 'person',     // already singular
+    child: 'child',       // already singular
+};
+
+/**
+ * Words that naturally end in 's' but are singular
+ */
+const SINGULAR_EXCEPTIONS = [
+    'status',
+    'class',
+    'address',
+    'access',
+    'success',
+    'process',
+    'bus',
+    'focus',
+    'virus',
+];
+
+/**
+ * Check if a word is already plural
+ * @param {string} word - The word to check
+ * @returns {boolean} - True if the word is plural
+ */
+export function isPlural(word) {
+    // Check irregular plurals first
+    if (IRREGULAR_PLURALS[word.toLowerCase()]) {
+        return IRREGULAR_PLURALS[word.toLowerCase()] === word.toLowerCase();
+    }
+
+    // Check singular exceptions - these end in 's' but are not plural
+    if (SINGULAR_EXCEPTIONS.includes(word.toLowerCase())) {
+        return false;
+    }
+
+    // Check common plural endings
+    if (word.endsWith('ies') || word.endsWith('es') || word.endsWith('s')) {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Convert plural word to singular
+ * @param {string} word - The word to singularize
+ * @returns {string} - The singular form of the word
+ */
+export function singularize(word) {
+    // Handle empty or short words
+    if (!word || word.length <= 1) {
+        return word;
+    }
+
+    // Check irregular singulars first
+    const lowerWord = word.toLowerCase();
+    if (IRREGULAR_SINGULARS[lowerWord]) {
+        return IRREGULAR_SINGULARS[lowerWord];
+    }
+
+    // Already singular (check exceptions)
+    if (SINGULAR_EXCEPTIONS.includes(lowerWord)) {
+        return word;
+    }
+
+    // -ies → -y (activities → activity)
+    if (word.endsWith('ies')) {
+        return word.slice(0, -3) + 'y';
+    }
+
+    // -ses → -s (processes → process, but 'process' is already singular)
+    // -xes → -x (boxes → box)
+    // -ches → -ch (watches → watch)
+    // -shes → -sh (dishes → dish)
+    if (word.endsWith('ses') || word.endsWith('xes') || word.endsWith('ches') || word.endsWith('shes')) {
+        return word.slice(0, -2);
+    }
+
+    // Regular -s ending (cats → cat)
+    // But avoid words ending in -ss (class, success, etc.)
+    if (word.endsWith('s') && !word.endsWith('ss') && word.length > 1) {
+        return word.slice(0, -1);
+    }
+
+    return word;
+}
+
+/**
+ * Convert singular word to plural
+ * @param {string} word - The word to pluralize
+ * @returns {string} - The plural form of the word
+ */
+export function pluralize(word) {
+    // Handle empty or short words
+    if (!word || word.length <= 1) {
+        return word;
+    }
+
+    // Check if already plural
+    if (isPlural(word)) {
+        return word;
+    }
+
+    // Check irregular plurals first
+    const lowerWord = word.toLowerCase();
+    if (IRREGULAR_PLURALS[lowerWord]) {
+        return IRREGULAR_PLURALS[lowerWord];
+    }
+
+    // -y ending (not vowel+y) → -ies (activity → activities)
+    if (word.endsWith('y') && !['ay', 'ey', 'iy', 'oy', 'uy'].includes(word.slice(-2))) {
+        return word.slice(0, -1) + 'ies';
+    }
+
+    // -x, -ch, -sh endings → add 'es' (box → boxes, watch → watches, dish → dishes)
+    if (word.endsWith('x') || word.endsWith('ch') || word.endsWith('sh')) {
+        return word + 'es';
+    }
+
+    // Regular: add 's' (cat → cats, dog → dogs)
+    return word + 's';
+}

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

@@ -1,7 +1,7 @@
 import React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const badgeVariants: (props?: {
-    variant?: "success" | "secondary" | "default" | "info" | "warning" | "destructive" | "outline";
+    variant?: "success" | "secondary" | "warning" | "info" | "default" | "destructive" | "outline";
     size?: "sm" | "lg" | "default";
 } & import("class-variance-authority/types").ClassProp) => string;
 export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {

package/dist/atoms/components/data/DataTable/DataTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataTable.d.ts","sourceRoot":"","sources":["../../../../../src/atoms/components/data/DataTable/DataTable.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AASpD,OAAO,KAAK,EAGV,cAAc,EACf,MAAM,mBAAmB,CAAC;AAK3B,YAAY,EACV,MAAM,EACN,gBAAgB,EAChB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAI3B,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC3D,IAAI,EACJ,OAAO,EACP,iBAA+B,EAC/B,QAAa,EACb,cAAqB,EACrB,UAAiB,EACjB,UAAU,EACV,YAAkC,EAClC,SAAc,EACd,KAAa,EACb,SAAiB,EACjB,gBAAoB,EACpB,UAAiB,EACjB,gBAAgB,EAChB,EAAE,GACH,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,aAAa,2CA0XnC"}
+{"version":3,"file":"DataTable.d.ts","sourceRoot":"","sources":["../../../../../src/atoms/components/data/DataTable/DataTable.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AASpD,OAAO,KAAK,EAGV,cAAc,EACf,MAAM,mBAAmB,CAAC;AAK3B,YAAY,EACV,MAAM,EACN,gBAAgB,EAChB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAI3B,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC3D,IAAI,EACJ,OAAO,EACP,iBAA+B,EAC/B,QAAa,EACb,cAAqB,EACrB,UAAiB,EACjB,UAAU,EACV,YAAkC,EAClC,SAAc,EACd,KAAa,EACb,SAAiB,EACjB,gBAAoB,EACpB,UAAiB,EACjB,gBAAgB,EAChB,EAAE,GACH,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,aAAa,2CA4YnC"}

package/dist/atoms/components/data/DataTable/DataTable.types.d.ts

@@ -1,5 +1,5 @@
 import type { ResponsiveColumnConfig, DisplayMode, ResponsiveValue, Breakpoint } from "../../../config/responsive";
-import type { UIConfig } from "../../../types/ui-config";
+import type { UIConfig, UIFieldType, FieldFormat } from "../../../types/ui-config";
 export interface Column<T> {
     key: string;
     header: string | React.ReactNode;
@@ -7,8 +7,20 @@ export interface Column<T> {
     sortable?: boolean;
     filterable?: boolean;
     width?: string;
-    /** Auto-render badges for status/category columns */
-    type?: "status" | "category" | "default";
+    /**
+     * Field type for automatic rendering.
+     * When set, DataTable uses defaultFieldRenderers to format the cell.
+     * Overridden by custom `cell` renderer if provided.
+     *
+     * Supports all UIFieldType values: status, category, money, percent,
+     * date, datetime, user, entity, boolean, text, number, email, url, phone.
+     */
+    type?: UIFieldType;
+    /**
+     * Format configuration for typed fields.
+     * Used by money (currency, decimals, locale), date (locale), status (statusColors), etc.
+     */
+    format?: FieldFormat;
 }
 export interface ResponsiveColumn<T> extends Column<T>, ResponsiveColumnConfig {
     /** Responsive width adjustments */