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

package/esm/convertors/toBackend/MeasureConverter.js

@@ -0,0 +1,83 @@
+// (C) 2019-2026 GoodData Corporation
+import { isEmpty } from "lodash-es";
+import { isArithmeticMeasure, isPoPMeasure, isPreviousPeriodMeasure, isSimpleMeasure, measureAggregation, measureAlias, measureArithmeticOperands, measureArithmeticOperator, measureDoesComputeRatio, measureFilters, measureFormat, measureIdentifier, measureLocalId, measureMasterIdentifier, measurePopAttribute, measurePreviousPeriodDateDataSets, measureTitle, measureUri, } from "@gooddata/sdk-model";
+import { convertAggregation } from "./afm/MeasureConverter.js";
+import { convertFilter } from "./FilterConverter.js";
+import { toBearRef } from "./ObjRefConverter.js";
+const convertPreviousPeriodDataSet = (dataSet) => {
+    return {
+        dataSet: toBearRef(dataSet.dataSet),
+        periodsAgo: dataSet.periodsAgo,
+    };
+};
+const convertPreviousPeriodMeasureDefinition = (measure) => {
+    return {
+        previousPeriodMeasure: {
+            measureIdentifier: measureMasterIdentifier(measure),
+            dateDataSets: measurePreviousPeriodDateDataSets(measure).map(convertPreviousPeriodDataSet),
+        },
+    };
+};
+const convertPoPMeasureDefinition = (measure) => {
+    return {
+        popMeasureDefinition: {
+            measureIdentifier: measureMasterIdentifier(measure),
+            popAttribute: toBearRef(measurePopAttribute(measure)),
+        },
+    };
+};
+const convertArithmeticMeasureDefinition = (measure) => {
+    return {
+        arithmeticMeasure: {
+            measureIdentifiers: measureArithmeticOperands(measure),
+            operator: measureArithmeticOperator(measure),
+        },
+    };
+};
+const convertSimpleMeasureDefinition = (measure, options) => {
+    const identifier = measureIdentifier(measure);
+    const uri = measureUri(measure);
+    if (!identifier && !uri) {
+        throw new Error("Measure has neither uri nor identifier.");
+    }
+    const aggregation = convertAggregation(measureAggregation(measure));
+    const computeRatio = measureDoesComputeRatio(measure);
+    const filters = (measureFilters(measure) || []).map((filter) => convertFilter(filter, options));
+    return {
+        measureDefinition: {
+            item: identifier ? { identifier } : { uri: uri },
+            ...(aggregation && { aggregation }),
+            ...(computeRatio && { computeRatio }),
+            ...(!isEmpty(filters) && { filters }),
+        },
+    };
+};
+const convertMeasureDefinition = (measure, options) => {
+    if (isSimpleMeasure(measure)) {
+        return convertSimpleMeasureDefinition(measure, options);
+    }
+    else if (isArithmeticMeasure(measure)) {
+        return convertArithmeticMeasureDefinition(measure);
+    }
+    else if (isPoPMeasure(measure)) {
+        return convertPoPMeasureDefinition(measure);
+    }
+    else if (isPreviousPeriodMeasure(measure)) {
+        return convertPreviousPeriodMeasureDefinition(measure);
+    }
+    throw new Error("Unknown measure type");
+};
+export const convertMeasure = (measure, options) => {
+    const alias = measureAlias(measure);
+    const format = measureFormat(measure);
+    const title = measureTitle(measure);
+    return {
+        measure: {
+            definition: convertMeasureDefinition(measure, options),
+            localIdentifier: measureLocalId(measure),
+            ...(alias && { alias }),
+            ...(format && { format }),
+            ...(title && { title }),
+        },
+    };
+};

package/esm/convertors/toBackend/ObjRefConverter.d.ts

