@gooddata/sdk-ui-analytical-designer 0.0.0-stage → 11.65.0-alpha.7

package/esm/store/buckets/buckets_read_helpers.d.ts

@@ -0,0 +1,72 @@
+import { type ITotal, type ObjRef } from "@gooddata/sdk-model";
+import { type IRawBucket, type IRawBucketItem, type IRawBucketItems, type IRawBuckets } from "../../typings/buckets.js";
+import { type IBucketItem } from "../../typings/metadata.js";
+export declare function getMeasuresInBuckets(buckets: IRawBuckets): IRawBucketItems;
+export declare function getAttributesInBuckets(buckets: IRawBuckets): IRawBucketItems;
+export declare function getMeasuresWithoutArithmeticInBuckets(buckets: IRawBuckets): IRawBucketItems;
+export declare function getDerivedBucketItemsInBuckets(buckets: IRawBuckets): IRawBucketItems;
+export declare function getMasterMeasuresInBuckets(buckets: IRawBuckets): IRawBucketItems;
+export declare function findAllInvalidArithmeticMeasuresInBuckets(buckets: IRawBuckets): IRawBucketItems;
+/** Every arithmetic measure that uses `operandBucketItem` as an operand. */
+export declare function findAllReferencingArithmeticMeasuresInBuckets(buckets: IRawBuckets, operandBucketItem: IRawBucketItem): IRawBucketItems;
+/**
+ * The attributes of ONE bucket, plain — the shape the totals rules consume.
+ *
+ * The `?? []` aligns this with {@link getBucketTotalsInBuckets}, which has always had it. No producer
+ * in the package builds a bucket without an `items` key, so the difference was not reachable — but
+ * `sanitizeTotals` reads `.length` off this result, and a declared `IBucketItem[]` that can answer
+ * `undefined` is the kind of gap that only stays harmless until someone adds a producer.
+ */
+export declare function getBucketAttributesInBuckets(buckets: IRawBuckets, bucketLocalIdentifier: string): IBucketItem[];
+/** The totals of ONE bucket, plain; `[]` both when the bucket and when the `totals` key is absent. */
+export declare function getBucketTotalsInBuckets(buckets: IRawBuckets, bucketLocalIdentifier: string): ITotal[];
+/**
+ * The bucket with this local identifier, or `undefined`.
+ *
+ * The optional return type is deliberate: absence is ordinary here —
+ * `optional_stacking_selector` guards with `|| {}` while other callers read straight through — so
+ * the type has to say so rather than leave each caller to guess.
+ */
+export declare function getBucketByLocalIdentifierInBuckets(buckets: IRawBuckets, localIdentifier: string): IRawBucket | undefined;
+export declare function getBucketIdentifierByItemIdInBuckets(buckets: IRawBuckets, itemIdentifier: string): string;
+export declare function getBucketByBucketItemLocalIdentifierInBuckets(buckets: IRawBuckets, bucketItemLocalIdentifier: string): IRawBucket;
+/**
+ * The measures of the MEASURES bucket only. Wrapping the single bucket keeps ONE flattening
+ * implementation rather than reaching into `items` here.
+ *
+ * The absent-bucket guard is explicit rather than left to the flattening: the reader this replaced
+ * (`getBucketItemsFromBuckets`) carried its own `bucket ? … : []` hole-tolerance, and de-duplicating
+ * it against `getBucketItemsInBuckets` — which relies on `getIn`'s null walk instead — is exactly
+ * where such a guard goes missing unnoticed.
+ */
+export declare function getPrimaryMeasuresFromMeasureBucketInBuckets(buckets: IRawBuckets): IRawBucketItems;
+/** The first non-derived metric in bucket order, or null. */
+export declare function getFirstMasterMeasureInBuckets(buckets: IRawBuckets): IRawBucketItem | null;
+export declare function getAttributeBucketItemsByRefInBuckets(buckets: IRawBuckets, ref: ObjRef): IBucketItem[];
+export declare function isSelectedViewByDateOfWeekGranularityInBuckets(buckets: IRawBuckets): boolean;
+export declare function isDerivedMeasurePresentInBuckets(buckets: IRawBuckets): boolean;
+/** The local identifiers of every bucket item — the validity set the sort-item rules filter against. */
+export declare function getBucketItemLocalIdentifiersInBuckets(buckets: IRawBuckets): string[];
+/**
+ * The local identifiers of the SLICING bucket items — the attributes and dates an insight is broken
+ * down by. Used by the removal chain to ask whether any slicing survives a removal, which decides
+ * whether the dimensionality-bearing filters can keep their granularity.
+ *
+ * "Slicing" is exactly what {@link getAttributesInBuckets} answers (`ATTRIBUTE` + `DATE`), so this is
+ * the ONE definition.
+ *
+ * `toShallowArray` before the map, for the same reason {@link getBucketItemLocalIdentifiersInBuckets}
+ * does it: the reader it builds on PRESERVES its input's container, so a wrong-kind value would turn
+ * the caller's `remaining.length === 0` test into a silent always-false instead of an error.
+ */
+export declare function getSlicingBucketItemLocalIdentifiersInBuckets(buckets: IRawBuckets): string[];
+/** The date bucket items of any buckets family (state or extended reference point). */
+export declare function getDateBucketItemsInBuckets(buckets: IRawBuckets): IRawBucketItems;
+/**
+ * The date bucket items of ONE named bucket — the recommendation and shortcut operations
+ * plant/re-point a date item in a specific bucket. Deliberately UNGUARDED on a missing bucket: the
+ * `.filter` on the absent items throws.
+ */
+export declare function getDateBucketItemsInBucket(buckets: IRawBuckets, bucketLocalIdentifier: string): IRawBucketItems;
+export declare function hasDateBucketItemInBuckets(buckets: IRawBuckets): boolean;
+//# sourceMappingURL=buckets_read_helpers.d.ts.map

