@ram_28/kf-ai-sdk 1.0.7 → 1.0.8

package/sdk/components/hooks/useTable/useTable.ts

@@ -18,44 +18,11 @@ interface SortingState<T> {
   direction: "asc" | "desc" | null;
 }
 
-interface FilteringState {
-  global: string;
-}
-
 interface PaginationState {
   pageNo: number; // 1-indexed page number
   pageSize: number;
 }
 
-// ============================================================
-// FIELD TYPE DETECTION
-// ============================================================
-
-/**
- * Detect field type for auto-formatting
- * This will be enhanced with actual type introspection in the future
- * Currently unused but kept for future auto-formatting implementation
- */
-// function _detectFieldType<T>(fieldId: keyof T): string {
-//   const fieldName = String(fieldId);
-//
-//   // Basic pattern matching - will be replaced with actual type introspection
-//   if (fieldName.includes('price') || fieldName.includes('cost') || fieldName.includes('amount')) {
-//     return 'currency';
-//   }
-//   if (fieldName.includes('date') || fieldName.includes('At') || fieldName === 'created' || fieldName === 'updated') {
-//     return 'datetime';
-//   }
-//   if (fieldName.includes('stock') || fieldName.includes('quantity') || fieldName.includes('count')) {
-//     return 'number';
-//   }
-//   if (fieldName.includes('status') || fieldName.includes('type') || fieldName.includes('category')) {
-//     return 'string';
-//   }
-//
-//   return 'string'; // default
-// }
-
 // ============================================================
 // MAIN HOOK
 // ============================================================
@@ -76,12 +43,8 @@ export function useTable<T = any>(
     direction: options.initialState?.sorting?.direction || null,
   });
 
-  const [filtering, setFiltering] = useState<FilteringState>({
-    global: options.initialState?.globalFilter || "",
-  });
-
   const [pagination, setPagination] = useState<PaginationState>({
-    pageNo: options.initialState?.pagination?.pageNo || 1, // Start at page 1
+    pageNo: options.initialState?.pagination?.pageNo || 1,
     pageSize: options.initialState?.pagination?.pageSize || 10,
   });
 
