@gooddata/sdk-backend-base 8.13.0-alpha.2 → 8.13.0-alpha.21

package/esm/dummyBackend/index.js

@@ -1,4 +1,3 @@
-import { __assign, __awaiter, __extends, __generator, __spreadArrays } from "tslib";
 // (C) 2019-2023 GoodData Corporation
 import { NoDataError, NotSupported, } from "@gooddata/sdk-backend-spi";
 import { defFingerprint, defWithDimensions, defWithSorting, defWithDateFormat, idRef, isIdentifierRef, isUriRef, } from "@gooddata/sdk-model";
@@ -8,7 +7,7 @@ import { AbstractExecutionFactory } from "../toolkit/execution";
 /**
  *
  */
-export var defaultDummyBackendConfig = {
+export const defaultDummyBackendConfig = {
     hostname: "test",
     raiseNoDataExceptions: "without-data-view",
 };
@@ -24,54 +23,53 @@ export var defaultDummyBackendConfig = {
  * @param config - Provide configuration of the backend (host/user)
  * @internal
  */
-export function dummyBackend(config) {
-    if (config === void 0) { config = defaultDummyBackendConfig; }
-    var noopBackend = {
+export function dummyBackend(config = defaultDummyBackendConfig) {
+    const noopBackend = {
         capabilities: {
             canCalculateTotals: true,
             canCalculateSubTotals: true,
             canCalculateNativeTotals: true,
             canCalculateGrandTotals: true,
         },
-        config: config,
-        onHostname: function (hostname) {
-            return dummyBackend(__assign(__assign({}, config), { hostname: hostname }));
+        config,
+        onHostname(hostname) {
+            return dummyBackend(Object.assign(Object.assign({}, config), { hostname }));
         },
-        withTelemetry: function (_component, _props) {
+        withTelemetry(_component, _props) {
             return noopBackend;
         },
-        withAuthentication: function (_) {
+        withAuthentication(_) {
             return this;
         },
-        organization: function (organizationId) {
+        organization(organizationId) {
             return new DummyOrganization(organizationId);
         },
-        organizations: function () {
+        organizations() {
             return {
-                getCurrentOrganization: function () {
+                getCurrentOrganization() {
                     return Promise.resolve(new DummyOrganization("dummy-organization-id"));
                 },
             };
         },
-        currentUser: function () {
+        currentUser() {
             throw new NotSupported("not supported");
         },
-        workspace: function (id) {
+        workspace(id) {
             return dummyWorkspace(id, config);
         },
-        entitlements: function () {
+        entitlements() {
             throw new NotSupported("not supported");
         },
-        workspaces: function () {
+        workspaces() {
             throw new NotSupported("not supported");
         },
-        authenticate: function () {
+        authenticate() {
             return Promise.resolve({ userId: "dummyUser" });
         },
-        deauthenticate: function () {
+        deauthenticate() {
             return Promise.resolve();
         },
-        isAuthenticated: function () {
+        isAuthenticated() {
             return Promise.resolve({ userId: "dummyUser" });
         },
     };
@@ -103,23 +101,22 @@ export function dummyBackendEmptyData() {
  * @returns new instance of data view
  * @internal
  */
-export function dummyDataView(definition, result, config) {
-    if (config === void 0) { config = defaultDummyBackendConfig; }
-    var factory = new DummyExecutionFactory(config, definition.workspace);
-    var execResult = result ? result : dummyExecutionResult(definition, factory, config);
-    var fp = defFingerprint(definition) + "/emptyView";
+export function dummyDataView(definition, result, config = defaultDummyBackendConfig) {
+    const factory = new DummyExecutionFactory(config, definition.workspace);
+    const execResult = result ? result : dummyExecutionResult(definition, factory, config);
+    const fp = defFingerprint(definition) + "/emptyView";
     return {
-        definition: definition,
+        definition,
         result: execResult,
         headerItems: [],
         data: [],
         offset: [0, 0],
         count: [0, 0],
         totalCount: [0, 0],
-        fingerprint: function () {
+        fingerprint() {
             return fp;
         },
-        equals: function (other) {
+        equals(other) {
             return fp === other.fingerprint();
         },
     };
@@ -129,60 +126,56 @@ export function dummyDataView(definition, result, config) {
 //
 function dummyWorkspace(workspace, config) {
     return {
-        workspace: workspace,
-        getDescriptor: function () {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, dummyDescriptor(this.workspace)];
-                });
-            });
+        workspace,
+        async getDescriptor() {
+            return dummyDescriptor(this.workspace);
         },
-        getParentWorkspace: function () {
+        getParentWorkspace() {
             throw new NotSupported("not supported");
         },
-        execution: function () {
+        execution() {
             return new DummyExecutionFactory(config, workspace);
         },
-        catalog: function () {
+        catalog() {
             return new DummyWorkspaceCatalogFactory(workspace);
         },
-        attributes: function () {
+        attributes() {
             return new DummyWorkspaceAttributesService(workspace);
         },
-        measures: function () {
+        measures() {
             return new DummyWorkspaceMeasuresService(workspace);
         },
-        facts: function () {
+        facts() {
             throw new NotSupported("not supported");
         },
-        settings: function () {
+        settings() {
             return new DummyWorkspaceSettingsService(workspace);
         },
-        insights: function () {
+        insights() {
             throw new NotSupported("not supported");
         },
-        dashboards: function () {
+        dashboards() {
             throw new NotSupported("not supported");
         },
-        styling: function () {
+        styling() {
             throw new NotSupported("not supported");
         },
-        datasets: function () {
+        datasets() {
             throw new NotSupported("not supported");
         },
-        permissions: function () {
+        permissions() {
             throw new NotSupported("not supported");
         },
-        users: function () {
+        users() {
             throw new NotSupported("not supported");
         },
-        userGroups: function () {
+        userGroups() {
             throw new NotSupported("not supported");
         },
-        dateFilterConfigs: function () {
+        dateFilterConfigs() {
             throw new NotSupported("not supported");
         },
-        accessControl: function () {
+        accessControl() {
             throw new NotSupported("not supported");
         },
     };
@@ -195,20 +188,17 @@ function dummyDescriptor(workspaceId) {
         isDemo: false,
     };
 }
-var DummyExecutionFactory = /** @class */ (function (_super) {
-    __extends(DummyExecutionFactory, _super);
-    function DummyExecutionFactory(config, workspace) {
-        var _this = _super.call(this, workspace) || this;
-        _this.config = config;
-        return _this;
-    }
-    DummyExecutionFactory.prototype.forDefinition = function (def) {
+class DummyExecutionFactory extends AbstractExecutionFactory {
+    constructor(config, workspace) {
+        super(workspace);
+        this.config = config;
+    }
+    forDefinition(def) {
         return dummyPreparedExecution(def, this, this.config);
-    };
-    return DummyExecutionFactory;
-}(AbstractExecutionFactory));
+    }
+}
 function dummyExecutionResult(definition, executionFactory, config) {
-    var fp = defFingerprint(definition) + "/emptyResult";
+    const fp = defFingerprint(definition) + "/emptyResult";
     function dummyRead() {
         if (config.raiseNoDataExceptions) {
             return Promise.reject(new NoDataError("Empty data view from dummy backend", config.raiseNoDataExceptions === "with-data-view"
@@ -217,71 +207,63 @@ function dummyExecutionResult(definition, executionFactory, config) {
         }
         return Promise.resolve(dummyDataView(definition, result, config));
     }
-    var result = {
-        definition: definition,
+    const result = {
+        definition,
         dimensions: [],
-        readAll: function () {
+        readAll() {
             return dummyRead();
         },
-        readWindow: function (_1, _2) {
+        readWindow(_1, _2) {
             return dummyRead();
         },
-        fingerprint: function () {
+        fingerprint() {
             return fp;
         },
-        equals: function (other) {
+        equals(other) {
             return fp === other.fingerprint();
         },
-        export: function (_) {
+        export(_) {
             throw new NotSupported("...");
         },
-        exportToBlob: function (_) {
+        exportToBlob(_) {
             throw new NotSupported("...");
         },
-        transform: function () {
+        transform() {
             return executionFactory.forDefinition(definition);
         },
     };
     return result;
 }
 function dummyPreparedExecution(definition, executionFactory, config) {
-    var fp = defFingerprint(definition);
+    const fp = defFingerprint(definition);
     return {
-        definition: definition,
-        withDimensions: function () {
-            var dim = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                dim[_i] = arguments[_i];
-            }
-            return executionFactory.forDefinition(defWithDimensions.apply(void 0, __spreadArrays([definition], dim)));
+        definition,
+        withDimensions(...dim) {
+            return executionFactory.forDefinition(defWithDimensions(definition, ...dim));
         },
-        withSorting: function () {
-            var items = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                items[_i] = arguments[_i];
-            }
+        withSorting(...items) {
             return executionFactory.forDefinition(defWithSorting(definition, items));
         },
-        withDateFormat: function (dateFormat) {
+        withDateFormat(dateFormat) {
             return executionFactory.forDefinition(defWithDateFormat(definition, dateFormat));
         },
-        execute: function () {
+        execute() {
             return Promise.resolve(dummyExecutionResult(definition, executionFactory, config));
         },
-        explain: function () {
+        explain() {
             console.warn("Backend does not support explain mode");
             return {
-                data: function () { return Promise.reject(new Error("Backend does not support explain mode data call.")); },
-                download: function () { return Promise.resolve(); },
+                data: () => Promise.reject(new Error(`Backend does not support explain mode data call.`)),
+                download: () => Promise.resolve(),
             };
         },
-        fingerprint: function () {
+        fingerprint() {
             return fp;
         },
-        equals: function (other) {
+        equals(other) {
             return isEqual(this.definition, other.definition);
         },
-        withExecConfig: function (config) {
+        withExecConfig(config) {
             if (!isEmpty(config === null || config === void 0 ? void 0 : config.dataSamplingPercentage)) {
                 console.warn("Backend does not support data sampling, result will be not affected");
             }
@@ -289,203 +271,197 @@ function dummyPreparedExecution(definition, executionFactory, config) {
         },
     };
 }
-var DummyWorkspaceCatalogFactory = /** @class */ (function () {
-    function DummyWorkspaceCatalogFactory(workspace, options) {
-        if (options === void 0) { options = {
-            types: ["attribute", "measure", "fact", "dateDataset"],
-            excludeTags: [],
-            includeTags: [],
-            loadGroups: true,
-        }; }
+class DummyWorkspaceCatalogFactory {
+    constructor(workspace, options = {
+        types: ["attribute", "measure", "fact", "dateDataset"],
+        excludeTags: [],
+        includeTags: [],
+        loadGroups: true,
+    }) {
         this.workspace = workspace;
         this.options = options;
     }
-    DummyWorkspaceCatalogFactory.prototype.withOptions = function (options) {
-        var newOptions = __assign(__assign({}, this.options), options);
+    withOptions(options) {
+        const newOptions = Object.assign(Object.assign({}, this.options), options);
         return new DummyWorkspaceCatalogFactory(this.workspace, newOptions);
-    };
-    DummyWorkspaceCatalogFactory.prototype.forDataset = function (dataset) {
+    }
+    forDataset(dataset) {
         return this.withOptions({
-            dataset: dataset,
+            dataset,
         });
-    };
-    DummyWorkspaceCatalogFactory.prototype.forTypes = function (types) {
+    }
+    forTypes(types) {
         return this.withOptions({
-            types: types,
+            types,
         });
-    };
-    DummyWorkspaceCatalogFactory.prototype.includeTags = function (tags) {
+    }
+    includeTags(tags) {
         return this.withOptions({
             includeTags: tags,
         });
-    };
-    DummyWorkspaceCatalogFactory.prototype.excludeTags = function (tags) {
+    }
+    excludeTags(tags) {
         return this.withOptions({
             excludeTags: tags,
         });
-    };
-    DummyWorkspaceCatalogFactory.prototype.withGroups = function (loadGroups) {
+    }
+    withGroups(loadGroups) {
         return this.withOptions({
-            loadGroups: loadGroups,
+            loadGroups,
         });
-    };
-    DummyWorkspaceCatalogFactory.prototype.load = function () {
+    }
+    load() {
         return Promise.resolve(new DummyWorkspaceCatalog(this.workspace));
-    };
-    return DummyWorkspaceCatalogFactory;
-}());
-var DummyWorkspaceCatalog = /** @class */ (function () {
-    function DummyWorkspaceCatalog(workspace) {
+    }
+}
+class DummyWorkspaceCatalog {
+    constructor(workspace) {
         this.workspace = workspace;
     }
-    DummyWorkspaceCatalog.prototype.allItems = function () {
+    allItems() {
         return [];
-    };
-    DummyWorkspaceCatalog.prototype.attributes = function () {
+    }
+    attributes() {
         return [];
-    };
-    DummyWorkspaceCatalog.prototype.availableItems = function () {
+    }
+    availableItems() {
         return new DummyWorkspaceCatalogAvailableItemsFactory(this.workspace);
-    };
-    DummyWorkspaceCatalog.prototype.dateDatasets = function () {
+    }
+    dateDatasets() {
         return [];
-    };
-    DummyWorkspaceCatalog.prototype.facts = function () {
+    }
+    facts() {
         return [];
-    };
-    DummyWorkspaceCatalog.prototype.groups = function () {
+    }
+    groups() {
         return [];
-    };
-    DummyWorkspaceCatalog.prototype.measures = function () {
+    }
+    measures() {
         return [];
-    };
-    return DummyWorkspaceCatalog;
-}());
-var DummyWorkspaceCatalogAvailableItemsFactory = /** @class */ (function () {
-    function DummyWorkspaceCatalogAvailableItemsFactory(workspace, options) {
-        if (options === void 0) { options = {
-            items: [],
-            excludeTags: [],
-            insight: undefined,
-            dataset: undefined,
-            production: false,
-            includeDateGranularities: [],
-            includeTags: [],
-            loadGroups: false,
-            types: [],
-        }; }
+    }
+}
+class DummyWorkspaceCatalogAvailableItemsFactory {
+    constructor(workspace, options = {
+        items: [],
+        excludeTags: [],
+        insight: undefined,
+        dataset: undefined,
+        production: false,
+        includeDateGranularities: [],
+        includeTags: [],
+        loadGroups: false,
+        types: [],
+    }) {
         this.workspace = workspace;
         this.options = options;
     }
-    DummyWorkspaceCatalogAvailableItemsFactory.prototype.excludeTags = function (excludeTags) {
+    excludeTags(excludeTags) {
         return this.withOptions({
-            excludeTags: excludeTags,
+            excludeTags,
         });
-    };
+    }
     //eslint-disable-next-line sonarjs/no-identical-functions
-    DummyWorkspaceCatalogAvailableItemsFactory.prototype.forDataset = function (dataset) {
+    forDataset(dataset) {
         return this.withOptions({
-            dataset: dataset,
+            dataset,
         });
-    };
-    DummyWorkspaceCatalogAvailableItemsFactory.prototype.forInsight = function (insight) {
+    }
+    forInsight(insight) {
         return this.withOptions({
-            insight: insight,
+            insight,
         });
-    };
-    DummyWorkspaceCatalogAvailableItemsFactory.prototype.forItems = function (items) {
+    }
+    forItems(items) {
         return this.withOptions({
-            items: items,
+            items,
         });
-    };
+    }
     //eslint-disable-next-line sonarjs/no-identical-functions
-    DummyWorkspaceCatalogAvailableItemsFactory.prototype.forTypes = function (types) {
+    forTypes(types) {
         return this.withOptions({
-            types: types,
+            types,
         });
-    };
-    DummyWorkspaceCatalogAvailableItemsFactory.prototype.includeTags = function (includeTags) {
+    }
+    includeTags(includeTags) {
         return this.withOptions({
-            includeTags: includeTags,
+            includeTags,
         });
-    };
-    DummyWorkspaceCatalogAvailableItemsFactory.prototype.load = function () {
+    }
+    load() {
         return Promise.resolve(new DummyWorkspaceCatalogWithAvailableItems(this.workspace));
-    };
+    }
     //eslint-disable-next-line sonarjs/no-identical-functions
-    DummyWorkspaceCatalogAvailableItemsFactory.prototype.withGroups = function (loadGroups) {
+    withGroups(loadGroups) {
         return this.withOptions({
-            loadGroups: loadGroups,
+            loadGroups,
         });
-    };
-    DummyWorkspaceCatalogAvailableItemsFactory.prototype.withOptions = function (options) {
-        var newOptions = __assign(__assign({}, this.options), options);
+    }
+    withOptions(options) {
+        const newOptions = Object.assign(Object.assign({}, this.options), options);
         return new DummyWorkspaceCatalogAvailableItemsFactory(this.workspace, newOptions);
-    };
-    return DummyWorkspaceCatalogAvailableItemsFactory;
-}());
-var DummyWorkspaceCatalogWithAvailableItems = /** @class */ (function () {
-    function DummyWorkspaceCatalogWithAvailableItems(workspace) {
+    }
+}
+class DummyWorkspaceCatalogWithAvailableItems {
+    constructor(workspace) {
         this.workspace = workspace;
     }
-    DummyWorkspaceCatalogWithAvailableItems.prototype.allAvailableItems = function () {
+    allAvailableItems() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.allItems = function () {
+    }
+    allItems() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.attributes = function () {
+    }
+    attributes() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.availableAttributes = function () {
+    }
+    availableAttributes() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.availableDateDatasets = function () {
+    }
+    availableDateDatasets() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.availableFacts = function () {
+    }
+    availableFacts() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.availableMeasures = function () {
+    }
+    availableMeasures() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.dateDatasets = function () {
+    }
+    dateDatasets() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.facts = function () {
+    }
+    facts() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.groups = function () {
+    }
+    groups() {
         return [];
-    };
-    DummyWorkspaceCatalogWithAvailableItems.prototype.measures = function () {
+    }
+    measures() {
         return [];
-    };
-    return DummyWorkspaceCatalogWithAvailableItems;
-}());
-var DummyOrganization = /** @class */ (function () {
-    function DummyOrganization(organizationId) {
+    }
+}
+class DummyOrganization {
+    constructor(organizationId) {
         this.organizationId = organizationId;
     }
-    DummyOrganization.prototype.getDescriptor = function () {
+    getDescriptor() {
         return Promise.resolve({
             id: this.organizationId,
             title: "dummy organization",
         });
-    };
-    DummyOrganization.prototype.securitySettings = function () {
+    }
+    securitySettings() {
         return {
-            scope: "/gdc/domains/" + this.organizationId,
-            isUrlValid: function (_url, _context) {
+            scope: `/gdc/domains/${this.organizationId}`,
+            isUrlValid(_url, _context) {
                 return Promise.resolve(true);
             },
-            isDashboardPluginUrlValid: function (_url, _workspace) {
+            isDashboardPluginUrlValid(_url, _workspace) {
                 return Promise.resolve(true);
             },
         };
-    };
-    DummyOrganization.prototype.styling = function () {
-        var resolveTheme = function (theme) {
+    }
+    styling() {
+        const resolveTheme = (theme) => {
             return Promise.resolve({
                 type: "theme",
                 id: "theme_id",
@@ -499,57 +475,54 @@ var DummyOrganization = /** @class */ (function () {
                 theme: theme.theme,
             });
         };
-        var resolveColorPalette = function (colorPalette) {
-            return Promise.resolve({
-                type: "colorPalette",
-                id: "color_palette_id",
-                title: "Color Palette 1",
-                description: "",
-                production: true,
-                deprecated: false,
-                unlisted: false,
-                ref: idRef("color_palette_id"),
-                uri: "color_palette_uri",
-                colorPalette: colorPalette.colorPalette,
-            });
-        };
+        const resolveColorPalette = (colorPalette) => Promise.resolve({
+            type: "colorPalette",
+            id: "color_palette_id",
+            title: "Color Palette 1",
+            description: "",
+            production: true,
+            deprecated: false,
+            unlisted: false,
+            ref: idRef("color_palette_id"),
+            uri: "color_palette_uri",
+            colorPalette: colorPalette.colorPalette,
+        });
         return {
-            getThemes: function () { return Promise.resolve([]); },
-            getActiveTheme: function () { return Promise.resolve(undefined); },
-            setActiveTheme: function () { return Promise.resolve(); },
-            clearActiveTheme: function () { return Promise.resolve(); },
+            getThemes: () => Promise.resolve([]),
+            getActiveTheme: () => Promise.resolve(undefined),
+            setActiveTheme: () => Promise.resolve(),
+            clearActiveTheme: () => Promise.resolve(),
             createTheme: resolveTheme,
             updateTheme: resolveTheme,
-            deleteTheme: function () { return Promise.resolve(); },
-            getColorPalettes: function () { return Promise.resolve([]); },
-            getActiveColorPalette: function () { return Promise.resolve(undefined); },
-            setActiveColorPalette: function () { return Promise.resolve(); },
-            clearActiveColorPalette: function () { return Promise.resolve(); },
+            deleteTheme: () => Promise.resolve(),
+            getColorPalettes: () => Promise.resolve([]),
+            getActiveColorPalette: () => Promise.resolve(undefined),
+            setActiveColorPalette: () => Promise.resolve(),
+            clearActiveColorPalette: () => Promise.resolve(),
             createColorPalette: resolveColorPalette,
             updateColorPalette: resolveColorPalette,
-            deleteColorPalette: function () { return Promise.resolve(); },
+            deleteColorPalette: () => Promise.resolve(),
         };
-    };
-    DummyOrganization.prototype.settings = function () {
+    }
+    settings() {
         return {
-            setWhiteLabeling: function () { return Promise.resolve(); },
-            setLocale: function () { return Promise.resolve(); },
-            getSettings: function () { return Promise.resolve({}); },
+            setWhiteLabeling: () => Promise.resolve(),
+            setLocale: () => Promise.resolve(),
+            getSettings: () => Promise.resolve({}),
         };
-    };
-    return DummyOrganization;
-}());
-var DummyWorkspaceSettingsService = /** @class */ (function () {
-    function DummyWorkspaceSettingsService(workspace) {
+    }
+}
+class DummyWorkspaceSettingsService {
+    constructor(workspace) {
         this.workspace = workspace;
     }
-    DummyWorkspaceSettingsService.prototype.getSettings = function () {
+    getSettings() {
         return Promise.resolve({
             workspace: this.workspace,
             testSetting: "test_value",
         });
-    };
-    DummyWorkspaceSettingsService.prototype.getSettingsForCurrentUser = function () {
+    }
+    getSettingsForCurrentUser() {
         return Promise.resolve({
             workspace: this.workspace,
             testSetting: "test_value",
@@ -560,165 +533,148 @@ var DummyWorkspaceSettingsService = /** @class */ (function () {
                 decimal: ".",
             },
         });
-    };
-    DummyWorkspaceSettingsService.prototype.setLocale = function (_locale) {
+    }
+    setLocale(_locale) {
         return Promise.resolve();
-    };
-    return DummyWorkspaceSettingsService;
-}());
-var DummyElementsQueryResult = /** @class */ (function () {
-    function DummyElementsQueryResult(items, limit, offset, totalCount) {
+    }
+}
+class DummyElementsQueryResult {
+    constructor(items, limit, offset, totalCount) {
         this.items = items;
         this.limit = limit;
         this.offset = offset;
         this.totalCount = totalCount;
     }
-    DummyElementsQueryResult.prototype.next = function () {
+    next() {
         throw new NotSupported("not supported");
-    };
-    DummyElementsQueryResult.prototype.goTo = function (_pageIndex) {
+    }
+    goTo(_pageIndex) {
         throw new NotSupported("not supported");
-    };
-    DummyElementsQueryResult.prototype.all = function () {
+    }
+    all() {
         throw new NotSupported("not supported");
-    };
-    DummyElementsQueryResult.prototype.allSorted = function (_compareFn) {
+    }
+    allSorted(_compareFn) {
         throw new NotSupported("not supported");
-    };
-    return DummyElementsQueryResult;
-}());
-var DummyElementsQuery = /** @class */ (function () {
-    function DummyElementsQuery(workspace, ref) {
-        var _this = this;
+    }
+}
+class DummyElementsQuery {
+    constructor(workspace, ref) {
         this.workspace = workspace;
         this.ref = ref;
         this.offset = 0;
         this.limit = 50;
-        this.query = function () { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, new DummyElementsQueryResult([], this.limit, this.offset, 0)];
-            });
-        }); };
+        this.query = async () => {
+            return new DummyElementsQueryResult([], this.limit, this.offset, 0);
+        };
     }
-    DummyElementsQuery.prototype.withLimit = function (limit) {
+    withLimit(limit) {
         this.limit = limit;
         return this;
-    };
-    DummyElementsQuery.prototype.withOffset = function (offset) {
+    }
+    withOffset(offset) {
         this.offset = offset;
         return this;
-    };
-    DummyElementsQuery.prototype.withAttributeFilters = function (_filters) {
+    }
+    withAttributeFilters(_filters) {
         throw new NotSupported("not supported");
-    };
-    DummyElementsQuery.prototype.withMeasures = function (_measures) {
+    }
+    withMeasures(_measures) {
         throw new NotSupported("not supported");
-    };
-    DummyElementsQuery.prototype.withOptions = function (_options) {
+    }
+    withOptions(_options) {
         throw new NotSupported("not supported");
-    };
-    DummyElementsQuery.prototype.withDateFilters = function (_filters) {
+    }
+    withDateFilters(_filters) {
         throw new NotSupported("not supported");
-    };
-    DummyElementsQuery.prototype.withSignal = function (_) {
+    }
+    withSignal(_) {
         throw new NotSupported("not supported");
-    };
-    return DummyElementsQuery;
-}());
-var DummyElementsQueryFactory = /** @class */ (function () {
-    function DummyElementsQueryFactory(workspace) {
+    }
+}
+class DummyElementsQueryFactory {
+    constructor(workspace) {
         this.workspace = workspace;
     }
-    DummyElementsQueryFactory.prototype.forDisplayForm = function (ref) {
+    forDisplayForm(ref) {
         return new DummyElementsQuery(this.workspace, ref);
-    };
-    DummyElementsQueryFactory.prototype.forFilter = function (_filter, _dateFilterDisplayForm) {
+    }
+    forFilter(_filter, _dateFilterDisplayForm) {
         throw new NotSupported("not supported");
-    };
-    return DummyElementsQueryFactory;
-}());
-var DummyWorkspaceAttributesService = /** @class */ (function () {
-    function DummyWorkspaceAttributesService(workspace) {
+    }
+}
+class DummyWorkspaceAttributesService {
+    constructor(workspace) {
         this.workspace = workspace;
     }
-    DummyWorkspaceAttributesService.prototype.elements = function () {
+    elements() {
         return new DummyElementsQueryFactory(this.workspace);
-    };
-    DummyWorkspaceAttributesService.prototype.getAttributeDisplayForm = function (ref) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, {
-                        attribute: idRef("dummyAttribute"),
-                        deprecated: false,
-                        description: "Dummy attribute",
-                        id: isIdentifierRef(ref) ? ref.identifier : "dummyDisplayForm",
-                        production: true,
-                        ref: ref,
-                        title: "Dummy display form",
-                        type: "displayForm",
-                        unlisted: false,
-                        uri: isUriRef(ref) ? ref.uri : "/gdc/md/" + ref.identifier,
-                    }];
-            });
-        });
-    };
-    DummyWorkspaceAttributesService.prototype.getAttributeDisplayForms = function (refs) {
-        var _this = this;
-        return Promise.all(refs.map(function (ref) { return _this.getAttributeDisplayForm(ref); }));
-    };
-    DummyWorkspaceAttributesService.prototype.getAttribute = function (_ref) {
+    }
+    async getAttributeDisplayForm(ref) {
+        return {
+            attribute: idRef("dummyAttribute"),
+            deprecated: false,
+            description: "Dummy attribute",
+            id: isIdentifierRef(ref) ? ref.identifier : "dummyDisplayForm",
+            production: true,
+            ref,
+            title: "Dummy display form",
+            type: "displayForm",
+            unlisted: false,
+            uri: isUriRef(ref) ? ref.uri : `/gdc/md/${ref.identifier}`,
+        };
+    }
+    getAttributeDisplayForms(refs) {
+        return Promise.all(refs.map((ref) => this.getAttributeDisplayForm(ref)));
+    }
+    getAttribute(_ref) {
         throw new NotSupported("not supported");
-    };
-    DummyWorkspaceAttributesService.prototype.getAttributeByDisplayForm = function (ref) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, {
-                        deprecated: false,
-                        description: "Dummy attribute",
-                        displayForms: [
-                            {
-                                attribute: idRef("dummyAttribute"),
-                                deprecated: false,
-                                description: "Dummy attribute",
-                                id: isIdentifierRef(ref) ? ref.identifier : "dummyDisplayForm",
-                                production: true,
-                                ref: ref,
-                                title: "Dummy display form",
-                                type: "displayForm",
-                                unlisted: false,
-                                uri: isUriRef(ref) ? ref.uri : "/gdc/md/" + ref.identifier,
-                            },
-                        ],
-                        id: "dummyAttribute",
-                        production: true,
-                        ref: idRef("dummyAttribute"),
-                        title: "Dummy attribute",
-                        type: "attribute",
-                        unlisted: false,
-                        uri: "/gdc/md/dummyAttribute",
-                    }];
-            });
-        });
-    };
-    DummyWorkspaceAttributesService.prototype.getAttributes = function (_refs) {
+    }
+    async getAttributeByDisplayForm(ref) {
+        return {
+            deprecated: false,
+            description: "Dummy attribute",
+            displayForms: [
+                {
+                    attribute: idRef("dummyAttribute"),
+                    deprecated: false,
+                    description: "Dummy attribute",
+                    id: isIdentifierRef(ref) ? ref.identifier : "dummyDisplayForm",
+                    production: true,
+                    ref,
+                    title: "Dummy display form",
+                    type: "displayForm",
+                    unlisted: false,
+                    uri: isUriRef(ref) ? ref.uri : `/gdc/md/${ref.identifier}`,
+                },
+            ],
+            id: "dummyAttribute",
+            production: true,
+            ref: idRef("dummyAttribute"),
+            title: "Dummy attribute",
+            type: "attribute",
+            unlisted: false,
+            uri: "/gdc/md/dummyAttribute",
+        };
+    }
+    getAttributes(_refs) {
         throw new NotSupported("not supported");
-    };
-    DummyWorkspaceAttributesService.prototype.getCommonAttributes = function (_attributeRefs) {
+    }
+    getCommonAttributes(_attributeRefs) {
         throw new NotSupported("not supported");
-    };
-    DummyWorkspaceAttributesService.prototype.getCommonAttributesBatch = function (_attributesRefsBatch) {
+    }
+    getCommonAttributesBatch(_attributesRefsBatch) {
         throw new NotSupported("not supported");
-    };
-    DummyWorkspaceAttributesService.prototype.getAttributeDatasetMeta = function (_ref) {
+    }
+    getAttributeDatasetMeta(_ref) {
         throw new NotSupported("not supported");
-    };
-    return DummyWorkspaceAttributesService;
-}());
-var DummyWorkspaceMeasuresService = /** @class */ (function () {
-    function DummyWorkspaceMeasuresService(workspace) {
+    }
+}
+class DummyWorkspaceMeasuresService {
+    constructor(workspace) {
         this.workspace = workspace;
     }
-    DummyWorkspaceMeasuresService.prototype.createMeasure = function (measure) {
+    createMeasure(measure) {
         return Promise.resolve({
             id: "test_metric_id",
             uri: "test_metric_id",
@@ -733,19 +689,18 @@ var DummyWorkspaceMeasuresService = /** @class */ (function () {
             isLocked: measure.isLocked || false,
             unlisted: measure.unlisted || false,
         });
-    };
-    DummyWorkspaceMeasuresService.prototype.deleteMeasure = function (_measureRef) {
+    }
+    deleteMeasure(_measureRef) {
         return Promise.resolve(undefined);
-    };
-    DummyWorkspaceMeasuresService.prototype.getMeasureExpressionTokens = function (_ref) {
+    }
+    getMeasureExpressionTokens(_ref) {
         return Promise.resolve([]);
-    };
-    DummyWorkspaceMeasuresService.prototype.getMeasureReferencingObjects = function (_measureRef) {
+    }
+    getMeasureReferencingObjects(_measureRef) {
         return Promise.resolve({});
-    };
-    DummyWorkspaceMeasuresService.prototype.updateMeasure = function (measure) {
-        return Promise.resolve(__assign({}, measure));
-    };
-    return DummyWorkspaceMeasuresService;
-}());
+    }
+    updateMeasure(measure) {
+        return Promise.resolve(Object.assign({}, measure));
+    }
+}
 //# sourceMappingURL=index.js.map