@gooddata/sdk-ui-filters 11.54.0-alpha.4 → 11.54.0-alpha.5

package/esm/AttributeFilterHandler/fixtures.d.ts

@@ -0,0 +1,34 @@
+import { type ElementsQueryOptionsElementsSpecification, type IElementsQueryAttributeFilter } from "@gooddata/sdk-backend-spi";
+import { type IAttributeElement, type IAttributeFilter, type IMeasure, type IRelativeDateFilter } from "@gooddata/sdk-model";
+export declare const particularAttributeElements: ElementsQueryOptionsElementsSpecification;
+export declare const anotherParticularAttributeElements: ElementsQueryOptionsElementsSpecification;
+export declare const limitingAttributeFilters: IElementsQueryAttributeFilter[];
+export declare const limitingMeasures: IMeasure[];
+export declare const limitingDateFilters: IRelativeDateFilter[];
+export declare const staticElements: IAttributeElement[];
+export declare const hiddenElements: string[];
+export declare const newTestAttributeFilterHandler: (useCase: "hidden" | "negative" | "nonExisting" | "positive" | "static") => import("./types/attributeFilterHandler.js").IMultiSelectAttributeFilterHandler;
+export declare const positiveAttributeFilterDefaultDF: import("@gooddata/sdk-model").IPositiveAttributeFilter;
+export declare const emptyPositiveAttributeFilterDefaultDF: import("@gooddata/sdk-model").IPositiveAttributeFilter;
+export declare const negativeAttributeFilterDefaultDF: import("@gooddata/sdk-model").INegativeAttributeFilter;
+export declare const newTestAttributeFilterHandlerWithAttributeFilter: (attributeFilter: IAttributeFilter, advancedOptions?: {
+    staticElements?: IAttributeElement[] | undefined;
+    hiddenElements?: string[] | undefined;
+} | undefined) => import("./types/attributeFilterHandler.js").IMultiSelectAttributeFilterHandler;
+/**
+ * Handler whose elements loads can be made to fail on demand.
+ *
+ * The failure is injected into the backend the handler talks to, so that the tests of the error
+ * paths do not have to mock the internal loadElements module. A module mock cannot be relied on
+ * here, because the test files share the module registry (see `isolate: false` in vitest.config.ts)
+ * and the module is already evaluated unmocked by the time such a suite runs.
+ */
+export declare const newTestAttributeFilterHandlerWithElementsLoadFailures: (attributeFilter: IAttributeFilter) => {
+    attributeFilterHandler: import("./types/attributeFilterHandler.js").IMultiSelectAttributeFilterHandler;
+    /**
+     * Makes the next elements load reject with the provided error. Call it repeatedly to queue up
+     * more failures, one per load - the equivalent of several mockRejectedValueOnce() calls.
+     */
+    failNextElementsLoad: (error: unknown) => void;
+};
+//# sourceMappingURL=fixtures.d.ts.map

package/esm/AttributeFilterHandler/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/AttributeFilterHandler/fixtures.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yCAAyC,EAG9C,KAAK,6BAA6B,EACrC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAQ3B,MAAM,qBAAqB,CAAC;AAI7B,eAAO,MAAM,2BAA2B,EAAE,yCAEzC,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,yCAEhD,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,6BAA6B,EAOnE,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,EAAyB,CAAC;AAEjE,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,EAEpD,CAAC;AAyDF,eAAO,MAAM,cAAc,qBAKpB,CAAC;AAIR,eAAO,MAAM,cAAc,UAAsB,CAAC;AAElD,eAAO,MAAM,6BAA6B,4JAuBzC,CAAC;AAEF,eAAO,MAAM,gCAAgC,wDAE3C,CAAC;AAEH,eAAO,MAAM,qCAAqC,wDAEhD,CAAC;AAEH,eAAO,MAAM,gCAAgC,wDAE3C,CAAC;AAEH,eAAO,MAAM,gDAAgD;;;gGAU5D,CAAC;AA2EF;;;;;;;GAOG;AACH,eAAO,MAAM,qDAAqD;;IAU1D;;;OAGG;;CAKV,CAAC"}

package/esm/AttributeFilterHandler/fixtures.js