@@ -0,0 +1,25 @@
+import { type ObjRef, type ObjRefInScope } from "@gooddata/sdk-model";
+/**
+ * Converts reference into the qualifier format of the legacy (bear era) structures. URI references are
+ * left as-is; identifier references keep their object type.
+ *
+ * @remarks
+ * The bear backend required the type to be stripped. These structures are today only emitted through
+ * the post message API (drill events), whose identifier qualifier carries an optional type: consumers
+ * can tell a label (`displayForm`) from a computed attribute (`computedAttribute`), a metric from a
+ * date dataset, without any lookup. A computed attribute has no labels and is referenced directly, so
+ * for it the type is the only distinguishing information.
+ *
+ * @param ref - reference
+ * @internal
+ */
+export declare function toBearRef(ref: ObjRef): ObjRef;
+/**
+ * Converts scoped reference into the qualifier format of the legacy structures. URI references are left
+ * as-is, scoped references are left as is, identifier references keep their object type.
+ *
+ * @param ref - reference
+ * @internal
+ */
+export declare function toScopedBearRef(ref: ObjRefInScope): ObjRefInScope;
+//# sourceMappingURL=ObjRefConverter.d.ts.map

package/esm/convertors/toBackend/ObjRefConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjRefConverter.d.ts","sourceRoot":"","sources":["../../../src/convertors/toBackend/ObjRefConverter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAyC,MAAM,qBAAqB,CAAC;AAE7G;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM7C;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,GAAG,aAAa,CAMjE"}

package/esm/convertors/toBackend/ObjRefConverter.js

@@ -0,0 +1,35 @@
+// (C) 2007-2026 GoodData Corporation
+import { idRef, isLocalIdRef, isUriRef, uriRef } from "@gooddata/sdk-model";
+/**
+ * Converts reference into the qualifier format of the legacy (bear era) structures. URI references are
+ * left as-is; identifier references keep their object type.
+ *
+ * @remarks
+ * The bear backend required the type to be stripped. These structures are today only emitted through
+ * the post message API (drill events), whose identifier qualifier carries an optional type: consumers
+ * can tell a label (`displayForm`) from a computed attribute (`computedAttribute`), a metric from a
+ * date dataset, without any lookup. A computed attribute has no labels and is referenced directly, so
+ * for it the type is the only distinguishing information.
+ *
+ * @param ref - reference
+ * @internal
+ */
+export function toBearRef(ref) {
+    if (isUriRef(ref)) {
+        return uriRef(ref.uri);
+    }
+    return idRef(ref.identifier, ref.type);
+}
+/**
+ * Converts scoped reference into the qualifier format of the legacy structures. URI references are left
+ * as-is, scoped references are left as is, identifier references keep their object type.
+ *
+ * @param ref - reference
+ * @internal
+ */
+export function toScopedBearRef(ref) {
+    if (isLocalIdRef(ref)) {
+        return ref;
+    }
+    return toBearRef(ref);
+}

package/esm/convertors/toBackend/afm/ExecutionConverter.d.ts

@@ -0,0 +1,13 @@
+import { type IExecutionDefinition } from "@gooddata/sdk-model";
+import { type IExecution, type IResultSpec } from "../../../typings/bear/bearTypes.js";
+export declare function convertResultSpec(def: IExecutionDefinition): IResultSpec;
+/**
+ * Converts execution definition to AFM Execution
+ *
+ * @param def - execution definition
+ * @returns AFM Execution
+ *
+ * @internal
+ */
+export declare const toAfmExecution: (def: IExecutionDefinition) => IExecution;
+//# sourceMappingURL=ExecutionConverter.d.ts.map

package/esm/convertors/toBackend/afm/ExecutionConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionConverter.d.ts","sourceRoot":"","sources":["../../../../src/convertors/toBackend/afm/ExecutionConverter.ts"],"names":[],"mappings":"AAKA,OAAO,EAEH,KAAK,oBAAoB,EAS5B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAMH,KAAK,UAAU,EAEf,KAAK,WAAW,EAGnB,MAAM,oCAAoC,CAAC;AA4H5C,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,oBAAoB,GAAG,WAAW,CAUxE;AAGD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,QAAS,oBAAoB,KAAG,UAO1D,CAAC"}

package/esm/convertors/toBackend/afm/ExecutionConverter.js

