@allurereport/web-commons 3.0.1 → 3.2.0

package/dist/attachments.d.ts

@@ -1,21 +1,34 @@
-export interface Attachments {
+type AttachmentImageData = {
+    img: string;
+    id?: string;
+};
+type AttachmentTextData = {
+    text: string;
+};
+type AttachmentVideoData = {
+    src: string;
+    id?: string;
+    contentType?: string;
+};
+type AttachmentImageDiffData = {
+    diff: {
+        actual?: string;
+        expected?: string;
+        diff?: string;
+    };
+};
+export type AttachmentData = AttachmentImageData | AttachmentTextData | AttachmentVideoData | AttachmentImageDiffData;
+type AttachmentPayload = {
     id?: string;
     ext?: string;
     contentType?: string;
-    text?: string;
-    src?: string;
-    img?: string;
-}
-export declare const fetchFromUrl: ({ id, ext, contentType }: Attachments) => Promise<Response>;
-export declare const fetchAttachment: (id: string, ext: string, contentType?: string) => Promise<Attachments | null>;
+};
+export declare const fetchFromUrl: ({ id, ext, contentType }: AttachmentPayload) => Promise<Response>;
+export declare const fetchAttachment: (id: string, ext: string, contentType?: string) => Promise<AttachmentData | null>;
 export declare const blobAttachment: (id: string, ext: string, contentType: string) => Promise<Blob>;
 export declare const downloadAttachment: (id: string, ext: string, contentType: string) => Promise<void>;
 export declare const openAttachmentInNewTab: (id: string, ext: string, contentType: string) => Promise<void>;
-export declare const attachmentType: (type?: string) => {
-    type: string;
-    icon: string;
-} | {
-    type: null;
-    icon: string;
-};
+export type AttachmentType = "css" | "json" | "image" | "svg" | "code" | "text" | "html" | "table" | "video" | "uri" | "archive" | "image-diff";
+export declare const attachmentType: (type?: string) => AttachmentType | null;
 export declare const restrictedContentTypes: string[];
+export {};

package/dist/attachments.js

@@ -9,7 +9,10 @@ export const fetchAttachment = async (id, ext, contentType) => {
     }
     const response = await fetchFromUrl({ id, ext, contentType });
     const fileType = attachmentType(contentType);
