@archbase/tools 3.0.0 → 3.0.2

package/dist/debug/ArchbaseConsoleLogger.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Enhanced console logger with colored output and grouping
+ */
+export declare class ArchbaseConsoleLogger {
+    private static instance;
+    private enabled;
+    private logLevel;
+    private prefix;
+    private constructor();
+    static getInstance(): ArchbaseConsoleLogger;
+    setEnabled(enabled: boolean): this;
+    setLogLevel(level: 'debug' | 'info' | 'warn' | 'error'): this;
+    setPrefix(prefix: string): this;
+    private shouldLog;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, error?: Error, ...args: any[]): void;
+    group(label: string, fn: () => void): void;
+    time(label: string): void;
+    timeEnd(label: string): void;
+    table(data: any[], columns?: string[]): void;
+}
+export declare const logger: ArchbaseConsoleLogger;

package/dist/debug/ArchbaseDebugPanel.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+interface DebugInfo {
+    id: string;
+    timestamp: number;
+    type: 'render' | 'state' | 'props' | 'api' | 'performance';
+    component?: string;
+    message: string;
+    data?: any;
+    duration?: number;
+}
+interface ArchbaseDebugPanelProps {
+    enabled?: boolean;
+    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+    maxEntries?: number;
+}
+/**
+ * Debug panel component for development
+ */
+export declare const ArchbaseDebugPanel: React.FC<ArchbaseDebugPanelProps>;
+/**
+ * Helper function to emit debug events
+ */
+export declare function emitDebugInfo(info: Omit<DebugInfo, 'id' | 'timestamp'>): void;
+export {};

package/dist/dev-utils/ArchbaseDataSourceInspector.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+interface ArchbaseDataSourceInspectorProps {
+    /** DataSource instances to monitor */
+    dataSources?: Array<{
+        name: string;
+        dataSource: any;
+    }>;
+    /** Enable automatic discovery of DataSources */
+    autoDiscover?: boolean;
+    /** Hotkey to toggle inspector */
+    hotkey?: string;
+    /** Show inspector by default */
+    visible?: boolean;
+    /** Position of the floating window */
+    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    /** Maximum number of operations to track */
+    maxOperations?: number;
+}
+/**
+ * Advanced DataSource inspector with real-time monitoring
+ */
+export declare const ArchbaseDataSourceInspector: React.FC<ArchbaseDataSourceInspectorProps>;
+export {};

package/dist/dev-utils/ArchbaseErrorBoundary.d.ts

@@ -0,0 +1,30 @@
+import { default as React, Component, ReactNode, ErrorInfo } from 'react';
+interface Props {
+    children: ReactNode;
+    fallback?: (error: Error, errorInfo: ErrorInfo) => ReactNode;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    showStack?: boolean;
+    logToConsole?: boolean;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: ErrorInfo | null;
+    errorHistory: Array<{
+        error: Error;
+        errorInfo: ErrorInfo;
+        timestamp: number;
+    }>;
+}
+/**
+ * Enhanced error boundary with debugging capabilities
+ */
+export declare class ArchbaseErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): Partial<State>;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    handleRetry: () => void;
+    handleClearHistory: () => void;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

package/dist/dev-utils/ArchbaseLocalStorageViewer.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface ArchbaseLocalStorageViewerProps {
+    prefix?: string;
+    onItemClick?: (key: string, value: any) => void;
+    showSize?: boolean;
+}
+/**
+ * Component to view and manage localStorage in development
+ */
+export declare const ArchbaseLocalStorageViewer: React.FC<ArchbaseLocalStorageViewerProps>;
+export {};

package/dist/dev-utils/ArchbaseMemoryLeakDetector.d.ts

