@resistdesign/voltra 3.0.0-alpha.5 → 3.0.0-alpha.51

package/chunk-TJFTWPXQ.js

@@ -0,0 +1,39 @@
+// src/app/utils/easy-layout/computeTracks.ts
+var computeTrackPixels = ({
+  tracks,
+  totalPx,
+  gapPx = 0,
+  paddingPx = 0
+}) => {
+  if (!tracks.length) {
+    return [];
+  }
+  const gapsPx = Math.max(0, tracks.length - 1) * Math.max(0, gapPx);
+  const usablePx = Math.max(0, totalPx - Math.max(0, paddingPx) * 2 - gapsPx);
+  let fixedPx = 0;
+  let frTotal = 0;
+  for (const track of tracks) {
+    if (track.kind === "px") {
+      fixedPx += track.value;
+    } else if (track.kind === "pct") {
+      fixedPx += usablePx * track.value / 100;
+    } else {
+      frTotal += track.value;
+    }
+  }
+  const remainderPx = Math.max(0, usablePx - fixedPx);
+  return tracks.map((track) => {
+    if (track.kind === "px") {
+      return track.value;
+    }
+    if (track.kind === "pct") {
+      return usablePx * track.value / 100;
+    }
+    if (frTotal <= 0) {
+      return 0;
+    }
+    return remainderPx * track.value / frTotal;
+  });
+};
+
+export { computeTrackPixels };

package/chunk-XHOMAXLR.js

