awing-library 2.1.2-dev.9 → 2.1.2-dev.90

package/dist/esm/Helpers/query.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Available filter operation types
+ */
+export declare enum FilterOperationType {
+    EQ = "eq",// Equal
+    CONTAINS = "contains",// Contains substring
+    STARTSWITH = "startswith",// Starts with
+    ENDSWITH = "endswith",// Ends with
+    GT = "gt",// Greater than
+    GTE = "gte",// Greater than or equal
+    LT = "lt",// Less than
+    LTE = "lte",// Less than or equal
+    IN = "in",// In array
+    BETWEEN = "between",// Between two values
+    NE = "ne",// Not equal
+    NOTCONTAINS = "notcontains",// Does not contain substring
+    NOTIN = "notin",// Not in array
+    CUSTOM = "custom"
+}
+/**
+ * Logical operators for combining filter conditions
+ */
+export declare enum LogicalOperatorType {
+    AND = "and",
+    OR = "or",
+    NOT = "not"
+}
+/**
+ * Structure for a single filter item
+ */
+export interface FilterItem {
+    key: string;
+    value: any;
+    type: FilterOperationType | string;
+    isArray?: boolean;
+}
+/**
+ * Structure for a filter group that can contain nested conditions
+ */
+export interface FilterGroup {
+    operator: LogicalOperatorType;
+    filters: Array<FilterItem | FilterGroup>;
+}
+/**
+ * Filter expression can be either a single item or a group
+ */
+export type FilterExpression = FilterItem | FilterGroup;
+/**
+ * Converts an array of filter objects to a string condition
+ * @param filters - Array of objects with key, value, and type properties
+ * @param defaultOperator - Default logical operator to use when combining filters (AND or OR)
+ * @returns Object with a 'condition' property containing the string condition and optional 'params' array
+ */
+export declare function convertArrayFiltersToCondition(filters: Array<FilterItem>, defaultOperator?: LogicalOperatorType): {
+    condition: string;
+    params?: string[];
+} | null;
+/**
+ * Converts a complex filter expression to a string condition
+ * @param filterExpression - Filter expression (can be nested with logical operators)
+ * @returns Object with a 'condition' property containing the string condition and optional 'params' array
+ */
+export declare function convertFilterExpressionToCondition(filterExpression: FilterExpression): {
+    condition: string;
+    params?: string[];
+} | null;
+/**
+ * Usage examples:
+ *  * Simple filter with AND:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'name', value: 'John', type: FilterOperationType.CONTAINS },
+ *   { key: 'age', value: 30, type: FilterOperationType.GTE }
+ * ];
+ * const result = convertArrayFiltersToCondition(filters); // name.Contains("John") && age>=30
+ * ```
+ *
+ * Simple filter with OR:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'status', value: 'active', type: FilterOperationType.EQ },
+ *   { key: 'status', value: 'pending', type: FilterOperationType.EQ }
+ * ];
+ * const result = convertArrayFiltersToCondition(filters, LogicalOperatorType.OR); // status="active" || status="pending"
+ * ```
+ *
+ * Filter with isArray property:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'objectTypeCode', value: 'OBJECTFILTER', type: FilterOperationType.EQ, isArray: false },
+ *   { key: 'name', value: 'Long', type: FilterOperationType.EQ, isArray: true },
+ * ];
+ * const result = convertArrayFiltersToCondition(filters);
+ * // Returns: { condition: 'objectTypeCode="OBJECTFILTER" && @0.Contains(name)', params: ["Long"] }
+ * ```
+ *
+ * Filter with isArray and array values:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'id', value: [1, 2, 3], type: FilterOperationType.EQ, isArray: true },
+ *   { key: 'names', value: ['name1', 'name2', 'name3'], type: FilterOperationType.EQ, isArray: true },
+ * ];
+ * const result = convertArrayFiltersToCondition(filters);
+ * // Returns: { condition: '@0.Contains(id) && @1.Contains(names)', params: ["1,2,3", "name1,name2,name3"] }
+ * ```
+ *
+ * Complex nested filter:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     { key: 'name', value: 'John', type: FilterOperationType.CONTAINS },
+ *     {
+ *       operator: LogicalOperatorType.OR,
+ *       filters: [
+ *         { key: 'age', value: 30, type: FilterOperationType.GTE },
+ *         { key: 'vip', value: true, type: FilterOperationType.EQ }
+ *       ]
+ *     },
+ *     {
+ *       operator: LogicalOperatorType.NOT,
+ *       filters: [
+ *         { key: 'status', value: 'inactive', type: FilterOperationType.EQ }
+ *       ]
+ *     }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // name.Contains("John") && (age>=30 || vip="true") && !(status="inactive")
+ * ```
+ *
+ * Complex filter with parameterized values:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     { key: 'objectTypeCode', value: 'OBJECTFILTER', type: FilterOperationType.EQ },
+ *     { key: 'name', value: 'Long', type: FilterOperationType.EQ, isArray: true }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // Returns: { condition: 'objectTypeCode="OBJECTFILTER" && @0.Contains(name)', params: ["Long"] }
+ * ```
+ *
+ * Complex filter with array values:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     { key: 'objectTypeCode', value: 'OBJECTFILTER', type: FilterOperationType.EQ },
+ *     { key: 'id', value: [1, 2], type: FilterOperationType.EQ, isArray: true },
+ *     { key: 'name', value: ['name1', 'name2'], type: FilterOperationType.EQ, isArray: true }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // Returns: {
+ * //   condition: 'objectTypeCode="OBJECTFILTER" && @0.Contains(id) && @1.Contains(name)',
+ * //   params: ["1,2", "name1,name2"]
+ * // }
+ * ```
+ */