@intellegens/cornerstone-client 0.0.9999-alpha-3 → 0.0.9999-alpha-5

package/utils/search/index.d.ts

@@ -0,0 +1,34 @@
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType, ReadSelectedSearchDefinitionDto } from '../../data';
+/**
+ * Creates a ReadSelectedSearchDefinitionDto ready to be used with the CollectionViewAdapter
+ *
+ * @param logicalOperator - specify `ReadSelectedLogicalOperator` that will apply to all ReadSelectedSearchPropertyDefinitionDto property definitions included in this search definition
+ * @param conditions - Variable number of condition objects containing:
+ *   - propertyName: The property name from the DTO to search on
+ *   - operator: The `ReadSelectedComparisonOperator` enum
+ *   - value: The value to compare against
+ *   - valueType: The `ReadSelectedPropertyType` being compared
+ */
+export declare function condition<T>(logicalOperator: ReadSelectedLogicalOperator, ...conditions: Array<{
+    propertyName: keyof T;
+    operator: ReadSelectedComparisonOperator;
+    value: unknown;
+    valueType: ReadSelectedPropertyType;
+}>): ReadSelectedSearchDefinitionDto<T>;
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
+ */
+export declare function and<T>(...definitions: ReadSelectedSearchDefinitionDto<T>[]): ReadSelectedSearchDefinitionDto<T>;
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
+ */
+export declare function or<T>(...definitions: ReadSelectedSearchDefinitionDto<T>[]): ReadSelectedSearchDefinitionDto<T>;
+/**
+ * Preset implementation for filtering by searchTerm. String types will search by provided `textSearchableProperties` with `ReadSelectedComparisonOperator.Contains`. Numeric types will search by provided `numericSearchableProperties`, `parseInt` the search term and use `ReadSelectedComparisonOperator.Equal`.
+ */
+export declare function searchTerm<T>(searchTerm: string, textSearchableProperties: (keyof T)[], numericSearchableProperties: (keyof T)[]): void | ReadSelectedSearchDefinitionDto<T>;
+/**
+ * Preset implementation for filtering a date range. User may select desired `ReadSelectedComparisonOperator` and `ReadSelectedPropertyType` for the from and to dates. Valid object property must be provided for `searchableProperty`.
+ */
+export declare function dateInterval<T>(fromDate: Date, toDate: Date, fromDateComparisonOperator: ReadSelectedComparisonOperator, toDateComparisonOperator: ReadSelectedComparisonOperator, valueType: ReadSelectedPropertyType, searchableProperty: keyof T): void | ReadSelectedSearchDefinitionDto<T>;
+export declare function toPascalCase<T>(str: keyof T): keyof T;

package/utils/search/index.js

@@ -0,0 +1,106 @@
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType, } from '../../data';
+/**
+ * Creates a ReadSelectedSearchDefinitionDto ready to be used with the CollectionViewAdapter
+ *
+ * @param logicalOperator - specify `ReadSelectedLogicalOperator` that will apply to all ReadSelectedSearchPropertyDefinitionDto property definitions included in this search definition
+ * @param conditions - Variable number of condition objects containing:
+ *   - propertyName: The property name from the DTO to search on
+ *   - operator: The `ReadSelectedComparisonOperator` enum
+ *   - value: The value to compare against
+ *   - valueType: The `ReadSelectedPropertyType` being compared
+ */
+export function condition(logicalOperator, ...conditions) {
+    return {
+        logicalOperator: logicalOperator,
+        propertyCriteria: conditions.map(condition => ({
+            propertyName: toPascalCase(condition.propertyName),
+            comparisonOperator: condition.operator,
+            valueType: condition.valueType,
+            value: condition.value,
+        })),
+    };
+}
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
+ */
+export function and(...definitions) {
+    return {
+        logicalOperator: ReadSelectedLogicalOperator.And,
+        searches: definitions,
+    };
+}
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
+ */
+export function or(...definitions) {
+    return {
+        logicalOperator: ReadSelectedLogicalOperator.Or,
+        searches: definitions,
+    };
+}
+/**
+ * Preset implementation for filtering by searchTerm. String types will search by provided `textSearchableProperties` with `ReadSelectedComparisonOperator.Contains`. Numeric types will search by provided `numericSearchableProperties`, `parseInt` the search term and use `ReadSelectedComparisonOperator.Equal`.
+ */
+export function searchTerm(searchTerm, textSearchableProperties, numericSearchableProperties) {
+    let comparisonOperator;
+    let valueType;
+    let searchableProperties;
+    let searchValue;
+    try {
+        const numericValue = parseInt(searchTerm);
+        if (!Number.isNaN(numericValue) && String(numericValue) === searchTerm.trim()) {
+            comparisonOperator = ReadSelectedComparisonOperator.Equal;
+            valueType = ReadSelectedPropertyType.Int;
+            searchableProperties = numericSearchableProperties;
+            searchValue = numericValue;
+        }
+        else {
+            comparisonOperator = ReadSelectedComparisonOperator.Contains;
+            valueType = ReadSelectedPropertyType.String;
+            searchableProperties = textSearchableProperties;
+            searchValue = searchTerm;
+        }
+        const searchConditions = searchableProperties.map(propertyName => ({
+            propertyName: toPascalCase(propertyName),
+            operator: comparisonOperator,
+            value: searchValue,
+            valueType: valueType,
+        }));
+        return condition(ReadSelectedLogicalOperator.Or, ...searchConditions);
+    }
+    catch {
+        return;
+    }
+}
+/**
+ * Preset implementation for filtering a date range. User may select desired `ReadSelectedComparisonOperator` and `ReadSelectedPropertyType` for the from and to dates. Valid object property must be provided for `searchableProperty`.
+ */
+export function dateInterval(fromDate, toDate, fromDateComparisonOperator, toDateComparisonOperator, valueType, searchableProperty) {
+    try {
+        if (!(valueType === ReadSelectedPropertyType.DateOnly ||
+            valueType === ReadSelectedPropertyType.DateTime ||
+            valueType === ReadSelectedPropertyType.DateTimeOffset)) {
+            return;
+        }
+        return condition(ReadSelectedLogicalOperator.And, {
+            propertyName: toPascalCase(searchableProperty),
+            operator: fromDateComparisonOperator,
+            value: fromDate,
+            valueType: valueType,
+        }, {
+            propertyName: toPascalCase(searchableProperty),
+            operator: toDateComparisonOperator,
+            value: toDate,
+            valueType: valueType,
+        });
+    }
+    catch {
+        return;
+    }
+}
+export function toPascalCase(str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    return (str.charAt(0).toUpperCase() + str.slice(1));
+}