package/esm/store/buckets/buckets_read_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buckets_read_helpers.d.ts","sourceRoot":"","sources":["../../../src/store/buckets/buckets_read_helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,EAAmB,MAAM,qBAAqB,CAAC;AAWhF,OAAO,EACH,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,WAAW,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAuB7D,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAE1E;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAE5E;AAED,wBAAgB,qCAAqC,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAI3F;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAEpF;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAEhF;AAED,wBAAgB,yCAAyC,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAI/F;AAED,4EAA4E;AAC5E,wBAAgB,6CAA6C,CACzD,OAAO,EAAE,WAAW,EACpB,iBAAiB,EAAE,cAAc,GAClC,eAAe,CAIjB;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CACxC,OAAO,EAAE,WAAW,EACpB,qBAAqB,EAAE,MAAM,GAC9B,WAAW,EAAE,CAGf;AAED,sGAAsG;AACtG,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,GAAG,MAAM,EAAE,CAGtG;AAED;;;;;;GAMG;AACH,wBAAgB,mCAAmC,CAC/C,OAAO,EAAE,WAAW,EACpB,eAAe,EAAE,MAAM,GACxB,UAAU,GAAG,SAAS,CAExB;AAED,wBAAgB,oCAAoC,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAMzG;AAED,wBAAgB,6CAA6C,CACzD,OAAO,EAAE,WAAW,EACpB,yBAAyB,EAAE,MAAM,GAClC,UAAU,CAMZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,4CAA4C,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAGlG;AAED,6DAA6D;AAC7D,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,GAAG,IAAI,CAY1F;AAED,wBAAgB,qCAAqC,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,EAAE,CAItG;AAED,wBAAgB,8CAA8C,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAI5F;AAED,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAE9E;AAED,wGAAwG;AACxG,wBAAgB,sCAAsC,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,EAAE,CAErF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6CAA6C,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,EAAE,CAE5F;AAED,uFAAuF;AACvF,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAEjF;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACtC,OAAO,EAAE,WAAW,EACpB,qBAAqB,EAAE,MAAM,GAC9B,eAAe,CAIjB;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAExE"}

package/esm/store/buckets/buckets_read_helpers.js

