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

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

@@ -0,0 +1,117 @@
+import { type IAddBucketItemResult } from "./buckets_add_operation.js";
+import { type IBucketItemEditResult, type IDualAxisToggleResult, type IVisualizationTypeSelectionResult } from "./buckets_edit_operations.js";
+import { type IFilterRemovalResult } from "./buckets_filter_removal_operation.js";
+import { type IRemoveBucketItemsCommit, type IReorderBucketItemResult, type ISwapBucketItemResult } from "./buckets_move_operations.js";
+import { type IDerivedBucketItemsPlacedResult, type IExtendedReferencePointAppliedResult } from "./extended_reference_point_operations.js";
+/**
+ * THE SEMANTIC EVENTS OF THE BUCKETS FAMILY.
+ *
+ * Every buckets trigger resolves to one of the operations below. Each operation is a pure value-level
+ * calculation (`buckets_*_operation*.ts`), each is driven by ONE saga handler
+ * (`buckets_operations_saga.ts`) and each commits its result with ONE of these events — which the
+ * owning slices and leaves consume as ordinary cases.
+ *
+ * THREE PROPERTIES ARE THE POINT, and all three are structural rather than asserted:
+ *
+ * 1. **One gesture is one store write.** The trigger writes nothing at all, so there is no
+ *    intermediate state a subscriber can observe, `observeStore` fires at most once, and undo needs
+ *    no batching.
+ * 2. **The payload is the operation's RESULT — different per operation, and that is deliberate.**
+ *    `visualizationTypeSelected` carries three values, `bucketItemAdded` nine. A universal payload, a
+ *    presence map or a change set would erase exactly the information these types carry.
+ * 3. **`isVisualizationMdObjectValid` is named separately wherever it is produced.** It is an OUTPUT
+ *    of the mutating gesture, not reference-point state.
+ *
+ * Values are carried UNCONDITIONALLY and the helpers answer the ORIGINAL reference when nothing
+ * changed, so an unchanged value reaching a slice case returns the same state and `combineBranch`
+ * short-circuits on identity. That is why there is no diff: the returned values already carry the
+ * information.
+ *
+ * The type strings live in a namespace of their own rather than in `ActionTypeKeys`: no external
+ * consumer matches on them, and keeping them out is what makes "which strings are frozen behavior"
+ * answerable. They are deliberately NOT undoable — time travel keys on the TRIGGER, which reaches
+ * the store first (see store/_infra/time_travel.ts).
+ */
+export declare enum BucketsOperationActionTypeKeys {
+    STORE_BUCKET_ITEM_ADDED = "STORE/BUCKETS/BUCKET_ITEM_ADDED",
+    STORE_BUCKET_ITEMS_REMOVED = "STORE/BUCKETS/BUCKET_ITEMS_REMOVED",
+    STORE_BUCKET_ITEM_REPLACED = "STORE/BUCKETS/BUCKET_ITEM_REPLACED",
+    STORE_BUCKET_ITEMS_SWAPPED = "STORE/BUCKETS/BUCKET_ITEMS_SWAPPED",
+    STORE_BUCKET_ITEM_REORDERED = "STORE/BUCKETS/BUCKET_ITEM_REORDERED",
+    STORE_BUCKET_ITEM_EDITED = "STORE/BUCKETS/BUCKET_ITEM_EDITED",
+    STORE_DUAL_AXIS_TOGGLED = "STORE/BUCKETS/DUAL_AXIS_TOGGLED",
+    STORE_BUCKETS_DATE_DATASET_CHANGED = "STORE/BUCKETS/DATE_DATASET_CHANGED",
+    STORE_VISUALIZATION_TYPE_SELECTED = "STORE/BUCKETS/VISUALIZATION_TYPE_SELECTED",
+    STORE_EXTENDED_REFERENCE_POINT_APPLIED = "STORE/BUCKETS/EXTENDED_REFERENCE_POINT_APPLIED",
+    STORE_DERIVED_BUCKET_ITEMS_PLACED = "STORE/BUCKETS/DERIVED_BUCKET_ITEMS_PLACED",
+    STORE_FILTER_REMOVAL_APPLIED = "STORE/BUCKETS/FILTER_REMOVAL_APPLIED"
+}
+/**
+ * A catalog item was dropped into a bucket (`BUCKETS_DND_ITEM_INSERT`). The widest of the edits: the
+ * add itself is narrow, but a measure added while every reference-point measure already compares over
+ * time drags the whole over-time-comparison operation in behind it — which is where the filter bar,
+ * the notifications and the extended reference point in this payload come from.
+ */
+export declare const bucketItemAdded: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IAddBucketItemResult], IAddBucketItemResult, BucketsOperationActionTypeKeys.STORE_BUCKET_ITEM_ADDED, never, never>;
+/**
+ * Bucket items were removed — the drag-out gesture, the explicit multi-item removal and the
+ * derived-items purge (`DND_ITEM_REMOVE`, `REMOVE_ITEMS`, `REMOVE_DERIVED_ITEMS`), which are three
+ * triggers over one operation because they differ only in which local identifiers they name.
+ */
+export declare const bucketItemsRemoved: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IRemoveBucketItemsCommit], IRemoveBucketItemsCommit, BucketsOperationActionTypeKeys.STORE_BUCKET_ITEMS_REMOVED, never, never>;
+/** A bucket item was replaced by a catalog item in place (`DND_ITEM_REPLACE`) — an add and a removal. */
+export declare const bucketItemReplaced: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IRemoveBucketItemsCommit], IRemoveBucketItemsCommit, BucketsOperationActionTypeKeys.STORE_BUCKET_ITEM_REPLACED, never, never>;
+/** Two bucket items swapped, or one moved into another bucket (`DND_ITEM_SWAP`). */
+export declare const bucketItemsSwapped: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: ISwapBucketItemResult], ISwapBucketItemResult, BucketsOperationActionTypeKeys.STORE_BUCKET_ITEMS_SWAPPED, never, never>;
+/** A bucket item moved to another position inside its bucket (`DND_ITEM_REORDER`). */
+export declare const bucketItemReordered: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IReorderBucketItemResult], IReorderBucketItemResult, BucketsOperationActionTypeKeys.STORE_BUCKET_ITEM_REORDERED, never, never>;
+/**
+ * One bucket item's own properties changed — the eleven edit triggers (title, format, showAllValues,
+ * aggregation, chart type, isTotalMeasure, showOnSecondaryAxis, isThresholdMeasure, showInPercent,
+ * granularity, display form). ONE event, because the reference-point consequence is the same for all of
+ * them and the buckets value is the only thing that differs. Dual axis is NOT one of them — see
+ * {@link dualAxisToggled}.
+ */
+export declare const bucketItemEdited: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IBucketItemEditResult], IBucketItemEditResult, BucketsOperationActionTypeKeys.STORE_BUCKET_ITEM_EDITED, never, never>;
+/**
+ * The dual axis was toggled for one bucket (`BUCKET_TOGGLE_DUAL_AXIS`) — the one edit that decides TWO
+ * domains, so it gets its own event rather than joining {@link bucketItemEdited}: the visualization
+ * properties' `dualAxis` control and the bucket items' `showOnSecondaryAxis` have to land together, or
+ * the control is on while the items are not yet flagged.
+ */
+export declare const dualAxisToggled: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IDualAxisToggleResult], IDualAxisToggleResult, BucketsOperationActionTypeKeys.STORE_DUAL_AXIS_TOGGLED, never, never>;
+/**
+ * Date bucket items were re-pointed at another date dataset — the three `SET_*_DATE_DATASET` triggers.
+ * Separate from {@link bucketItemEdited} for one observable reason: it answers the md-object flag
+ * TRUE, because a dataset change needs no pluggable-visualization round trip to become valid.
+ */
+export declare const bucketsDateDatasetChanged: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IBucketItemEditResult], IBucketItemEditResult, BucketsOperationActionTypeKeys.STORE_BUCKETS_DATE_DATASET_CHANGED, never, never>;
+/**
+ * The user picked another visualization type (`BUCKETS_SELECT_VISUALIZATION_TYPE`). Reads NOTHING —
+ * the payload is the class — and the extended reference point is CLEARED, which is what makes the
+ * next plug-viz answer authoritative.
+ */
+export declare const visualizationTypeSelected: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IVisualizationTypeSelectionResult], IVisualizationTypeSelectionResult, BucketsOperationActionTypeKeys.STORE_VISUALIZATION_TYPE_SELECTED, never, never>;
+/**
+ * A pluggable visualization answered with an extended reference point
+ * (`EXTENDED_REFERENCE_POINT_CHANGED`) and AD applied it.
+ *
+ * THE WATCHERS THAT MUST SEE THE APPLIED STATE KEY ON THIS EVENT, not on the trigger — the catalog's
+ * availability flow and the embedded `insight_changed` notification both read state this operation
+ * writes, and after this row the trigger writes none of it. Narrower and safer than the prototype's
+ * `isCascadeAppliedFor(<trigger>)`: the event exists per operation, so it cannot fail to arrive for a
+ * cascade that computed a no-op.
+ */
+export declare const extendedReferencePointApplied: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IExtendedReferencePointAppliedResult], IExtendedReferencePointAppliedResult, BucketsOperationActionTypeKeys.STORE_EXTENDED_REFERENCE_POINT_APPLIED, never, never>;
+/**
+ * The pluggable visualization placed the derived measures AD had queued
+ * (`NEW_DERIVED_BUCKET_ITEMS_PLACED`), so the queue is emptied and the totals are mirrored onto them.
+ */
+export declare const derivedBucketItemsPlaced: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IDerivedBucketItemsPlacedResult], IDerivedBucketItemsPlacedResult, BucketsOperationActionTypeKeys.STORE_DERIVED_BUCKET_ITEMS_PLACED, never, never>;
+/**
+ * Filters were removed, so the buckets follow (`SAGA_FILTERS_WERE_CHANGED`): the removed filters' meta
+ * markers are dropped, and a removed date filter that was comparing over time takes the derived
+ * measures with it.
+ */
+export declare const filterRemovalApplied: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: IFilterRemovalResult], IFilterRemovalResult, BucketsOperationActionTypeKeys.STORE_FILTER_REMOVAL_APPLIED, never, never>;
+//# sourceMappingURL=buckets_operation_events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buckets_operation_events.d.ts","sourceRoot":"","sources":["../../../src/store/buckets/buckets_operation_events.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EACH,KAAK,qBAAqB,EAE1B,KAAK,qBAAqB,EAC1B,KAAK,iCAAiC,EACzC,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EACH,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAE7B,KAAK,qBAAqB,EAC7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACH,KAAK,+BAA+B,EACpC,KAAK,oCAAoC,EAC5C,MAAM,0CAA0C,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oBAAY,8BAA8B;IACtC,uBAAuB,oCAAoC;IAC3D,0BAA0B,uCAAuC;IACjE,0BAA0B,uCAAuC;IACjE,0BAA0B,uCAAuC;IACjE,2BAA2B,wCAAwC;IACnE,wBAAwB,qCAAqC;IAC7D,uBAAuB,oCAAoC;IAC3D,kCAAkC,uCAAuC;IACzE,iCAAiC,8CAA8C;IAC/E,sCAAsC,mDAAmD;IACzF,iCAAiC,8CAA8C;IAC/E,4BAA4B,yCAAyC;CACxE;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,0LAG3B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,qMAG9B,CAAC;AAEF,yGAAyG;AACzG,eAAO,MAAM,kBAAkB,qMAG9B,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,+LAG9B,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,mBAAmB,sMAG/B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,6LAG5B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,4LAG3B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,uMAGrC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,8NAGrC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,yOAGzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,0NAGpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,+LAGhC,CAAC"}

