@nice2dev/ui-core 1.0.10

package/dist/performance/concurrent.d.ts

@@ -0,0 +1,190 @@
+/**
+ * @file concurrent.ts
+ * @description Nice2Dev Performance — Concurrent Rendering Utilities
+ *
+ * React 18+ concurrent rendering optimizations.
+ * Uses useTransition, useDeferredValue for responsive UIs.
+ */
+export interface DeferredSearchConfig<T> {
+    /** Items to search through */
+    items: T[];
+    /** Search function */
+    searchFn: (item: T, query: string) => boolean;
+    /** Debounce time in ms */
+    debounce?: number;
+    /** Minimum query length to trigger search */
+    minLength?: number;
+}
+export interface TransitionState<T> {
+    /** Current stable value */
+    value: T;
+    /** Pending value (during transition) */
+    pendingValue: T;
+    /** Is transition in progress */
+    isPending: boolean;
+    /** Update value with transition */
+    setValue: (value: T | ((prev: T) => T)) => void;
+    /** Update value immediately */
+    setValueImmediate: (value: T | ((prev: T) => T)) => void;
+}
+export interface ChunkedProcessorConfig<T, R> {
+    /** Items to process */
+    data: T[];
+    /** Processing function */
+    processFn: (item: T, index: number) => R;
+    /** Chunk size (items per frame) */
+    chunkSize?: number;
+    /** Priority (user-blocking, user-visible, background) */
+    priority?: 'user-blocking' | 'user-visible' | 'background';
+}
+/**
+ * Search with deferred value for responsive UI
+ *
+ * @example
+ * ```tsx
+ * function SearchableList({ items }) {
+ *   const { query, setQuery, results, isStale } = useDeferredSearch({
+ *     items,
+ *     searchFn: (item, q) => item.name.toLowerCase().includes(q.toLowerCase()),
+ *   });
+ *
+ *   return (
+ *     <>
+ *       <input value={query} onChange={e => setQuery(e.target.value)} />
+ *       <div style={{ opacity: isStale ? 0.7 : 1 }}>
+ *         {results.map(item => <div key={item.id}>{item.name}</div>)}
+ *       </div>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function useDeferredSearch<T>(config: DeferredSearchConfig<T>): {
+    query: string;
+    setQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    results: T[];
+    isStale: boolean;
+    deferredQuery: string;
+};
+/**
+ * State with useTransition for non-blocking updates
+ *
+ * @example
+ * ```tsx
+ * function Tab({ content }) {
+ *   const { value, setValue, isPending } = useTransitionState(0);
+ *
+ *   return (
+ *     <>
+ *       <nav>
+ *         {tabs.map((tab, i) => (
+ *           <button key={i} onClick={() => setValue(i)}>
+ *             {tab.title}
+ *           </button>
+ *         ))}
+ *       </nav>
+ *       {isPending && <Spinner />}
+ *       <TabPanel index={value} />
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function useTransitionState<T>(initialValue: T): TransitionState<T>;
+/**
+ * Process large arrays in chunks to keep UI responsive
+ *
+ * @example
+ * ```tsx
+ * function DataProcessor({ data }) {
+ *   const { result, progress, isProcessing } = useChunkedProcessor({
+ *     data,
+ *     processFn: (item) => complexTransform(item),
+ *     chunkSize: 1000,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {isProcessing && <ProgressBar value={progress} />}
+ *       {result && <DataView data={result} />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useChunkedProcessor<T, R>(config: ChunkedProcessorConfig<T, R>): {
+    result: R[] | null;
+    progress: number;
+    isProcessing: boolean;
+    process: () => Promise<void>;
+    cancel: () => void;
+};
+/**
+ * List that renders items progressively for fast initial display
+ *
+ * @example
+ * ```tsx
+ * function LargeList({ items }) {
+ *   const { visibleItems, isComplete } = useDeferredList(items, {
+ *     initialCount: 20,
+ *     batchSize: 50,
+ *   });
+ *
+ *   return (
+ *     <ul>
+ *       {visibleItems.map(item => <li key={item.id}>{item.name}</li>)}
+ *       {!isComplete && <li>Loading more...</li>}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+export declare function useDeferredList<T>(items: T[], options?: {
+    /** Initial items to render */
+    initialCount?: number;
+    /** Items to add per batch */
+    batchSize?: number;
+    /** Delay between batches */
+    batchDelay?: number;
+}): {
+    visibleItems: T[];
+    visibleCount: number;
+    totalCount: number;
+    isComplete: boolean;
+    progress: number;
+};
+export interface OptimisticConfig<T> {
+    /** Initial value */
+    initial: T;
+    /** Async mutation function */
+    mutate: (value: T) => Promise<T>;
+    /** Rollback on error */
+    rollbackOnError?: boolean;
+}
+/**
+ * Optimistic UI updates with automatic rollback
+ *
+ * @example
+ * ```tsx
+ * function LikeButton({ postId, initialLikes }) {
+ *   const { value, update, isPending, error } = useOptimistic({
+ *     initial: initialLikes,
+ *     mutate: (likes) => api.updateLikes(postId, likes),
+ *   });
+ *
+ *   return (
+ *     <button onClick={() => update(value + 1)}>
+ *       ❤️ {value} {isPending && '...'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useOptimistic<T>(config: OptimisticConfig<T>): {
+    value: T;
+    update: (newValue: T) => Promise<void>;
+    isPending: boolean;
+    error: Error | null;
+    reset: () => void;
+};
+//# sourceMappingURL=concurrent.d.ts.map

package/dist/performance/concurrent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrent.d.ts","sourceRoot":"","sources":["../../src/performance/concurrent.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiBH,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,8BAA8B;IAC9B,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,sBAAsB;IACtB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,2BAA2B;IAC3B,KAAK,EAAE,CAAC,CAAC;IACT,wCAAwC;IACxC,YAAY,EAAE,CAAC,CAAC;IAChB,gCAAgC;IAChC,SAAS,EAAE,OAAO,CAAC;IACnB,mCAAmC;IACnC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC;IAChD,+BAA+B;IAC/B,iBAAiB,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC;CAC1D;AAED,MAAM,WAAW,sBAAsB,CAAC,CAAC,EAAE,CAAC;IAC1C,uBAAuB;IACvB,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,0BAA0B;IAC1B,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,CAAC;IACzC,mCAAmC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,eAAe,GAAG,cAAc,GAAG,YAAY,CAAC;CAC5D;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;;;;;;EA8CnE;AAMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAoCzE;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;EAoF7E;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,GAAE;IACP,8BAA8B;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB;;;;;;EAuCP;AAMD,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,oBAAoB;IACpB,OAAO,EAAE,CAAC,CAAC;IACX,8BAA8B;IAC9B,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACjC,wBAAwB;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;;uBASvC,CAAC;;;;EAoCrB"}

package/dist/performance/images.d.ts

@@ -0,0 +1,189 @@
+/**
+ * @file images.ts
+ * @description Nice2Dev Performance — Image Optimization Utilities
+ *
+ * Lazy loading, progressive rendering, responsive images, and format detection.
+ */
+export interface ImageFormat {
+    format: 'avif' | 'webp' | 'jpg' | 'png' | 'gif';
+    mimeType: string;
+    supported: boolean;
+}
+export interface ResponsiveImageSource {
+    src: string;
+    width: number;
+    format?: ImageFormat['format'];
+}
+export interface ProgressiveImageState {
+    /** Current displayed source */
+    currentSrc: string | null;
+    /** Thumbnail/LQIP source */
+    thumbnailSrc: string | null;
+    /** Full-res source */
+    fullSrc: string;
+    /** Loading stage: 'idle' | 'thumbnail' | 'loading' | 'loaded' | 'error' */
+    stage: 'idle' | 'thumbnail' | 'loading' | 'loaded' | 'error';
+    /** Is fully loaded */
+    isLoaded: boolean;
+    /** Is in viewport */
+    isInView: boolean;
+    /** Error if any */
+    error: Error | null;
+}
+export interface LazyImageConfig {
+    /** Intersection Observer root margin */
+    rootMargin?: string;
+    /** Intersection Observer threshold */
+    threshold?: number;
+    /** Enable progressive loading */
+    progressive?: boolean;
+    /** Low-quality image placeholder src */
+    lqip?: string;
+    /** Blur amount for LQIP (in px) */
+    blurRadius?: number;
+    /** Delay before loading (for prioritization) */
+    delay?: number;
+    /** Priority: 'high' | 'low' | 'auto' */
+    priority?: 'high' | 'low' | 'auto';
+    /** Callback when loaded */
+    onLoad?: () => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Check if browser supports a specific image format
+ */
+export declare function checkFormatSupport(format: 'avif' | 'webp'): Promise<boolean>;
+/**
+ * Hook to get supported image formats
+ */
+export declare function useImageFormats(): {
+    formats: Record<string, boolean>;
+    isChecking: boolean;
+};
+/**
+ * Generate srcset string from sources
+ */
+export declare function generateSrcset(sources: ResponsiveImageSource[]): string;
+/**
+ * Generate sizes attribute for responsive images
+ */
+export declare function generateSizes(breakpoints: {
+    maxWidth: number;
+    size: string;
+}[], defaultSize: string): string;
+/**
+ * Select optimal image source based on viewport and DPR
+ */
+export declare function selectOptimalSource(sources: ResponsiveImageSource[], containerWidth: number, dpr?: number): ResponsiveImageSource;
+/**
+ * Hook for progressive image loading (blur-up technique)
+ *
+ * @example
+ * ```tsx
+ * function ProgressiveImage({ src, lqip, alt }) {
+ *   const { currentSrc, stage, style, ref } = useProgressiveImage({
+ *     src,
+ *     lqip,
+ *     blurRadius: 20,
+ *   });
+ *
+ *   return (
+ *     <img
+ *       ref={ref}
+ *       src={currentSrc}
+ *       alt={alt}
+ *       style={style}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare function useProgressiveImage(config: LazyImageConfig & {
+    src: string;
+}): {
+    style: import("react").CSSProperties;
+    /** Current displayed source */
+    currentSrc: string | null;
+    /** Thumbnail/LQIP source */
+    thumbnailSrc: string | null;
+    /** Full-res source */
+    fullSrc: string;
+    /** Loading stage: 'idle' | 'thumbnail' | 'loading' | 'loaded' | 'error' */
+    stage: "idle" | "thumbnail" | "loading" | "loaded" | "error";
+    /** Is fully loaded */
+    isLoaded: boolean;
+    /** Is in viewport */
+    isInView: boolean;
+    /** Error if any */
+    error: Error | null;
+    ref: import("react").RefObject<HTMLImageElement>;
+};
+/**
+ * Preload images in the background
+ */
+export declare function preloadImages(urls: string[]): Promise<void[]>;
+/**
+ * Hook for preloading images on mount
+ */
+export declare function useImagePreload(urls: string[]): {
+    loaded: number;
+    total: number;
+    isComplete: boolean;
+    errors: string[];
+};
+/**
+ * Load and decode image off main thread
+ */
+export declare function loadAndDecodeImage(src: string): Promise<HTMLImageElement>;
+/**
+ * Hook that loads and decodes image before rendering
+ */
+export declare function useDecodedImage(src: string | null): {
+    image: HTMLImageElement | null;
+    isLoading: boolean;
+    error: Error | null;
+};
+type LazyLoadCallback = (entry: IntersectionObserverEntry) => void;
+/**
+ * Shared IntersectionObserver for multiple images
+ * Reduces overhead compared to one observer per image
+ */
+export declare function createImageObserver(options?: IntersectionObserverInit): {
+    observe: (element: Element, callback: LazyLoadCallback) => void;
+    unobserve: (element: Element) => void;
+    disconnect: () => void;
+};
+/**
+ * Hook for using shared image observer
+ */
+export declare function useSharedImageObserver(observer: ReturnType<typeof createImageObserver>, onIntersect: () => void): {
+    ref: import("react").RefObject<HTMLImageElement>;
+    isInView: boolean;
+};
+/**
+ * Generate a solid color placeholder as data URI
+ */
+export declare function generateColorPlaceholder(color: string, width?: number, height?: number): string;
+/**
+ * Generate a gradient placeholder as data URI
+ */
+export declare function generateGradientPlaceholder(colors: [string, string], direction?: 'horizontal' | 'vertical', width?: number, height?: number): string;
+export declare const ImageOptimization: {
+    checkFormatSupport: typeof checkFormatSupport;
+    useImageFormats: typeof useImageFormats;
+    generateSrcset: typeof generateSrcset;
+    generateSizes: typeof generateSizes;
+    selectOptimalSource: typeof selectOptimalSource;
+    useProgressiveImage: typeof useProgressiveImage;
+    preloadImages: typeof preloadImages;
+    useImagePreload: typeof useImagePreload;
+    loadAndDecodeImage: typeof loadAndDecodeImage;
+    useDecodedImage: typeof useDecodedImage;
+    createImageObserver: typeof createImageObserver;
+    useSharedImageObserver: typeof useSharedImageObserver;
+    generateColorPlaceholder: typeof generateColorPlaceholder;
+    generateGradientPlaceholder: typeof generateGradientPlaceholder;
+};
+export {};
+//# sourceMappingURL=images.d.ts.map