@@ -0,0 +1,146 @@
+// (C) 2007-2026 GoodData Corporation
+import { areObjRefsEqual } from "@gooddata/sdk-model";
+import { ATTRIBUTE, DATE, MEASURES, METRIC } from "../../constants/bucket.js";
+import { isArithmeticMeasure, isDerived, isInvalidArithmeticMeasure, isMasterMeasure, } from "../../models/bucket_item.js";
+import { DATE_DATASET_ATTRIBUTE } from "../../models/date_item.js";
+import { GRANULARITY } from "../../models/granularity.js";
+import { getBucketItemsInBuckets } from "./buckets_write_helpers.js";
+import { isDateBucketItem, isOperandInArithmeticMeasure } from "./helpers/bucket_item_predicates.js";
+/**
+ * Value-level DERIVED READS over a buckets value. Every function here answers a question about
+ * `buckets` alone; `services/buckets_service.ts` keeps a one-line selector per entry point that
+ * reads the subtree and delegates here, so there is ONE implementation behind two entry points and a
+ * saga operation and a component cannot drift apart.
+ *
+ * The field reads are OPTIONAL-CHAINED throughout because these same implementations are also handed
+ * extended-reference-point buckets and caller-built bucket items, whose shapes are not guaranteed to
+ * carry every field.
+ */
+/** Every bucket item, in bucket order, filtered by `type`. */
+function getBucketItemsOfType(buckets, ...types) {
+    return getBucketItemsInBuckets(buckets).filter((item) => types.includes(item?.type));
+}
+export function getMeasuresInBuckets(buckets) {
+    return getBucketItemsOfType(buckets, METRIC);
+}
+export function getAttributesInBuckets(buckets) {
+    return getBucketItemsOfType(buckets, ATTRIBUTE, DATE);
+}
+export function getMeasuresWithoutArithmeticInBuckets(buckets) {
+    return getMeasuresInBuckets(buckets).filter((item) => !isArithmeticMeasure(item));
+}
+export function getDerivedBucketItemsInBuckets(buckets) {
+    return getBucketItemsInBuckets(buckets).filter(isDerived);
+}
+export function getMasterMeasuresInBuckets(buckets) {
+    return getBucketItemsInBuckets(buckets).filter(isMasterMeasure);
+}
+export function findAllInvalidArithmeticMeasuresInBuckets(buckets) {
+    return getBucketItemsInBuckets(buckets).filter((bucketItem) => isInvalidArithmeticMeasure(bucketItem));
+}
+/** Every arithmetic measure that uses `operandBucketItem` as an operand. */
+export function findAllReferencingArithmeticMeasuresInBuckets(buckets, operandBucketItem) {
+    return getBucketItemsInBuckets(buckets).filter((bucketItem) => isOperandInArithmeticMeasure(operandBucketItem, bucketItem));
+}
+/**
+ * The attributes of ONE bucket, plain — the shape the totals rules consume.
+ *
+ * The `?? []` aligns this with {@link getBucketTotalsInBuckets}, which has always had it. No producer
+ * in the package builds a bucket without an `items` key, so the difference was not reachable — but
+ * `sanitizeTotals` reads `.length` off this result, and a declared `IBucketItem[]` that can answer
+ * `undefined` is the kind of gap that only stays harmless until someone adds a producer.
+ */
+export function getBucketAttributesInBuckets(buckets, bucketLocalIdentifier) {
+    const attributeBucket = getBucketByLocalIdentifierInBuckets(buckets, bucketLocalIdentifier);
+    return attributeBucket ? (attributeBucket?.items ?? []) : [];
+}
+/** The totals of ONE bucket, plain; `[]` both when the bucket and when the `totals` key is absent. */
+export function getBucketTotalsInBuckets(buckets, bucketLocalIdentifier) {
+    const attributeBucket = getBucketByLocalIdentifierInBuckets(buckets, bucketLocalIdentifier);
+    return attributeBucket ? (attributeBucket?.totals ?? []) : [];
+}
+/**
+ * The bucket with this local identifier, or `undefined`.
+ *
+ * The optional return type is deliberate: absence is ordinary here —
+ * `optional_stacking_selector` guards with `|| {}` while other callers read straight through — so
+ * the type has to say so rather than leave each caller to guess.
+ */
+export function getBucketByLocalIdentifierInBuckets(buckets, localIdentifier) {
+    return buckets.find((bucket) => bucket?.localIdentifier === localIdentifier);
+}
+export function getBucketIdentifierByItemIdInBuckets(buckets, itemIdentifier) {
+    const bucket = buckets?.find((candidate) => candidate?.items.find((item) => item?.localIdentifier === itemIdentifier));
+    return bucket?.localIdentifier;
+}
+export function getBucketByBucketItemLocalIdentifierInBuckets(buckets, bucketItemLocalIdentifier) {
+    return buckets.find((bucket) => bucket?.items.some((bucketItem) => bucketItem?.localIdentifier === bucketItemLocalIdentifier));
+}
+/**
+ * The measures of the MEASURES bucket only. Wrapping the single bucket keeps ONE flattening
+ * implementation rather than reaching into `items` here.
+ *
+ * The absent-bucket guard is explicit rather than left to the flattening: the reader this replaced
+ * (`getBucketItemsFromBuckets`) carried its own `bucket ? … : []` hole-tolerance, and de-duplicating
+ * it against `getBucketItemsInBuckets` — which relies on `getIn`'s null walk instead — is exactly
+ * where such a guard goes missing unnoticed.
+ */
+export function getPrimaryMeasuresFromMeasureBucketInBuckets(buckets) {
+    const measureBucket = getBucketByLocalIdentifierInBuckets(buckets, MEASURES);
+    return measureBucket ? getBucketItemsInBuckets([measureBucket]) : [];
+}
+/** The first non-derived metric in bucket order, or null. */
+export function getFirstMasterMeasureInBuckets(buckets) {
+    return (buckets.reduce((found, bucket) => {
+        // if we already found a metric, do not touch it
+        if (found) {
+            return found;
+        }
+        const items = bucket?.items;
+        return items.find((item) => item?.type === METRIC && !isDerived(item));
+    }, null) || null);
+}
+export function getAttributeBucketItemsByRefInBuckets(buckets, ref) {
+    return getAttributesInBuckets(buckets).filter((attribute) => areObjRefsEqual(attribute?.ref, ref));
+}
+export function isSelectedViewByDateOfWeekGranularityInBuckets(buckets) {
+    return getAttributesInBuckets(buckets).some((attribute) => attribute?.granularity === GRANULARITY.WEEK);
+}
+export function isDerivedMeasurePresentInBuckets(buckets) {
+    return getMeasuresInBuckets(buckets).some(isDerived);
+}
+/** The local identifiers of every bucket item — the validity set the sort-item rules filter against. */
+export function getBucketItemLocalIdentifiersInBuckets(buckets) {
+    return [...(getBucketItemsInBuckets(buckets) ?? [])].map((item) => item?.localIdentifier);
+}
+/**
+ * The local identifiers of the SLICING bucket items — the attributes and dates an insight is broken
+ * down by. Used by the removal chain to ask whether any slicing survives a removal, which decides
+ * whether the dimensionality-bearing filters can keep their granularity.
+ *
+ * "Slicing" is exactly what {@link getAttributesInBuckets} answers (`ATTRIBUTE` + `DATE`), so this is
+ * the ONE definition.
+ *
+ * `toShallowArray` before the map, for the same reason {@link getBucketItemLocalIdentifiersInBuckets}
+ * does it: the reader it builds on PRESERVES its input's container, so a wrong-kind value would turn
+ * the caller's `remaining.length === 0` test into a silent always-false instead of an error.
+ */
+export function getSlicingBucketItemLocalIdentifiersInBuckets(buckets) {
+    return [...(getAttributesInBuckets(buckets) ?? [])].map((item) => item?.localIdentifier);
+}
+/** The date bucket items of any buckets family (state or extended reference point). */
+export function getDateBucketItemsInBuckets(buckets) {
+    return getBucketItemsInBuckets(buckets).filter(isDateBucketItem);
+}
+/**
+ * The date bucket items of ONE named bucket — the recommendation and shortcut operations
+ * plant/re-point a date item in a specific bucket. Deliberately UNGUARDED on a missing bucket: the
+ * `.filter` on the absent items throws.
+ */
+export function getDateBucketItemsInBucket(buckets, bucketLocalIdentifier) {
+    const bucket = buckets.find((candidate) => candidate?.localIdentifier === bucketLocalIdentifier);
+    return bucket?.items.filter((item) => item?.attribute === DATE_DATASET_ATTRIBUTE);
+}
+export function hasDateBucketItemInBuckets(buckets) {
+    return (getDateBucketItemsInBuckets(buckets)?.length ?? 0) > 0;
+}

package/esm/store/buckets/buckets_removal_helpers.d.ts

