mtrl-addons 0.1.1 → 0.2.1

package/src/core/collection/features/api/loading.ts

@@ -1,279 +0,0 @@
-/**
- * API Loading Plugin
- *
- * Handles data loading from adapters (loadPage, loadMore, refresh)
- */
-
-import type {
-  CollectionItem,
-  CollectionAdapter,
-  BaseCollection,
-  AdapterResponse,
-} from "../../types";
-import { CollectionDataEvents } from "../../types";
-import { DATA_LOGGING, COLLECTION_DEFAULTS } from "../../constants";
-import { createEventPayload, CollectionEvents } from "../../events";
-
-export interface LoadingConfig {
-  pageSize?: number;
-  sequential?: boolean; // Whether to load pages sequentially or allow random access
-}
-
-export interface LoadingFeatures<T extends CollectionItem> {
-  loadPage(page: number): Promise<AdapterResponse<T>>;
-  loadMore(): Promise<AdapterResponse<T>>;
-  refresh(): Promise<AdapterResponse<T>>;
-  getCurrentPage(): number;
-  hasNext(): boolean;
-}
-
-/**
- * API Loading Plugin (Pure Data Feature)
- */
-export const withLoading =
-  <T extends CollectionItem = CollectionItem>(config: LoadingConfig = {}) =>
-  (
-    baseCollection: BaseCollection<T>
-  ): BaseCollection<T> & LoadingFeatures<T> => {
-    // Get adapter from config
-    const adapter = baseCollection._config.adapter;
-    if (!adapter) {
-      console.warn(
-        `${DATA_LOGGING.PREFIX} No adapter configured for loading plugin`
-      );
-    }
-
-    // Plugin state
-    let currentPage = COLLECTION_DEFAULTS.CURRENT_PAGE;
-    let pageSize =
-      config.pageSize ||
-      baseCollection._config.pageSize ||
-      COLLECTION_DEFAULTS.PAGE_SIZE;
-    let hasMore = true;
-    let isLoadingMore = false;
-    let totalItemsExpected = 0;
-
-    /**
-     * Apply data transformations if configured
-     */
-    const applyDataTransformations = (items: any[]): T[] => {
-      let processedItems = [...items];
-
-      // Apply normalization if configured
-      if (baseCollection._config.normalize) {
-        processedItems = baseCollection._config.normalize(processedItems);
-      }
-
-      // Apply transformation if configured
-      if (baseCollection._config.transform) {
-        processedItems = processedItems.map(baseCollection._config.transform);
-      }
-
-      // Apply validation if configured
-      if (baseCollection._config.validate) {
-        processedItems = processedItems.filter(baseCollection._config.validate);
-      }
-
-      return processedItems;
-    };
-
-    /**
-     * Determine if there's more data to load
-     */
-    const determineHasMore = (
-      response: AdapterResponse<T>,
-      itemsLength: number
-    ): boolean => {
-      const apiHasNext = response.meta?.hasNext;
-      const gotFullPage = itemsLength === pageSize;
-      const apiTotal = response.meta?.total;
-
-      console.log(
-        `${DATA_LOGGING.PREFIX} LOADING-PLUGIN determineHasMore debug:`,
-        {
-          apiTotal,
-          apiHasNext,
-          gotFullPage,
-          itemsLength,
-          pageSize,
-          totalItemsExpected,
-          currentItemsLength: baseCollection.getState().items.length,
-        }
-      );
-
-      if (apiTotal !== undefined) {
-        const result = totalItemsExpected < apiTotal;
-        console.log(
-          `${DATA_LOGGING.PREFIX} LOADING-PLUGIN Using apiTotal logic: ${totalItemsExpected} < ${apiTotal} = ${result}`
-        );
-        return result;
-      } else if (apiHasNext !== undefined) {
-        console.log(
-          `${DATA_LOGGING.PREFIX} LOADING-PLUGIN Using apiHasNext logic: ${apiHasNext}`
-        );
-        return apiHasNext;
-      } else {
-        console.log(
-          `${DATA_LOGGING.PREFIX} LOADING-PLUGIN Using gotFullPage logic: ${gotFullPage}`
-        );
-        return gotFullPage;
-      }
-    };
-
-    /**
-     * Load a specific page of data
-     */
-    const loadPage = async (page: number): Promise<AdapterResponse<T>> => {
-      if (!adapter) {
-        throw new Error("No adapter configured");
-      }
-
-      // Calculate what data range this page represents
-      const startIndex = (page - 1) * pageSize;
-      const endIndex = startIndex + pageSize - 1;
-
-      const currentState = baseCollection.getState();
-      const currentItems = currentState.items;
-
-      // Check if we already have this data
-      const hasData = currentItems.length > endIndex;
-
-      if (hasData) {
-        console.log(
-          `${DATA_LOGGING.PREFIX} Data already loaded for page ${page} (items ${startIndex}-${endIndex})`
-        );
-
-        // Return the subset we already have
-        const pageItems = currentItems.slice(startIndex, startIndex + pageSize);
-
-        currentPage = page;
-
-        // Emit items loaded event
-        baseCollection.emit(CollectionDataEvents.ITEMS_LOADED, {
-          items: pageItems,
-          meta: { page, total: totalItemsExpected },
-        });
-
-        return {
-          items: pageItems,
-          meta: {
-            total: totalItemsExpected,
-            page: page,
-            hasNext: hasMore,
-            hasPrev: page > 1,
-          },
-        };
-      }
-
-      console.log(`${DATA_LOGGING.PREFIX} Loading page ${page} from adapter`);
-
-      try {
-        baseCollection.emit(
-          CollectionDataEvents.LOADING_START,
-          createEventPayload.loadingStart(`Loading page ${page}`)
-        );
-
-        baseCollection.setState({ loading: true });
-
-        const response = await adapter.read({
-          page,
-          pageSize,
-        });
-
-        if (response.error) {
-          throw new Error(response.error.message);
-        }
-
-        const processedItems = applyDataTransformations(response.items);
-
-        // Add to existing items (append if sequential)
-        let updatedItems: T[];
-        if (startIndex === currentItems.length) {
-          // Sequential loading - just append
-          updatedItems = [...currentItems, ...processedItems];
-        } else {
-          // Non-sequential - for now just append (could be more sophisticated)
-          updatedItems = [...currentItems, ...processedItems];
-        }
-
-        totalItemsExpected = response.meta?.total || updatedItems.length;
-
-        baseCollection.setState({
-          items: updatedItems,
-          totalCount: totalItemsExpected,
-          loading: false,
-          error: null,
-        });
-
-        currentPage = page;
-        hasMore = determineHasMore(response, processedItems.length);
-
-        baseCollection.emit(
-          CollectionDataEvents.ITEMS_LOADED,
-          createEventPayload.itemsLoaded(processedItems, response.meta)
-        );
-
-        return response;
-      } catch (error) {
-        const errorObj = error as Error;
-        baseCollection.setState({
-          loading: false,
-          error: errorObj,
-        });
-
-        baseCollection.emit(
-          CollectionDataEvents.ERROR_OCCURRED,
-          createEventPayload.errorOccurred(errorObj, { page })
-        );
-
-        throw error;
-      }
-    };
-
-    /**
-     * Load more items (next page)
-     */
-    const loadMore = async (): Promise<AdapterResponse<T>> => {
-      if (!adapter || isLoadingMore) {
-        throw new Error("No adapter configured or already loading");
-      }
-
-      isLoadingMore = true;
-      const nextPage = currentPage + 1;
-
-      try {
-        const response = await loadPage(nextPage);
-        return response;
-      } finally {
-        isLoadingMore = false;
-      }
-    };
-
-    /**
-     * Refresh all data (start from beginning)
-     */
-    const refresh = async (): Promise<AdapterResponse<T>> => {
-      // Reset state
-      currentPage = 0;
-      hasMore = true;
-      totalItemsExpected = 0;
-
-      baseCollection.setState({
-        items: [],
-        filteredItems: [],
-        totalCount: 0,
-      });
-
-      return loadMore();
-    };
-
-    console.log(`${DATA_LOGGING.PREFIX} Loading plugin installed`);
-
-    return Object.assign(baseCollection, {
-      loadPage,
-      loadMore,
-      refresh,
-      getCurrentPage: () => currentPage,
-      hasNext: () => hasMore,
-    });
-  };

