mtrl 0.3.8 → 0.4.0

package/src/core/collection/adapters/route.ts

@@ -1,201 +0,0 @@
-// src/core/collection/adapters/route.js
-
-import { OPERATORS, createBaseAdapter } from './base'
-
-const QUERY_PARAMS = {
-  [OPERATORS.EQ]: 'eq',
-  [OPERATORS.NE]: 'ne',
-  [OPERATORS.GT]: 'gt',
-  [OPERATORS.GTE]: 'gte',
-  [OPERATORS.LT]: 'lt',
-  [OPERATORS.LTE]: 'lte',
-  [OPERATORS.IN]: 'in',
-  [OPERATORS.NIN]: 'nin',
-  [OPERATORS.CONTAINS]: 'contains',
-  [OPERATORS.STARTS_WITH]: 'startsWith',
-  [OPERATORS.ENDS_WITH]: 'endsWith'
-}
-
-export const createRouteAdapter = (config = {}) => {
-  const base = createBaseAdapter(config)
-  let controller = null
-  const cache = new Map()
-
-  const buildUrl = (endpoint, params = {}) => {
-    const url = new URL(config.base + endpoint)
-    Object.entries(params).forEach(([key, value]) => {
-      if (Array.isArray(value)) {
-        value.forEach(v => url.searchParams.append(key, v))
-      } else if (value !== null && value !== undefined) {
-        url.searchParams.append(key, value)
-      }
-    })
-    return url.toString()
-  }
-
-  const transformQuery = (query) => {
-    const params = {}
-    Object.entries(query).forEach(([field, conditions]) => {
-      if (typeof conditions === 'object') {
-        Object.entries(conditions).forEach(([op, value]) => {
-          const paramKey = QUERY_PARAMS[op]
-          if (paramKey) {
-            params[`${field}_${paramKey}`] = value
-          }
-        })
-      } else {
-        params[field] = conditions
-      }
-    })
-    return params
-  }
-
-  const request = async (url, options = {}) => {
-    if (controller) {
-      controller.abort()
-    }
-    controller = new AbortController()
-
-    try {
-      const response = await fetch(url, {
-        ...options,
-        headers: {
-          'Content-Type': 'application/json',
-          ...config.headers,
-          ...options.headers
-        },
-        signal: controller.signal
-      })
-
-      if (!response.ok) {
-        const error = await response.json()
-        return base.handleError(new Error(error.message || 'API request failed'))
-      }
-
-      return await response.json()
-    } catch (error) {
-      if (error.name === 'AbortError') return null
-      return base.handleError(error)
-    } finally {
-      controller = null
-    }
-  }
-
-  const getCache = (key) => {
-    if (!config.cache) return null
-
-    const cached = cache.get(key)
-    if (!cached) return null
-
-    const { data, timestamp } = cached
-    const now = Date.now()
-
-    if (now - timestamp > 5 * 60 * 1000) {
-      cache.delete(key)
-      return null
-    }
-
-    return data
-  }
-
-  const setCache = (key, data) => {
-    if (!config.cache) return
-    cache.set(key, { data, timestamp: Date.now() })
-  }
-
-  return {
-    ...base,
-
-    create: async (items) => {
-      const url = buildUrl(config.endpoints.create)
-      const response = await request(url, {
-        method: 'POST',
-        body: JSON.stringify({ items })
-      })
-      return response.items
-    },
-
-    read: async (query = {}, options = {}) => {
-      const {
-        page = 1,
-        limit = 20,
-        sort,
-        fields
-      } = options
-
-      const params = {
-        ...transformQuery(query),
-        page,
-        limit,
-        sort,
-        fields
-      }
-
-      const url = buildUrl(config.endpoints.list, params)
-      const cacheKey = url.toString()
-
-      const cached = getCache(cacheKey)
-      if (cached) return cached
-
-      const response = await request(url)
-      setCache(cacheKey, response.items)
-
-      return response.items
-    },
-
-    update: async (items) => {
-      const url = buildUrl(config.endpoints.update)
-      const response = await request(url, {
-        method: 'PUT',
-        body: JSON.stringify({ items })
-      })
-      return response.items
-    },
-
-    delete: async (ids) => {
-      const url = buildUrl(config.endpoints.delete)
-      const response = await request(url, {
-        method: 'DELETE',
-        body: JSON.stringify({ ids })
-      })
-      return response.ids
-    },
-
-    query: async (query = {}, options = {}) => {
-      const {
-        page = 1,
-        limit = 20,
-        sort,
-        fields,
-        ...rest
-      } = options
-
-      const params = {
-        ...transformQuery(query),
-        ...rest,
-        page,
-        limit,
-        sort,
-        fields
-      }
-
-      const url = buildUrl(config.endpoints.list, params)
-      const response = await request(url)
-
-      return {
-        items: response.items,
-        total: response.total,
-        page: response.page,
-        pages: response.pages
-      }
-    },
-
-    disconnect: () => {
-      if (controller) {
-        controller.abort()
-        controller = null
-      }
-      cache.clear()
-    }
-  }
-}