@@ -0,0 +1,99 @@
+import { type ObjRef } from "@gooddata/sdk-model";
+import { type IRawBuckets } from "../../typings/buckets.js";
+import { type IBucketNotificationsState } from "../bucket_notifications/bucket_notifications_types.js";
+import { type IFilterBarState } from "../filter_bar/filter_bar_state.js";
+import { type IExtendedReferencePointState } from "../reference_point/extended_reference_point_state.js";
+import { type IBucketsMetaState } from "./buckets_meta_state.js";
+import { type BucketItemRefResolver } from "./helpers/filter_dependencies.js";
+/**
+ * REMOVING BUCKET ITEMS — the widest pure cross-domain calculation of the buckets cluster.
+ *
+ * It is genuinely cross-domain: removing one bucket item can take derived measures, arithmetic
+ * measures, filters, filter dimensionality, auto-created markers, sort items and totals with it.
+ * Hence the EXPLICIT named input and result, resolvers for the foreign lookups and named booleans for
+ * the feature flags.
+ *
+ * **What it deliberately does NOT do:** re-sync the reference point or set
+ * `isVisualizationMdObjectValid`. That tail belongs to the OPERATION, because the flag is an output of
+ * the mutating gesture rather than reference-point state. {@link IRemoveBucketItemsResult} is
+ * therefore the five domains this calculation decides, and nothing more.
+ *
+ * ORDER IS THE CONTRACT. Four facts are load-bearing and none of them is visible from the signatures:
+ *
+ * 1. the four filter sanitizers run BEFORE the "which filters must go" question. They convert filters
+ *    that reference a disappearing bucket measure/attribute into catalog-`ObjRef` filters, and it is
+ *    precisely that conversion which then makes them NOT count as having a missing dependency. Ask
+ *    first and sanitize second and every such filter is silently deleted;
+ * 2. the notification counts are taken from the SANITIZED filter bar but the ORIGINAL buckets — the
+ *    measures are still there to be counted at that point, and the filters have already been rescued;
+ * 3. the notification is computed BEFORE the filters are removed, for the same reason;
+ * 4. `sanitizeTotals` compares the ORIGINAL buckets with the reduced ones, and it runs AFTER the
+ *    sort-item validation, not before.
+ *
+ * IDENTITY, precisely: a removal that removes nothing answers FOUR of the five inputs by reference —
+ * each sanitizer answers the filter bar it was given, `removeAutoCreatedMarker` answers the same
+ * `bucketsMeta` for an item with no marker, `removeSingleBucketItemInBuckets` answers the same buckets
+ * for an identifier that is not there. The FILTER BAR is the exception: the chain ends with an
+ * unconditional `removeFilters`, and `setFilterItems` under it always builds `{...filterBar, items}`
+ * with no identity guard, so it comes back deep-equal but rebuilt. Pinned in
+ * `test/buckets_operations.test.ts`; adding the guard would be a behavior change (one fewer store
+ * notification per no-op removal).
+ */
+/** Resolves a catalog metric's cache identifier to its `ObjRef`, or null. Backed by the item cache. */
+export type CatalogMetricRefResolver = (metricIdentifier: string) => ObjRef | null;
+export interface IRemoveBucketItemsInput {
+    buckets: IRawBuckets;
+    /** carries the `autoCreated` markers the removal drops, and the ones `getUneditedFilters` asks about */
+    bucketsMeta: IBucketsMetaState;
+    filterBar: IFilterBarState;
+    bucketNotifications: IBucketNotificationsState;
+    /** absent until a pluggable visualization has answered — the sort-item validation tolerates that */
+    extendedReferencePoint: IExtendedReferencePointState | undefined;
+}
+export interface IRemoveBucketItemsParams {
+    localIdentifiers: ReadonlyArray<string>;
+    /**
+     * Report only the items removed AS DEPENDENCIES, not the ones asked for. Set by the replace-item
+     * gestures, where the user knows perfectly well what they just replaced.
+     */
+    notifyOnlyAboutRemovedDependencies: boolean;
+}
+export interface IRemoveBucketItemsDeps {
+    catalogMetricRef: CatalogMetricRefResolver;
+    bucketItemRef: BucketItemRefResolver;
+    /** `enableImprovedRankingFilter` */
+    improvedRankingFilter: boolean;
+    /** `enableNewPivotTable`, for the totals re-pointing */
+    reorderByMeasures: boolean;
+}
+export interface IRemoveBucketItemsResult {
+    buckets: IRawBuckets;
+    bucketsMeta: IBucketsMetaState;
+    filterBar: IFilterBarState;
+    bucketNotifications: IBucketNotificationsState;
+    extendedReferencePoint: IExtendedReferencePointState;
+}
+/**
+ * Everything that depends on `localIdentifier` — derived measures and arithmetic measures referencing
+ * it, transitively. Recursive because a derived measure can itself be an arithmetic operand.
+ */
+export declare function getAllDependantBucketItems(buckets: IRawBuckets, localIdentifier: string): string[];
+/**
+ * An arithmetic measure needs two operands. Removing a measure can leave one with fewer, and those go
+ * too — but only when the removal actually drops the measure count to the point where they cannot be
+ * satisfied, which is what the `> 2` test approximates.
+ *
+ * `findDerivedBucketItemsInBuckets(buckets, undefined)` is deliberately unguarded for a local
+ * identifier that is not in the buckets: `isDerivedFrom(item, undefined)` is TRUE for every
+ * non-derived item, so the count is meaningless there — and irrelevant, because `isMeasure(undefined)`
+ * is false and the function returns `[]` before the count is used.
+ */
+export declare function findInvalidArithmeticMeasuresForRemoval(buckets: IRawBuckets, removedBucketItemLocalIdentifier: string): string[];
+/**
+ * The attribute/date filters the app created for `cacheItemIdentifier` and the user never touched — the
+ * only ones it may remove on their behalf. Measure value and ranking filters are excluded: they are
+ * never auto-created.
+ */
+export declare function getUneditedFilters(filterBar: IFilterBarState, bucketsMeta: IBucketsMetaState, cacheItemIdentifier: string): string[];
+export declare function removeBucketItemsWithDependencies({ buckets, bucketsMeta, filterBar, bucketNotifications, extendedReferencePoint }: IRemoveBucketItemsInput, { localIdentifiers, notifyOnlyAboutRemovedDependencies }: IRemoveBucketItemsParams, { catalogMetricRef, bucketItemRef, improvedRankingFilter, reorderByMeasures }: IRemoveBucketItemsDeps): IRemoveBucketItemsResult;
+//# sourceMappingURL=buckets_removal_helpers.d.ts.map