-    switch (fileType.type) {
+    if (!response.ok) {
+        throw new Error("Failed to fetch");
+    }
+    switch (fileType) {
         case "svg":
         case "image": {
             const blob = await response.blob();
@@ -29,6 +32,10 @@ export const fetchAttachment = async (id, ext, contentType) => {
             const src = URL.createObjectURL(blob);
             return { src, id, contentType };
         }
+        case "image-diff": {
+            const json = await response.json();
+            return { diff: json };
+        }
         default:
             return null;
     }
@@ -67,10 +74,7 @@ export const attachmentType = (type) => {
         case "image/jpg":
         case "image/png":
         case "image/*":
-            return {
-                type: "image",
-                icon: "file",
-            };
+            return "image";
         case "text/xml":
         case "text/json":
         case "text/yaml":
@@ -100,63 +104,34 @@ export const attachmentType = (type) => {
         case "application/x-yaml":
         case "application/xml":
         case "application/json":
-            return {
-                type: "code",
-                icon: "file",
-            };
+            return "code";
         case "text/plain":
         case "text/markdown":
         case "text/*":
-            return {
-                type: "text",
-                icon: "txt",
-            };
+            return "text";
         case "text/html":
-            return {
-                type: "html",
-                icon: "file",
-            };
+            return "html";
         case "text/csv":
-            return {
-                type: "table",
-                icon: "csv",
-            };
         case "text/tab-separated-values":
-            return {
-                type: "table",
-                icon: "table",
-            };
+            return "table";
         case "image/svg+xml":
-            return {
-                type: "svg",
-                icon: "file",
-            };
+            return "svg";
         case "video/mp4":
         case "video/ogg":
         case "video/webm":
-            return {
-                type: "video",
-                icon: "file",
-            };
+            return "video";
         case "text/uri-list":
-            return {
-                type: "uri",
-                icon: "list",
-            };
+            return "uri";
         case "application/x-tar":
         case "application/x-gtar":
         case "application/x-bzip2":
         case "application/gzip":
         case "application/zip":
-            return {
-                type: "archive",
-                icon: "file",
-            };
+            return "archive";
+        case "application/vnd.allure.image.diff":
+            return "image-diff";
         default:
-            return {
-                type: null,
-                icon: "file",
-            };
+            return null;
     }
 };
 export const restrictedContentTypes = ["application/gzip"];

package/dist/charts/generateStatusAgePyramid.d.ts

@@ -0,0 +1,5 @@
+import type { AllureChartsStoreData, StatusAgePyramidChartData, StatusAgePyramidChartOptions } from "@allurereport/charts-api";
+export declare const generateStatusAgePyramid: (props: {
+    options: StatusAgePyramidChartOptions;
+    storeData: AllureChartsStoreData;
+}) => StatusAgePyramidChartData;

package/dist/charts/{generateFBSUAgePyramid.js → generateStatusAgePyramid.js}

@@ -1,15 +1,14 @@
 import { ChartType, DEFAULT_CHART_HISTORY_LIMIT } from "@allurereport/charts-api";
-import { htrsByTr } from "@allurereport/core-api";
 import { limitHistoryDataPoints } from "./chart-utils.js";
-const createEmptyStats = (statuses) => {
-    return statuses.reduce((acc, status) => {
+const createEmptyStats = () => {
+    return STATUSES.reduce((acc, status) => {
         acc[status] = 0;
         return acc;
     }, {});
 };
 const STATUSES = ["failed", "broken", "skipped", "unknown"];
 const isFBSUStatus = (status) => STATUSES.includes(status);
-export const generateFBSUAgePyramid = (props) => {
+export const generateStatusAgePyramid = (props) => {
     const { options, storeData } = props;
     const { limit = DEFAULT_CHART_HISTORY_LIMIT } = options;
     const { historyDataPoints, testResults } = storeData;
@@ -17,23 +16,35 @@ export const generateFBSUAgePyramid = (props) => {
     const limitedHistoryPoints = limitHistoryDataPoints(historyDataPoints, limit).sort((a, b) => a.timestamp - b.timestamp);
     if (limitedHistoryPoints.length === 0) {
         return {
-            type: ChartType.FBSUAgePyramid,
+            type: ChartType.StatusAgePyramid,
             title: options.title,
             data: [
                 {
                     id: "current",
                     timestamp: currentReportTimestamp,
-                    ...createEmptyStats(STATUSES),
+                    ...createEmptyStats(),
                 },
             ],
             statuses: STATUSES,
         };
     }
-    const [earliestHdp, ...hdps] = limitedHistoryPoints;
+    const hdps = limitedHistoryPoints.map((datapoint) => ({
+        ...datapoint,
+        testResults: Object.values(datapoint.testResults).reduce((acc, testResult) => {
+            if (!testResult.historyId) {
+                return acc;
+            }
+            const isInCurrentRun = testResults.findIndex((tr) => tr.historyId === testResult.historyId) !== -1;
+            if (isInCurrentRun) {
+                acc[testResult.historyId] = testResult;
+            }
+            return acc;
+        }, {}),
+    }));
     const dataPoints = [
         ...hdps.map((hdp) => ({
             ...hdp,
-            ...createEmptyStats(STATUSES),
+            ...createEmptyStats(),
         })),
         {
             testResults: testResults.reduce((acc, testResult) => {
@@ -42,22 +53,23 @@ export const generateFBSUAgePyramid = (props) => {
             }, {}),
             uuid: "current",
             timestamp: currentReportTimestamp,
-            ...createEmptyStats(STATUSES),
+            ...createEmptyStats(),
         },
     ];
-    dataPoints.forEach((dp, index, dataPointsAscending) => {
+    dataPoints.forEach((dp, index, dps) => {
         const { testResults: trs } = dp;
-        const isFirst = index === 0;
-        const hpsPriorToCurrent = isFirst ? [earliestHdp] : dataPointsAscending.slice(0, index);
+        const historyAfter = dps.slice(index, dps.length - 1);
         const currentTrs = Object.values(trs);
         for (const cTr of currentTrs) {
-            if (!isFBSUStatus(cTr.status)) {
+            const currentTrStatus = cTr.status;
+            if (!isFBSUStatus(currentTrStatus)) {
                 continue;
             }
-            const htrsPriortoCurr = htrsByTr(hpsPriorToCurrent, cTr);
-            if (htrsPriortoCurr.length === 0) {
-                dp[cTr.status]++;
+            const historyAfterTrsStatuses = historyAfter.map((hdp) => hdp.testResults[cTr.historyId]?.status ?? undefined);
+            if (historyAfterTrsStatuses.some((status) => status !== currentTrStatus)) {
+                continue;
             }
+            dp[currentTrStatus]++;
         }
     });
     const data = dataPoints.map(({ uuid, timestamp, ...stats }) => ({
@@ -69,7 +81,7 @@ export const generateFBSUAgePyramid = (props) => {
         unknown: stats.unknown ?? 0,
     }));
     return {
-        type: ChartType.FBSUAgePyramid,
+        type: ChartType.StatusAgePyramid,
         title: options.title,
         data: data,
         statuses: STATUSES,

package/dist/charts/generators.d.ts

@@ -1,4 +1,5 @@
 import { type ChartOptions, type GeneratedChartsData } from "@allurereport/charts-api";
+import type { TestResult } from "@allurereport/core-api";
 import { type AllureStore } from "@allurereport/plugin-api";
 type ChartsWidgetData = {
     general: GeneratedChartsData;
@@ -6,5 +7,5 @@ type ChartsWidgetData = {
         [env: string]: GeneratedChartsData;
     };
 };
-export declare const generateCharts: (chartsOptions: ChartOptions[], store: AllureStore, reportName: string, generateUuid: () => string) => Promise<ChartsWidgetData>;
+export declare const generateCharts: (chartsOptions: ChartOptions[], store: AllureStore, reportName: string, generateUuid: () => string, filter?: (testResult: TestResult) => boolean) => Promise<ChartsWidgetData>;
 export {};

package/dist/charts/generators.js

@@ -3,8 +3,8 @@ import { DEFAULT_ENVIRONMENT } from "@allurereport/core-api";
 import { generateCurrentStatusChart } from "./generateCurrentStatusChart.js";
 import { generateDurationDynamicsChart } from "./generateDurationDynamicsChart.js";
 import { generateDurationsChart } from "./generateDurationsChart.js";
-import { generateFBSUAgePyramid } from "./generateFBSUAgePyramid.js";
 import { generateStabilityDistributionChart } from "./generateStabilityDistributionChart.js";
+import { generateStatusAgePyramid } from "./generateStatusAgePyramid.js";
 import { generateStatusDynamicsChart } from "./generateStatusDynamicsChart.js";
 import { generateStatusTransitionsChart } from "./generateStatusTransitionsChart.js";
 import { generateTestBaseGrowthDynamicsChart } from "./generateTestBaseGrowthDynamicsChart.js";
@@ -13,12 +13,61 @@ import { generateTrSeveritiesChart } from "./generateTrSeveritiesChart.js";
 import { generateHeatMapChart } from "./heatMap.js";
 import { generateTreeMapChart } from "./treeMap.js";
 const generateChartData = async (props) => {
-    const { env, chartsOptions, store, reportName, generateUuid } = props;
+    const { env, chartsOptions, store, generateUuid, filter } = props;
     const result = {};
+    const getTrs = async () => {
+        let trs = [];
+        if (env) {
+            trs = await store.testResultsByEnvironment(env);
+        }
+        else {
+            trs = await store.allTestResults();
+        }
+        if (filter) {
+            trs = trs.filter(filter);
+        }
+        return trs;
+    };
+    const getHistoryDataPoints = async () => {
+        let historyDataPoints = [];
+        if (env) {
+            historyDataPoints = await store.allHistoryDataPointsByEnvironment(env);
+        }
+        historyDataPoints = await store.allHistoryDataPoints();
+        if (typeof filter === "function") {
+            historyDataPoints = historyDataPoints.map((hdp) => {
+                const trsEntries = Object.entries(hdp.testResults);
+                const filteredTrsEntries = trsEntries.filter(([, tr]) => {
+                    try {
+                        return filter(tr);
+                    }
+                    catch (error) {
+                        return false;
+                    }
+                });
+                return {
+                    ...hdp,
+                    testResults: Object.fromEntries(filteredTrsEntries),
+                };
+            });
+        }
+        return historyDataPoints;
+    };
+    const getStatistic = () => {
+        return store.testsStatistic((tr) => {
+            if (env && tr.environment !== env) {
+                return false;
+            }
+            if (typeof filter === "function" && !filter(tr)) {
+                return false;
+            }
+            return true;
+        });
+    };
     const storeData = await Promise.all([
-        env ? await store.allHistoryDataPointsByEnvironment(env) : await store.allHistoryDataPoints(),
-        env ? await store.testResultsByEnvironment(env) : await store.allTestResults(),
-        env ? await store.testsStatistic((tr) => tr.environment === env) : await store.testsStatistic(),
+        await getHistoryDataPoints(),
+        await getTrs(),
+        await getStatistic(),
     ]).then(([historyDataPoints, testResults, statistic]) => ({
         historyDataPoints,
         testResults,
@@ -48,8 +97,8 @@ const generateChartData = async (props) => {
             case ChartType.TestBaseGrowthDynamics:
                 result[chartId] = generateTestBaseGrowthDynamicsChart({ options: chartOption, storeData });
                 break;
-            case ChartType.FBSUAgePyramid:
-                result[chartId] = generateFBSUAgePyramid({ options: chartOption, storeData });
+            case ChartType.StatusAgePyramid:
+                result[chartId] = generateStatusAgePyramid({ options: chartOption, storeData });
                 break;
             case ChartType.TrSeverities:
                 result[chartId] = generateTrSeveritiesChart({ options: chartOption, storeData });
@@ -75,10 +124,10 @@ const generateChartData = async (props) => {
 const hasOnlyDefaultEnvironment = (environments) => {
     return environments.length === 1 && environments[0] === DEFAULT_ENVIRONMENT;
 };
-export const generateCharts = async (chartsOptions, store, reportName, generateUuid) => {
+export const generateCharts = async (chartsOptions, store, reportName, generateUuid, filter) => {
     const environments = await store.allEnvironments();
     const chartsData = {
-        general: await generateChartData({ chartsOptions, store, reportName, generateUuid }),
+        general: await generateChartData({ chartsOptions, store, reportName, generateUuid, filter }),
         byEnv: {},
     };
     if (hasOnlyDefaultEnvironment(environments)) {
@@ -91,6 +140,7 @@ export const generateCharts = async (chartsOptions, store, reportName, generateU
             reportName,
             env: environment,
             generateUuid,
+            filter,
         });
     }
     return chartsData;

package/dist/charts/types.d.ts

@@ -1,4 +1,4 @@
-import type { ChartId, ChartType, DurationDynamicsChartData, DurationsChartData, FBSUAgePyramidChartData, HeatMapSerie, StabilityDistributionChartData, StatusTransitionsChartData, TestBaseGrowthDynamicsChartData, TestingPyramidChartData, TrSeveritiesChartData, TreeMapNode } from "@allurereport/charts-api";
+import type { ChartId, ChartType, DurationDynamicsChartData, DurationsChartData, HeatMapSerie, StabilityDistributionChartData, StatusAgePyramidChartData, StatusTransitionsChartData, TestBaseGrowthDynamicsChartData, TestingPyramidChartData, TrSeveritiesChartData, TreeMapNode } from "@allurereport/charts-api";
 import type { Statistic, TestStatus } from "@allurereport/core-api";
 export type TreeMapTooltipAccessor = <T>(node: T) => string[];
 export interface Point {
@@ -58,8 +58,8 @@ export interface UITreeMapChartData extends ResponseTreeMapChartData {
 export interface UIHeatMapChartData extends ResponseHeatMapChartData {
     colors: (value: number, domain?: number[]) => string;
 }
-export type ChartData = CurrentStatusChartData | StatusDynamicsChartData | StatusTransitionsChartData | DurationsChartData | StabilityDistributionChartData | ResponseTreeMapChartData | ResponseHeatMapChartData | TestBaseGrowthDynamicsChartData | FBSUAgePyramidChartData | TrSeveritiesChartData | DurationDynamicsChartData | TestingPyramidChartData;
-export type UIChartData = UICurrentStatusChartData | UIStatusDynamicsChartData | UITreeMapChartData | UIHeatMapChartData | UIStatusTransitionsChartData | UIDurationsChartData | TestBaseGrowthDynamicsChartData | FBSUAgePyramidChartData | StabilityDistributionChartData | TrSeveritiesChartData | DurationDynamicsChartData | TestingPyramidChartData;
+export type ChartData = CurrentStatusChartData | StatusDynamicsChartData | StatusTransitionsChartData | DurationsChartData | StabilityDistributionChartData | ResponseTreeMapChartData | ResponseHeatMapChartData | TestBaseGrowthDynamicsChartData | StatusAgePyramidChartData | TrSeveritiesChartData | DurationDynamicsChartData | TestingPyramidChartData;
+export type UIChartData = UICurrentStatusChartData | UIStatusDynamicsChartData | UITreeMapChartData | UIHeatMapChartData | UIStatusTransitionsChartData | UIDurationsChartData | TestBaseGrowthDynamicsChartData | StatusAgePyramidChartData | StabilityDistributionChartData | TrSeveritiesChartData | DurationDynamicsChartData | TestingPyramidChartData;
 export type ChartsData = Record<ChartId, ChartData>;
 export type ChartsDataWithEnvs = {
     general: Record<ChartId, ChartData>;

package/dist/charts/utils.js

@@ -107,7 +107,7 @@ export const createCharts = (res) => {
         else if (chart.type === ChartType.TestBaseGrowthDynamics) {
             acc[chartId] = res[chartId];
         }
-        else if (chart.type === ChartType.FBSUAgePyramid) {
+        else if (chart.type === ChartType.StatusAgePyramid) {
             acc[chartId] = res[chartId];
         }
         else if (chart.type === ChartType.TrSeverities) {

package/dist/data.d.ts

@@ -4,8 +4,12 @@ export declare const loadReportData: (name: string) => Promise<string>;
 export declare const reportDataUrl: (path: string, contentType?: string, params?: {
     bustCache: boolean;
 }) => Promise<string>;
+export declare class ReportFetchError extends Error {
+    readonly response: Response;
+    constructor(message: string, response: Response);
+}
 export declare const fetchReportJsonData: <T>(path: string, params?: {
     bustCache: boolean;
 }) => Promise<T>;
 export declare const fetchReportAttachment: (path: string, contentType?: string) => Promise<Response>;
-export declare const getReportOptions: <T>() => T;
+export declare const getReportOptions: <T>() => Readonly<T>;

package/dist/data.js

@@ -28,7 +28,7 @@ export const reportDataUrl = async (path, contentType = "application/octet-strea
     const baseEl = globalThis.document.head.querySelector("base")?.href ?? "https://localhost";
     const url = new URL(path, baseEl);
     const liveReloadHash = globalThis.localStorage.getItem(ALLURE_LIVE_RELOAD_HASH_STORAGE_KEY);
-    const cacheKey = globalThis.allureReportOptions?.cacheKey;
+    const cacheKey = getReportOptions()?.cacheKey;
     if (liveReloadHash) {
         url.searchParams.set("live_reload_hash", liveReloadHash);
     }
@@ -37,11 +37,17 @@ export const reportDataUrl = async (path, contentType = "application/octet-strea
     }
     return url.toString();
 };
+export class ReportFetchError extends Error {
+    constructor(message, response) {
+        super(message);
+        this.response = response;
+    }
+}
 export const fetchReportJsonData = async (path, params) => {
     const url = await reportDataUrl(path, undefined, params);
     const res = await globalThis.fetch(url);
     if (!res.ok) {
-        throw new Error(`Failed to fetch ${url}, response status: ${res.status}`);
+        throw new ReportFetchError(`Failed to fetch ${url}, response status: ${res.status}`, res);
     }
     const data = res.json();
     return data;

package/dist/filters/builders.d.ts

@@ -0,0 +1,4 @@
+import type { AqlExpression } from "@allurereport/aql";
+import { type Filter } from "./model.js";
+export declare const buildFieldFilters: <T extends string = string>(filters: Filter<T>[]) => AqlExpression;
+export declare const buildFilterPredicate: <Keys extends string = string>(filters: Filter<Keys>[]) => (item: Record<Keys, any>) => boolean;

package/dist/filters/builders.js

@@ -0,0 +1,160 @@
+import { aqlArrayConditionExpression, aqlBinaryExpression, aqlConditionExpression, aqlParenExpression, createAqlPredicate, } from "@allurereport/aql";
+import { MAX_ARRAY_FIELD_VALUES, } from "./model.js";
+const buildAqlFromFieldFilter = (field) => {
+    const { value: fieldValue } = field;
+    const { key, type, strict, value } = fieldValue;
+    if (type === "array") {
+        if (value.length === 0) {
+            throw new Error("ArrayField value cannot be empty");
+        }
+        if (strict === false) {
+            return buildArrayIntersectionFilter(key, value, MAX_ARRAY_FIELD_VALUES);
+        }
+        return aqlArrayConditionExpression({
+            type: "arrayCondition",
+            left: {
+                identifier: key,
+            },
+            operator: "IN",
+            right: value.map((item) => ({
+                value: item,
+                type: "STRING",
+            })),
+        });
+    }
+    let expressionValue;
+    let valueType;
+    let operator = "EQ";
+    switch (type) {
+        case "number": {
+            expressionValue = String(value);
+            operator = (strict ?? true) ? "EQ" : "CONTAINS";
+            valueType = "NUMBER";
+            break;
+        }
+        case "boolean": {
+            expressionValue = value ? "true" : "false";
+            valueType = "BOOLEAN";
+            operator = "EQ";
+            break;
+        }
+        case "string": {
+            expressionValue = String(value);
+            operator = (strict ?? true) ? "EQ" : "CONTAINS";
+            valueType = "STRING";
+            break;
+        }
+        default: {
+            const exhaustiveCheck = type;
+            throw new Error(`Unsupported field type: ${String(exhaustiveCheck)}`);
+        }
+    }
+    return aqlConditionExpression({
+        type: "condition",
+        left: {
+            identifier: key,
+        },
+        operator,
+        right: {
+            value: expressionValue,
+            type: valueType,
+        },
+    });
+};
+export const buildFieldFilters = (filters) => {
+    if (filters.length === 0) {
+        throw new Error("chainFieldFilters: filters array cannot be empty");
+    }
+    const buildAqlFromFilterGroup = (group) => {
+        const { value } = group;
+        if (value.length === 0) {
+            throw new Error("buildFieldFilters: value array cannot be empty");
+        }
+        if (value.length === 1) {
+            return buildFieldFilters([value[0]]);
+        }
+        return aqlParenExpression({
+            type: "paren",
+            expression: buildFieldFilters(value),
+        });
+    };
+    if (filters.length === 1) {
+        const [filter] = filters;
+        if (filter.type === "field") {
+            return buildAqlFromFieldFilter(filter);
+        }
+        return buildAqlFromFilterGroup(filter);
+    }
+    const [first, second, ...rest] = filters;
+    if (rest.length === 0) {
+        return aqlBinaryExpression({
+            type: "binary",
+            operator: first.logicalOperator ?? "AND",
+            left: buildFieldFilters([first]),
+            right: buildFieldFilters([second]),
+        });
+    }
+    return rest.reduce((acc, filter) => {
+        return aqlBinaryExpression({
+            type: "binary",
+            operator: filter.logicalOperator ?? "AND",
+            left: acc,
+            right: buildFieldFilters([filter]),
+        });
+    }, buildFieldFilters([first, second]));
+};
+const buildArrayIntersectionFilter = (key, values, maxIndex = 20) => {
+    if (values.length === 0) {
+        throw new Error("buildArrayIntersectionFilter: values array cannot be empty");
+    }
+    const conditionsPerValue = values.map((value) => {
+        const indexConditions = Array.from({ length: maxIndex + 1 }, (_, index) => {
+            return aqlConditionExpression({
+                type: "condition",
+                left: {
+                    identifier: key,
+                    param: {
+                        value: index,
+                        type: "number",
+                    },
+                },
+                operator: "EQ",
+                right: {
+                    value,
+                    type: "STRING",
+                },
+            });
+        });
+        if (indexConditions.length === 1) {
+            return indexConditions[0];
+        }
+        return indexConditions.reduce((acc, condition, index) => {
+            if (index === 0) {
+                return condition;
+            }
+            return aqlBinaryExpression({
+                type: "binary",
+                operator: "OR",
+                left: acc,
+                right: condition,
+            });
+        }, indexConditions[0]);
+    });
+    if (conditionsPerValue.length === 1) {
+        return conditionsPerValue[0];
+    }
+    return conditionsPerValue.reduce((acc, condition, index) => {
+        if (index === 0) {
+            return condition;
+        }
+        return aqlBinaryExpression({
+            type: "binary",
+            operator: "OR",
+            left: acc,
+            right: condition,
+        });
+    }, conditionsPerValue[0]);
+};
+export const buildFilterPredicate = (filters) => {
+    return createAqlPredicate(buildFieldFilters(filters));
+};

package/dist/filters/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./builders.js";
+export type { ArrayField, BooleanField, Field, FieldFilter, FieldFilterGroup, Filter, LogicalOperator, NumberField, StringField, } from "./model.js";
+export { MAX_ARRAY_FIELD_VALUES } from "./model.js";

package/dist/filters/index.js

@@ -0,0 +1,2 @@
+export * from "./builders.js";
+export { MAX_ARRAY_FIELD_VALUES } from "./model.js";