@@ -0,0 +1,84 @@
+// src/common/SearchTypes.ts
+var LogicalOperators = /* @__PURE__ */ ((LogicalOperators2) => {
+  LogicalOperators2["AND"] = "AND";
+  LogicalOperators2["OR"] = "OR";
+  return LogicalOperators2;
+})(LogicalOperators || {});
+var ComparisonOperators = /* @__PURE__ */ ((ComparisonOperators2) => {
+  ComparisonOperators2["EQUALS"] = "EQUALS";
+  ComparisonOperators2["NOT_EQUALS"] = "NOT_EQUALS";
+  ComparisonOperators2["GREATER_THAN"] = "GREATER_THAN";
+  ComparisonOperators2["GREATER_THAN_OR_EQUAL"] = "GREATER_THAN_OR_EQUAL";
+  ComparisonOperators2["LESS_THAN"] = "LESS_THAN";
+  ComparisonOperators2["LESS_THAN_OR_EQUAL"] = "LESS_THAN_OR_EQUAL";
+  ComparisonOperators2["IN"] = "IN";
+  ComparisonOperators2["NOT_IN"] = "NOT_IN";
+  ComparisonOperators2["LIKE"] = "LIKE";
+  ComparisonOperators2["NOT_LIKE"] = "NOT_LIKE";
+  ComparisonOperators2["EXISTS"] = "EXISTS";
+  ComparisonOperators2["NOT_EXISTS"] = "NOT_EXISTS";
+  ComparisonOperators2["IS_NOT_EMPTY"] = "IS_NOT_EMPTY";
+  ComparisonOperators2["IS_EMPTY"] = "IS_EMPTY";
+  ComparisonOperators2["BETWEEN"] = "BETWEEN";
+  ComparisonOperators2["NOT_BETWEEN"] = "NOT_BETWEEN";
+  ComparisonOperators2["CONTAINS"] = "CONTAINS";
+  ComparisonOperators2["NOT_CONTAINS"] = "NOT_CONTAINS";
+  ComparisonOperators2["STARTS_WITH"] = "STARTS_WITH";
+  ComparisonOperators2["ENDS_WITH"] = "ENDS_WITH";
+  ComparisonOperators2["DOES_NOT_START_WITH"] = "DOES_NOT_START_WITH";
+  ComparisonOperators2["DOES_NOT_END_WITH"] = "DOES_NOT_END_WITH";
+  return ComparisonOperators2;
+})(ComparisonOperators || {});
+
+// src/common/TypeInfoORM/Types.ts
+var ITEM_RELATIONSHIP_DAC_RESOURCE_NAME = "TYPE_INFO_ORM_ITEM_RELATIONSHIP";
+var RelationshipOperation = /* @__PURE__ */ ((RelationshipOperation2) => {
+  RelationshipOperation2["GET"] = "GET";
+  RelationshipOperation2["SET"] = "SET";
+  RelationshipOperation2["UNSET"] = "UNSET";
+  return RelationshipOperation2;
+})(RelationshipOperation || {});
+var OperationGroup = /* @__PURE__ */ ((OperationGroup2) => {
+  OperationGroup2["ALL_OPERATIONS"] = "ALL_OPERATIONS";
+  OperationGroup2["ALL_ITEM_OPERATIONS"] = "ALL_ITEM_OPERATIONS";
+  OperationGroup2["ALL_RELATIONSHIP_OPERATIONS"] = "ALL_RELATIONSHIP_OPERATIONS";
+  return OperationGroup2;
+})(OperationGroup || {});
+var TypeInfoORMServiceError = /* @__PURE__ */ ((TypeInfoORMServiceError2) => {
+  TypeInfoORMServiceError2["NO_DRIVERS_SUPPLIED"] = "NO_DRIVERS_SUPPLIED";
+  TypeInfoORMServiceError2["NO_RELATIONSHIP_DRIVERS_SUPPLIED"] = "NO_RELATIONSHIP_DRIVERS_SUPPLIED";
+  TypeInfoORMServiceError2["NO_PRIMARY_FIELD_VALUE_SUPPLIED"] = "NO_PRIMARY_FIELD_VALUE_SUPPLIED";
+  TypeInfoORMServiceError2["INVALID_DRIVER"] = "INVALID_DRIVER";
+  TypeInfoORMServiceError2["INVALID_RELATIONSHIP_DRIVER"] = "INVALID_RELATIONSHIP_DRIVER";
+  TypeInfoORMServiceError2["INVALID_TYPE_INFO"] = "INVALID_TYPE_INFO";
+  TypeInfoORMServiceError2["TYPE_INFO_MISSING_PRIMARY_FIELD"] = "TYPE_INFO_MISSING_PRIMARY_FIELD";
+  TypeInfoORMServiceError2["INVALID_RELATIONSHIP"] = "INVALID_RELATIONSHIP";
+  TypeInfoORMServiceError2["INVALID_OPERATION"] = "INVALID_OPERATION";
+  TypeInfoORMServiceError2["INVALID_UPDATE_OPERATOR"] = "INVALID_UPDATE_OPERATOR";
+  TypeInfoORMServiceError2["MISSING_ACCESSING_ROLE"] = "MISSING_ACCESSING_ROLE";
+  TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_CRITERIA"] = "INDEXING_UNSUPPORTED_CRITERIA";
+  TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_COMBINATION"] = "INDEXING_UNSUPPORTED_COMBINATION";
+  TypeInfoORMServiceError2["INDEXING_MISSING_BACKEND"] = "INDEXING_MISSING_BACKEND";
+  TypeInfoORMServiceError2["INDEXING_REQUIRES_CRITERIA"] = "INDEXING_REQUIRES_CRITERIA";
+  return TypeInfoORMServiceError2;
+})(TypeInfoORMServiceError || {});
+var TypeInfoORMAPIRoutePaths = /* @__PURE__ */ ((TypeInfoORMAPIRoutePaths2) => {
+  TypeInfoORMAPIRoutePaths2["CREATE"] = "create";
+  TypeInfoORMAPIRoutePaths2["READ"] = "read";
+  TypeInfoORMAPIRoutePaths2["UPDATE"] = "update";
+  TypeInfoORMAPIRoutePaths2["DELETE"] = "delete";
+  TypeInfoORMAPIRoutePaths2["LIST"] = "list";
+  TypeInfoORMAPIRoutePaths2["CREATE_RELATIONSHIP"] = "create-relationship";
+  TypeInfoORMAPIRoutePaths2["DELETE_RELATIONSHIP"] = "delete-relationship";
+  TypeInfoORMAPIRoutePaths2["LIST_RELATIONSHIPS"] = "list-relationships";
+  TypeInfoORMAPIRoutePaths2["LIST_RELATED_ITEMS"] = "list-related-items";
+  return TypeInfoORMAPIRoutePaths2;
+})(TypeInfoORMAPIRoutePaths || {});
+var TypeInfoORMUpdateOperators = {
+  NUMBER: {
+    INCREMENT: "INCREMENT",
+    DECREMENT: "DECREMENT"
+  }
+};
+
+export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError, TypeInfoORMUpdateOperators };