package/esm/store/buckets/buckets_removal_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buckets_removal_helpers.d.ts","sourceRoot":"","sources":["../../../src/store/buckets/buckets_removal_helpers.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEjF,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,uDAAuD,CAAC;AAQvG,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAGzE,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,sDAAsD,CAAC;AAGzG,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAgBjE,OAAO,EACH,KAAK,qBAAqB,EAI7B,MAAM,kCAAkC,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,uGAAuG;AACvG,MAAM,MAAM,wBAAwB,GAAG,CAAC,gBAAgB,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;AAEnF,MAAM,WAAW,uBAAuB;IACpC,OAAO,EAAE,WAAW,CAAC;IACrB,wGAAwG;IACxG,WAAW,EAAE,iBAAiB,CAAC;IAC/B,SAAS,EAAE,eAAe,CAAC;IAC3B,mBAAmB,EAAE,yBAAyB,CAAC;IAC/C,oGAAoG;IACpG,sBAAsB,EAAE,4BAA4B,GAAG,SAAS,CAAC;CACpE;AAED,MAAM,WAAW,wBAAwB;IACrC,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC;;;OAGG;IACH,kCAAkC,EAAE,OAAO,CAAC;CAC/C;AAED,MAAM,WAAW,sBAAsB;IACnC,gBAAgB,EAAE,wBAAwB,CAAC;IAC3C,aAAa,EAAE,qBAAqB,CAAC;IACrC,oCAAoC;IACpC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,wDAAwD;IACxD,iBAAiB,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,wBAAwB;IACrC,OAAO,EAAE,WAAW,CAAC;IACrB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,SAAS,EAAE,eAAe,CAAC;IAC3B,mBAAmB,EAAE,yBAAyB,CAAC;IAC/C,sBAAsB,EAAE,4BAA4B,CAAC;CACxD;AAID;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBlG;AAED;;;;;;;;;GASG;AACH,wBAAgB,uCAAuC,CACnD,OAAO,EAAE,WAAW,EACpB,gCAAgC,EAAE,MAAM,GACzC,MAAM,EAAE,CAiBV;AA2LD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAC9B,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,iBAAiB,EAC9B,mBAAmB,EAAE,MAAM,GAC5B,MAAM,EAAE,CAUV;AAuGD,wBAAgB,iCAAiC,CAC7C,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,EAAE,uBAAuB,EACzG,EAAE,gBAAgB,EAAE,kCAAkC,EAAE,EAAE,wBAAwB,EAClF,EAAE,gBAAgB,EAAE,aAAa,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,EAAE,sBAAsB,GACtG,wBAAwB,CAqF1B"}

package/esm/store/buckets/buckets_removal_helpers.js