@@ -0,0 +1,184 @@
+// (C) 2019-2026 GoodData Corporation
+import { ReferenceMd, ReferenceRecordings } from "@gooddata/reference-workspace";
+import { recordedBackend } from "@gooddata/sdk-backend-mockingbird";
+import { attributeIdentifier, idRef, measureIdentifier, newNegativeAttributeFilter, newPositiveAttributeFilter, newRelativeDateFilter, } from "@gooddata/sdk-model";
+import { newAttributeFilterHandler } from "./factory.js";
+export const particularAttributeElements = {
+    values: ["TouchAll", "WonderKid"],
+};
+export const anotherParticularAttributeElements = {
+    values: ["PhoenixSoft"],
+};
+export const limitingAttributeFilters = [
+    {
+        attributeFilter: newPositiveAttributeFilter(ReferenceMd.Product.Name, {
+            uris: ["460488"],
+        }),
+        overAttribute: idRef("attr.opportunitysnapshot.id"),
+    },
+];
+export const limitingMeasures = [ReferenceMd.Amount];
+export const limitingDateFilters = [
+    newRelativeDateFilter(ReferenceMd.DateDatasets.Snapshot.SnapshotDate.identifier, "GDC.time.date", 0, -1),
+];
+const productNameAttrId = attributeIdentifier(ReferenceMd.Product.Name);
+const amountMeasureId = measureIdentifier(ReferenceMd.Amount);
+const snapshotDateId = ReferenceMd.DateDatasets.Snapshot.SnapshotDate.identifier;
+const productDefaultId = attributeIdentifier(ReferenceMd.Product.Default);
+const backend = recordedBackend(ReferenceRecordings.Recordings, {
+    attributeElementsFiltering: {
+        attributeFilters: {
+            [productNameAttrId]: (_element, index) => {
+                return (index + 1) % 2 === 0;
+            },
+            [productDefaultId]: (_element, index) => {
+                return (index + 1) % 2 === 0;
+            },
+        },
+        measures: {
+            [amountMeasureId]: (_element, index) => {
+                return (index + 1) % 3 === 0;
+            },
+        },
+        dateFilters: {
+            [snapshotDateId]: (_element, index) => {
+                return (index + 1) % 4 === 0;
+            },
+        },
+    },
+});
+const workspace = "testWorkspace";
+const positiveAttributeFilter = newPositiveAttributeFilter(ReferenceMd.Product.Name, {
+    uris: ["165678", "165847"],
+});
+const emptyPositiveAttributeFilter = newPositiveAttributeFilter(ReferenceMd.Product.Name, {
+    uris: [],
+});
+const negativeAttributeFilter = newNegativeAttributeFilter(ReferenceMd.Product.Name, {
+    uris: ["165678", "165847"],
+});
+const nonExistingAttributeFilter = newPositiveAttributeFilter("non-existing-displayForm", {
+    uris: [],
+});
+const createDummyElements = (createElement, size) => new Array(size).fill(null).reduce((result, _, index) => {
+    result.push(createElement(index));
+    return result;
+}, []);
+export const staticElements = createDummyElements((index) => {
+    return {
+        title: `Element ${index}`,
+        uri: `/element?id=${index}`,
+    };
+}, 100);
+// This actually does not filter elements in mockingbirg
+// It just triggers usage of the attributeElementsFiltering
+export const hiddenElements = ["/hidden-element"];
+export const newTestAttributeFilterHandler = (useCase) => {
+    let filter = positiveAttributeFilter;
+    const options = {
+        selectionMode: "multi",
+    };
+    if (useCase === "positive") {
+        filter = positiveAttributeFilter;
+    }
+    else if (useCase === "negative") {
+        filter = negativeAttributeFilter;
+    }
+    else if (useCase === "nonExisting") {
+        filter = nonExistingAttributeFilter;
+    }
+    else if (useCase === "static") {
+        filter = emptyPositiveAttributeFilter;
+        options.staticElements = staticElements;
+    }
+    else if (useCase === "hidden") {
+        filter = positiveAttributeFilter;
+        options.hiddenElements = hiddenElements;
+    }
+    return newAttributeFilterHandler(backend, workspace, filter, options);
+};
+export const positiveAttributeFilterDefaultDF = newPositiveAttributeFilter(ReferenceMd.Product.Default, {
+    uris: ["165678", "165847"],
+});
+export const emptyPositiveAttributeFilterDefaultDF = newPositiveAttributeFilter(ReferenceMd.Product.Default, {
+    uris: [],
+});
+export const negativeAttributeFilterDefaultDF = newNegativeAttributeFilter(ReferenceMd.Product.Default, {
+    uris: ["165678", "165847"],
+});
+export const newTestAttributeFilterHandlerWithAttributeFilter = (attributeFilter, advancedOptions) => {
+    const options = {
+        selectionMode: "multi",
+        ...(advancedOptions ?? {}),
+    };
+    return newAttributeFilterHandler(backend, workspace, attributeFilter, options);
+};
+const isFunction = (value) => typeof value === "function";
+const isElementsQuery = (value) => typeof value === "object" && value !== null && isFunction(value.query);
+/**
+ * Facade of `target` with a single method replaced.
+ *
+ * A proxy is used instead of an object spread, because the backend services are class instances -
+ * their methods live on the prototype and a spread would drop them.
+ */
+const withReplacedMethod = (target, method, replacement) => new Proxy(target, {
+    get(proxiedTarget, property) {
+        if (property === method) {
+            return replacement;
+        }
+        const value = Reflect.get(proxiedTarget, property, proxiedTarget);
+        return isFunction(value) ? value.bind(proxiedTarget) : value;
+    },
+});
+/**
+ * Elements query that rejects with the queued errors, one error per query() call, and delegates to
+ * the recorded implementation once the queue is empty.
+ */
+const withQueuedElementsLoadFailures = (elementsQuery, errors) => new Proxy(elementsQuery, {
+    get(proxiedTarget, property) {
+        const value = Reflect.get(proxiedTarget, property, proxiedTarget);
+        if (!isFunction(value)) {
+            return value;
+        }
+        if (property === "query") {
+            return (...args) => errors.length > 0 ? Promise.reject(errors.shift()) : value.apply(proxiedTarget, args);
+        }
+        return (...args) => {
+            const result = value.apply(proxiedTarget, args);
+            // The builder methods return the query itself, so the result has to be wrapped again
+            // to keep the interception in place for the rest of the chain.
+            return isElementsQuery(result) ? withQueuedElementsLoadFailures(result, errors) : result;
+        };
+    },
+});
+const backendWithQueuedElementsLoadFailures = (errors) => withReplacedMethod(backend, "workspace", (workspaceId) => {
+    const analyticalWorkspace = backend.workspace(workspaceId);
+    return withReplacedMethod(analyticalWorkspace, "attributes", () => {
+        const attributes = analyticalWorkspace.attributes();
+        return withReplacedMethod(attributes, "elements", () => {
+            const elements = attributes.elements();
+            return withReplacedMethod(elements, "forDisplayForm", (ref) => withQueuedElementsLoadFailures(elements.forDisplayForm(ref), errors));
+        });
+    });
+});
+/**
+ * Handler whose elements loads can be made to fail on demand.
+ *
+ * The failure is injected into the backend the handler talks to, so that the tests of the error
+ * paths do not have to mock the internal loadElements module. A module mock cannot be relied on
+ * here, because the test files share the module registry (see `isolate: false` in vitest.config.ts)
+ * and the module is already evaluated unmocked by the time such a suite runs.
+ */
+export const newTestAttributeFilterHandlerWithElementsLoadFailures = (attributeFilter) => {
+    const errors = [];
+    return {
+        attributeFilterHandler: newAttributeFilterHandler(backendWithQueuedElementsLoadFailures(errors), workspace, attributeFilter, { selectionMode: "multi" }),
+        /**
+         * Makes the next elements load reject with the provided error. Call it repeatedly to queue up
+         * more failures, one per load - the equivalent of several mockRejectedValueOnce() calls.
+         */
+        failNextElementsLoad: (error) => {
+            errors.push(error);
+        },
+    };
+};