package/esm/store/buckets/buckets_operation_events.js

@@ -0,0 +1,114 @@
+// (C) 2026 GoodData Corporation
+import { createAction } from "@reduxjs/toolkit";
+/**
+ * THE SEMANTIC EVENTS OF THE BUCKETS FAMILY.
+ *
+ * Every buckets trigger resolves to one of the operations below. Each operation is a pure value-level
+ * calculation (`buckets_*_operation*.ts`), each is driven by ONE saga handler
+ * (`buckets_operations_saga.ts`) and each commits its result with ONE of these events — which the
+ * owning slices and leaves consume as ordinary cases.
+ *
+ * THREE PROPERTIES ARE THE POINT, and all three are structural rather than asserted:
+ *
+ * 1. **One gesture is one store write.** The trigger writes nothing at all, so there is no
+ *    intermediate state a subscriber can observe, `observeStore` fires at most once, and undo needs
+ *    no batching.
+ * 2. **The payload is the operation's RESULT — different per operation, and that is deliberate.**
+ *    `visualizationTypeSelected` carries three values, `bucketItemAdded` nine. A universal payload, a
+ *    presence map or a change set would erase exactly the information these types carry.
+ * 3. **`isVisualizationMdObjectValid` is named separately wherever it is produced.** It is an OUTPUT
+ *    of the mutating gesture, not reference-point state.
+ *
+ * Values are carried UNCONDITIONALLY and the helpers answer the ORIGINAL reference when nothing
+ * changed, so an unchanged value reaching a slice case returns the same state and `combineBranch`
+ * short-circuits on identity. That is why there is no diff: the returned values already carry the
+ * information.
+ *
+ * The type strings live in a namespace of their own rather than in `ActionTypeKeys`: no external
+ * consumer matches on them, and keeping them out is what makes "which strings are frozen behavior"
+ * answerable. They are deliberately NOT undoable — time travel keys on the TRIGGER, which reaches
+ * the store first (see store/_infra/time_travel.ts).
+ */
+export var BucketsOperationActionTypeKeys;
+(function (BucketsOperationActionTypeKeys) {
+    BucketsOperationActionTypeKeys["STORE_BUCKET_ITEM_ADDED"] = "STORE/BUCKETS/BUCKET_ITEM_ADDED";
+    BucketsOperationActionTypeKeys["STORE_BUCKET_ITEMS_REMOVED"] = "STORE/BUCKETS/BUCKET_ITEMS_REMOVED";
+    BucketsOperationActionTypeKeys["STORE_BUCKET_ITEM_REPLACED"] = "STORE/BUCKETS/BUCKET_ITEM_REPLACED";
+    BucketsOperationActionTypeKeys["STORE_BUCKET_ITEMS_SWAPPED"] = "STORE/BUCKETS/BUCKET_ITEMS_SWAPPED";
+    BucketsOperationActionTypeKeys["STORE_BUCKET_ITEM_REORDERED"] = "STORE/BUCKETS/BUCKET_ITEM_REORDERED";
+    BucketsOperationActionTypeKeys["STORE_BUCKET_ITEM_EDITED"] = "STORE/BUCKETS/BUCKET_ITEM_EDITED";
+    BucketsOperationActionTypeKeys["STORE_DUAL_AXIS_TOGGLED"] = "STORE/BUCKETS/DUAL_AXIS_TOGGLED";
+    BucketsOperationActionTypeKeys["STORE_BUCKETS_DATE_DATASET_CHANGED"] = "STORE/BUCKETS/DATE_DATASET_CHANGED";
+    BucketsOperationActionTypeKeys["STORE_VISUALIZATION_TYPE_SELECTED"] = "STORE/BUCKETS/VISUALIZATION_TYPE_SELECTED";
+    BucketsOperationActionTypeKeys["STORE_EXTENDED_REFERENCE_POINT_APPLIED"] = "STORE/BUCKETS/EXTENDED_REFERENCE_POINT_APPLIED";
+    BucketsOperationActionTypeKeys["STORE_DERIVED_BUCKET_ITEMS_PLACED"] = "STORE/BUCKETS/DERIVED_BUCKET_ITEMS_PLACED";
+    BucketsOperationActionTypeKeys["STORE_FILTER_REMOVAL_APPLIED"] = "STORE/BUCKETS/FILTER_REMOVAL_APPLIED";
+})(BucketsOperationActionTypeKeys || (BucketsOperationActionTypeKeys = {}));
+/**
+ * A catalog item was dropped into a bucket (`BUCKETS_DND_ITEM_INSERT`). The widest of the edits: the
+ * add itself is narrow, but a measure added while every reference-point measure already compares over
+ * time drags the whole over-time-comparison operation in behind it — which is where the filter bar,
+ * the notifications and the extended reference point in this payload come from.
+ */
+export const bucketItemAdded = createAction(BucketsOperationActionTypeKeys.STORE_BUCKET_ITEM_ADDED, (payload) => ({ payload }));
+/**
+ * Bucket items were removed — the drag-out gesture, the explicit multi-item removal and the
+ * derived-items purge (`DND_ITEM_REMOVE`, `REMOVE_ITEMS`, `REMOVE_DERIVED_ITEMS`), which are three
+ * triggers over one operation because they differ only in which local identifiers they name.
+ */
+export const bucketItemsRemoved = createAction(BucketsOperationActionTypeKeys.STORE_BUCKET_ITEMS_REMOVED, (payload) => ({ payload }));
+/** A bucket item was replaced by a catalog item in place (`DND_ITEM_REPLACE`) — an add and a removal. */
+export const bucketItemReplaced = createAction(BucketsOperationActionTypeKeys.STORE_BUCKET_ITEM_REPLACED, (payload) => ({ payload }));
+/** Two bucket items swapped, or one moved into another bucket (`DND_ITEM_SWAP`). */
+export const bucketItemsSwapped = createAction(BucketsOperationActionTypeKeys.STORE_BUCKET_ITEMS_SWAPPED, (payload) => ({ payload }));
+/** A bucket item moved to another position inside its bucket (`DND_ITEM_REORDER`). */
+export const bucketItemReordered = createAction(BucketsOperationActionTypeKeys.STORE_BUCKET_ITEM_REORDERED, (payload) => ({ payload }));
+/**
+ * One bucket item's own properties changed — the eleven edit triggers (title, format, showAllValues,
+ * aggregation, chart type, isTotalMeasure, showOnSecondaryAxis, isThresholdMeasure, showInPercent,
+ * granularity, display form). ONE event, because the reference-point consequence is the same for all of
+ * them and the buckets value is the only thing that differs. Dual axis is NOT one of them — see
+ * {@link dualAxisToggled}.
+ */
+export const bucketItemEdited = createAction(BucketsOperationActionTypeKeys.STORE_BUCKET_ITEM_EDITED, (payload) => ({ payload }));
+/**
+ * The dual axis was toggled for one bucket (`BUCKET_TOGGLE_DUAL_AXIS`) — the one edit that decides TWO
+ * domains, so it gets its own event rather than joining {@link bucketItemEdited}: the visualization
+ * properties' `dualAxis` control and the bucket items' `showOnSecondaryAxis` have to land together, or
+ * the control is on while the items are not yet flagged.
+ */
+export const dualAxisToggled = createAction(BucketsOperationActionTypeKeys.STORE_DUAL_AXIS_TOGGLED, (payload) => ({ payload }));
+/**
+ * Date bucket items were re-pointed at another date dataset — the three `SET_*_DATE_DATASET` triggers.
+ * Separate from {@link bucketItemEdited} for one observable reason: it answers the md-object flag
+ * TRUE, because a dataset change needs no pluggable-visualization round trip to become valid.
+ */
+export const bucketsDateDatasetChanged = createAction(BucketsOperationActionTypeKeys.STORE_BUCKETS_DATE_DATASET_CHANGED, (payload) => ({ payload }));
+/**
+ * The user picked another visualization type (`BUCKETS_SELECT_VISUALIZATION_TYPE`). Reads NOTHING —
+ * the payload is the class — and the extended reference point is CLEARED, which is what makes the
+ * next plug-viz answer authoritative.
+ */
+export const visualizationTypeSelected = createAction(BucketsOperationActionTypeKeys.STORE_VISUALIZATION_TYPE_SELECTED, (payload) => ({ payload }));
+/**
+ * A pluggable visualization answered with an extended reference point
+ * (`EXTENDED_REFERENCE_POINT_CHANGED`) and AD applied it.
+ *
+ * THE WATCHERS THAT MUST SEE THE APPLIED STATE KEY ON THIS EVENT, not on the trigger — the catalog's
+ * availability flow and the embedded `insight_changed` notification both read state this operation
+ * writes, and after this row the trigger writes none of it. Narrower and safer than the prototype's
+ * `isCascadeAppliedFor(<trigger>)`: the event exists per operation, so it cannot fail to arrive for a
+ * cascade that computed a no-op.
+ */
+export const extendedReferencePointApplied = createAction(BucketsOperationActionTypeKeys.STORE_EXTENDED_REFERENCE_POINT_APPLIED, (payload) => ({ payload }));
+/**
+ * The pluggable visualization placed the derived measures AD had queued
+ * (`NEW_DERIVED_BUCKET_ITEMS_PLACED`), so the queue is emptied and the totals are mirrored onto them.
+ */
+export const derivedBucketItemsPlaced = createAction(BucketsOperationActionTypeKeys.STORE_DERIVED_BUCKET_ITEMS_PLACED, (payload) => ({ payload }));
+/**
+ * Filters were removed, so the buckets follow (`SAGA_FILTERS_WERE_CHANGED`): the removed filters' meta
+ * markers are dropped, and a removed date filter that was comparing over time takes the derived
+ * measures with it.
+ */
+export const filterRemovalApplied = createAction(BucketsOperationActionTypeKeys.STORE_FILTER_REMOVAL_APPLIED, (payload) => ({ payload }));

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

