mtrl 0.3.6 → 0.3.8

package/src/components/textfield/types.ts

@@ -97,6 +97,12 @@ export interface TextfieldConfig {
   /** Whether supporting text indicates an error */
   error?: boolean;
   
+  /** Prefix text to display before the input */
+  prefixText?: string;
+  
+  /** Suffix text to display after the input */
+  suffixText?: string;
+  
   /** Additional CSS classes */
   class?: string;
   
@@ -138,6 +144,54 @@ export interface TextfieldComponent {
   /** Gets the textfield's label text */
   getLabel: () => string;
   
+  /** Leading icon element (if present) */
+  leadingIcon: HTMLElement | null;
+  
+  /** Sets the leading icon HTML content */
+  setLeadingIcon: (html: string) => TextfieldComponent;
+  
+  /** Removes the leading icon */
+  removeLeadingIcon: () => TextfieldComponent;
+  
+  /** Trailing icon element (if present) */
+  trailingIcon: HTMLElement | null;
+  
+  /** Sets the trailing icon HTML content */
+  setTrailingIcon: (html: string) => TextfieldComponent;
+  
+  /** Removes the trailing icon */
+  removeTrailingIcon: () => TextfieldComponent;
+  
+  /** Supporting text element (if present) */
+  supportingTextElement: HTMLElement | null;
+  
+  /** Sets the supporting text content */
+  setSupportingText: (text: string, isError?: boolean) => TextfieldComponent;
+  
+  /** Removes the supporting text */
+  removeSupportingText: () => TextfieldComponent;
+  
+  /** Prefix text element (if present) */
+  prefixTextElement: HTMLElement | null;
+  
+  /** Sets the prefix text content */
+  setPrefixText: (text: string) => TextfieldComponent;
+  
+  /** Removes the prefix text */
+  removePrefixText: () => TextfieldComponent;
+  
+  /** Suffix text element (if present) */
+  suffixTextElement: HTMLElement | null;
+  
+  /** Sets the suffix text content */
+  setSuffixText: (text: string) => TextfieldComponent;
+  
+  /** Removes the suffix text */
+  removeSuffixText: () => TextfieldComponent;
+  
+  /** Manually update element positions (useful after DOM changes) */
+  updatePositions: () => TextfieldComponent;
+  
   /** Adds event listener */
   on: (event: string, handler: Function) => TextfieldComponent;
   
@@ -182,6 +236,22 @@ export interface BaseComponent {
     setText: (content: string) => any;
     getText: () => string;
   };
+  leadingIcon?: HTMLElement | null;
+  setLeadingIcon?: (html: string) => any;
+  removeLeadingIcon?: () => any;
+  trailingIcon?: HTMLElement | null;
+  setTrailingIcon?: (html: string) => any;
+  removeTrailingIcon?: () => any;
+  supportingTextElement?: HTMLElement | null;
+  setSupportingText?: (text: string, isError?: boolean) => any;
+  removeSupportingText?: () => any;
+  prefixTextElement?: HTMLElement | null;
+  setPrefixText?: (text: string) => any;
+  removePrefixText?: () => any;
+  suffixTextElement?: HTMLElement | null;
+  setSuffixText?: (text: string) => any;
+  removeSuffixText?: () => any;
+  updateElementPositions?: () => any;
   on?: (event: string, handler: Function) => any;
   off?: (event: string, handler: Function) => any;
   disabled?: {

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

@@ -0,0 +1,62 @@
+// src/core/collection/adapters/base.ts
+
+/**
+ * Query operators for filtering data
+ */
+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 query operators
+ */
+export type Operator = keyof typeof OPERATORS;
+
+/**
+ * Configuration for base adapter
+ */
+export interface BaseAdapterConfig {
+  /**
+   * Error handler function
+   */
+  onError?: (error: Error, context?: any) => void;
+}
+
+/**
+ * Base adapter interface
+ */
+export interface BaseAdapter {
+  /**
+   * Handles errors in adapter operations
+   * @param error - The error that occurred
+   * @param context - Optional context information about the error
+   * @throws The original error after processing
+   */
+  handleError(error: Error, context?: any): never;
+}
+
+/**
+ * Creates a base adapter with error handling
+ * @param config - Adapter configuration
+ * @returns Base adapter with error handling
+ */
+export const createBaseAdapter = (config: BaseAdapterConfig = {}): BaseAdapter => {
+  const handleError = (error: Error, context?: any): never => {
+    config.onError?.(error, context);
+    throw error;
+  };
+
+  return {
+    handleError
+  };
+};

package/src/core/collection/collection.ts

@@ -0,0 +1,300 @@
+// 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

@@ -0,0 +1,57 @@
+// 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';