@ram_28/kf-ai-sdk 1.0.7 → 1.0.9

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])
-  );
-};