package/esm/AttributeFilterHandler/testUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const waitForAsync: () => Promise<any>;
+//# sourceMappingURL=testUtils.d.ts.map

package/esm/AttributeFilterHandler/testUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../../src/AttributeFilterHandler/testUtils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,oBAAmF,CAAC"}

package/esm/AttributeFilterHandler/testUtils.js

@@ -0,0 +1,2 @@
+// (C) 2019-2026 GoodData Corporation
+export const waitForAsync = () => new Promise((resolve) => setTimeout(resolve, 0));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-filters",
-  "version": "11.54.0-alpha.4",
+  "version": "11.54.0-alpha.5",
   "description": "GoodData.UI SDK - Filter Components",
   "license": "MIT",
   "author": "GoodData Corporation",
@@ -46,11 +46,11 @@
     "ts-invariant": "0.10.3",
     "tslib": "2.8.1",
     "uuid": "11.1.1",
-    "@gooddata/sdk-model": "11.54.0-alpha.4",
-    "@gooddata/sdk-backend-spi": "11.54.0-alpha.4",
-    "@gooddata/sdk-ui-kit": "11.54.0-alpha.4",
-    "@gooddata/sdk-ui": "11.54.0-alpha.4",
-    "@gooddata/util": "11.54.0-alpha.4"
+    "@gooddata/sdk-backend-spi": "11.54.0-alpha.5",
+    "@gooddata/sdk-model": "11.54.0-alpha.5",
+    "@gooddata/sdk-ui": "11.54.0-alpha.5",
+    "@gooddata/sdk-ui-kit": "11.54.0-alpha.5",
+    "@gooddata/util": "11.54.0-alpha.5"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.0",
@@ -92,12 +92,12 @@
     "typescript": "5.9.3",
     "vitest": "4.1.8",
     "vitest-dom": "0.1.1",
-    "@gooddata/eslint-config": "11.54.0-alpha.4",
-    "@gooddata/oxlint-config": "11.54.0-alpha.4",
-    "@gooddata/reference-workspace": "11.54.0-alpha.4",
-    "@gooddata/sdk-backend-mockingbird": "11.54.0-alpha.4",
-    "@gooddata/stylelint-config": "11.54.0-alpha.4",
-    "@gooddata/sdk-ui-theme-provider": "11.54.0-alpha.4"
+    "@gooddata/eslint-config": "11.54.0-alpha.5",
+    "@gooddata/oxlint-config": "11.54.0-alpha.5",
+    "@gooddata/reference-workspace": "11.54.0-alpha.5",
+    "@gooddata/sdk-backend-mockingbird": "11.54.0-alpha.5",
+    "@gooddata/sdk-ui-theme-provider": "11.54.0-alpha.5",
+    "@gooddata/stylelint-config": "11.54.0-alpha.5"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",