mtrl 0.4.4 → 0.5.0

package/dist/core/collection/list-manager/scroll-tracker.d.ts

@@ -1,20 +0,0 @@
-import { ListManagerElements, ListManagerConfig } from "./types";
-/**
- * Common interface for scroll tracking strategies
- */
-export interface ScrollTracker {
-    setup(): () => void;
-    getScrollTop(): number;
-}
-/**
- * Factory to create the appropriate scroll tracker based on strategy
- * @param container Container element
- * @param elements DOM elements
- * @param config List manager configuration
- * @param callbacks Callbacks for scroll events
- * @returns ScrollTracker implementation
- */
-export declare function createScrollTracker(container: HTMLElement, elements: ListManagerElements, config: ListManagerConfig, callbacks: {
-    onScroll: (scrollTop: number) => void;
-    onLoadMore: () => void;
-}): ScrollTracker;

package/dist/core/collection/list-manager/state.d.ts

@@ -1,60 +0,0 @@
-import { ListManagerState, ListManagerConfig } from './types';
-/**
- * Creates the initial state for a list manager
- * @param config List manager configuration
- * @returns Initialized state object
- */
-export declare function createInitialState(config: ListManagerConfig): ListManagerState;
-/**
- * Updates the state after a load operation
- * @param state Current state
- * @param newItems New items array
- * @param meta Pagination metadata
- * @param dedupe Whether to deduplicate items
- * @returns Updated state
- */
-export declare function updateStateAfterLoad(state: ListManagerState, newItems: any[], meta: {
-    cursor?: string | null;
-    hasNext?: boolean;
-    total?: number;
-    page?: number;
-}, dedupe?: boolean): Partial<ListManagerState>;
-/**
- * Updates the visible items in state
- * @param state Current state
- * @param visibleItems New visible items array
- * @param visibleRange New visible range
- * @returns Updated state
- */
-export declare function updateVisibleItems(state: ListManagerState, visibleItems: any[], visibleRange: {
-    start: number;
-    end: number;
-}): Partial<ListManagerState>;
-/**
- * Updates total height in state
- * @param state Current state
- * @param totalHeight New total height
- * @returns Updated state
- */
-export declare function updateTotalHeight(state: ListManagerState, totalHeight: number): Partial<ListManagerState>;
-/**
- * Updates loading state
- * @param state Current state
- * @param loading New loading state
- * @returns Updated state
- */
-export declare function updateLoadingState(state: ListManagerState, loading: boolean): Partial<ListManagerState>;
-/**
- * Resets the state for a refresh operation
- * @param state Current state
- * @param initialItems Initial items array for static mode
- * @returns Reset state
- */
-export declare function resetState(state: ListManagerState, initialItems?: any[]): Partial<ListManagerState>;
-/**
- * Creates load params for the next page based on pagination strategy
- * @param state Current state
- * @param paginationStrategy Optional pagination strategy override
- * @returns Load parameters object
- */
-export declare function createLoadParams(state: ListManagerState, paginationStrategy?: string): Record<string, any>;

package/dist/core/collection/list-manager/types.d.ts