package/common/CommandLine/collectRequiredEnvironmentVariables.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Collect required environment variables or throw with a missing-name error.
+ *
+ * @typeParam VarName - Allowed environment variable names.
+ * @param varNames - List of required environment variable names.
+ * @returns Map of environment variable names to values.
+ * @throws Error when a required variable is missing or empty.
+ */
+export declare const collectRequiredEnvironmentVariables: <VarName extends string>(varNames: VarName[]) => Record<VarName, string>;

package/common/CommandLine/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ *
+ * Command-line utilities.
+ */
+export * from "./collectRequiredEnvironmentVariables";

package/common/HelperTypes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Expand inferred types for clearer IntelliSense/display.
+ *
+ * @typeParam T - Type to expand.
+ */
+export type ExpandComplexType<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export declare const HelperTypes: {};

package/common/IdGeneration/getSimpleId.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get a simple id, unique to the current run session.
+ *
+ * Includes a counter and timestamp so it stays unique within the same process.
+ *
+ * @returns A process-unique string id.
+ */
+export declare const getSimpleId: () => string;

package/common/IdGeneration/index.d.ts

@@ -0,0 +1 @@
+export * from "./getSimpleId";

package/common/ItemRelationshipInfoTypes.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Relationship info types used by ORM and relationship utilities.
+ */
+import type { ExpandComplexType } from "./HelperTypes";
+/**
+ * The keys for item relationship info.
+ * */
+export declare enum ItemRelationshipInfoKeys {
+    /**
+     * Relationship origin type name.
+     * */
+    fromTypeName = "fromTypeName",
+    /**
+     * Relationship origin field name.
+     * */
+    fromTypeFieldName = "fromTypeFieldName",
+    /**
+     * Relationship origin primary field value.
+     * */
+    fromTypePrimaryFieldValue = "fromTypePrimaryFieldValue",
+    /**
+     * Relationship destination primary field value.
+     * */
+    toTypePrimaryFieldValue = "toTypePrimaryFieldValue"
+}
+/**
+ * The identifying keys for item relationship info.
+ * */
+export declare enum ItemRelationshipInfoIdentifyingKeys {
+    /**
+     * Identifier value for a relationship item.
+     * */
+    id = "id"
+}
+/**
+ * The basis for an `ItemRelationshipInfo` without an assigned identifier.
+ * */
+export type BaseItemRelationshipInfo = Record<ItemRelationshipInfoKeys, string>;
+/**
+ * An item containing the information about a relationship between two items.
+ * */
+export type ItemRelationshipInfo = BaseItemRelationshipInfo & Record<ItemRelationshipInfoIdentifyingKeys, string>;
+/**
+ * The origination portion of an `ItemRelationshipInfo`.
+ * */
+export type ItemRelationshipOriginInfo = Record<ItemRelationshipInfoKeys.fromTypeName | ItemRelationshipInfoKeys.fromTypeFieldName, string>;
+/**
+ * The origination portion of an `ItemRelationshipInfo` for a specific item and field relationship.
+ * */
+export type ItemRelationshipOriginItemInfo = ExpandComplexType<ItemRelationshipOriginInfo & Record<ItemRelationshipInfoKeys.fromTypePrimaryFieldValue, string>>;
+/**
+ * The destination portion of an `ItemRelationshipInfo` for a specific, related item.
+ * */
+export type ItemRelationshipDestinationItemInfo = Record<ItemRelationshipInfoKeys.toTypePrimaryFieldValue, string>;
+/**
+ * The originating item info portion of an `ItemRelationshipInfo`.
+ *
+ * Used for relationship originating from a specific item, regardless of field relationship.
+ * */
+export type ItemRelationshipOriginatingItemInfo = Record<ItemRelationshipInfoKeys.fromTypeName | ItemRelationshipInfoKeys.fromTypePrimaryFieldValue, string>;
+/**
+ * One of the various types describing an item relationship.
+ * */
+export type ItemRelationshipInfoType = BaseItemRelationshipInfo | ItemRelationshipInfo | ItemRelationshipOriginInfo | ItemRelationshipOriginItemInfo;