@@ -0,0 +1,130 @@
+// (C) 2007-2026 GoodData Corporation
+import invariant from "invariant";
+import { isEmpty } from "lodash-es";
+import { MeasureGroupIdentifier, dimensionTotals, dimensionsFindItem, isAttributeLocator, isMeasureSort, totalIsNative, } from "@gooddata/sdk-model";
+import { toBearRef } from "../ObjRefConverter.js";
+import { convertFilters } from "./FilterConverter.js";
+import { convertMeasure } from "./MeasureConverter.js";
+function convertAttribute(attribute, idx) {
+    const alias = attribute.attribute.alias;
+    const aliasProp = alias ? { alias } : {};
+    return {
+        displayForm: toBearRef(attribute.attribute.displayForm),
+        localIdentifier: attribute.attribute.localIdentifier || `a${idx + 1}`,
+        ...aliasProp,
+    };
+}
+function convertAFM(def) {
+    const attributes = def.attributes.map(convertAttribute);
+    const attrProp = attributes.length ? { attributes } : {};
+    const measures = def.measures.map(convertMeasure);
+    const measuresProp = measures.length ? { measures } : {};
+    const filters = convertFilters(def.filters);
+    const filtersProp = filters.length ? { filters } : {};
+    const nativeTotals = convertNativeTotals(def);
+    const nativeTotalsProp = nativeTotals.length ? { nativeTotals } : {};
+    return {
+        ...measuresProp,
+        ...attrProp,
+        ...filtersProp,
+        ...nativeTotalsProp,
+    };
+}
+function convertNativeTotals(def) {
+    // first find all native totals defined across dimensions
+    const nativeTotals = def.dimensions
+        .map(dimensionTotals)
+        .reduce((acc, totals) => {
+        acc.push(...totals);
+        return acc;
+    }, [])
+        .filter(totalIsNative);
+    return nativeTotals.map((t) => {
+        // then for each native total, look across buckets (if any) for an attribute that is specified in
+        // the total definition
+        const attributeInDims = dimensionsFindItem(def.dimensions, t.attributeIdentifier);
+        if (attributeInDims.length) {
+            if (attributeInDims.length > 1) {
+                throw new Error(`Native total references attribute that is in multiple dimensions: ${t.attributeIdentifier}`);
+            }
+        }
+        else {
+            throw new Error(`Native total references attribute that is not in any dimension: ${t.attributeIdentifier}`);
+        }
+        const attributeDim = attributeInDims[0];
+        let rollupAttributes;
+        // now, knowing the dimension and index of the attribute.. roll up all attributes that are before it
+        // and create native total such, that it rolls up all those attributes
+        if (attributeDim.dimIdx === 1) {
+            const mergedItemsId = [...def.dimensions[0].itemIdentifiers, ...attributeDim.dim.itemIdentifiers];
+            const index = mergedItemsId.findIndex((itemId) => itemId === t.attributeIdentifier);
+            rollupAttributes = mergedItemsId.slice(0, index).filter((id) => id !== MeasureGroupIdentifier);
+        }
+        else {
+            rollupAttributes = attributeDim.dim.itemIdentifiers
+                .slice(0, attributeDim.itemIdx)
+                .filter((id) => id !== MeasureGroupIdentifier);
+        }
+        return {
+            measureIdentifier: t.measureIdentifier,
+            attributeIdentifiers: rollupAttributes,
+        };
+    });
+}
+function convertTotals(totals = []) {
+    return totals.map((t) => {
+        return {
+            type: t.type,
+            attributeIdentifier: t.attributeIdentifier,
+            measureIdentifier: t.measureIdentifier,
+        };
+    });
+}
+function convertDimensions(def) {
+    return def.dimensions.map((dim) => {
+        const totals = convertTotals(dim.totals);
+        const totalsProp = isEmpty(totals) ? {} : { totals };
+        return {
+            itemIdentifiers: dim.itemIdentifiers,
+            ...totalsProp,
+        };
+    });
+}
+function assertNoNullsInSortBy(sortBy) {
+    sortBy.forEach((item) => {
+        if (isMeasureSort(item)) {
+            item.measureSortItem.locators.forEach((locator) => {
+                if (isAttributeLocator(locator)) {
+                    invariant(locator.attributeLocatorItem.element !== null, "Nulls are not supported as attribute element values or uris on bear");
+                }
+            });
+        }
+    });
+}
+export function convertResultSpec(def) {
+    assertNoNullsInSortBy(def.sortBy ?? []);
+    const sortsProp = isEmpty(def.sortBy) ? {} : { sorts: def.sortBy };
+    const dims = convertDimensions(def);
+    const dimsProp = isEmpty(dims) ? {} : { dimensions: dims };
+    return {
+        ...sortsProp,
+        ...dimsProp,
+    };
+}
+// This has to be const function, otherwise api-extractor breaks...
+/**
+ * Converts execution definition to AFM Execution
+ *
+ * @param def - execution definition
+ * @returns AFM Execution
+ *
+ * @internal
+ */
+export const toAfmExecution = (def) => {
+    return {
+        execution: {
+            afm: convertAFM(def),
+            resultSpec: convertResultSpec(def),
+        },
+    };
+};