package/src/core/collection/features/operations/data-operations.ts

@@ -1,147 +0,0 @@
-/**
- * Data Operations Plugin
- *
- * Handles CRUD operations on collection items (add, update, remove, clear)
- */
-
-import type { CollectionItem, BaseCollection } from "../../types";
-import { CollectionDataEvents } from "../../types";
-import { DATA_LOGGING } from "../../constants";
-
-export interface DataOperationsFeatures<T extends CollectionItem> {
-  addItems(items: T[]): Promise<T[]>;
-  updateItems(items: Partial<T>[]): Promise<T[]>;
-  removeItems(ids: string[]): Promise<void>;
-  clearItems(): Promise<void>;
-}
-
-/**
- * Data Operations Plugin
- */
-export const withDataOperations =
-  <T extends CollectionItem = CollectionItem>() =>
-  (
-    baseCollection: BaseCollection<T>
-  ): BaseCollection<T> & DataOperationsFeatures<T> => {
-    /**
-     * Apply data transformations if configured
-     */
-    const applyDataTransformations = (items: any[]): T[] => {
-      let processedItems = [...items];
-
-      // Apply normalization if configured
-      if (baseCollection._config.normalize) {
-        processedItems = baseCollection._config.normalize(processedItems);
-      }
-
-      // Apply transformation if configured
-      if (baseCollection._config.transform) {
-        processedItems = processedItems.map(baseCollection._config.transform);
-      }
-
-      // Apply validation if configured
-      if (baseCollection._config.validate) {
-        processedItems = processedItems.filter(baseCollection._config.validate);
-      }
-
-      return processedItems;
-    };
-
-    /**
-     * Add items to the collection
-     */
-    const addItems = async (items: T[]): Promise<T[]> => {
-      const processedItems = applyDataTransformations(items);
-      const currentState = baseCollection.getState();
-
-      // Add to existing items
-      const newItems = [...currentState.items, ...processedItems];
-
-      baseCollection.setState({
-        items: newItems,
-        totalCount: newItems.length,
-      });
-
-      // Emit data event
-      baseCollection.emit(CollectionDataEvents.ITEMS_ADDED, {
-        items: processedItems,
-        indices: [currentState.items.length],
-      });
-
-      return processedItems;
-    };
-
-    /**
-     * Update existing items in the collection
-     */
-    const updateItems = async (items: Partial<T>[]): Promise<T[]> => {
-      const currentState = baseCollection.getState();
-      const updatedItems: T[] = [];
-
-      // Update existing items
-      const newItems = currentState.items.map((item: T) => {
-        const update = items.find((u) => u.id === item.id);
-        if (update) {
-          const updatedItem = { ...item, ...update };
-          updatedItems.push(updatedItem);
-          return updatedItem;
-        }
-        return item;
-      });
-
-      baseCollection.setState({ items: newItems });
-
-      // Emit data event
-      baseCollection.emit(CollectionDataEvents.ITEMS_UPDATED, {
-        items: updatedItems,
-        indices: [],
-      });
-
-      return updatedItems;
-    };
-
-    /**
-     * Remove items from the collection
-     */
-    const removeItems = async (ids: string[]): Promise<void> => {
-      const currentState = baseCollection.getState();
-
-      // Remove items by ID
-      const newItems = currentState.items.filter(
-        (item: T) => !ids.includes(item.id)
-      );
-
-      baseCollection.setState({
-        items: newItems,
-        totalCount: newItems.length,
-      });
-
-      // Emit data event
-      baseCollection.emit(CollectionDataEvents.ITEMS_REMOVED, {
-        ids,
-      });
-    };
-
-    /**
-     * Clear all items from the collection
-     */
-    const clearItems = async (): Promise<void> => {
-      baseCollection.setState({
-        items: [],
-        filteredItems: [],
-        totalCount: 0,
-      });
-
-      // Emit data event
-      baseCollection.emit(CollectionDataEvents.ITEMS_CLEARED, {});
-    };
-
-    console.log(`${DATA_LOGGING.PREFIX} Data Operations plugin installed`);
-
-    return Object.assign(baseCollection, {
-      addItems,
-      updateItems,
-      removeItems,
-      clearItems,
-    });
-  };

