advanced-filter-system 1.5.1 → 1.5.2

package/package.json

@@ -1,14 +1,17 @@
 {
     "name": "advanced-filter-system",
-    "version": "1.5.1",
+    "version": "1.5.2",
     "description": "Advanced filtering system for DOM elements with multiple features",
     "main": "dist/afs.legacy.js",
     "module": "dist/afs.modern.js",
     "browser": "dist/afs.legacy.min.js",
     "private": false,
     "type": "module",
+    "types": "./src/types/index.d.ts",
+    "typings": "./src/types/index.d.ts",
     "exports": {
         ".": {
+            "types": "./src/types/index.d.ts",
             "import": "./dist/afs.modern.js",
             "require": "./dist/afs.legacy.js",
             "browser": "./dist/afs.legacy.min.js"
@@ -35,6 +38,7 @@
     },
     "files": [
         "dist",
+        "src/types",
         "LICENSE",
         "README.md"
     ],
@@ -49,7 +53,9 @@
         "browser",
         "manipulation",
         "element-filter",
-        "web"
+        "web",
+        "typescript",
+        "types"
     ],
     "author": "misits",
     "license": "MIT",

package/src/types/core.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Core Types for Advanced Filter System
+ * @fileoverview TypeScript definitions for core classes
+ */
+
+import { AFSOptions, AFSEventData, EventCallback, FilterMode, FilterCategoryMode } from './index';
+
+// Options Class
+export declare class Options {
+  static readonly defaults: AFSOptions;
+  readonly options: AFSOptions;
+  
+  constructor(userOptions?: Partial<AFSOptions>);
+  
+  get(path: string): any;
+  set(path: string, value: any): void;
+  update(updates: Partial<AFSOptions>): void;
+  reset(): void;
+  export(): AFSOptions;
+}
+
+// State Class
+export declare class State {
+  constructor();
+  
+  getState(): any;
+  setState(path: string, value: any): void;
+  resetState(): void;
+  export(): any;
+  import(state: any): void;
+  reset(): void;
+}
+
+// Logger Class
+export declare class Logger {
+  constructor(debug?: boolean, logLevel?: string);
+  
+  debug(...args: any[]): void;
+  info(...args: any[]): void;
+  warn(...args: any[]): void;
+  error(...args: any[]): void;
+  log(level: string, ...args: any[]): void;
+}
+
+// EventEmitter Class
+export declare class EventEmitter {
+  constructor();
+  
+  on(event: string, callback: EventCallback): void;
+  off(event: string, callback?: EventCallback): void;
+  emit(event: string, data?: AFSEventData): void;
+  once(event: string, callback: EventCallback): void;
+  removeAllListeners(event?: string): void;
+}
+
+// StyleManager Class
+export declare class StyleManager {
+  constructor(options: Options);
+  
+  applyStyles(): void;
+  removeStyles(): void;
+  updateStyles(newOptions: Partial<AFSOptions>): void;
+  injectCSS(css: string, id?: string): void;
+  removeCSS(id: string): void;
+}

package/src/types/date-filter.ts

@@ -0,0 +1,18 @@
+export interface DateRangeOptions {
+    key: string;
+    container: HTMLElement;
+    format?: string;
+    minDate?: Date;
+    maxDate?: Date;
+}
+
+export interface DateRange {
+    startDate: Date;
+    endDate: Date;
+}
+
+export interface DateFilterEvent {
+    key: string;
+    startDate: Date;
+    endDate: Date;
+}

package/src/types/features.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Feature Types for Advanced Filter System
+ * @fileoverview TypeScript definitions for feature classes
+ */
+
+import { 
+  SortDirection, 
+  SortCriteria, 
+  FilterMode, 
+  FilterTypeConfig,
+  RangeSliderOptions,
+  DateFilterOptions,
+  PageInfo,
+  AFSEventData
+} from './index';
+import { AFS } from './index';
+
+// Filter Feature
+export declare class Filter {
+  constructor(afs: AFS);
+  
+  addFilter(filter: string): void;
+  removeFilter(filter: string): void;
+  toggleFilter(filter: string): void;
+  toggleFilterExclusive(filter: string): void;
+  clearAllFilters(): void;
+  clearFilterCategory(category: string): void;
+  getActiveFilters(): Set<string>;
+  setFilterTypeLogic(type: string, logic: FilterMode | FilterTypeConfig): void;
+  applyFilters(): void;
+  getFilteredItems(): Set<HTMLElement>;
+  isFilterActive(filter: string): boolean;
+  getFiltersByType(type: string): Set<string>;
+  destroy(): void;
+}
+
+// Search Feature
+export declare class Search {
+  constructor(afs: AFS);
+  
+  search(query: string): void;
+  clearSearch(): void;
+  setValue(value: string): void;
+  getValue(): string;
+  getMatches(): HTMLElement[];
+  highlightMatches(enable?: boolean): void;
+  configure(options: { 
+    keys?: string[];
+    debounce?: number;
+    minLength?: number;
+    caseSensitive?: boolean;
+  }): void;
+  destroy(): void;
+}
+
+// Sort Feature
+export declare class Sort {
+  constructor(afs: AFS);
+  
+  sort(key: string, direction?: SortDirection): void;
+  sortMultiple(criteria: SortCriteria[]): void;
+  sortWithComparator(key: string, comparator: (a: any, b: any) => number): void;
+  shuffle(): void;
+  reset(): void;
+  getCurrentSort(): SortCriteria | null;
+  getSortValue(element: HTMLElement, key: string): any;
+  addCustomComparator(name: string, comparator: (a: any, b: any) => number): void;
+  destroy(): void;
+}
+
+// Pagination Feature
+export declare class Pagination {
+  constructor(afs: AFS);
+  
+  goToPage(page: number): void;
+  nextPage(): void;
+  previousPage(): void;
+  firstPage(): void;
+  lastPage(): void;
+  setPaginationMode(enabled: boolean): void;
+  setItemsPerPage(count: number): void;
+  getPageInfo(): PageInfo;
+  getCurrentPage(): number;
+  getTotalPages(): number;
+  getItemsPerPage(): number;
+  update(): void;
+  render(): void;
+  destroy(): void;
+}
+
+// Range Filter Feature
+export declare class RangeFilter {
+  constructor(afs: AFS);
+  
+  addRangeSlider(options: RangeSliderOptions): void;
+  removeRangeSlider(key: string): void;
+  getRangeValue(key: string): { min: number; max: number } | null;
+  setRangeValue(key: string, min: number, max: number): void;
+  resetRange(key: string): void;
+  getRangeSliders(): Map<string, any>;
+  updateHistogram(key: string): void;
+  destroy(): void;
+}
+
+// Date Filter Feature
+export declare class DateFilter {
+  constructor(afs: AFS);
+  
+  addDateRange(options: DateFilterOptions): void;
+  removeDateRange(key: string): void;
+  getDateRange(key: string): { start: Date; end: Date } | null;
+  setDateRange(key: string, start: Date, end: Date): void;
+  resetDateRange(key: string): void;
+  getDateFilters(): Map<string, any>;
+  parseDate(dateString: string, format?: string): Date;
+  formatDate(date: Date, format?: string): string;
+  destroy(): void;
+}
+
+// URL Manager Feature
+export declare class URLManager {
+  constructor(afs: AFS);
+  
+  initialize(): void;
+  updateURL(): void;
+  loadFromURL(): void;
+  clearURL(): void;
+  getURLParams(): URLSearchParams;
+  hasParams(): boolean;
+  getParam(param: string): string | null;
+  setParam(param: string, value: string): void;
+  removeParam(param: string): void;
+  serializeState(): string;
+  deserializeState(serialized: string): any;
+  destroy(): void;
+}
+
+// Input Range Filter Feature
+export declare class InputRangeFilter {
+  constructor(afs: AFS);
+  
+  addInput(selector: string, key: string): void;
+  removeInput(key: string): void;
+  getValue(key: string): string | null;
+  setValue(key: string, value: string): void;
+  getInputs(): Map<string, HTMLInputElement>;
+  destroy(): void;
+}

package/src/types/filter.ts

@@ -0,0 +1,17 @@
+export interface FilterOptions {
+    mode: 'AND' | 'OR';
+    activeClass: string;
+    hiddenClass: string;
+}
+
+export interface FilterGroupOptions {
+    filters: string[];
+    operator: 'AND' | 'OR';
+}
+
+export interface FilterEvent {
+    filter: string;
+    activeFilters: string[];
+    visibleItems: number;
+    hiddenItems: number;
+}