package/esm/convertors/toBackend/afm/FilterConverter.d.ts

@@ -0,0 +1,10 @@
+import { type IAbsoluteDateFilter, type IFilter, type IMeasureFilter, type IMeasureValueFilter, type IRankingFilter, type IRelativeDateFilter } from "@gooddata/sdk-model";
+import { type CompatibilityFilter, type ExtendedFilter, type FilterItem, type IMeasureValueFilter as IBearMeasureValueFilter, type IRankingFilter as IBearRankingFilter } from "../../../typings/bear/bearTypes.js";
+export declare function convertAbsoluteDateFilter({ absoluteDateFilter }: IAbsoluteDateFilter): FilterItem | null;
+export declare function convertRelativeDateFilter(dateFilter: IRelativeDateFilter): FilterItem | null;
+export declare function convertMeasureValueFilter(filter: IMeasureValueFilter): IBearMeasureValueFilter | null;
+export declare function convertRankingFilter(filter: IRankingFilter): IBearRankingFilter | null;
+export declare function convertFilter(filter: IFilter): ExtendedFilter | null;
+export declare function convertMeasureFilter(filter: IMeasureFilter): FilterItem | null;
+export declare function convertFilters(filters: IFilter[]): CompatibilityFilter[];
+//# sourceMappingURL=FilterConverter.d.ts.map

package/esm/convertors/toBackend/afm/FilterConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterConverter.d.ts","sourceRoot":"","sources":["../../../../src/convertors/toBackend/afm/FilterConverter.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,mBAAmB,EAExB,KAAK,OAAO,EACZ,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EAc3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAEH,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,mBAAmB,IAAI,uBAAuB,EACnD,KAAK,cAAc,IAAI,kBAAkB,EAC5C,MAAM,oCAAoC,CAAC;AAiD5C,wBAAgB,yBAAyB,CAAC,EAAE,kBAAkB,EAAE,EAAE,mBAAmB,GAAG,UAAU,GAAG,IAAI,CAYxG;AAED,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,mBAAmB,GAAG,UAAU,GAAG,IAAI,CAmB5F;AA2CD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,mBAAmB,GAAG,uBAAuB,GAAG,IAAI,CA+BrG;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,kBAAkB,GAAG,IAAI,CActF;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CAgBpE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,UAAU,GAAG,IAAI,CAW9E;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,mBAAmB,EAAE,CAExE"}

package/esm/convertors/toBackend/afm/FilterConverter.js