package/common/ItemRelationships/ItemRelationshipValidation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Validation helpers for relationship items.
+ */
+import type { TypeInfoValidationResults } from "../TypeParsing/Validation";
+import { ItemRelationshipInfoKeys, ItemRelationshipInfoType } from "../ItemRelationshipInfoTypes";
+/**
+ * Error codes for relationship validation.
+ * */
+export declare const TYPE_INFO_ORM_RELATIONSHIP_ERRORS: {
+    INVALID_RELATIONSHIP_ITEM: string;
+    INVALID_RELATIONSHIP_ITEM_FIELD: string;
+    MISSING_RELATIONSHIP_ITEM_FIELD: string;
+};
+/**
+ * Validates a relationship item.
+ *
+ * @param relationshipItem - Relationship item to validate.
+ * @param omitFields - Relationship keys to ignore during validation.
+ * @returns Validation results with errors and errorMap when invalid.
+ * */
+export declare const validateRelationshipItem: (relationshipItem: ItemRelationshipInfoType, omitFields: ItemRelationshipInfoKeys[]) => TypeInfoValidationResults;

package/common/ItemRelationships/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ItemRelationshipValidation";
+export * from "../TypeParsing/Validation";

package/common/Logging/Utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Logging tags used by {@link logFunctionCall}.
+ */
+export declare enum LOGGING_MESSAGES {
+    LOGGING_FUNCTION_CALL = "LOGGING_FUNCTION_CALL",
+    INPUT = "INPUT",
+    OUTPUT = "OUTPUT",
+    ERROR = "ERROR"
+}
+export declare const logFunctionCall: (label: string, args: any[], functionRef: (...args: any[]) => Promise<any> | any, enabled: boolean) => Promise<any>;

package/common/Logging/index.d.ts

@@ -0,0 +1 @@
+export * from "./Utils";