package/dist/performance/images.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"images.d.ts","sourceRoot":"","sources":["../../src/performance/images.ts"],"names":[],"mappings":"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"}

package/dist/performance/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file index.ts
+ * @description Nice2Dev Performance — Core Utilities
+ *
+ * High-performance utilities for React applications:
+ * - Virtualization for 500k+ rows
+ * - Concurrent rendering with React 18+
+ * - Web Worker offloading
+ * - Memory optimization (WeakMap caches, cleanup)
+ * - Image lazy loading & progressive rendering
+ */
+export * from './virtualization';
+export * from './concurrent';
+export * from './workers';
+export * from './memory';
+export * from './images';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/performance/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/performance/memory.d.ts

@@ -0,0 +1,223 @@
+/**
+ * @file memory.ts
+ * @description Nice2Dev Performance — Memory Optimization Utilities
+ *
+ * Memory-efficient caching, automatic cleanup, and monitoring.
+ */
+export interface WeakCacheOptions<K extends object> {
+    /** Maximum cache size (for LRU eviction on fallback) */
+    maxSize?: number;
+    /** TTL in milliseconds (optional) */
+    ttl?: number;
+    /** Key extractor function */
+    getKey?: (key: K) => string;
+}
+export interface MemoryStats {
+    /** JS heap size limit */
+    jsHeapSizeLimit: number;
+    /** Total JS heap size */
+    totalJSHeapSize: number;
+    /** Used JS heap size */
+    usedJSHeapSize: number;
+    /** Used heap percentage */
+    usedPercent: number;
+    /** Is available */
+    isSupported: boolean;
+}
+export interface EventCleanup {
+    /** Add event listener with automatic cleanup */
+    add: <K extends keyof WindowEventMap>(target: EventTarget, event: K | string, handler: EventListener, options?: AddEventListenerOptions) => void;
+    /** Remove all registered listeners */
+    removeAll: () => void;
+    /** Get count of active listeners */
+    count: () => number;
+}
+/**
+ * WeakMap-based cache that automatically releases memory
+ * when keys are garbage collected.
+ *
+ * @example
+ * ```tsx
+ * const userCache = createWeakCache<User, UserProfile>();
+ *
+ * function UserCard({ user }) {
+ *   let profile = userCache.get(user);
+ *
+ *   if (!profile) {
+ *     profile = computeExpensiveProfile(user);
+ *     userCache.set(user, profile);
+ *   }
+ *
+ *   return <div>{profile.name}</div>;
+ * }
+ * ```
+ */
+export declare function createWeakCache<K extends object, V>(): {
+    get: (key: K) => V | undefined;
+    set: (key: K, value: V) => void;
+    has: (key: K) => boolean;
+    delete: (key: K) => boolean;
+};
+/**
+ * LRU cache with optional TTL and WeakRef for values
+ *
+ * @example
+ * ```tsx
+ * const imageCache = createLRUCache<string, ImageBitmap>({
+ *   maxSize: 100,
+ *   ttl: 60000, // 1 minute
+ * });
+ * ```
+ */
+export declare function createLRUCache<K, V>(options?: {
+    maxSize?: number;
+    ttl?: number;
+}): {
+    get: (key: K) => V | undefined;
+    set: (key: K, value: V) => void;
+    has: (key: K) => boolean;
+    delete: (key: K) => boolean;
+    clear: () => void;
+    size: () => number;
+    keys: () => K[];
+};
+/**
+ * Cache using WeakRef for values - allows GC to collect unused values
+ *
+ * @example
+ * ```tsx
+ * const componentCache = createWeakRefCache<string, React.ComponentType>();
+ *
+ * // Values can be garbage collected when no other references exist
+ * componentCache.set('MyComponent', MyComponent);
+ * ```
+ */
+export declare function createWeakRefCache<K, V extends object>(): {
+    get: (key: K) => V | undefined;
+    set: (key: K, value: V) => void;
+    has: (key: K) => boolean;
+    delete: (key: K) => boolean;
+    clear: () => void;
+    size: () => number;
+};
+/**
+ * Hook for automatic event listener cleanup
+ *
+ * @example
+ * ```tsx
+ * function ScrollTracker() {
+ *   const events = useEventCleanup();
+ *
+ *   useEffect(() => {
+ *     events.add(window, 'scroll', handleScroll);
+ *     events.add(document, 'keydown', handleKeyDown);
+ *     // All listeners automatically removed on unmount
+ *   }, []);
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ */
+export declare function useEventCleanup(): EventCleanup;
+/**
+ * Create standalone event cleanup manager
+ */
+export declare function createEventCleanup(): EventCleanup & {
+    dispose: () => void;
+};
+/**
+ * Get current memory stats (Chrome only)
+ */
+export declare function getMemoryStats(): MemoryStats;
+/**
+ * Hook for monitoring memory usage
+ *
+ * @example
+ * ```tsx
+ * function MemoryMonitor() {
+ *   const { stats, isHighUsage } = useMemoryMonitor({
+ *     warningThreshold: 80, // Warn at 80% usage
+ *     pollInterval: 5000,
+ *   });
+ *
+ *   if (isHighUsage) {
+ *     console.warn('High memory usage!');
+ *   }
+ * }
+ * ```
+ */
+export declare function useMemoryMonitorPerf(options?: {
+    warningThreshold?: number;
+    pollInterval?: number;
+    onHighUsage?: (stats: MemoryStats) => void;
+}): {
+    stats: MemoryStats;
+    isHighUsage: boolean;
+};
+export interface LazyImageOptions {
+    /** Intersection Observer root margin */
+    rootMargin?: string;
+    /** Intersection Observer threshold */
+    threshold?: number;
+    /** Placeholder while loading */
+    placeholder?: string;
+    /** Enable progressive loading (blur-up) */
+    progressive?: boolean;
+}
+/**
+ * Hook for lazy loading images with intersection observer
+ *
+ * @example
+ * ```tsx
+ * function LazyImage({ src, alt }) {
+ *   const { ref, isLoaded, isInView } = useLazyImage({ src });
+ *
+ *   return (
+ *     <img
+ *       ref={ref}
+ *       src={isInView ? src : placeholder}
+ *       alt={alt}
+ *       className={isLoaded ? 'loaded' : 'loading'}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare function useLazyImage(options: LazyImageOptions & {
+    src: string;
+}): {
+    ref: import("react").RefObject<HTMLImageElement>;
+    isInView: boolean;
+    isLoaded: boolean;
+    currentSrc: string;
+};
+/**
+ * Object pool for reducing GC pressure
+ *
+ * @example
+ * ```tsx
+ * const vectorPool = createObjectPool({
+ *   create: () => ({ x: 0, y: 0 }),
+ *   reset: (v) => { v.x = 0; v.y = 0; },
+ *   maxSize: 100,
+ * });
+ *
+ * function useVector() {
+ *   const v = vectorPool.acquire();
+ *   // Use vector...
+ *   vectorPool.release(v);
+ * }
+ * ```
+ */
+export declare function createObjectPool<T>(options: {
+    create: () => T;
+    reset?: (obj: T) => void;
+    maxSize?: number;
+}): {
+    acquire: () => T;
+    release: (obj: T) => void;
+    preallocate: (count: number) => void;
+    clear: () => void;
+    size: () => number;
+};
+//# sourceMappingURL=memory.d.ts.map

package/dist/performance/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/performance/memory.ts"],"names":[],"mappings":"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"}