@@ -0,0 +1,179 @@
+// (C) 2007-2026 GoodData Corporation
+import { compact } from "lodash-es";
+import { filterIsEmpty, isAbsoluteDateFilter, isArbitraryAttributeFilter, isAttributeFilterWithSelection, isComparisonCondition, isMatchAttributeFilter, isMeasureValueFilter, isNegativeAttributeFilter, isObjRef, isRankingFilter, isRelativeBoundedDateFilter, isRelativeDateFilter, } from "@gooddata/sdk-model";
+import { toBearRef, toScopedBearRef } from "../ObjRefConverter.js";
+import { assertNoNulls } from "../utils.js";
+function convertAttributeFilter(filter) {
+    /*
+     * When sending either positive or negative filter and the in/notIn is empty, backend will bomb
+     * with "Cannot parse MAQL expression(s): %s". Previously code was only throwing away empty negative
+     * filters.
+     * Skip `All` filters represented by negative filter with empty selection, have no effect on execution now.
+     * Pass by positive empty filters `None` as they are handled later in execution by NO DATA error
+     */
+    if (isNegativeAttributeFilter(filter) && filterIsEmpty(filter)) {
+        return null;
+    }
+    if (isNegativeAttributeFilter(filter)) {
+        assertNoNulls(filter.negativeAttributeFilter.notIn);
+        //NOTE: Currently in designer filters we are not support local identifiers, so we can safely assume that
+        // that displayForm is ObjRef
+        if (!isObjRef(filter.negativeAttributeFilter.displayForm)) {
+            throw new Error("Expected negative attribute filter display form to be ObjRef");
+        }
+        return {
+            negativeAttributeFilter: {
+                displayForm: toBearRef(filter.negativeAttributeFilter.displayForm),
+                notIn: filter.negativeAttributeFilter.notIn, // checked above so the cast is ok
+            },
+        };
+    }
+    assertNoNulls(filter.positiveAttributeFilter.in);
+    //NOTE: Currently in designer filters we are not support local identifiers, so we can safely assume that
+    // that displayForm is ObjRef
+    if (!isObjRef(filter.positiveAttributeFilter.displayForm)) {
+        throw new Error("Expected positive attribute filter display form to be ObjRef");
+    }
+    return {
+        positiveAttributeFilter: {
+            displayForm: toBearRef(filter.positiveAttributeFilter.displayForm),
+            in: filter.positiveAttributeFilter.in, // checked above so the cast is ok
+        },
+    };
+}
+export function convertAbsoluteDateFilter({ absoluteDateFilter }) {
+    if (absoluteDateFilter.from === undefined || absoluteDateFilter.to === undefined) {
+        return null;
+    }
+    return {
+        absoluteDateFilter: {
+            dataSet: toBearRef(absoluteDateFilter.dataSet),
+            from: String(absoluteDateFilter.from),
+            to: String(absoluteDateFilter.to),
+        },
+    };
+}
+export function convertRelativeDateFilter(dateFilter) {
+    const { relativeDateFilter } = dateFilter;
+    if (relativeDateFilter.from === undefined) {
+        return null;
+    }
+    const boundedFilter = isRelativeBoundedDateFilter(dateFilter)
+        ? dateFilter.relativeDateFilter.boundedFilter
+        : undefined;
+    return {
+        relativeDateFilter: {
+            dataSet: toBearRef(relativeDateFilter.dataSet),
+            granularity: relativeDateFilter.granularity,
+            from: Number(relativeDateFilter.from),
+            to: Number(relativeDateFilter.to),
+            ...(boundedFilter ? { boundedFilter } : {}),
+        },
+    };
+}
+// Bear supports up to 6 decimal places
+const MAX_DECIMAL_PLACES = 6;
+function trimNumberToSupportedPrecision(num) {
+    return parseFloat(num.toFixed(MAX_DECIMAL_PLACES));
+}
+function trimConditionToSupportedPrecision(condition) {
+    if (isComparisonCondition(condition)) {
+        const nullValuesProp = condition.comparison.treatNullValuesAs === null ||
+            condition.comparison.treatNullValuesAs === undefined
+            ? {}
+            : { treatNullValuesAs: condition.comparison.treatNullValuesAs };
+        return {
+            comparison: {
+                operator: condition.comparison.operator,
+                value: trimNumberToSupportedPrecision(condition.comparison.value),
+                ...nullValuesProp,
+            },
+        };
+    }
+    else {
+        const nullValuesProp = condition.range.treatNullValuesAs === null || condition.range.treatNullValuesAs === undefined
+            ? {}
+            : { treatNullValuesAs: condition.range.treatNullValuesAs };
+        return {
+            range: {
+                operator: condition.range.operator,
+                from: trimNumberToSupportedPrecision(condition.range.from),
+                to: trimNumberToSupportedPrecision(condition.range.to),
+                ...nullValuesProp,
+            },
+        };
+    }
+}
+export function convertMeasureValueFilter(filter) {
+    const legacyCondition = filter.measureValueFilter.condition;
+    const conditions = filter.measureValueFilter.conditions?.length
+        ? filter.measureValueFilter.conditions
+        : legacyCondition
+            ? [legacyCondition]
+            : [];
+    if (!conditions.length) {
+        return null;
+    }
+    const dimensionalityProp = filter.measureValueFilter.dimensionality?.length
+        ? {
+            dimensionality: filter.measureValueFilter.dimensionality.map(toScopedBearRef),
+        }
+        : {};
+    const { applyOnResult } = filter.measureValueFilter;
+    const applyOnResultProp = applyOnResult === undefined ? {} : { applyOnResult };
+    const trimmed = conditions.map(trimConditionToSupportedPrecision);
+    return {
+        measureValueFilter: {
+            measure: toScopedBearRef(filter.measureValueFilter.measure),
+            ...(trimmed.length === 1 ? { condition: trimmed[0] } : { conditions: trimmed }),
+            ...dimensionalityProp,
+            ...applyOnResultProp,
+        },
+    };
+}
+export function convertRankingFilter(filter) {
+    const { measure, attributes, operator, value, applyOnResult, strictLimitOfRows } = filter.rankingFilter;
+    const applyOnResultProp = applyOnResult === undefined ? {} : { applyOnResult };
+    const strictLimitOfRowsProp = strictLimitOfRows === undefined ? {} : { strictLimitOfRows };
+    return {
+        rankingFilter: {
+            measures: [toScopedBearRef(measure)],
+            attributes: attributes?.map(toScopedBearRef),
+            operator,
+            value,
+            ...applyOnResultProp,
+            ...strictLimitOfRowsProp,
+        },
+    };
+}
+export function convertFilter(filter) {
+    if (isMeasureValueFilter(filter)) {
+        return convertMeasureValueFilter(filter);
+    }
+    if (isRankingFilter(filter)) {
+        return convertRankingFilter(filter);
+    }
+    if (isArbitraryAttributeFilter(filter) || isMatchAttributeFilter(filter)) {
+        // These filter types are persisted in the VisualizationObject but are not supported
+        // in the Bear AFM execution format and cannot be sent to the execution engine.
+        return null;
+    }
+    return convertMeasureFilter(filter);
+}
+export function convertMeasureFilter(filter) {
+    if (isAttributeFilterWithSelection(filter)) {
+        return convertAttributeFilter(filter);
+    }
+    else if (isAbsoluteDateFilter(filter)) {
+        return convertAbsoluteDateFilter(filter);
+    }
+    else if (isRelativeDateFilter(filter)) {
+        return convertRelativeDateFilter(filter);
+    }
+    // New text-based attribute filter types (arbitrary, match) are handled in convertFilter() above
+    // before convertMeasureFilter() is called, so they will not reach this fallthrough.
+    return null;
+}
+export function convertFilters(filters) {
+    return filters ? compact(filters.map(convertFilter)) : [];
+}