@@ -0,0 +1,88 @@
+import { type IReferencePointSyncDeps } from "../reference_point/reference_point_sync.js";
+import { type IAppState } from "../types.js";
+import { type IAddBucketItemDeps, type IAddBucketItemInput } from "./buckets_add_operation.js";
+import { type DateDatasetByRefResolver } from "./buckets_date_helpers.js";
+import { type IBucketItemEditDeps, type IBucketItemEditInput, type IBucketsDateDatasetChangeDeps, type IDualAxisToggleInput } from "./buckets_edit_operations.js";
+import { type IFilterRemovalDeps, type IFilterRemovalInput } from "./buckets_filter_removal_operation.js";
+import { type IBucketsMetaState } from "./buckets_meta_state.js";
+import { type IRemoveBucketItemsOperationDeps, type IRemoveBucketItemsOperationInput, type IReplaceBucketItemDeps, type ISwapBucketItemDeps, type ISwapBucketItemInput } from "./buckets_move_operations.js";
+import { type CatalogMetricRefResolver } from "./buckets_removal_helpers.js";
+import { type IDerivedBucketItemsPlacedInput, type IExtendedReferencePointAppliedDeps, type IExtendedReferencePointAppliedInput } from "./extended_reference_point_operations.js";
+import { type BucketItemRefResolver } from "./helpers/filter_dependencies.js";
+import { type CatalogItemTypeResolver } from "./helpers/measure_format.js";
+import { type IPluggableVisualizationState } from "./pluggable_visualization_state.js";
+/**
+ * THE SAGA BOUNDARY of the buckets operations.
+ *
+ * This is the ONE module of the family that is allowed to know about the root state, and it is the whole
+ * reason the operations themselves do not: everything foreign an operation needs — another domain's
+ * value, a feature flag, a uiConfig answer, a catalog lookup — is resolved here and handed over as a
+ * typed argument, a named boolean or a lazy resolver.
+ *
+ * Its callers are the operation sagas: this family's, plus the properties, arithmetic, recommendation
+ * and shortcut ones that compose the buckets operations on values.
+ */
+/** Resolves a date dataset by ObjRef out of the store — the lazy resolver the date helpers take. */
+export declare function dateDatasetByRefResolver(state: IAppState): DateDatasetByRefResolver;
+/**
+ * Resolves a measure's catalog item type for the format helpers; undefined = no catalog item.
+ * Exported — the arithmetic-measure operator edit asks the same format question.
+ */
+export declare function catalogItemTypeResolver(state: IAppState): CatalogItemTypeResolver;
+export declare const readBucketsMeta: (state: IAppState) => IBucketsMetaState;
+export declare const readIsVisualizationMdObjectValid: (state: IAppState) => boolean;
+export declare const readPluggableVisualization: (state: IAppState) => IPluggableVisualizationState | undefined;
+/**
+ * The reference-point sync's two foreign facts as VALUES — for the operations that do not rewrite the
+ * filter bar or the buckets meta on their way through (every bucket-item edit).
+ */
+export declare function readReferencePointSyncValues(state: IAppState): {
+    refPointFilters: import("../reference_point/reference_point_state.js").IRefPointFiltersBucket;
+    sortItems: import("@gooddata/sdk-model").ISortItem[] | undefined;
+};
+/** The same two facts as RESOLVERS — for the operations built on the removal chain. */
+export declare function buildReferencePointSyncDeps(state: IAppState): IReferencePointSyncDeps;
+/** The removal calculation's four foreign facts. */
+export declare function buildRemovalDeps(state: IAppState): {
+    catalogMetricRef: CatalogMetricRefResolver;
+    bucketItemRef: BucketItemRefResolver;
+    improvedRankingFilter: boolean;
+    reorderByMeasures: boolean;
+};
+export declare const readBucketItemEditInput: (state: IAppState) => IBucketItemEditInput;
+export declare const buildBucketItemEditDeps: (state: IAppState) => IBucketItemEditDeps;
+export declare const buildBucketsDateDatasetChangeDeps: (state: IAppState) => IBucketsDateDatasetChangeDeps;
+export declare const readDualAxisToggleInput: (state: IAppState) => IDualAxisToggleInput;
+export declare const readAddBucketItemInput: (state: IAppState) => IAddBucketItemInput;
+/**
+ * The add's foreign facts. The three uiConfig answers are about the TARGET bucket, so they are resolved
+ * per gesture rather than handed over as a uiConfig value — which is what keeps the operation from having
+ * to know that "accepts" and "transformAttributeToMeasure" live in the extended reference point.
+ *
+ * BOTH callers — the drag-in saga and the `addItem` adapter — take the same three answers. The replace
+ * path wants a different answer and says so directly: see `bucketEnablesSecondaryAxis: false` in
+ * {@link buildReplaceBucketItemDeps}.
+ */
+export declare const buildAddBucketItemDeps: (state: IAppState, bucketLocalIdentifier: string) => IAddBucketItemDeps;
+export declare const readRemoveBucketItemsInput: (state: IAppState) => IRemoveBucketItemsOperationInput;
+export declare const buildRemoveBucketItemsDeps: (state: IAppState) => IRemoveBucketItemsOperationDeps;
+export declare const buildReplaceBucketItemDeps: (state: IAppState, bucketLocalIdentifier: string) => IReplaceBucketItemDeps;
+export declare const readSwapBucketItemInput: (state: IAppState) => ISwapBucketItemInput;
+/**
+ * The swap's foreign facts. `synchronizedDatesPreferred` folds together the uiConfig preference AND
+ * the "does the target bucket already hold a date item" question, both asked of the PRE-move buckets:
+ * they gate the same branch, and resolving them here keeps the operation from reading either.
+ */
+export declare const buildSwapBucketItemDeps: (state: IAppState, targetBucketLocalIdentifier: string | undefined) => ISwapBucketItemDeps;
+export declare const buildReorderBucketItemDeps: (state: IAppState) => {
+    refPointFilters: import("../reference_point/reference_point_sync.js").RefPointFiltersResolver;
+    sortItems: import("@gooddata/sdk-model").ISortItem[] | undefined;
+    reorderByMeasures: boolean;
+};
+export declare const readExtendedReferencePointAppliedInput: (state: IAppState) => IExtendedReferencePointAppliedInput;
+export declare const buildExtendedReferencePointAppliedDeps: (state: IAppState) => IExtendedReferencePointAppliedDeps;
+export declare const readDerivedBucketItemsPlacedInput: (state: IAppState) => IDerivedBucketItemsPlacedInput;
+/** The filter-removal reaction shares the removal chain's input and deps — it can widen into it. */
+export declare const readFilterRemovalInput: (state: IAppState) => IFilterRemovalInput;
+export declare const buildFilterRemovalDeps: (state: IAppState) => IFilterRemovalDeps;
+//# sourceMappingURL=buckets_operation_inputs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buckets_operation_inputs.d.ts","sourceRoot":"","sources":["../../../src/store/buckets/buckets_operation_inputs.ts"],"names":[],"mappings":"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"}