@@ -0,0 +1,83 @@
+interface MemorySnapshot {
+    id: string;
+    timestamp: number;
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+    jsHeapSizeLimit: number;
+    totalJSHeapSize: number;
+    usedJSHeapSize: number;
+}
+interface LeakSuspicion {
+    type: 'memory-growth' | 'heap-limit' | 'external-growth';
+    severity: 'low' | 'medium' | 'high';
+    message: string;
+    trend: number[];
+    recommendation: string;
+}
+/**
+ * Memory leak detection utility for development
+ */
+export declare class ArchbaseMemoryLeakDetector {
+    private static instance;
+    private snapshots;
+    private intervalId;
+    private isMonitoring;
+    private readonly maxSnapshots;
+    private readonly growthThreshold;
+    private readonly criticalThreshold;
+    private constructor();
+    static getInstance(): ArchbaseMemoryLeakDetector;
+    /**
+     * Start monitoring memory usage
+     */
+    startMonitoring(intervalMs?: number): void;
+    /**
+     * Stop monitoring
+     */
+    stopMonitoring(): void;
+    /**
+     * Take a memory snapshot
+     */
+    takeSnapshot(): MemorySnapshot | null;
+    /**
+     * Analyze memory patterns for potential leaks
+     */
+    analyzeMemoryPatterns(): LeakSuspicion[];
+    private checkMemoryGrowth;
+    private checkHeapLimit;
+    private checkExternalGrowth;
+    /**
+     * Force garbage collection (Chrome DevTools only)
+     */
+    forceGarbageCollection(): boolean;
+    /**
+     * Get memory usage statistics
+     */
+    getMemoryStats(): {
+        current: MemorySnapshot | null;
+        peak: MemorySnapshot | null;
+        average: number;
+        growth: number;
+        suspicions: LeakSuspicion[];
+    };
+    /**
+     * Get all snapshots
+     */
+    getSnapshots(): MemorySnapshot[];
+    /**
+     * Clear all snapshots
+     */
+    clearSnapshots(): void;
+    /**
+     * Export memory data
+     */
+    exportData(): string;
+    private isMemoryAPIAvailable;
+    /**
+     * Check if monitoring is active
+     */
+    isActive(): boolean;
+}
+export declare const memoryLeakDetector: ArchbaseMemoryLeakDetector;
+export {};

package/dist/dev-utils/ArchbaseNetworkMonitor.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface ArchbaseNetworkMonitorProps {
+    filterUrls?: string[];
+    excludeUrls?: string[];
+    maxRequests?: number;
+}
+/**
+ * Network request monitor component
+ */
+export declare const ArchbaseNetworkMonitor: React.FC<ArchbaseNetworkMonitorProps>;
+export {};

package/dist/dev-utils/ArchbaseStateInspector.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+interface ArchbaseStateInspectorProps {
+    stores?: Array<{
+        name: string;
+        type: 'redux' | 'zustand' | 'context' | 'custom';
+        getState: () => any;
+        subscribe?: (listener: () => void) => () => void;
+    }>;
+    maxSnapshots?: number;
+}
+/**
+ * State inspector for debugging application state
+ */
+export declare const ArchbaseStateInspector: React.FC<ArchbaseStateInspectorProps>;
+export {};

package/dist/dev-utils/useArchbaseDataSourceDebug.d.ts