package/esm/convertors/toBackend/afm/MeasureConverter.d.ts

@@ -0,0 +1,5 @@
+import { type IMeasure, type MeasureAggregation } from "@gooddata/sdk-model";
+import { type MeasureAggregation as BearMeasureAggregation, type IMeasure as IBearMeasure } from "../../../typings/bear/bearTypes.js";
+export declare function convertMeasure(measure: IMeasure): IBearMeasure;
+export declare function convertAggregation(aggregation?: MeasureAggregation): BearMeasureAggregation | undefined;
+//# sourceMappingURL=MeasureConverter.d.ts.map

package/esm/convertors/toBackend/afm/MeasureConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeasureConverter.d.ts","sourceRoot":"","sources":["../../../../src/convertors/toBackend/afm/MeasureConverter.ts"],"names":[],"mappings":"AAIA,OAAO,EAEH,KAAK,QAAQ,EAKb,KAAK,kBAAkB,EAK1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACH,KAAK,kBAAkB,IAAI,sBAAsB,EAGjD,KAAK,QAAQ,IAAI,YAAY,EAKhC,MAAM,oCAAoC,CAAC;AAM5C,wBAAgB,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,YAAY,CAmB9D;AAED,wBAAgB,kBAAkB,CAAC,WAAW,CAAC,EAAE,kBAAkB,GAAG,sBAAsB,GAAG,SAAS,CAMvG"}