package/esm/store/buckets/buckets_operation_inputs.js

@@ -0,0 +1,244 @@
+// (C) 2026 GoodData Corporation
+import { areObjRefsEqual } from "@gooddata/sdk-model";
+import { METRIC } from "../../constants/bucket.js";
+import { getCacheKeyForAttributeItem } from "../../models/item_cache_lookup.js";
+import { filterSupportedDisplayForms } from "../../selectors/buckets_selector.js";
+import { enableImprovedRankingFilter, enableNewPivotTable, isApproxCountEnabled, } from "../../selectors/feature_flag_selector.js";
+import { getItemCache } from "../../selectors/item_cache_selector.js";
+import { isSynchronizedDatesPreferred } from "../../selectors/ui_config_selector.js";
+import { getBucketAcceptsItemType, getBucketTransformsAttributeItemToMeasure, getPrimaryDateDatasetRef, isBucketEnabledSecondaryAxis, } from "../../services/buckets_service.js";
+import { DateDatasetsService } from "../../services/date_datasets_service.js";
+import { convertFiltersToRefPoint } from "../../services/reference_point_service.js";
+import { getCatalogItemById } from "../catalog/catalog_selector.js";
+import { convertFromExtendedRefPointFilters } from "../filter_bar/filter_bar_helpers.js";
+import { getFilterBarState } from "../filter_bar/filter_bar_selector.js";
+import { getVisualizationPropertiesSortItems } from "../properties/properties_selectors.js";
+import { getUiConfigSupportedOverTimeComparisonTypes } from "../reference_point/extended_reference_point_selectors.js";
+import { getExtendedReferencePoint, getReferencePoint, } from "../reference_point/reference_point_selectors.js";
+import { getBucketItemDimensionalityRef, setBucketItemsDateDataset, } from "./buckets_date_helpers.js";
+import { bucketHoldsDateItem, } from "./buckets_move_operations.js";
+import { getBucketsState } from "./buckets_selectors.js";
+import { findBucketItemInBuckets } from "./buckets_write_helpers.js";
+import { isDateBucketItem } from "./helpers/bucket_item_predicates.js";
+/**
+ * THE SAGA BOUNDARY of the buckets operations.
+ *
+ * This is the ONE module of the family that is allowed to know about the root state, and it is the whole
+ * reason the operations themselves do not: everything foreign an operation needs — another domain's
+ * value, a feature flag, a uiConfig answer, a catalog lookup — is resolved here and handed over as a
+ * typed argument, a named boolean or a lazy resolver.
+ *
+ * Its callers are the operation sagas: this family's, plus the properties, arithmetic, recommendation
+ * and shortcut ones that compose the buckets operations on values.
+ */
+// --- the resolvers ---------------------------------------------------------------------------------
+/** Resolves a date dataset by ObjRef out of the store — the lazy resolver the date helpers take. */
+export function dateDatasetByRefResolver(state) {
+    return (ref) => DateDatasetsService.getDateDatasetByRef(state, ref);
+}
+/** Resolves a catalog metric's cache identifier to its display ObjRef, out of the item cache. */
+function catalogMetricRefResolver(state) {
+    return (metricIdentifier) => getItemCache(state)[`metric.${metricIdentifier}`]?.ref ?? null;
+}
+/** Resolves an attribute cache-item identifier to its display-form ObjRef, out of the item cache. */
+function attributeDfRefResolver(state) {
+    return (cacheItemIdentifier, isComputedAttribute) => {
+        // the caller reads the namespace off the bucket item, so this is exact - no fallback needed
+        const cacheItem = getItemCache(state)[getCacheKeyForAttributeItem(cacheItemIdentifier, isComputedAttribute)];
+        return cacheItem ? (cacheItem.dfRef ?? null) : null;
+    };
+}
+/** Resolves a removed bucket item's local identifier to the ObjRef a dimensionality entry keeps. */
+function bucketItemRefResolver(state) {
+    return (localIdentifier) => getBucketItemDimensionalityRef(findBucketItemInBuckets(getBucketsState(state), localIdentifier), {
+        dateDatasetByRef: dateDatasetByRefResolver(state),
+        attributeDfRefByIdentifier: attributeDfRefResolver(state),
+    });
+}
+/**
+ * Resolves a measure's catalog item type for the format helpers; undefined = no catalog item.
+ * Exported — the arithmetic-measure operator edit asks the same format question.
+ */
+export function catalogItemTypeResolver(state) {
+    return (measureIdentifier) => getCatalogItemById(measureIdentifier)(state)?.type;
+}
+/** Resolves one of an attribute's cached display forms by ObjRef. */
+function attributeDisplayFormByRefResolver(state) {
+    return (cacheItemIdentifier, displayFormRef, isComputedAttribute) => getItemCache(state)[getCacheKeyForAttributeItem(cacheItemIdentifier, isComputedAttribute)]?.displayForms?.find((displayForm) => areObjRefsEqual(displayForm.ref, displayFormRef));
+}
+/**
+ * The SUPPORTED display forms of a catalog item, by the cache key the built item implies.
+ *
+ * The key convention is not symmetrical: a DATE item is cached under its bare identifier, an item
+ * built from a computed attribute under `computedAttribute.<identifier>`, everything
+ * else under `attribute.<identifier>`.
+ */
+function supportedDisplayFormsResolver(state) {
+    return (catalogItemIdentifier, isDate, isComputedAttribute) => {
+        const itemCacheId = isDate
+            ? catalogItemIdentifier
+            : getCacheKeyForAttributeItem(catalogItemIdentifier, isComputedAttribute);
+        const displayForms = getItemCache(state)[itemCacheId]?.displayForms;
+        return displayForms ? filterSupportedDisplayForms(displayForms) : undefined;
+    };
+}
+// --- the shared reads -----------------------------------------------------------------------------
+export const readBucketsMeta = (state) => state.data.bucketsMeta;
+export const readIsVisualizationMdObjectValid = (state) => state.data.isVisualizationMdObjectValid;
+export const readPluggableVisualization = (state) => state.data.pluggableVisualization;
+/**
+ * The reference-point sync's two foreign facts as VALUES — for the operations that do not rewrite the
+ * filter bar or the buckets meta on their way through (every bucket-item edit).
+ */
+export function readReferencePointSyncValues(state) {
+    return {
+        refPointFilters: convertFiltersToRefPoint(getFilterBarState(state).items, readBucketsMeta(state)),
+        sortItems: getVisualizationPropertiesSortItems(state),
+    };
+}
+/** The same two facts as RESOLVERS — for the operations built on the removal chain. */
+export function buildReferencePointSyncDeps(state) {
+    return {
+        refPointFilters: (filterBar, bucketsMeta) => convertFiltersToRefPoint(filterBar.items, bucketsMeta),
+        sortItems: getVisualizationPropertiesSortItems(state),
+    };
+}
+/** The removal calculation's four foreign facts. */
+export function buildRemovalDeps(state) {
+    return {
+        catalogMetricRef: catalogMetricRefResolver(state),
+        bucketItemRef: bucketItemRefResolver(state),
+        improvedRankingFilter: enableImprovedRankingFilter(state),
+        reorderByMeasures: enableNewPivotTable(state),
+    };
+}
+// --- the bucket-item edits ------------------------------------------------------------------------
+export const readBucketItemEditInput = (state) => ({
+    buckets: getBucketsState(state),
+    referencePoint: getReferencePoint(state),
+});
+export const buildBucketItemEditDeps = (state) => ({
+    ...readReferencePointSyncValues(state),
+    catalogItemType: catalogItemTypeResolver(state),
+    dateDatasetByRef: dateDatasetByRefResolver(state),
+    attributeDisplayFormByRef: attributeDisplayFormByRefResolver(state),
+});
+export const buildBucketsDateDatasetChangeDeps = (state) => ({
+    ...readReferencePointSyncValues(state),
+    dateDatasetByRef: dateDatasetByRefResolver(state),
+});
+export const readDualAxisToggleInput = (state) => ({
+    ...readBucketItemEditInput(state),
+    visualizationProperties: state.data.visualizationProperties,
+});
+// --- picking a visualization type -----------------------------------------------------------------
+// --- adding a catalog item -------------------------------------------------------------------------
+export const readAddBucketItemInput = (state) => ({
+    buckets: getBucketsState(state),
+    bucketsMeta: readBucketsMeta(state),
+    configurationPanel: state.data.configurationPanel,
+    filterBar: getFilterBarState(state),
+    bucketNotifications: state.data.bucketNotifications,
+    extendedReferencePoint: getExtendedReferencePoint(state),
+    pluggableVisualization: readPluggableVisualization(state),
+    referencePoint: getReferencePoint(state),
+    isVisualizationMdObjectValid: readIsVisualizationMdObjectValid(state),
+});
+/**
+ * The add's foreign facts. The three uiConfig answers are about the TARGET bucket, so they are resolved
+ * per gesture rather than handed over as a uiConfig value — which is what keeps the operation from having
+ * to know that "accepts" and "transformAttributeToMeasure" live in the extended reference point.
+ *
+ * BOTH callers — the drag-in saga and the `addItem` adapter — take the same three answers. The replace
+ * path wants a different answer and says so directly: see `bucketEnablesSecondaryAxis: false` in
+ * {@link buildReplaceBucketItemDeps}.
+ */
+export const buildAddBucketItemDeps = (state, bucketLocalIdentifier) => ({
+    ...buildRemovalDeps(state),
+    ...buildReferencePointSyncDeps(state),
+    primaryDateDatasetRef: getPrimaryDateDatasetRef(state),
+    dateDatasetByRef: dateDatasetByRefResolver(state),
+    bucketAcceptsMeasures: getBucketAcceptsItemType(bucketLocalIdentifier, METRIC, state),
+    bucketTransformsAttributeToMeasure: getBucketTransformsAttributeItemToMeasure(bucketLocalIdentifier, state),
+    bucketEnablesSecondaryAxis: isBucketEnabledSecondaryAxis(state, bucketLocalIdentifier),
+    approxCount: isApproxCountEnabled(state),
+    supportedDisplayForms: supportedDisplayFormsResolver(state),
+    supportedOverTimeComparisonTypes: getUiConfigSupportedOverTimeComparisonTypes(state, []),
+});
+// --- removing items --------------------------------------------------------------------------------
+export const readRemoveBucketItemsInput = (state) => ({
+    buckets: getBucketsState(state),
+    bucketsMeta: readBucketsMeta(state),
+    filterBar: getFilterBarState(state),
+    bucketNotifications: state.data.bucketNotifications,
+    extendedReferencePoint: getExtendedReferencePoint(state),
+    referencePoint: getReferencePoint(state),
+});
+export const buildRemoveBucketItemsDeps = (state) => ({
+    ...buildRemovalDeps(state),
+    ...buildReferencePointSyncDeps(state),
+});
+// --- replacing an item -----------------------------------------------------------------------------
+export const buildReplaceBucketItemDeps = (state, bucketLocalIdentifier) => ({
+    ...buildRemoveBucketItemsDeps(state),
+    primaryDateDatasetRef: getPrimaryDateDatasetRef(state),
+    dateDatasetByRef: dateDatasetByRefResolver(state),
+    bucketAcceptsMeasures: getBucketAcceptsItemType(bucketLocalIdentifier, METRIC, state),
+    bucketTransformsAttributeToMeasure: getBucketTransformsAttributeItemToMeasure(bucketLocalIdentifier, state),
+    bucketEnablesSecondaryAxis: false,
+    supportedDisplayForms: supportedDisplayFormsResolver(state),
+});
+// --- swapping and reordering -----------------------------------------------------------------------
+export const readSwapBucketItemInput = (state) => ({
+    buckets: getBucketsState(state),
+    bucketsMeta: readBucketsMeta(state),
+    filterBar: getFilterBarState(state),
+    referencePoint: getReferencePoint(state),
+});
+/**
+ * The swap's foreign facts. `synchronizedDatesPreferred` folds together the uiConfig preference AND
+ * the "does the target bucket already hold a date item" question, both asked of the PRE-move buckets:
+ * they gate the same branch, and resolving them here keeps the operation from reading either.
+ */
+export const buildSwapBucketItemDeps = (state, targetBucketLocalIdentifier) => {
+    const buckets = getBucketsState(state);
+    return {
+        ...buildReferencePointSyncDeps(state),
+        acceptsItemType: (bucketLocalIdentifier, itemType) => getBucketAcceptsItemType(bucketLocalIdentifier, itemType, state),
+        secondaryAxisEnabled: targetBucketLocalIdentifier
+            ? isBucketEnabledSecondaryAxis(state, targetBucketLocalIdentifier)
+            : false,
+        synchronizedDatesPreferred: Boolean(targetBucketLocalIdentifier &&
+            isSynchronizedDatesPreferred(state, targetBucketLocalIdentifier) &&
+            bucketHoldsDateItem(buckets, targetBucketLocalIdentifier, (item) => isDateBucketItem(item))),
+        primaryDateDatasetRef: getPrimaryDateDatasetRef(state),
+        setDateDatasetForItem: (currentBuckets, ref, localIdentifier) => setBucketItemsDateDataset(currentBuckets, ref, { bucketItemLocalIdentifier: localIdentifier }, dateDatasetByRefResolver(state)),
+        reorderByMeasures: enableNewPivotTable(state),
+    };
+};
+export const buildReorderBucketItemDeps = (state) => ({
+    ...buildReferencePointSyncDeps(state),
+    reorderByMeasures: enableNewPivotTable(state),
+});
+// --- the pluggable-visualization answer ------------------------------------------------------------
+export const readExtendedReferencePointAppliedInput = (state) => ({
+    buckets: getBucketsState(state),
+    filterBar: getFilterBarState(state),
+    referencePoint: getReferencePoint(state),
+    sortItems: getVisualizationPropertiesSortItems(state),
+});
+export const buildExtendedReferencePointAppliedDeps = (state) => ({
+    convertFromExtendedRefPointFilters,
+    catalogItemType: catalogItemTypeResolver(state),
+    dateDatasetByRef: dateDatasetByRefResolver(state),
+    reorderByMeasures: enableNewPivotTable(state),
+});
+export const readDerivedBucketItemsPlacedInput = (state) => ({
+    extendedReferencePoint: getExtendedReferencePoint(state),
+    pluggableVisualization: readPluggableVisualization(state),
+    referencePoint: getReferencePoint(state),
+});
+// --- filters were removed --------------------------------------------------------------------------
+/** The filter-removal reaction shares the removal chain's input and deps — it can widen into it. */
+export const readFilterRemovalInput = (state) => readRemoveBucketItemsInput(state);
+export const buildFilterRemovalDeps = (state) => buildRemoveBucketItemsDeps(state);

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