package/common/Routing.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Helpers for parsing and composing path strings used by the Router utilities.
+ */
+/**
+ * The delimiter used to separate paths.
+ */
+export declare const PATH_DELIMITER = "/";
+/**
+ * Parse a string into JSON if possible, otherwise return the raw value.
+ *
+ * @param value - Input string to parse.
+ * @returns Parsed JSON or the original string.
+ */
+export declare const getPotentialJSONValue: (value: string) => any;
+/**
+ * Get the path segments from a path string.
+ *
+ * @param path - Path string to split.
+ * @param delimiter - Delimiter used to split the path.
+ * @param filterEmptyOutput - Whether to remove empty output segments.
+ * @param filterEmptyInput - Whether to remove empty input segments.
+ * @param useJson - Whether to parse each segment as JSON.
+ * @param uriDecodeParts - Whether to URI-decode each segment.
+ * @returns Array of path segments.
+ * */
+export declare const getPathArray: (path: string, delimiter?: string, filterEmptyOutput?: boolean, filterEmptyInput?: boolean, useJson?: boolean, uriDecodeParts?: boolean) => any[];
+/**
+ * Get the path string from path segments.
+ *
+ * @param parts - Path segments to join.
+ * @param delimiter - Delimiter used to join the path.
+ * @param filterEmptyInput - Whether to remove empty input segments.
+ * @param useJson - Whether to JSON-stringify each segment.
+ * @param uriEncodeParts - Whether to URI-encode each segment.
+ * @returns Joined path string.
+ * */
+export declare const getPathString: (parts?: any[], delimiter?: string, filterEmptyInput?: boolean, useJson?: boolean, uriEncodeParts?: boolean) => string;
+/**
+ * Merge two path strings.
+ *
+ * @param path1 - First path string.
+ * @param path2 - Second path string.
+ * @param delimiter - Delimiter used to split and join paths.
+ * @param filterEmptyOutput - Whether to remove empty output segments.
+ * @param filterEmptyInput - Whether to remove empty input segments.
+ * @param useJson - Whether to parse/serialize segments as JSON.
+ * @param uriEncodeParts - Whether to URI-encode each segment.
+ * @returns Merged path string.
+ * */
+export declare const mergeStringPaths: (path1: string, path2: string, delimiter?: string, filterEmptyOutput?: boolean, filterEmptyInput?: boolean, useJson?: boolean, uriEncodeParts?: boolean) => string;
+/**
+ * Resolve a path string against another path string.
+ *
+ * @param currentPath - Base path to resolve against.
+ * @param newPath - New path to resolve, absolute or relative.
+ * @returns Resolved path string.
+ * */
+export declare const resolvePath: (currentPath: string, newPath: string) => string;
+/**
+ * Resolve RouteAdapter navigation input against the current path.
+ *
+ * Rules:
+ * - `"/x"` resolves from root.
+ * - `"x"` and `"./x"` resolve under current path.
+ * - `"../x"` resolves one level up per `..`.
+ * - `"/"` and `""` both resolve to root (`"/"`).
+ *
+ * @param currentPath - Current absolute path (query/hash ignored).
+ * @param nextPath - Adapter navigation target (absolute or relative).
+ * @returns Resolved absolute path string.
+ */
+export declare const resolveRouteAdapterPath: (currentPath: string, nextPath: string) => string;
+/**
+ * Get the parameter values from a path string and test the `path` against a `testPath`.
+ *
+ * @param path - Actual path to test.
+ * @param testPath - Route pattern to match against.
+ * @param exact - Whether to require an exact match.
+ * @returns Params object when matched, otherwise false.
+ * */
+export declare const getParamsAndTestPath: (path: string, testPath: string, exact?: boolean) => Record<string, any> | false;

package/common/SearchTypes.d.ts