@@ -1,361 +0,0 @@
-import { Collection } from '../collection';
-/**
- * Configuration for list manager
- */
-export interface ListManagerConfig {
-    /**
-     * Transform function for items
-     */
-    transform?: (item: any) => any;
-    /**
-     * Base URL for API requests
-     */
-    baseUrl?: string | null;
-    /**
-     * Function to render an item
-     */
-    renderItem: (item: any, index: number, recycledElement?: HTMLElement) => HTMLElement;
-    /**
-     * Callback after load operations
-     */
-    afterLoad?: (result: LoadStatus) => void;
-    /**
-     * Items for static mode
-     */
-    staticItems?: any[] | null;
-    /**
-     * Number of extra items to render outside viewport
-     */
-    renderBufferSize?: number;
-    /**
-     * Number of items to keep in DOM but invisible
-     */
-    overscanCount?: number;
-    /**
-     * Default height for items
-     */
-    itemHeight?: number;
-    /**
-     * Whether items can have varying heights
-     * When false (default), all items use the same height for better performance
-     * When true, each item's height is measured individually
-     */
-    dynamicItemSize?: boolean;
-    /**
-     * Whether to measure initial items
-     */
-    measureItemsInitially?: boolean;
-    /**
-     * Number of items per page
-     */
-    pageSize?: number;
-    /**
-     * Threshold for loading more (0.0-1.0)
-     */
-    loadThreshold?: number;
-    /**
-     * Throttle time for scroll events (ms)
-     */
-    throttleMs?: number;
-    /**
-     * Whether to deduplicate items by ID
-     */
-    dedupeItems?: boolean;
-    /**
-     * Scroll detection strategy
-     */
-    scrollStrategy?: ScrollStrategy;
-    /**
-     * Legacy support for static items
-     */
-    items?: any[];
-    /**
-     * Collection name
-     */
-    collection?: string;
-    /**
-     * Pagination configuration
-     */
-    pagination?: {
-        /**
-         * Pagination strategy to use ('cursor', 'page', or 'offset')
-         * @default 'cursor'
-         */
-        strategy?: 'cursor' | 'page' | 'offset';
-        /**
-         * Parameter name for page size (for page-based pagination)
-         * @default 'per_page'
-         */
-        perPageParamName?: string;
-        /**
-         * Parameter name for limit (for cursor/offset pagination)
-         * @default 'limit'
-         */
-        limitParamName?: string;
-    };
-}
-/**
- * Scroll tracking strategies
- */
-export type ScrollStrategy = 'scroll' | 'intersection' | 'hybrid';
-/**
- * List manager interface
- */
-export interface ListManager {
-    /**
-     * Loads items from API or static data
-     */
-    loadItems: (params?: any) => Promise<{
-        items: any[];
-        meta: PaginationMeta;
-    }>;
-    /**
-     * Loads more items (next page)
-     */
-    loadMore: () => Promise<{
-        hasNext: boolean;
-        items: any[];
-    }>;
-    /**
-     * Refreshes the list
-     */
-    refresh: () => Promise<void>;
-    /**
-     * Updates visible items based on scroll position
-     */
-    updateVisibleItems: (scrollTop?: number) => void;
-    /**
-     * Scrolls to a specific item by ID
-     */
-    scrollToItem: (itemId: string, position?: ScrollToPosition) => void;
-    /**
-     * Sets custom heights for items
-     */
-    setItemHeights: (heightsMap: Record<string, number>) => boolean;
-    /**
-     * Gets the underlying collection
-     */
-    getCollection: () => Collection<any>;
-    /**
-     * Gets currently visible items
-     */
-    getVisibleItems: () => any[];
-    /**
-     * Gets all items
-     */
-    getAllItems: () => any[];
-    /**
-     * Checks if list is loading
-     */
-    isLoading: () => boolean;
-    /**
-     * Checks if there are more items to load
-     */
-    hasNextPage: () => boolean;
-    /**
-     * Checks if list is in API mode
-     */
-    isApiMode: () => boolean;
-    /**
-     * Sets a hook function for rendering
-     */
-    setRenderHook?: (hookFn: (item: any, element: HTMLElement) => void) => void;
-    /**
-     * Destroys the list manager
-     */
-    destroy: () => void;
-}
-/**
- * Position for scrolling to an item
- */
-export type ScrollToPosition = 'start' | 'center' | 'end';
-/**
- * Pagination metadata
- */
-export interface PaginationMeta {
-    cursor: string | null;
-    hasNext: boolean;
-    total?: number;
-}
-/**
- * Load operation status
- */
-export interface LoadStatus {
-    loading: boolean;
-    hasNext: boolean;
-    hasPrev: boolean;
-    items: any[];
-    allItems: any[];
-}
-/**
- * List interface
- */
-export interface List {
-    component: HTMLElement;
-    items: any[];
-    setItems: (items: any[]) => void;
-}
-/**
- * Page loader configuration
- */
-export interface PageLoaderConfig {
-    onLoad?: (status: LoadStatus) => void;
-    pageSize?: number;
-}
-/**
- * Page loader interface
- */
-export interface PageLoader {
-    load: (cursor?: string | null, addToHistory?: boolean) => Promise<{
-        hasNext: boolean;
-        hasPrev: boolean;
-    }>;
-    loadNext: () => Promise<{
-        hasNext: boolean;
-        hasPrev: boolean;
-    }>;
-    loadPrev: () => Promise<{
-        hasNext: boolean;
-        hasPrev: boolean;
-    }>;
-    loading: boolean;
-    cursor: string | null;
-}
-/**
- * Item interface
- */
-export interface ListItem {
-    id: string;
-    headline: string;
-    supportingText: string;
-    meta: string;
-}
-/**
- * Internal list manager state
- */
-/**
- * Internal list manager state
- */
-export interface ListManagerState {
-    /**
-     * All items
-     */
-    items: any[];
-    /**
-     * Currently visible items
-     */
-    visibleItems: any[];
-    /**
-     * Visible range indices
-     */
-    visibleRange: {
-        start: number;
-        end: number;
-    };
-    /**
-     * Total height of all items
-     */
-    totalHeight: number;
-    /**
-     * Whether total height needs recalculation
-     */
-    totalHeightDirty: boolean;
-    /**
-     * Map of item heights (legacy - use itemMeasurement)
-     */
-    itemHeights: Map<string, number>;
-    /**
-     * Whether list is currently loading
-     */
-    loading: boolean;
-    /**
-     * Current pagination cursor
-     */
-    cursor: string | null;
-    /**
-     * Current page number (when using page-based pagination)
-     */
-    page?: number;
-    /**
-     * Pagination strategy being used
-     */
-    paginationStrategy?: string;
-    /**
-     * Whether there are more items to load
-     */
-    hasNext: boolean;
-    /**
-     * Map of item elements for DOM recycling
-     */
-    itemElements: Map<string, HTMLElement>;
-    /**
-     * Current scroll position
-     */
-    scrollTop: number;
-    /**
-     * Container height
-     */
-    containerHeight: number;
-    /**
-     * RequestAnimationFrame ID for scroll updates
-     */
-    scrollRAF: number | null;
-    /**
-     * RequestAnimationFrame ID for resize updates
-     */
-    resizeRAF: number | null;
-    /**
-     * Whether component is mounted
-     */
-    mounted: boolean;
-    /**
-     * Total item count (may differ from items.length)
-     */
-    itemCount: number;
-    /**
-     * Whether list is in static mode
-     */
-    useStatic: boolean;
-    /**
-     * Custom render hook function
-     */
-    renderHook: ((item: any, element: HTMLElement) => void) | null;
-}
-/**
- * DOM elements used by the list manager
- */
-export interface ListManagerElements {
-    /**
-     * Container element
-     */
-    container: HTMLElement;
-    /**
-     * Content container element
-     */
-    content: HTMLElement;
-    /**
-     * Spacer element for scroll height
-     */
-    spacer: HTMLElement;
-    /**
-     * Top sentinel for intersection detection
-     */
-    topSentinel?: HTMLElement | null;
-    /**
-     * Bottom sentinel for intersection detection
-     */
-    bottomSentinel?: HTMLElement | null;
-}
-/**
- * Visible range calculation result
- */
-export interface VisibleRange {
-    /**
-     * Start index
-     */
-    start: number;
-    /**
-     * End index
-     */
-    end: number;
-}