package/esm/convertors/toBackend/afm/MeasureConverter.js

@@ -0,0 +1,108 @@
+// (C) 2007-2026 GoodData Corporation
+import { compact } from "lodash-es";
+import { isArithmeticMeasureDefinition, isMeasureDefinition, isPoPMeasureDefinition, isPreviousPeriodMeasureDefinition, } from "@gooddata/sdk-model";
+import { toBearRef } from "../ObjRefConverter.js";
+import { DEFAULT_INTEGER_FORMAT, DEFAULT_PERCENTAGE_FORMAT } from "./constants.js";
+import { convertMeasureFilter } from "./FilterConverter.js";
+export function convertMeasure(measure) {
+    const { measure: { definition }, } = measure;
+    const convertedDefinition = convertMeasureDefinition(definition);
+    const format = getFormat(measure);
+    const formatProp = format ? { format } : {};
+    const alias = measure.measure.alias ? measure.measure.alias : measure.measure.title;
+    const aliasProp = alias ? { alias } : {};
+    return {
+        localIdentifier: measure.measure.localIdentifier,
+        definition: convertedDefinition,
+        ...aliasProp,
+        ...formatProp,
+    };
+}
+export function convertAggregation(aggregation) {
+    if (aggregation === "approximate_count") {
+        // Bear doesn't support approximate_count so transparently fallback to exact count.
+        return "count";
+    }
+    return aggregation;
+}
+function convertMeasureDefinition(definition) {
+    if (isMeasureDefinition(definition)) {
+        return convertSimpleMeasureDefinition(definition);
+    }
+    else if (isPoPMeasureDefinition(definition)) {
+        return convertPopMeasureDefinition(definition);
+    }
+    else if (isPreviousPeriodMeasureDefinition(definition)) {
+        return convertPreviousPeriodMeasureDefinition(definition);
+    }
+    else if (isArithmeticMeasureDefinition(definition)) {
+        return convertArithmeticMeasureDefinition(definition);
+    }
+    else {
+        throw Error("The measure definition is not supported: " + JSON.stringify(definition));
+    }
+}
+function convertSimpleMeasureDefinition({ measureDefinition }) {
+    const filters = measureDefinition.filters
+        ? compact(measureDefinition.filters.map(convertMeasureFilter))
+        : [];
+    const filtersProp = filters.length ? { filters } : {};
+    const aggregation = convertAggregation(measureDefinition.aggregation);
+    const aggregationProp = aggregation ? { aggregation } : {};
+    const computeRatio = measureDefinition.computeRatio;
+    const computeRatioProp = computeRatio ? { computeRatio } : {};
+    return {
+        measure: {
+            item: toBearRef(measureDefinition.item),
+            ...filtersProp,
+            ...aggregationProp,
+            ...computeRatioProp,
+        },
+    };
+}
+function convertPopMeasureDefinition({ popMeasureDefinition, }) {
+    return {
+        popMeasure: {
+            measureIdentifier: popMeasureDefinition.measureIdentifier,
+            popAttribute: toBearRef(popMeasureDefinition.popAttribute),
+        },
+    };
+}
+function convertPreviousPeriodMeasureDefinition({ previousPeriodMeasure, }) {
+    return {
+        previousPeriodMeasure: {
+            measureIdentifier: previousPeriodMeasure.measureIdentifier,
+            dateDataSets: previousPeriodMeasure.dateDataSets.map((dateDataSet) => ({
+                dataSet: toBearRef(dateDataSet.dataSet),
+                periodsAgo: dateDataSet.periodsAgo,
+            })),
+        },
+    };
+}
+function convertArithmeticMeasureDefinition({ arithmeticMeasure, }) {
+    return {
+        arithmeticMeasure: {
+            measureIdentifiers: arithmeticMeasure.measureIdentifiers.slice(),
+            operator: arithmeticMeasure.operator,
+        },
+    };
+}
+function getFormat({ measure: { definition, format } }) {
+    if (format) {
+        return format;
+    }
+    const isArithmeticMeasureChange = isArithmeticMeasureDefinition(definition) && definition.arithmeticMeasure.operator === "change";
+    if (isArithmeticMeasureChange) {
+        return DEFAULT_PERCENTAGE_FORMAT;
+    }
+    if (isMeasureDefinition(definition)) {
+        const { measureDefinition } = definition;
+        if (measureDefinition.computeRatio) {
+            return DEFAULT_PERCENTAGE_FORMAT;
+        }
+        if (measureDefinition.aggregation === "count") {
+            return DEFAULT_INTEGER_FORMAT;
+        }
+    }
+    return undefined;
+}