package/src/core/collection/collection.ts

@@ -1,300 +0,0 @@
-// src/core/collection/collection.ts
-
-/**
- * Event types for collection changes
- */
-export const COLLECTION_EVENTS = {
-  CHANGE: 'change',
-  ADD: 'add',
-  UPDATE: 'update',
-  REMOVE: 'remove',
-  ERROR: 'error',
-  LOADING: 'loading'
-} as const;
-
-/**
- * Collection event type
- */
-export type CollectionEvent = keyof typeof COLLECTION_EVENTS;
-
-/**
- * Observer callback type for collection events
- */
-export type CollectionObserver<T> = (payload: { event: CollectionEvent; data: any }) => void;
-
-/**
- * Query operators for filtering
- */
-export const OPERATORS = {
-  EQ: 'eq',
-  NE: 'ne',
-  GT: 'gt',
-  GTE: 'gte',
-  LT: 'lt',
-  LTE: 'lte',
-  IN: 'in',
-  NIN: 'nin',
-  CONTAINS: 'contains',
-  STARTS_WITH: 'startsWith',
-  ENDS_WITH: 'endsWith'
-} as const;
-
-/**
- * Type for all collection items
- */
-export interface CollectionItem {
-  id: string;
-  [key: string]: any;
-}
-
-/**
- * Collection configuration
- */
-export interface CollectionConfig<T extends CollectionItem> {
-  /**
-   * Transform function for items
-   */
-  transform?: (item: any) => T;
-  
-  /**
-   * Validation function for items
-   */
-  validate?: (item: any) => boolean;
-}
-
-/**
- * Base Collection class providing data management interface
- * @template T - Type of items in collection
- */
-export class Collection<T extends CollectionItem> {
-  #items = new Map<string, T>();
-  #observers = new Set<CollectionObserver<T>>();
-  #query: ((item: T) => boolean) | null = null;
-  #sort: ((a: T, b: T) => number) | null = null;
-  #loading = false;
-  #error: Error | null = null;
-
-  /**
-   * Transform function for items
-   */
-  transform: (item: any) => T;
-  
-  /**
-   * Validation function for items
-   */
-  validate: (item: any) => boolean;
-
-  /**
-   * Creates a new collection instance
-   * @param config - Collection configuration
-   */
-  constructor(config: CollectionConfig<T> = {}) {
-    this.transform = config.transform || ((item: any) => item as T);
-    this.validate = config.validate || (() => true);
-  }
-
-  /**
-   * Subscribe to collection changes
-   * @param observer - Observer callback
-   * @returns Unsubscribe function
-   */
-  subscribe(observer: CollectionObserver<T>): () => void {
-    this.#observers.add(observer);
-    return () => this.#observers.delete(observer);
-  }
-
-  /**
-   * Notify observers of collection changes
-   * @param event - Event type
-   * @param data - Event data
-   */
-  #notify(event: CollectionEvent, data: any): void {
-    this.#observers.forEach(observer => observer({ event, data }));
-  }
-
-  /**
-   * Set loading state
-   * @param loading - Loading state
-   */
-  #setLoading(loading: boolean): void {
-    this.#loading = loading;
-    this.#notify(COLLECTION_EVENTS.LOADING, loading);
-  }
-
-  /**
-   * Set error state
-   * @param error - Error object
-   */
-  #setError(error: Error): void {
-    this.#error = error;
-    this.#notify(COLLECTION_EVENTS.ERROR, error);
-  }
-
-  /**
-   * Get collection items based on current query and sort
-   * @returns Collection items
-   */
-  get items(): T[] {
-    let result = Array.from(this.#items.values());
-
-    if (this.#query) {
-      result = result.filter(this.#query);
-    }
-
-    if (this.#sort) {
-      result.sort(this.#sort);
-    }
-
-    return result;
-  }
-
-  /**
-   * Get collection size
-   * @returns Number of items
-   */
-  get size(): number {
-    return this.#items.size;
-  }
-
-  /**
-   * Get loading state
-   * @returns Loading state
-   */
-  get loading(): boolean {
-    return this.#loading;
-  }
-
-  /**
-   * Get error state
-   * @returns Error object
-   */
-  get error(): Error | null {
-    return this.#error;
-  }
-
-  /**
-   * Set query filter
-   * @param queryFn - Query function
-   */
-  query(queryFn: (item: T) => boolean): void {
-    this.#query = queryFn;
-    this.#notify(COLLECTION_EVENTS.CHANGE, this.items);
-  }
-
-  /**
-   * Set sort function
-   * @param sortFn - Sort function
-   */
-  sort(sortFn: (a: T, b: T) => number): void {
-    this.#sort = sortFn;
-    this.#notify(COLLECTION_EVENTS.CHANGE, this.items);
-  }
-
-  /**
-   * Add items to collection
-   * @param items - Items to add
-   * @returns Added items
-   */
-  async add(items: T | T[]): Promise<T[]> {
-    try {
-      this.#setLoading(true);
-      const toAdd = Array.isArray(items) ? items : [items];
-
-      const validated = toAdd.filter(this.validate);
-      const transformed = validated.map(this.transform);
-
-      transformed.forEach(item => {
-        if (!item.id) {
-          throw new Error('Items must have an id property');
-        }
-        this.#items.set(item.id, item);
-      });
-
-      this.#notify(COLLECTION_EVENTS.ADD, transformed);
-      this.#notify(COLLECTION_EVENTS.CHANGE, this.items);
-
-      return transformed;
-    } catch (error) {
-      this.#setError(error as Error);
-      throw error;
-    } finally {
-      this.#setLoading(false);
-    }
-  }
-
-  /**
-   * Update items in collection
-   * @param items - Items to update
-   * @returns Updated items
-   */
-  async update(items: T | T[]): Promise<T[]> {
-    try {
-      this.#setLoading(true);
-      const toUpdate = Array.isArray(items) ? items : [items];
-
-      const updated = toUpdate.map(item => {
-        if (!this.#items.has(item.id)) {
-          throw new Error(`Item with id ${item.id} not found`);
-        }
-
-        const validated = this.validate(item);
-        if (!validated) {
-          throw new Error(`Invalid item: ${item.id}`);
-        }
-
-        const transformed = this.transform(item);
-        this.#items.set(item.id, transformed);
-        return transformed;
-      });
-
-      this.#notify(COLLECTION_EVENTS.UPDATE, updated);
-      this.#notify(COLLECTION_EVENTS.CHANGE, this.items);
-
-      return updated;
-    } catch (error) {
-      this.#setError(error as Error);
-      throw error;
-    } finally {
-      this.#setLoading(false);
-    }
-  }
-
-  /**
-   * Remove items from collection
-   * @param ids - Item IDs to remove
-   * @returns Removed item IDs
-   */
-  async remove(ids: string | string[]): Promise<string[]> {
-    try {
-      this.#setLoading(true);
-      const toRemove = Array.isArray(ids) ? ids : [ids];
-
-      toRemove.forEach(id => {
-        if (!this.#items.has(id)) {
-          throw new Error(`Item with id ${id} not found`);
-        }
-        this.#items.delete(id);
-      });
-
-      this.#notify(COLLECTION_EVENTS.REMOVE, toRemove);
-      this.#notify(COLLECTION_EVENTS.CHANGE, this.items);
-
-      return toRemove;
-    } catch (error) {
-      this.#setError(error as Error);
-      throw error;
-    } finally {
-      this.#setLoading(false);
-    }
-  }
-
-  /**
-   * Clear all items from collection
-   */
-  clear(): void {
-    this.#items.clear();
-    this.#query = null;
-    this.#sort = null;
-    this.#notify(COLLECTION_EVENTS.CHANGE, this.items);
-  }
-}

package/src/core/collection/index.ts

@@ -1,57 +0,0 @@
-// src/core/collection/index.ts
-
-// Export collection class and types
-export { 
-  Collection, 
-  COLLECTION_EVENTS, 
-  OPERATORS as COLLECTION_OPERATORS 
-} from './collection';
-
-export type { 
-  CollectionItem, 
-  CollectionConfig, 
-  CollectionEvent, 
-  CollectionObserver 
-} from './collection';
-
-// Export list manager
-export { 
-  createListManager, 
-  transforms 
-} from './list-manager';
-
-export type { 
-  ListManager,
-  ListManagerConfig,
-  ListItem,
-  List,
-  PageLoader,
-  PageLoaderConfig,
-  LoadStatus,
-  PaginationMeta
-} from './list-manager';
-
-// Export adapters
-export { 
-  createBaseAdapter, 
-  OPERATORS 
-} from './adapters/base';
-
-export type { 
-  BaseAdapter, 
-  BaseAdapterConfig,
-  Operator
-} from './adapters/base';
-
-export { 
-  createRouteAdapter 
-} from './adapters/route';
-
-export type { 
-  RouteAdapter,
-  RouteAdapterConfig,
-  RouteEndpoints,
-  QueryDefinition,
-  QueryCondition,
-  RequestOptions
-} from './adapters/route';