@@ -0,0 +1,280 @@
+// (C) 2007-2026 GoodData Corporation
+import { uniq } from "lodash-es";
+import { isArithmeticMeasure, isDerived, isMeasure } from "../../models/bucket_item.js";
+import { bucketNotificationsWithRemovedItems } from "../bucket_notifications/bucket_notifications_helpers.js";
+import { findMeasureValueFilterForMeasure, findMeasureValueFilters, findRankingFilter, removeFilters, storeFilter, } from "../filter_bar/filter_bar_helpers.js";
+import { FilterBar } from "../filter_bar/filter_bar_types.js";
+import { validateVisualizationProperties } from "../reference_point/extended_reference_point_helpers.js";
+import { isUnmodifiedAndAutoCreated, removeAutoCreatedMarker } from "./buckets_meta_helpers.js";
+import { findAllInvalidArithmeticMeasuresInBuckets, findAllReferencingArithmeticMeasuresInBuckets, getBucketByBucketItemLocalIdentifierInBuckets, getMeasuresInBuckets, getMeasuresWithoutArithmeticInBuckets, getSlicingBucketItemLocalIdentifiersInBuckets, } from "./buckets_read_helpers.js";
+import { sanitizeTotals } from "./buckets_totals_helpers.js";
+import { findBucketItemInBuckets, findDerivedBucketItemsInBuckets, removeSingleBucketItemInBuckets, } from "./buckets_write_helpers.js";
+import { isCategoriesOrStacks } from "./helpers/bucket_item_predicates.js";
+import { convertRemovedDimensionalityRefs, findFiltersRelyingOnSlicedInsight, isReferencedByRankingFilter, } from "./helpers/filter_dependencies.js";
+// --- what else has to go ---------------------------------------------------------------------------
+/**
+ * Everything that depends on `localIdentifier` — derived measures and arithmetic measures referencing
+ * it, transitively. Recursive because a derived measure can itself be an arithmetic operand.
+ */
+export function getAllDependantBucketItems(buckets, localIdentifier) {
+    const bucketItem = findBucketItemInBuckets(buckets, localIdentifier);
+    if (!bucketItem) {
+        return [];
+    }
+    const derivedBucketItems = findDerivedBucketItemsInBuckets(buckets, bucketItem);
+    const referencingArithmeticMeasures = findAllReferencingArithmeticMeasuresInBuckets(buckets, bucketItem);
+    return uniq([...derivedBucketItems, ...referencingArithmeticMeasures].flatMap((dependant) => [
+        dependant.localIdentifier,
+        ...getAllDependantBucketItems(buckets, dependant.localIdentifier),
+    ]));
+}
+/**
+ * An arithmetic measure needs two operands. Removing a measure can leave one with fewer, and those go
+ * too — but only when the removal actually drops the measure count to the point where they cannot be
+ * satisfied, which is what the `> 2` test approximates.
+ *
+ * `findDerivedBucketItemsInBuckets(buckets, undefined)` is deliberately unguarded for a local
+ * identifier that is not in the buckets: `isDerivedFrom(item, undefined)` is TRUE for every
+ * non-derived item, so the count is meaningless there — and irrelevant, because `isMeasure(undefined)`
+ * is false and the function returns `[]` before the count is used.
+ */
+export function findInvalidArithmeticMeasuresForRemoval(buckets, removedBucketItemLocalIdentifier) {
+    const removedBucketItem = findBucketItemInBuckets(buckets, removedBucketItemLocalIdentifier);
+    const derivedBucketItems = findDerivedBucketItemsInBuckets(buckets, removedBucketItem)?.length ?? 0;
+    const measuresWithoutArithmeticCount = getMeasuresWithoutArithmeticInBuckets(buckets)?.length ?? 0;
+    // the removed item may itself have derived bucket items, which are going away with it
+    const remainingMeasuresAfterRemoval = derivedBucketItems === 0
+        ? measuresWithoutArithmeticCount
+        : measuresWithoutArithmeticCount - derivedBucketItems;
+    if (remainingMeasuresAfterRemoval > 2 || !isMeasure(removedBucketItem)) {
+        return [];
+    }
+    return findAllInvalidArithmeticMeasuresInBuckets(buckets).map((invalidArithmeticMeasure) => invalidArithmeticMeasure.localIdentifier);
+}
+// --- rescuing the filters that can survive ---------------------------------------------------------
+/**
+ * "Simple measure" in AD terms: a catalog metric sitting in a bucket with no aggregation, neither
+ * arithmetic nor derived. Only those have a catalog `ObjRef` a filter can be re-pointed at.
+ */
+function isSimpleMetricBucketItem(bucketItem) {
+    return (isMeasure(bucketItem) &&
+        !isArithmeticMeasure(bucketItem) &&
+        !isDerived(bucketItem) &&
+        bucketItem?.aggregation == null);
+}
+/** The catalog `ObjRef` a filter can be re-pointed at, or null when there is none to point at. */
+function resolveCatalogMetricRef(bucketItem, catalogMetricRef) {
+    const metricIdentifier = bucketItem?.attribute;
+    return metricIdentifier ? catalogMetricRef(metricIdentifier) : null;
+}
+/**
+ * Keeps the measure value filters of removed SIMPLE metrics alive by converting them from
+ * `measureLocalIdentifier`- to `measureRef`-based, so they stay valid once the metric leaves the
+ * buckets.
+ */
+function sanitizeMeasureValueFilterMeasures(filterBar, buckets, bucketItemsToRemove, catalogMetricRef) {
+    if (findMeasureValueFilters(filterBar).length === 0) {
+        return filterBar;
+    }
+    let updatedFilterBar = filterBar;
+    for (const localIdentifier of bucketItemsToRemove) {
+        const bucketItem = findBucketItemInBuckets(buckets, localIdentifier);
+        if (!bucketItem || !isSimpleMetricBucketItem(bucketItem)) {
+            continue;
+        }
+        // the filter bar is re-read each round: an earlier iteration may already have stored one
+        const dependantMeasureValueFilter = findMeasureValueFilterForMeasure(updatedFilterBar, localIdentifier);
+        if (!dependantMeasureValueFilter) {
+            continue;
+        }
+        const measureRef = resolveCatalogMetricRef(bucketItem, catalogMetricRef);
+        if (!measureRef) {
+            continue;
+        }
+        const updatedFilter = {
+            ...dependantMeasureValueFilter,
+            measureLocalIdentifier: undefined,
+            measureRef,
+        };
+        updatedFilterBar = storeFilter(updatedFilterBar, updatedFilter);
+    }
+    return updatedFilterBar;
+}
+/** The ranking filter's mirror of {@link sanitizeMeasureValueFilterMeasures}. */
+function sanitizeRankingFilterMeasures(filterBar, buckets, bucketItemsToRemove, catalogMetricRef) {
+    const rankingFilter = findRankingFilter(filterBar);
+    if (!rankingFilter || !FilterBar.isBucketRankingFilter(rankingFilter)) {
+        return filterBar;
+    }
+    if (!bucketItemsToRemove.includes(rankingFilter.measureLocalIdentifier)) {
+        return filterBar;
+    }
+    const bucketItem = findBucketItemInBuckets(buckets, rankingFilter.measureLocalIdentifier);
+    if (!bucketItem || !isSimpleMetricBucketItem(bucketItem)) {
+        return filterBar;
+    }
+    const measureRef = resolveCatalogMetricRef(bucketItem, catalogMetricRef);
+    if (!measureRef) {
+        return filterBar;
+    }
+    const updatedFilter = {
+        ...rankingFilter,
+        measureLocalIdentifier: undefined,
+        measureRef,
+    };
+    return storeFilter(filterBar, updatedFilter);
+}
+/**
+ * Rewrites the measure value filters' DIMENSIONALITY: a removed attribute/date bucket item is promoted
+ * to its catalog `ObjRef` so the filter keeps its granularity instead of being dropped as a dependant.
+ */
+function sanitizeMeasureValueFilterDimensionality(filterBar, bucketItemsToRemove, bucketItemRef) {
+    const measureValueFilters = findMeasureValueFilters(filterBar);
+    if (measureValueFilters.length === 0) {
+        return filterBar;
+    }
+    let updatedFilterBar = filterBar;
+    for (const filter of measureValueFilters) {
+        const { dimensionality } = filter;
+        if (!dimensionality || dimensionality.length === 0) {
+            continue;
+        }
+        // unresolvable entries stay as their local identifier — existing filter validation handles them
+        const { items, changed } = convertRemovedDimensionalityRefs(dimensionality, bucketItemsToRemove, bucketItemRef);
+        if (changed) {
+            const updatedFilter = {
+                ...filter,
+                dimensionality: items,
+            };
+            updatedFilterBar = storeFilter(updatedFilterBar, updatedFilter);
+        }
+    }
+    return updatedFilterBar;
+}
+/**
+ * The improved ranking filter's "out of" attributes, treated exactly like the measure value filter's
+ * dimensionality. Never silently dropped: re-pointing the ranking at the REMAINING attributes would be
+ * a wrong result rather than an error.
+ */
+function sanitizeRankingFilterAttributes(filterBar, bucketItemsToRemove, bucketItemRef, improvedRankingFilter) {
+    if (!improvedRankingFilter) {
+        return filterBar;
+    }
+    const rankingFilter = findRankingFilter(filterBar);
+    if (!rankingFilter?.attributes?.length) {
+        return filterBar;
+    }
+    const { items, changed } = convertRemovedDimensionalityRefs(rankingFilter.attributes, bucketItemsToRemove, bucketItemRef);
+    if (!changed) {
+        return filterBar;
+    }
+    const updatedFilter = {
+        ...rankingFilter,
+        attributes: items,
+    };
+    return storeFilter(filterBar, updatedFilter);
+}
+// --- which filters cannot survive ------------------------------------------------------------------
+/**
+ * The attribute/date filters the app created for `cacheItemIdentifier` and the user never touched — the
+ * only ones it may remove on their behalf. Measure value and ranking filters are excluded: they are
+ * never auto-created.
+ */
+export function getUneditedFilters(filterBar, bucketsMeta, cacheItemIdentifier) {
+    return filterBar.items
+        .filter((filter) => !FilterBar.isMeasureValueFilter(filter) &&
+        !FilterBar.isRankingFilter(filter) &&
+        filter.cacheItemIdentifier === cacheItemIdentifier &&
+        isUnmodifiedAndAutoCreated(cacheItemIdentifier, bucketsMeta))
+        .map((filter) => filter.localIdentifier);
+}
+function getAllDependantFilters(filterBar, buckets, bucketsMeta, localIdentifier, improvedRankingFilter) {
+    const bucketItem = findBucketItemInBuckets(buckets, localIdentifier);
+    if (!bucketItem) {
+        return [];
+    }
+    const bucket = getBucketByBucketItemLocalIdentifierInBuckets(buckets, localIdentifier);
+    const dependantFilters = [];
+    if (isCategoriesOrStacks(bucket?.localIdentifier)) {
+        dependantFilters.push(...getUneditedFilters(filterBar, bucketsMeta, bucketItem?.attribute));
+    }
+    const dependantMeasureValueFilter = findMeasureValueFilterForMeasure(filterBar, localIdentifier);
+    if (dependantMeasureValueFilter) {
+        dependantFilters.push(dependantMeasureValueFilter.localIdentifier);
+    }
+    const rankingFilter = findRankingFilter(filterBar);
+    if (isReferencedByRankingFilter(rankingFilter, localIdentifier, improvedRankingFilter)) {
+        dependantFilters.push(rankingFilter.localIdentifier);
+    }
+    return dependantFilters;
+}
+function findFiltersToRemove(filterBar, buckets, bucketsMeta, bucketItemsToRemove, improvedRankingFilter) {
+    const remainingSlicingBucketItems = getSlicingBucketItemLocalIdentifiersInBuckets(buckets).filter((localIdentifier) => !bucketItemsToRemove.includes(localIdentifier));
+    const invalidFiltersFromNoLongerSlicedInsight = remainingSlicingBucketItems.length === 0
+        ? findFiltersRelyingOnSlicedInsight(findRankingFilter(filterBar), findMeasureValueFilters(filterBar), improvedRankingFilter)
+        : [];
+    const invalidFiltersWithMissingDependency = bucketItemsToRemove.flatMap((localIdentifier) => getAllDependantFilters(filterBar, buckets, bucketsMeta, localIdentifier, improvedRankingFilter));
+    return uniq([...invalidFiltersWithMissingDependency, ...invalidFiltersFromNoLongerSlicedInsight]);
+}
+// --- telling the user what disappeared -------------------------------------------------------------
+/**
+ * The "we removed these for you" banner's counts. Identity when nothing worth reporting happened —
+ * a removal of plain attributes reports nothing, and must not rebuild the notifications subtree.
+ */
+function bucketNotificationsAfterRemoval(bucketNotifications, buckets, filterBar, bucketItemsToRemove, filtersToRemove) {
+    const numberOfMeasuresToRemove = getMeasuresInBuckets(buckets).filter((measure) => bucketItemsToRemove.includes(measure.localIdentifier)).length;
+    const numberOfMeasureValueFiltersToRemove = findMeasureValueFilters(filterBar).filter((filter) => filtersToRemove.includes(filter.localIdentifier)).length;
+    const rankingFilter = findRankingFilter(filterBar);
+    const wasRankingFilterRemoved = rankingFilter !== null && filtersToRemove.includes(rankingFilter.localIdentifier);
+    if (numberOfMeasuresToRemove === 0 &&
+        numberOfMeasureValueFiltersToRemove === 0 &&
+        !wasRankingFilterRemoved) {
+        return bucketNotifications;
+    }
+    return bucketNotificationsWithRemovedItems(bucketNotifications, {
+        measures: numberOfMeasuresToRemove,
+        measureValueFilters: numberOfMeasureValueFiltersToRemove,
+        rankingFilter: wasRankingFilterRemoved,
+    });
+}
+// --- the operation ---------------------------------------------------------------------------------
+export function removeBucketItemsWithDependencies({ buckets, bucketsMeta, filterBar, bucketNotifications, extendedReferencePoint }, { localIdentifiers, notifyOnlyAboutRemovedDependencies }, { catalogMetricRef, bucketItemRef, improvedRankingFilter, reorderByMeasures }) {
+    const dependantBucketItemsToRemove = localIdentifiers.flatMap((localIdentifier) => getAllDependantBucketItems(buckets, localIdentifier));
+    const invalidArithmeticMeasuresToRemove = localIdentifiers.flatMap((localIdentifier) => findInvalidArithmeticMeasuresForRemoval(buckets, localIdentifier));
+    const bucketItemsToRemove = uniq([
+        ...localIdentifiers,
+        ...dependantBucketItemsToRemove,
+        ...invalidArithmeticMeasuresToRemove,
+    ]);
+    // rescue first, decide second (see fact 1 in the module note)
+    let updatedFilterBar = sanitizeMeasureValueFilterMeasures(filterBar, buckets, bucketItemsToRemove, catalogMetricRef);
+    updatedFilterBar = sanitizeRankingFilterMeasures(updatedFilterBar, buckets, bucketItemsToRemove, catalogMetricRef);
+    updatedFilterBar = sanitizeMeasureValueFilterDimensionality(updatedFilterBar, bucketItemsToRemove, bucketItemRef);
+    updatedFilterBar = sanitizeRankingFilterAttributes(updatedFilterBar, bucketItemsToRemove, bucketItemRef, improvedRankingFilter);
+    const filtersToRemove = findFiltersToRemove(updatedFilterBar, buckets, bucketsMeta, bucketItemsToRemove, improvedRankingFilter);
+    const notifiedRemovedBucketItems = notifyOnlyAboutRemovedDependencies
+        ? [...dependantBucketItemsToRemove, ...invalidArithmeticMeasuresToRemove]
+        : bucketItemsToRemove;
+    const updatedBucketNotifications = bucketNotificationsAfterRemoval(bucketNotifications, buckets, updatedFilterBar, notifiedRemovedBucketItems, filtersToRemove);
+    updatedFilterBar = removeFilters(updatedFilterBar, filtersToRemove);
+    let updatedBuckets = buckets;
+    let updatedBucketsMeta = bucketsMeta;
+    for (const localIdentifier of bucketItemsToRemove) {
+        // re-looked up against the progressively reduced buckets
+        const bucketItem = findBucketItemInBuckets(updatedBuckets, localIdentifier);
+        if (!bucketItem) {
+            continue;
+        }
+        updatedBucketsMeta = removeAutoCreatedMarker(updatedBucketsMeta, bucketItem?.attribute);
+        updatedBuckets = removeSingleBucketItemInBuckets(updatedBuckets, localIdentifier);
+    }
+    const updatedExtendedReferencePoint = validateVisualizationProperties(extendedReferencePoint, updatedBuckets);
+    updatedBuckets = sanitizeTotals(buckets, updatedBuckets, { reorderByMeasures });
+    return {
+        buckets: updatedBuckets,
+        bucketsMeta: updatedBucketsMeta,
+        filterBar: updatedFilterBar,
+        bucketNotifications: updatedBucketNotifications,
+        extendedReferencePoint: updatedExtendedReferencePoint,
+    };
+}