@@ -0,0 +1,227 @@
+/**
+ * Search-related types used by list/search APIs.
+ */
+import { ItemRelationshipInfo, ItemRelationshipOriginItemInfo } from "./ItemRelationshipInfoTypes";
+/**
+ * The logical operators for a search criteria.
+ * */
+export declare enum LogicalOperators {
+    /**
+     * Require all criteria to match.
+     * */
+    AND = "AND",
+    /**
+     * Require any criteria to match.
+     * */
+    OR = "OR"
+}
+/**
+ * The comparison operators for a field criterion.
+ * */
+export declare enum ComparisonOperators {
+    /**
+     * Field value equals the criterion value.
+     * */
+    EQUALS = "EQUALS",
+    /**
+     * Field value does not equal the criterion value.
+     * */
+    NOT_EQUALS = "NOT_EQUALS",
+    /**
+     * Field value is greater than the criterion value.
+     * */
+    GREATER_THAN = "GREATER_THAN",
+    /**
+     * Field value is greater than or equal to the criterion value.
+     * */
+    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL",
+    /**
+     * Field value is less than the criterion value.
+     * */
+    LESS_THAN = "LESS_THAN",
+    /**
+     * Field value is less than or equal to the criterion value.
+     * */
+    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL",
+    /**
+     * Field value is in the provided options.
+     * */
+    IN = "IN",
+    /**
+     * Field value is not in the provided options.
+     * */
+    NOT_IN = "NOT_IN",
+    /**
+     * Field value contains the criterion value as a substring.
+     * */
+    LIKE = "LIKE",
+    /**
+     * Field value does not contain the criterion value as a substring.
+     * */
+    NOT_LIKE = "NOT_LIKE",
+    /**
+     * Field value exists and is not null.
+     * */
+    EXISTS = "EXISTS",
+    /**
+     * Field value is missing or null.
+     * */
+    NOT_EXISTS = "NOT_EXISTS",
+    /**
+     * Field value is not empty.
+     * */
+    IS_NOT_EMPTY = "IS_NOT_EMPTY",
+    /**
+     * Field value is empty.
+     * */
+    IS_EMPTY = "IS_EMPTY",
+    /**
+     * Field value is within an inclusive range.
+     * */
+    BETWEEN = "BETWEEN",
+    /**
+     * Field value is outside an inclusive range.
+     * */
+    NOT_BETWEEN = "NOT_BETWEEN",
+    /**
+     * Field value array contains the criterion value.
+     * */
+    CONTAINS = "CONTAINS",
+    /**
+     * Field value array does not contain the criterion value.
+     * */
+    NOT_CONTAINS = "NOT_CONTAINS",
+    /**
+     * Field value starts with the criterion value.
+     * */
+    STARTS_WITH = "STARTS_WITH",
+    /**
+     * Field value ends with the criterion value.
+     * */
+    ENDS_WITH = "ENDS_WITH",
+    /**
+     * Field value does not start with the criterion value.
+     * */
+    DOES_NOT_START_WITH = "DOES_NOT_START_WITH",
+    /**
+     * Field value does not end with the criterion value.
+     * */
+    DOES_NOT_END_WITH = "DOES_NOT_END_WITH"
+}
+/**
+ * The field criterion for a search criteria.
+ * */
+export type FieldCriterion = {
+    /**
+     * Field name to compare.
+     * */
+    fieldName: string;
+    /**
+     * Comparison operator to apply.
+     * */
+    operator?: ComparisonOperators;
+    /**
+     * Custom operator label when using backend-specific operators.
+     * */
+    customOperator?: string;
+    /**
+     * Primary comparison value.
+     * */
+    value?: any;
+    /**
+     * Comparison value options (e.g., IN/BETWEEN).
+     * */
+    valueOptions?: any[];
+};
+/**
+ * The criteria for a search.
+ * */
+export type SearchCriteria = {
+    /**
+     * Logical operator to apply across field criteria.
+     * */
+    logicalOperator: LogicalOperators;
+    /**
+     * Field-level criteria to evaluate.
+     * */
+    fieldCriteria: FieldCriterion[];
+};
+/**
+ * The results from a request to list items.
+ * */
+export type ListItemsResults<ItemType extends Record<any, any>> = {
+    /**
+     * Cursor for paging into the next page, when available.
+     * */
+    cursor?: string;
+    /**
+     * Items returned by the request.
+     * */
+    items: ItemType[];
+};
+/**
+ * The information used to sort a list of items by a specified field.
+ * */
+export type SortField = {
+    /**
+     * Field name to sort by.
+     * */
+    field?: string;
+    /**
+     * Whether to reverse sort order.
+     * */
+    reverse?: boolean;
+};
+/**
+ * The data used to page a specific set of search results that uses full paging.
+ * @see SupportedTags.fullPaging
+ * */
+export type StandardExpandedPagingCursor = {
+    /**
+     * Current page number.
+     * */
+    currentPage?: number;
+    /**
+     * Total number of pages available.
+     * */
+    totalPages?: number;
+};
+/**
+ * The information for paging through a list of items.
+ * */
+export type PagingInfo = {
+    /**
+     * Items per page to request.
+     * */
+    itemsPerPage?: number;
+    /**
+     * Cursor token for paging.
+     * */
+    cursor?: string;
+};
+/**
+ * The configuration for listing and searching for items.
+ * */
+export type ListItemsConfig = PagingInfo & {
+    /**
+     * Structured search criteria.
+     * */
+    criteria?: SearchCriteria;
+    /**
+     * Sort fields to apply.
+     * */
+    sortFields?: SortField[];
+};
+/**
+ * A configuration for listing relationships.
+ * */
+export type ListRelationshipsConfig = PagingInfo & {
+    /**
+     * Relationship origin info used to filter related records.
+     * */
+    relationshipItemOrigin: ItemRelationshipOriginItemInfo;
+};
+/**
+ * The results from a request to list relationships.
+ * */
+export type ListRelationshipsResults = ListItemsResults<ItemRelationshipInfo>;