@@ -0,0 +1,111 @@
+interface DataSourceDebugOptions {
+    /** Enable automatic operation logging */
+    logOperations?: boolean;
+    /** Enable state change monitoring */
+    monitorState?: boolean;
+    /** Enable performance tracking */
+    trackPerformance?: boolean;
+    /** Maximum number of operations to keep in history */
+    maxHistory?: number;
+}
+interface DataSourceOperation {
+    id: string;
+    timestamp: number;
+    operation: string;
+    args?: any[];
+    duration?: number;
+    result?: any;
+    error?: any;
+}
+/**
+ * Hook for debugging DataSource operations and state
+ */
+export declare function useArchbaseDataSourceDebug<T, ID>(dataSource: any, name: string, options?: DataSourceDebugOptions): {
+    operations: DataSourceOperation[];
+    currentState: any;
+    performanceStats: {
+        method: string;
+        count: number;
+        avgDuration: number;
+        minDuration: number;
+        maxDuration: number;
+        totalDuration: number;
+    }[];
+    getOperationHistory: (methodName?: string) => DataSourceOperation[];
+    clearHistory: () => void;
+    exportDebugData: () => {
+        dataSourceName: string;
+        currentState: any;
+        operations: DataSourceOperation[];
+        performanceStats: {
+            method: string;
+            count: number;
+            avgDuration: number;
+            minDuration: number;
+            maxDuration: number;
+            totalDuration: number;
+        }[];
+        exportedAt: string;
+    };
+};
+/**
+ * Hook to register multiple DataSources for debugging
+ */
+/**
+ * useArchbaseDataSourceRegistry — hook que mantém múltiplos DataSources registrados para debug.
+ * @status stable
+ */
+export declare function useArchbaseDataSourceRegistry(): {
+    dataSources: {
+        name: string;
+        dataSource: any;
+        debugHook: ReturnType<typeof useArchbaseDataSourceDebug>;
+    }[];
+    registerDataSource: (name: string, dataSource: any, options?: DataSourceDebugOptions) => void;
+    unregisterDataSource: (name: string) => void;
+    getDataSource: (name: string) => {
+        name: string;
+        dataSource: any;
+        debugHook: ReturnType<typeof useArchbaseDataSourceDebug>;
+    } | undefined;
+    getAllDataSources: () => {
+        name: string;
+        dataSource: any;
+        debugHook: ReturnType<typeof useArchbaseDataSourceDebug>;
+    }[];
+    exportAllDebugData: () => {
+        dataSources: {
+            name: string;
+            debugData: {
+                operations: DataSourceOperation[];
+                currentState: any;
+                performanceStats: {
+                    method: string;
+                    count: number;
+                    avgDuration: number;
+                    minDuration: number;
+                    maxDuration: number;
+                    totalDuration: number;
+                }[];
+                getOperationHistory: (methodName?: string) => DataSourceOperation[];
+                clearHistory: () => void;
+                exportDebugData: () => {
+                    dataSourceName: string;
+                    currentState: any;
+                    operations: DataSourceOperation[];
+                    performanceStats: {
+                        method: string;
+                        count: number;
+                        avgDuration: number;
+                        minDuration: number;
+                        maxDuration: number;
+                        totalDuration: number;
+                    }[];
+                    exportedAt: string;
+                };
+            };
+        }[];
+        exportedAt: string;
+    };
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { ArchbaseConsoleLogger, logger } from './debug/ArchbaseConsoleLogger';
+export { ArchbaseDebugPanel, emitDebugInfo } from './debug/ArchbaseDebugPanel';
+export { ArchbasePerformanceMonitor, performanceMonitor } from './performance/ArchbasePerformanceMonitor';
+export { useArchbaseRenderTracker, useArchbaseWhyDidYouRender } from './performance/useArchbaseRenderTracker';
+export { ArchbaseLocalStorageViewer } from './dev-utils/ArchbaseLocalStorageViewer';
+export { ArchbaseNetworkMonitor } from './dev-utils/ArchbaseNetworkMonitor';
+export { ArchbaseStateInspector } from './dev-utils/ArchbaseStateInspector';
+export { ArchbaseErrorBoundary } from './dev-utils/ArchbaseErrorBoundary';
+export { ArchbaseMemoryLeakDetector, memoryLeakDetector } from './dev-utils/ArchbaseMemoryLeakDetector';
+export { ArchbaseDataSourceInspector } from './dev-utils/ArchbaseDataSourceInspector';
+export { useArchbaseDataSourceDebug, useArchbaseDataSourceRegistry } from './dev-utils/useArchbaseDataSourceDebug';
+export declare const ArchbaseToolsVersion = "3.0.0";

package/dist/performance/ArchbasePerformanceMonitor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Performance monitoring utility
+ */
+export declare class ArchbasePerformanceMonitor {
+    private static instance;
+    private marks;
+    private measures;
+    private constructor();
+    static getInstance(): ArchbasePerformanceMonitor;
+    /**
+     * Start measuring performance
+     */
+    start(label: string): void;
+    /**
+     * End measurement and return duration
+     */
+    end(label: string): number | null;
+    /**
+     * Get statistics for a label
+     */
+    getStats(label: string): {
+        count: number;
+        total: number;
+        average: number;
+        min: number;
+        max: number;
+        median: number;
+    } | null;
+    /**
+     * Clear all measurements
+     */
+    clear(label?: string): void;
+    /**
+     * Get all statistics
+     */
+    getAllStats(): Map<string, ReturnType<typeof this.getStats>>;
+    /**
+     * Print performance report to console
+     */
+    report(): void;
+}
+export declare const performanceMonitor: ArchbasePerformanceMonitor;

package/dist/performance/useArchbaseRenderTracker.d.ts

@@ -0,0 +1,16 @@
+interface RenderInfo {
+    componentName: string;
+    renderCount: number;
+    lastRenderTime: number;
+    averageRenderTime: number;
+    props?: Record<string, any>;
+}
+/**
+ * Hook to track component render performance
+ */
+export declare function useArchbaseRenderTracker(componentName: string, props?: Record<string, any>): RenderInfo;
+/**
+ * Hook to track why a component re-rendered
+ */
+export declare function useArchbaseWhyDidYouRender(componentName: string, props: Record<string, any>): void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archbase/tools",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Archbase React Tools - CLI, Development Tools, Generators",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,23 +16,25 @@
     "dist"
   ],
   "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
     "@mantine/core": "8.3.12",
     "@mantine/hooks": "8.3.12",
-    "@tabler/icons-react": "^3.0.0"
+    "@tabler/icons-react": "^3.0.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
   },
   "dependencies": {
-    "@archbase/core": "3.0.0"
+    "@archbase/core": "3.0.2"
   },
   "devDependencies": {
-    "@types/react": "^19.0.2",
+    "@types/react": "^19.0.6",
     "@types/react-dom": "^19.0.2",
     "typescript": "^5.7.2",
-    "vite": "^6.3.5"
+    "vite": "^6.3.5",
+    "vite-plugin-dts": "^4.5.4"
   },
+  "module": "./dist/index.js",
   "scripts": {
-    "build": "NODE_OPTIONS=\"--max-old-space-size=16384\" vite build && tsc --emitDeclarationOnly || true",
+    "build": "NODE_OPTIONS=\"--max-old-space-size=16384\" vite build",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src --ext .ts,.tsx",
     "clean": "rm -rf dist"