package/esm/store/buckets/buckets_selectors.d.ts

@@ -0,0 +1,10 @@
+import { type IRawBucketItems } from "../../typings/buckets.js";
+import { type IAppState } from "../types.js";
+/**
+ * The domain's single input selector. The whole-root readers in services/buckets_service.ts
+ * (`getBuckets`/`getMeasures`/`getAttributes`…) hang off it.
+ */
+export declare const getBucketsState: (state: IAppState) => import("../../typings/buckets.js").IRawBuckets;
+/** Flat view of every bucket item, in bucket order — the cluster's most common derived read. */
+export declare function getAllBucketItems(root: IAppState): IRawBucketItems;
+//# sourceMappingURL=buckets_selectors.d.ts.map

package/esm/store/buckets/buckets_selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buckets_selectors.d.ts","sourceRoot":"","sources":["../../../src/store/buckets/buckets_selectors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C;;;GAGG;AACH,eAAO,MAAM,eAAe,UAAW,SAAS,mDAAuB,CAAC;AAExE,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,CAElE"}

package/esm/store/buckets/buckets_selectors.js

@@ -0,0 +1,11 @@
+// (C) 2026 GoodData Corporation
+import { getBucketItemsInBuckets } from "./buckets_write_helpers.js";
+/**
+ * The domain's single input selector. The whole-root readers in services/buckets_service.ts
+ * (`getBuckets`/`getMeasures`/`getAttributes`…) hang off it.
+ */
+export const getBucketsState = (state) => state.data.buckets;
+/** Flat view of every bucket item, in bucket order — the cluster's most common derived read. */
+export function getAllBucketItems(root) {
+    return getBucketItemsInBuckets(getBucketsState(root));
+}

package/esm/store/buckets/buckets_slice.d.ts

@@ -0,0 +1,4 @@
+import { type Reducer } from "redux";
+import { type IBucketsState } from "./buckets_state.js";
+export declare const bucketsSliceReducer: Reducer<IBucketsState>;
+//# sourceMappingURL=buckets_slice.d.ts.map

package/esm/store/buckets/buckets_slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buckets_slice.d.ts","sourceRoot":"","sources":["../../../src/store/buckets/buckets_slice.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,OAAO,CAAC;AAsCrC,OAAO,EAAE,KAAK,aAAa,EAAuB,MAAM,oBAAoB,CAAC;AAgF7E,eAAO,MAAM,mBAAmB,EAAE,OAAO,CAAC,aAAa,CAAwB,CAAC"}