package/esm/convertors/toBackend/afm/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_DECIMAL_FORMAT = "#,##0.00";
+export declare const DEFAULT_PERCENTAGE_FORMAT = "#,##0.00%";
+export declare const DEFAULT_INTEGER_FORMAT = "#,##0";
+//# sourceMappingURL=constants.d.ts.map

package/esm/convertors/toBackend/afm/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/convertors/toBackend/afm/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB,aAAa,CAAC;AACjD,eAAO,MAAM,yBAAyB,cAAc,CAAC;AACrD,eAAO,MAAM,sBAAsB,UAAU,CAAC"}

package/esm/convertors/toBackend/afm/constants.js

@@ -0,0 +1,4 @@
+// (C) 2020-2026 GoodData Corporation
+export const DEFAULT_DECIMAL_FORMAT = "#,##0.00";
+export const DEFAULT_PERCENTAGE_FORMAT = "#,##0.00%";
+export const DEFAULT_INTEGER_FORMAT = "#,##0";

package/esm/convertors/toBackend/utils.d.ts

@@ -0,0 +1,3 @@
+import { type IAttributeElements } from "@gooddata/sdk-model";
+export declare function assertNoNulls(elements: IAttributeElements): void;
+//# sourceMappingURL=utils.d.ts.map

package/esm/convertors/toBackend/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/convertors/toBackend/utils.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,kBAAkB,EAA4B,MAAM,qBAAqB,CAAC;AAExF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAMhE"}

package/esm/convertors/toBackend/utils.js

@@ -0,0 +1,7 @@
+// (C) 2022-2026 GoodData Corporation
+import invariant from "invariant";
+import { isAttributeElementsByRef } from "@gooddata/sdk-model";
+export function assertNoNulls(elements) {
+    const rawData = isAttributeElementsByRef(elements) ? elements.uris : elements.values;
+    invariant(rawData.every((item) => item !== null), "Nulls are not supported as attribute element values or uris on bear");
+}

package/esm/create_store.d.ts

@@ -0,0 +1,18 @@
+import { type UnknownAction } from "redux";
+import createSagaMiddleware from "redux-saga";
+import { type IAppState } from "./store/types.js";
+declare global {
+    interface Window {
+        EMBEDDED?: boolean;
+        INITIALIZATION_TIMESTAMP: number;
+    }
+}
+export declare function createStore(reducer?: import("./store/_infra/time_travel.js").RootReducer): {
+    store: import("@reduxjs/toolkit").EnhancedStore<IAppState, UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+        dispatch: {};
+    }>, import("redux").StoreEnhancer]>>;
+    sagaMiddleware: createSagaMiddleware.SagaMiddleware<object>;
+    startSagas: () => createSagaMiddleware.Task<any>;
+    subscribeControls: () => (() => void);
+};
+//# sourceMappingURL=create_store.d.ts.map

package/esm/create_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_store.d.ts","sourceRoot":"","sources":["../src/create_store.ts"],"names":[],"mappings":"AAGA,OAAO,EAA4B,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AACrE,OAAO,oBAAoB,MAAM,YAAY,CAAC;AAW9C,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,CAAC,MAAM,CAAC;IAEX,UAAU,MAAM;QACZ,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,wBAAwB,EAAE,MAAM,CAAC;KACpC;CACJ;AA8CD,wBAAgB,WAAW,CAAC,OAAO,sDAAc;;;;;;6BAmCf,CAAC,MAAM,IAAI,CAAC;EAG7C"}