package/common/SearchUtils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Filtering and sorting utilities for search criteria.
+ */
+import { TypeInfoDataItem, TypeInfoMap } from "./TypeParsing/TypeInfo";
+import { ComparisonOperators, FieldCriterion, SearchCriteria, SortField } from "./SearchTypes";
+/**
+ * Basic comparison operators for filtering data.
+ * */
+export declare const COMPARATORS: Record<ComparisonOperators, (
+/**
+ * Criterion value to compare against.
+ * */
+criterionValue: any, 
+/**
+ * Criterion options for operators like IN/BETWEEN.
+ * */
+criterionValueOptions: any[] | undefined, 
+/**
+ * Field value from the item.
+ * */
+fieldValue: any) => boolean>;
+/**
+ * Compare a field criterion to a field value.
+ *
+ * @param fieldCriterion - Criterion to compare.
+ * @param fieldValue - Field value to test.
+ * @returns Whether the criterion matches the field value.
+ * */
+export declare const compare: (fieldCriterion: FieldCriterion, fieldValue: any) => boolean;
+/**
+ * Compare a field criterion to an array of field values.
+ *
+ * @param fieldCriterion - Criterion to compare.
+ * @param fieldValue - Array field value to test.
+ * @returns Whether the criterion matches the field value array.
+ * */
+export declare const compareArray: (fieldCriterion: FieldCriterion, fieldValue: any[] | undefined) => boolean;
+/**
+ * Get the filtered data items based on the search criteria.
+ *
+ * @param searchCriteria - Criteria to apply.
+ * @param items - Items to filter.
+ * @param typeInfoName - Optional type name for field metadata.
+ * @param typeInfoMap - Optional type info map for field metadata.
+ * @returns Filtered items that match the criteria.
+ * */
+export declare const getFilterTypeInfoDataItemsBySearchCriteria: (searchCriteria: SearchCriteria, items: TypeInfoDataItem[], typeInfoName?: string, typeInfoMap?: TypeInfoMap) => TypeInfoDataItem[];
+/**
+ * Get the sorted data items based on the given sort fields.
+ *
+ * @param sortFields - Sort field configuration.
+ * @param items - Items to sort.
+ * @returns Sorted items array.
+ * */
+export declare const getSortedItems: (sortFields?: SortField[], items?: TypeInfoDataItem[]) => TypeInfoDataItem[];

package/common/SearchValidation.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Validation rules for search criteria against TypeInfo definitions.
+ */
+import { FieldCriterion } from "./SearchTypes";
+import { CustomTypeInfoFieldValidatorMap, TypeInfoValidationResults } from "./TypeParsing/Validation";
+import { TypeInfoMap } from "./TypeParsing/TypeInfo";
+/**
+ * Search validation errors.
+ * */
+export declare const SEARCH_VALIDATION_ERRORS: {
+    INVALID_TYPE_INFO: string;
+    RELATIONAL_FIELDS_NOT_ALLOWED: string;
+    INVALID_FIELD: string;
+    INVALID_VALUE_OPTION: string;
+    INVALID_OPERATOR: string;
+};
+/**
+ * Validate search fields against type info fields.
+ *
+ * @param typeInfoName - Type name to validate against.
+ * @param typeInfoMap - Type info map containing field definitions.
+ * @param searchFields - Field criteria to validate.
+ * @param disallowRelationalFields - Whether to forbid relational fields.
+ * @param customValidators - Custom field validators by type name.
+ * @returns Validation results with errors and error map.
+ * */
+export declare const validateSearchFields: (typeInfoName: string, typeInfoMap: TypeInfoMap, searchFields?: FieldCriterion[], disallowRelationalFields?: boolean, customValidators?: CustomTypeInfoFieldValidatorMap) => TypeInfoValidationResults;