package/src/core/collection/index.ts

@@ -1,104 +0,0 @@
-/**
- * Collection System - Composition-Based Architecture
- *
- * Following the blueprint with functional composition and plugin system
- */
-
-import type { CollectionItem } from "./types";
-
-// New composition-based architecture exports
-export { createCollection, createDataCollection } from "./collection-composer";
-export { createBaseCollection } from "./base-collection";
-
-// Plugin exports
-export { withLoading } from "./features/api/loading";
-export { withDataOperations } from "./features/operations/data-operations";
-
-// Core types
-export type {
-  Collection,
-  BaseCollection,
-  CollectionConfig,
-  CollectionItem,
-  CollectionAdapter,
-  AdapterParams,
-  AdapterResponse,
-} from "./types";
-
-// Events and state
-export { CollectionDataEvents } from "./types";
-export { CollectionEvents, createEventPayload } from "./events";
-export { createCollectionState } from "./state";
-
-// Constants
-export * from "./constants";
-
-/**
- * Quick start utility for creating a simple REST adapter
- */
-export function createRestAdapter<T extends CollectionItem>(
-  baseUrl: string,
-  options: {
-    headers?: Record<string, string>;
-    timeout?: number;
-    transform?: (response: any) => { items: T[]; meta?: any };
-  } = {}
-) {
-  return {
-    async read(params: any = {}) {
-      const url = new URL(baseUrl);
-
-      // Add query parameters
-      if (params.page) url.searchParams.set("page", params.page.toString());
-      if (params.pageSize)
-        url.searchParams.set("limit", params.pageSize.toString());
-      if (params.search) url.searchParams.set("q", params.search);
-      if (params.cursor) url.searchParams.set("cursor", params.cursor);
-
-      try {
-        const response = await fetch(url.toString(), {
-          method: "GET",
-          headers: {
-            "Content-Type": "application/json",
-            ...options.headers,
-          },
-          signal: options.timeout
-            ? AbortSignal.timeout(options.timeout)
-            : undefined,
-        });
-
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-
-        const data = await response.json();
-
-        // Apply custom transform if provided
-        if (options.transform) {
-          return options.transform(data);
-        }
-
-        // Default transform
-        return {
-          items: data.items || data.data || [data].flat(),
-          meta: {
-            total: data.total,
-            page: data.page,
-            hasNext: data.hasNext || data.has_next,
-            hasPrev: data.hasPrev || data.has_prev,
-          },
-        };
-      } catch (error) {
-        return {
-          items: [],
-          error: {
-            message: error instanceof Error ? error.message : "Unknown error",
-            code: "FETCH_ERROR",
-          },
-        };
-      }
-    },
-  };
-}
-
-// Collection architecture is now complete!