@@ -0,0 +1,46 @@
+import { type Action } from "redux";
+import { type IExtendedReferencePointState } from "../reference_point/extended_reference_point_state.js";
+import { type IPluggableVisualizationState } from "./pluggable_visualization_state.js";
+/**
+ * THE THREE LEAVES the buckets operations commit into: `data.extendedReferencePoint`,
+ * `data.isVisualizationMdObjectValid` and `data.pluggableVisualization` — an explicit case per
+ * event, which is the same shape a slice gets, written out.
+ *
+ * WHY HAND-WRITTEN RATHER THAN `createSlice`, unlike `bucketsMeta` next door. `createSlice` runs its case
+ * reducers inside immer, which DEEP-FREEZES what they return in development builds. The extended
+ * reference point is the value AD hands straight back to a pluggable visualization on the next round
+ * trip, and the queue holds items the plug viz places — freezing either would turn a pre-existing
+ * in-place write somewhere in that contract into a hard throw. A plain reducer function has the
+ * identity short-circuit and none of the freeze exposure. `bucketsMeta` is a slice because it is
+ * AD's own marker maps and nothing outside AD ever holds them.
+ *
+ * Every case is `(_state, action) => action.payload.<domain>`. That looks trivial and is the point: the
+ * operation already decided the value, and it answers the ORIGINAL reference when it decided nothing,
+ * so an unchanged value returns the same state and the root combiner stays quiet.
+ */
+/**
+ * `data.extendedReferencePoint` — `undefined` until a pluggable visualization answers, which several
+ * readers distinguish from present-and-empty. The combined root mounts the leaf through
+ * `nullableLeaf` (the store holds `null` at rest; `getExtendedReferencePoint` converts back), so a
+ * case returning `undefined` and one writing an absent payload field land the same.
+ *
+ * `visualizationTypeSelected` CLEARS it, which is indistinguishable to every reader from an absent
+ * key: `getExtendedReferencePoint` answers `undefined` either way, and the one `Object.keys` reader
+ * tests emptiness.
+ */
+export declare function extendedReferencePointLeafReducer(state: IExtendedReferencePointState | undefined, action: Action): IExtendedReferencePointState | undefined;
+/**
+ * `data.isVisualizationMdObjectValid` — the flag every buckets operation produces. It is an
+ * OUTPUT of the mutating gesture rather than reference-point state, which is why it is named separately
+ * in every payload and owned by a leaf of its own.
+ *
+ * It seeds TRUE: a freshly built state has nothing to validate yet.
+ */
+export declare function isVisualizationMdObjectValidLeafReducer(state: boolean | undefined, action: Action): boolean;
+/**
+ * `data.pluggableVisualization` — the queue of derived measures AD wants placed. Only two operations
+ * touch it: the add (a measure joining an over-time comparison queues one) and the plug viz's own
+ * placement answer (which empties it).
+ */
+export declare function pluggableVisualizationLeafReducer(state: IPluggableVisualizationState | undefined, action: Action): IPluggableVisualizationState;
+//# sourceMappingURL=buckets_operation_leaves.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buckets_operation_leaves.d.ts","sourceRoot":"","sources":["../../../src/store/buckets/buckets_operation_leaves.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,OAAO,CAAC;AA6BpC,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,sDAAsD,CAAC;AAqBzG,OAAO,EACH,KAAK,4BAA4B,EAEpC,MAAM,oCAAoC,CAAC;AAE5C;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC7C,KAAK,EAAE,4BAA4B,GAAG,SAAS,EAC/C,MAAM,EAAE,MAAM,GACf,4BAA4B,GAAG,SAAS,CAkF1C;AAED;;;;;;GAMG;AACH,wBAAgB,uCAAuC,CAAC,KAAK,EAAE,OAAO,YAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAuGtG;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC7C,KAAK,EAAE,4BAA4B,YAAqC,EACxE,MAAM,EAAE,MAAM,GACf,4BAA4B,CAoC9B"}