package/dist/core/collection/list-manager/utils/recycling.d.ts

@@ -1,34 +0,0 @@
-/**
- * Creates a recycling pool manager for better performance
- * Reduces DOM creation by reusing elements
- */
-export declare const createRecyclingPool: () => {
-    /**
-     * Gets a recycled element of the appropriate type if available
-     * @param item Item to get recycled element for
-     * @returns Recycled element or null if none available
-     */
-    getRecycledElement: (item: any) => HTMLElement | null;
-    /**
-     * Adds an element to the recycling pool
-     * @param element Element to recycle
-     * @param forceRecycle Whether to force recycling even for small elements
-     */
-    recycleElement: (element: HTMLElement, forceRecycle?: boolean) => void;
-    /**
-     * Get all recycled elements in a pool
-     * @param itemType Type of items to get
-     * @returns Array of recycled elements
-     */
-    getPool: (itemType: string) => HTMLElement[];
-    /**
-     * Clears all recycling pools
-     */
-    clear: () => void;
-    /**
-     * Gets the total number of recycled elements
-     * @returns Total count of recycled elements
-     */
-    getSize: () => number;
-};
-export type RecyclingPool = ReturnType<typeof createRecyclingPool>;

package/dist/core/collection/list-manager/utils/visibility.d.ts