@@ -89,23 +52,9 @@ export function useTable<T = any>(
   // FILTER HOOK INTEGRATION
   // ============================================================
 
-  const filterHook = useFilter<T>({
+  const filter = useFilter({
     initialConditions: options.initialState?.filters,
-    initialLogicalOperator: options.initialState?.filterOperator || "And",
-    validateOnChange: true,
-    onValidationError: options.onFilterError,
-    onConditionAdd: () => {
-      // Reset to first page when adding filters
-      setPagination((prev) => ({ ...prev, pageNo: 1 }));
-    },
-    onConditionUpdate: () => {
-      // Reset to first page when updating filters
-      setPagination((prev) => ({ ...prev, pageNo: 1 }));
-    },
-    onConditionRemove: () => {
-      // Reset to first page when removing filters
-      setPagination((prev) => ({ ...prev, pageNo: 1 }));
-    },
+    initialOperator: options.initialState?.filterOperator || "And",
   });
 
   // ============================================================
@@ -122,12 +71,12 @@ export function useTable<T = any>(
     }
 
     // Add filter conditions (affects count)
-    if (filterHook.filterPayload) {
-      opts.Filter = filterHook.filterPayload;
+    if (filter.payload) {
+      opts.Filter = filter.payload;
     }
 
     return opts;
-  }, [search.query, filterHook.filterPayload]);
+  }, [search.query, filter.payload]);
 
   // Options for list query - includes all options
   const apiOptions = useMemo((): ListOptions => {
@@ -144,7 +93,7 @@ export function useTable<T = any>(
 
     // Add pagination
     if (options.enablePagination) {
-      opts.Page = pagination.pageNo; // Already 1-indexed
+      opts.Page = pagination.pageNo;
       opts.PageSize = pagination.pageSize;
     }
 
@@ -181,7 +130,7 @@ export function useTable<T = any>(
     gcTime: 0,
   });
 
-  // Count query for accurate total items (only depends on filters/search, not sorting/pagination)
+  // Count query for accurate total items
   const {
     data: countData,
     isLoading: isCountLoading,
@@ -222,14 +171,12 @@ export function useTable<T = any>(
   const toggleSort = useCallback((field: keyof T) => {
     setSorting((prev) => {
       if (prev.field === field) {
-        // Same field - toggle direction or clear
         if (prev.direction === "asc") {
           return { field, direction: "desc" };
         } else if (prev.direction === "desc") {
           return { field: null, direction: null };
         }
       }
-      // New field or no current sort
       return { field, direction: "asc" };
     });
   }, []);
@@ -251,7 +198,6 @@ export function useTable<T = any>(
 
   const setSearchQuery = useCallback((value: string) => {
     setSearch({ query: value });
-    // Reset to first page when searching
     setPagination((prev) => ({ ...prev, pageNo: 1 }));
   }, []);
 
@@ -259,20 +205,6 @@ export function useTable<T = any>(
     setSearch({ query: "" });
   }, []);
 
-  // ============================================================
-  // FILTERING OPERATIONS
-  // ============================================================
-
-  const setGlobalFilter = useCallback((value: string) => {
-    setFiltering((prev) => ({ ...prev, global: value }));
-    // Reset to first page when filtering
-    setPagination((prev) => ({ ...prev, pageNo: 1 }));
-  }, []);
-
-  const clearFilter = useCallback(() => {
-    setFiltering({ global: "" });
-  }, []);
-
   // ============================================================
   // PAGINATION OPERATIONS
   // ============================================================
@@ -294,7 +226,7 @@ export function useTable<T = any>(
 
   const goToPage = useCallback(
     (page: number) => {
-      const pageNo = Math.max(1, Math.min(page, totalPages)); // Clamp between 1 and totalPages
+      const pageNo = Math.max(1, Math.min(page, totalPages));
       setPagination((prev) => ({ ...prev, pageNo }));
     },
     [totalPages]
@@ -304,7 +236,7 @@ export function useTable<T = any>(
     setPagination((prev) => ({
       ...prev,
       pageSize: size,
-      pageNo: 1, // Reset to first page
+      pageNo: 1,
     }));
   }, []);
 
@@ -349,52 +281,12 @@ export function useTable<T = any>(
       set: setSort,
     },
 
-    // Legacy Global Filtering (Flat Access)
-    globalFilter: {
-      value: filtering.global,
-      setValue: setGlobalFilter,
-      clear: clearFilter,
-    },
-
-    // Advanced Filtering (Filter Conditions)
-    filter: {
-      // State
-      conditions: filterHook.conditions,
-      logicalOperator: filterHook.logicalOperator,
-      isValid: filterHook.isValid,
-      validationErrors: filterHook.validationErrors,
-      hasConditions: filterHook.hasConditions,
-
-      // Condition Management
-      addCondition: filterHook.addCondition,
-      updateCondition: filterHook.updateCondition,
-      removeCondition: filterHook.removeCondition,
-      clearConditions: filterHook.clearConditions,
-      getCondition: filterHook.getCondition,
-
-      // Logical Operator
-      setLogicalOperator: filterHook.setLogicalOperator,
-
-      // Bulk Operations
-      setConditions: filterHook.setConditions,
-      replaceCondition: filterHook.replaceCondition,
-
-      // Validation
-      validateCondition: filterHook.validateCondition,
-      validateAllConditions: filterHook.validateAllConditions,
-
-      // State Management
-      exportState: filterHook.exportState,
-      importState: filterHook.importState,
-      resetToInitial: filterHook.resetToInitial,
-
-      // Utilities
-      getConditionCount: filterHook.getConditionCount,
-    },
+    // Filter (Simplified chainable API)
+    filter,
 
     // Pagination (Flat Access)
     pagination: {
-      currentPage: pagination.pageNo, // Already 1-indexed
+      currentPage: pagination.pageNo,
       pageSize: pagination.pageSize,
       totalPages,
       totalItems,

package/sdk/types/common.ts

@@ -15,18 +15,20 @@ export type SortOption = Record<string, SortDirection>;
 export type Sort = SortOption[];
 
 /**
- * Filter operators for individual conditions (leaf nodes)
+ * Condition operators for individual conditions (leaf nodes)
+ * Used in Condition.Operator
  */
-export type FilterOperator =
+export type ConditionOperator =
   | "EQ" | "NE" | "GT" | "GTE" | "LT" | "LTE"
   | "Between" | "NotBetween" | "IN" | "NIN"
   | "Empty" | "NotEmpty" | "Contains" | "NotContains"
   | "MinLength" | "MaxLength";
 
 /**
- * Logical operators for combining filter conditions (tree nodes)
+ * Operators for combining conditions in a group (tree nodes)
+ * Used in ConditionGroup.Operator
  */
-export type LogicalOperator = "And" | "Or" | "Not";
+export type ConditionGroupOperator = "And" | "Or" | "Not";
 
 /**
  * RHS value type for filter conditions
@@ -34,19 +36,13 @@ export type LogicalOperator = "And" | "Or" | "Not";
 export type FilterRHSType = "Constant" | "BOField" | "AppVariable";
 
 /**
- * Base interface for all filter nodes
+ * Leaf condition (actual field comparison)
  */
-interface FilterNodeBase {
-  /** Operator type */
-  Operator: FilterOperator | LogicalOperator;
-}
-
-/**
- * Leaf filter condition (actual field comparison)
- */
-export interface FilterCondition extends FilterNodeBase {
+export interface Condition {
+  /** Optional ID for hook state management (omitted in API payload) */
+  id?: string;
   /** Condition operator */
-  Operator: FilterOperator;
+  Operator: ConditionOperator;
   /** Left-hand side field name */
   LHSField: string;
   /** Right-hand side value */
@@ -56,25 +52,45 @@ export interface FilterCondition extends FilterNodeBase {
 }
 
 /**
- * Logical filter node (combines multiple conditions)
+ * Group combining conditions (recursive structure)
  */
-export interface FilterLogical extends FilterNodeBase {
-  /** Logical operator */
-  Operator: LogicalOperator;
-  /** Nested conditions (can be FilterCondition or FilterLogical) */
-  Condition: Array<FilterCondition | FilterLogical>;
+export interface ConditionGroup {
+  /** Optional ID for hook state management (omitted in API payload) */
+  id?: string;
+  /** Group operator (And, Or, Not) */
+  Operator: ConditionGroupOperator;
+  /** Nested conditions (can be Condition or ConditionGroup) */
+  Condition: Array<Condition | ConditionGroup>;
 }
 
 /**
- * Filter structure matching API specification (root level)
- * This is a discriminated union - a filter is either a logical node or a condition
+ * Root filter type (alias for ConditionGroup)
+ */
+export type Filter = ConditionGroup;
+
+// ============================================================
+// LEGACY TYPE ALIASES (for backwards compatibility)
+// ============================================================
+
+/**
+ * @deprecated Use `Condition` instead
+ */
+export type FilterCondition = Condition;
+
+/**
+ * @deprecated Use `ConditionGroup` instead
+ */
+export type FilterLogical = ConditionGroup;
+
+/**
+ * @deprecated Use `ConditionGroupOperator` instead
  */
-export type Filter = FilterLogical;
+export type FilterOperator = ConditionGroupOperator;
 
 /**
- * Convenience type for any filter node (leaf or logical)
+ * @deprecated Use `Condition | ConditionGroup` instead
  */
-export type FilterNode = FilterCondition | FilterLogical;
+export type FilterNode = Condition | ConditionGroup;
 
 /**
  * DateTime encoding format used by the API

package/dist/components/hooks/useFilter/payloadBuilder.utils.d.ts

@@ -1,33 +0,0 @@
-import type { Filter, LogicalOperator } from "../../../types/common";
-import type { FilterConditionWithId, FilterState } from "../useFilter";
-/**
- * Build SDK Filter payload from filter state
- * Returns undefined if no valid conditions exist
- * Supports both flat and nested filter structures
- */
-export declare const buildFilterPayload: (conditions: FilterConditionWithId[], logicalOperator: LogicalOperator) => Filter | undefined;
-/**
- * Build filter payload from complete filter state
- */
-export declare const buildFilterPayloadFromState: (state: FilterState) => Filter | undefined;
-/**
- * Validate that a filter payload is well-formed (supports nested filters)
- */
-export declare const validateFilterPayload: (filter: Filter | undefined) => boolean;
-/**
- * Deep clone a filter payload (supports nested filters)
- */
-export declare const cloneFilterPayload: (filter: Filter | undefined) => Filter | undefined;
-/**
- * Merge multiple filter payloads with a logical operator
- */
-export declare const mergeFilterPayloads: (filters: (Filter | undefined)[], operator: LogicalOperator) => Filter | undefined;
-/**
- * Convert filter payload to a human-readable string for debugging (supports nested filters)
- */
-export declare const filterPayloadToString: (filter: Filter | undefined) => string;
-/**
- * Check if two filter payloads are equivalent (supports nested filters)
- */
-export declare const areFilterPayloadsEqual: (filter1: Filter | undefined, filter2: Filter | undefined) => boolean;
-//# sourceMappingURL=payloadBuilder.utils.d.ts.map

package/dist/components/hooks/useFilter/payloadBuilder.utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payloadBuilder.utils.d.ts","sourceRoot":"","sources":["../../../../sdk/components/hooks/useFilter/payloadBuilder.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAkC,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACrG,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAqCvE;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC7B,YAAY,qBAAqB,EAAE,EACnC,iBAAiB,eAAe,KAC/B,MAAM,GAAG,SAmBX,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,GAAI,OAAO,WAAW,KAAG,MAAM,GAAG,SAEzE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,GAAG,SAAS,KAAG,OAwClE,CAAC;AAwBF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,GAAG,SAAS,KAAG,MAAM,GAAG,SASxE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAC9B,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,EAC/B,UAAU,eAAe,KACxB,MAAM,GAAG,SAoBX,CAAC;AA6BF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,GAAG,SAAS,KAAG,MAYlE,CAAC;AAyCF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,MAAM,GAAG,SAAS,EAC3B,SAAS,MAAM,GAAG,SAAS,KAC1B,OAyBF,CAAC"}

package/sdk/components/hooks/useFilter/payloadBuilder.utils.ts

@@ -1,298 +0,0 @@
-import type { Filter, FilterCondition, FilterLogical, LogicalOperator } from "../../../types/common";
-import type { FilterConditionWithId, FilterState } from "../useFilter";
-
-// ============================================================
-// PAYLOAD BUILDING UTILITIES
-// ============================================================
-
-/**
- * Helper to check if operator is a logical operator
- */
-const isLogicalOperator = (operator: string): operator is LogicalOperator => {
-  return operator === 'And' || operator === 'Or' || operator === 'Not';
-};
-
-/**
- * Convert a single FilterConditionWithId to API format (FilterCondition or FilterLogical)
- */
-const buildCondition = (condition: FilterConditionWithId): FilterCondition | FilterLogical => {
-  // Check if this is a logical operator (nested group)
-  if (isLogicalOperator(condition.operator)) {
-    // Build nested logical filter
-    return {
-      Operator: condition.operator,
-      Condition: (condition.children || [])
-        .filter(child => child.isValid)
-        .map(child => buildCondition(child))
-    };
-  } else {
-    // Build simple condition
-    return {
-      Operator: condition.operator,
-      LHSField: condition.lhsField!,
-      RHSValue: condition.rhsValue,
-      RHSType: condition.rhsType || "Constant"
-    };
-  }
-};
-
-/**
- * Build SDK Filter payload from filter state
- * Returns undefined if no valid conditions exist
- * Supports both flat and nested filter structures
- */
-export const buildFilterPayload = (
-  conditions: FilterConditionWithId[],
-  logicalOperator: LogicalOperator
-): Filter | undefined => {
-  // Return undefined if no conditions
-  if (conditions.length === 0) {
-    return undefined;
-  }
-
-  // Filter out invalid conditions
-  const validConditions = conditions.filter(condition => condition.isValid);
-
-  // Return undefined if no valid conditions
-  if (validConditions.length === 0) {
-    return undefined;
-  }
-
-  // Build the filter payload
-  return {
-    Operator: logicalOperator,
-    Condition: validConditions.map(buildCondition)
-  };
-};
-
-/**
- * Build filter payload from complete filter state
- */
-export const buildFilterPayloadFromState = (state: FilterState): Filter | undefined => {
-  return buildFilterPayload(state.conditions, state.logicalOperator);
-};
-
-/**
- * Validate that a filter payload is well-formed (supports nested filters)
- */
-export const validateFilterPayload = (filter: Filter | undefined): boolean => {
-  if (!filter) {
-    return true; // undefined filter is valid (no filtering)
-  }
-
-  // Check operator
-  if (!filter.Operator || !['And', 'Or', 'Not'].includes(filter.Operator)) {
-    return false;
-  }
-
-  // Check conditions array
-  if (!Array.isArray(filter.Condition) || filter.Condition.length === 0) {
-    return false;
-  }
-
-  // Not operator can only have one child
-  if (filter.Operator === 'Not' && filter.Condition.length !== 1) {
-    return false;
-  }
-
-  // Validate each condition recursively
-  return filter.Condition.every(condition => {
-    if (!condition.Operator) {
-      return false;
-    }
-
-    // Check if this is a logical operator (nested)
-    if (isLogicalOperator(condition.Operator)) {
-      // Recursively validate nested filter
-      return validateFilterPayload(condition as FilterLogical);
-    } else {
-      // Validate simple condition
-      const simpleCondition = condition as FilterCondition;
-      return (
-        simpleCondition.LHSField !== undefined &&
-        simpleCondition.RHSValue !== undefined &&
-        (simpleCondition.RHSType === undefined || ['Constant', 'BOField', 'AppVariable'].includes(simpleCondition.RHSType))
-      );
-    }
-  });
-};
-
-/**
- * Deep clone a filter condition (supports nested filters)
- */
-const cloneCondition = (condition: FilterCondition | FilterLogical): FilterCondition | FilterLogical => {
-  if (isLogicalOperator(condition.Operator)) {
-    // Clone logical filter recursively
-    return {
-      Operator: condition.Operator,
-      Condition: (condition as FilterLogical).Condition.map(cloneCondition)
-    };
-  } else {
-    // Clone simple condition
-    const simpleCondition = condition as FilterCondition;
-    return {
-      Operator: simpleCondition.Operator,
-      LHSField: simpleCondition.LHSField,
-      RHSValue: simpleCondition.RHSValue,
-      RHSType: simpleCondition.RHSType
-    };
-  }
-};
-
-/**
- * Deep clone a filter payload (supports nested filters)
- */
-export const cloneFilterPayload = (filter: Filter | undefined): Filter | undefined => {
-  if (!filter) {
-    return undefined;
-  }
-
-  return {
-    Operator: filter.Operator,
-    Condition: filter.Condition.map(cloneCondition)
-  };
-};
-
-/**
- * Merge multiple filter payloads with a logical operator
- */
-export const mergeFilterPayloads = (
-  filters: (Filter | undefined)[],
-  operator: LogicalOperator
-): Filter | undefined => {
-  const validFilters = filters.filter((filter): filter is Filter =>
-    filter !== undefined && validateFilterPayload(filter)
-  );
-
-  if (validFilters.length === 0) {
-    return undefined;
-  }
-
-  if (validFilters.length === 1) {
-    return cloneFilterPayload(validFilters[0]);
-  }
-
-  // Flatten all conditions
-  const allConditions = validFilters.flatMap(filter => filter.Condition);
-
-  return {
-    Operator: operator,
-    Condition: allConditions
-  };
-};
-
-/**
- * Convert filter condition to a human-readable string (supports nested filters)
- */
-const conditionToString = (condition: FilterCondition | FilterLogical): string => {
-  if (isLogicalOperator(condition.Operator)) {
-    // Handle logical filter
-    const logicalFilter = condition as FilterLogical;
-    const childStrings = logicalFilter.Condition.map(conditionToString);
-
-    if (childStrings.length === 1) {
-      return condition.Operator === 'Not'
-        ? `NOT (${childStrings[0]})`
-        : childStrings[0];
-    }
-
-    return `(${childStrings.join(` ${condition.Operator} `)})`;
-  } else {
-    // Handle simple condition
-    const simpleCondition = condition as FilterCondition;
-    const rhsDisplay = Array.isArray(simpleCondition.RHSValue)
-      ? `[${simpleCondition.RHSValue.join(', ')}]`
-      : String(simpleCondition.RHSValue);
-
-    return `${simpleCondition.LHSField} ${simpleCondition.Operator} ${rhsDisplay}`;
-  }
-};
-
-/**
- * Convert filter payload to a human-readable string for debugging (supports nested filters)
- */
-export const filterPayloadToString = (filter: Filter | undefined): string => {
-  if (!filter) {
-    return "No filters";
-  }
-
-  const conditionStrings = filter.Condition.map(conditionToString);
-
-  if (conditionStrings.length === 1) {
-    return conditionStrings[0];
-  }
-
-  return `(${conditionStrings.join(` ${filter.Operator} `)})`;
-};
-
-/**
- * Check if two conditions are equivalent (supports nested filters)
- */
-const areConditionsEqual = (
-  condition1: FilterCondition | FilterLogical,
-  condition2: FilterCondition | FilterLogical
-): boolean => {
-  // Different operators
-  if (condition1.Operator !== condition2.Operator) {
-    return false;
-  }
-
-  // Check if logical operators
-  if (isLogicalOperator(condition1.Operator)) {
-    const logical1 = condition1 as FilterLogical;
-    const logical2 = condition2 as FilterLogical;
-
-    // Different number of children
-    if (logical1.Condition.length !== logical2.Condition.length) {
-      return false;
-    }
-
-    // Recursively compare all children
-    return logical1.Condition.every((child1, index) =>
-      areConditionsEqual(child1, logical2.Condition[index])
-    );
-  } else {
-    // Compare simple conditions
-    const simple1 = condition1 as FilterCondition;
-    const simple2 = condition2 as FilterCondition;
-
-    return (
-      simple1.LHSField === simple2.LHSField &&
-      JSON.stringify(simple1.RHSValue) === JSON.stringify(simple2.RHSValue) &&
-      simple1.RHSType === simple2.RHSType
-    );
-  }
-};
-
-/**
- * Check if two filter payloads are equivalent (supports nested filters)
- */
-export const areFilterPayloadsEqual = (
-  filter1: Filter | undefined,
-  filter2: Filter | undefined
-): boolean => {
-  // Both undefined
-  if (!filter1 && !filter2) {
-    return true;
-  }
-
-  // One undefined, one defined
-  if (!filter1 || !filter2) {
-    return false;
-  }
-
-  // Different operators
-  if (filter1.Operator !== filter2.Operator) {
-    return false;
-  }
-
-  // Different number of conditions
-  if (filter1.Condition.length !== filter2.Condition.length) {
-    return false;
-  }
-
-  // Compare each condition recursively
-  return filter1.Condition.every((condition1, index) =>
-    areConditionsEqual(condition1, filter2.Condition[index])
-  );
-};