@@ -1,45 +0,0 @@
-import { ItemMeasurement } from '../item-measurement';
-import { VisibleRange, ListManagerConfig } from '../types';
-/**
- * Optimized visible range calculation for fixed height items
- * Used as a fast path when all items have the same height
- *
- * @param scrollTop Current scroll position
- * @param itemHeight Fixed item height
- * @param containerHeight Container height
- * @param totalItems Total number of items
- * @param config List manager configuration
- * @returns Visible range with start and end indices
- */
-export declare function calculateVisibleRangeOptimized(scrollTop: number, itemHeight: number, containerHeight: number, totalItems: number, config: ListManagerConfig): VisibleRange;
-/**
- * Determines which items are visible within the viewport
- * @param scrollTop Current scroll position
- * @param items Array of items
- * @param containerHeight Container height
- * @param itemMeasurement Item measurement instance
- * @param config List manager configuration
- * @returns Visible range with start and end indices
- */
-export declare function calculateVisibleRange(scrollTop: number, items: any[], containerHeight: number, itemMeasurement: ItemMeasurement, config: ListManagerConfig): VisibleRange;
-/**
- * Calculate the position for each visible item
- * @param items All items
- * @param visibleRange Visible range with start and end indices
- * @param itemMeasurement Item measurement instance
- * @returns Array of positions with index, item, and offset
- */
-export declare function calculateItemPositions(items: any[], visibleRange: VisibleRange, itemMeasurement: ItemMeasurement): Array<{
-    index: number;
-    item: any;
-    offset: number;
-}>;
-/**
- * Checks if load threshold has been reached
- * @param scrollTop Current scroll top position
- * @param containerHeight Container height
- * @param totalHeight Total content height
- * @param loadThreshold Load threshold as fraction (0-1)
- * @returns Whether load threshold has been reached
- */
-export declare function isLoadThresholdReached(scrollTop: number, containerHeight: number, totalHeight: number, loadThreshold: number): boolean;

package/dist/core/compose/features/gestures/longpress.d.ts

@@ -1,85 +0,0 @@
-/**
- * @module core/compose/features/gestures
- * @description Adds long press gesture recognition to components
- */
-import { BaseComponent, ElementComponent } from "../../component";
-import { LongPressEvent, GestureHandler } from "../../../gestures";
-/**
- * Configuration for long press gesture feature
- */
-export interface LongPressGestureConfig {
-    /**
-     * Time (in ms) to recognize a long press
-     * @default 500
-     */
-    longPressTime?: number;
-    /**
-     * Distance threshold (in pixels) for movement that cancels long press
-     * @default 10
-     */
-    moveThreshold?: number;
-    /**
-     * Whether to prevent default behaviors on touch events
-     * @default true
-     */
-    preventDefault?: boolean;
-    /**
-     * Handler for long press gesture
-     */
-    onLongPress?: GestureHandler;
-    /**
-     * Whether to enable long press recognition immediately
-     * @default true
-     */
-    enabled?: boolean;
-    [key: string]: any;
-}
-/**
- * Component with long press gesture recognition capabilities
- */
-export interface LongPressGestureComponent extends BaseComponent {
-    /**
-     * Add a long press event handler
-     * @param handler - Event handler function
-     * @returns Component for chaining
-     */
-    onLongPress: (handler: (event: LongPressEvent) => void) => LongPressGestureComponent;
-    /**
-     * Remove a long press event handler
-     * @param handler - Event handler function
-     * @returns Component for chaining
-     */
-    offLongPress: (handler: (event: LongPressEvent) => void) => LongPressGestureComponent;
-    /**
-     * Enable long press recognition
-     * @returns Component for chaining
-     */
-    enableLongPress: () => LongPressGestureComponent;
-    /**
-     * Disable long press recognition
-     * @returns Component for chaining
-     */
-    disableLongPress: () => LongPressGestureComponent;
-}
-/**
- * Adds long press gesture recognition to a component.
- * This is a lightweight alternative to the full gesture system,
- * focused only on long press detection.
- *
- * @param config - Configuration object containing long press settings
- * @returns Function that enhances a component with long press capabilities
- *
- * @example
- * ```ts
- * // Add long press gesture recognition to a component
- * const component = pipe(
- *   createBase,
- *   withElement(...),
- *   withLongPressGesture({
- *     longPressTime: 800,
- *     onLongPress: (e) => showContextMenu(e.x, e.y)
- *   })
- * )(config);
- * ```
- */
-export declare const withLongPressGesture: (config?: LongPressGestureConfig) => <C extends ElementComponent>(component: C) => C & LongPressGestureComponent;