@sankhyalabs/sankhyablocks 8.6.0-dev.3 → 8.6.0-dev.5

package/dist/collection/lib/http/data-fetcher/fetchers/{dataunit-fetcher.js → data-unit/dataunit-fetcher.js}

@@ -10,15 +10,18 @@ var __rest = (this && this.__rest) || function (s, e) {
     }
   return t;
 };
-import { ChangeOperation, DataType, DataUnit, StringUtils, DataUnitStorage } from "@sankhyalabs/core";
+import { ChangeOperation, DataType, DataUnit, DataUnitStorage } from "@sankhyalabs/core";
 import { gql } from "graphql-request";
-import { DataFetcher } from "../DataFetcher";
+import { DataFetcher } from "../../DataFetcher";
 import { DISTINCT_FILTER_NAME_PREFIX } from "@sankhyalabs/ezui/dist/collection/utils/constants";
 import { DataUnitTransient } from "@sankhyalabs/core/dist/dataunit/metadata/UnitMetadata";
+import DataUnitDataLoader from "./DataUnitDataLoader";
+import PreloadManager from "./cache/PreloadManager";
+import ResourceIDUtils from "../../../../resourceid/ResourceIDUtils";
+const DATA_UNIT_NAME_PARSER = /dd:\/\/([^/]+)\/([^/?]+)/;
 export default class DataUnitFetcher {
   constructor() {
     this.templateByQuery = new Map();
-    this._loadDataTimeout = {};
     this.buldTemplates();
   }
   buldTemplates() {
@@ -57,24 +60,6 @@ export default class DataUnitFetcher {
                 }
               }
             }`);
-    this.templateByQuery.set("fetchData", gql `query($dataunit: String! $limit: Int $offset:Int $filters: [InputFilter!] $sort: [InputSort!] $parentRecordId: String) {
-            $queryAlias$: fetchDataUnit(name: $dataunit){
-              data(limit: $limit offset: $offset filters: $filters sort: $sort parentRecordId: $parentRecordId){
-                limit
-                offset
-                total
-                hasMore
-                records{
-                  id
-                  label
-                  fields {
-                    name
-                    value
-                  }
-                }
-              }
-            }
-          }`);
     this.templateByQuery.set("saveData", gql `mutation($changes: [InputBatchChange!]!) {
             $queryAlias$: batchOperationDataUnit(changes: $changes){
               oldId
@@ -103,11 +88,25 @@ export default class DataUnitFetcher {
           $queryAlias$: selectDistinct(dataUnit: $dataUnit, fieldName: $fieldName, argument: $argument, filters: $filters, parentRecordId: $parentRecordId)
       }`);
   }
+  static parseDataUnitName(name) {
+    if (name == undefined) {
+      return undefined;
+    }
+    const parts = DATA_UNIT_NAME_PARSER.exec(name);
+    if (!parts) {
+      return undefined;
+    }
+    return { entityName: parts[1], resourceID: parts[2] };
+  }
   getDataUnit(entityName, resourceID, parentDataUnit, configName) {
+    if (PreloadManager.applicationResourceID == undefined) {
+      //Por falta de um lugar melhor pra iniciar essa variável, fazemos isso aqui.
+      ResourceIDUtils.getResourceID().then(resourceID => PreloadManager.applicationResourceID = resourceID);
+    }
     const duName = `dd://${entityName}/${resourceID}${configName ? "/" + configName : ""}`;
     const dataUnit = parentDataUnit != undefined ? parentDataUnit.getChildDataunit(duName) : new DataUnit(duName);
     dataUnit.metadataLoader = (dataUnit) => this.loadMetadata(dataUnit);
-    dataUnit.dataLoader = (dataUnit, request) => this.loadData(dataUnit, request);
+    dataUnit.dataLoader = (dataUnit, request) => DataUnitDataLoader.loadData(dataUnit, request);
     dataUnit.saveLoader = (_dataUnit, changes) => this.saveData(dataUnit, changes);
     dataUnit.removeLoader = (dataUnit, recordIds) => this.removeRecords(dataUnit, recordIds);
     dataUnit.recordLoader = (dataUnit, recordIds) => this.loadRecord(dataUnit, recordIds);
@@ -147,24 +146,6 @@ export default class DataUnitFetcher {
       });
     });
   }
-  async loadData(dataUnit, request) {
-    try {
-      const duName = dataUnit.name;
-      if (this._loadDataTimeout[duName]) {
-        clearTimeout(this._loadDataTimeout[duName]);
-        delete this._loadDataTimeout[duName];
-      }
-      const result = await this.doLoadData(dataUnit, request);
-      delete this._loadDataTimeout[duName];
-      await new Promise(resolve => {
-        this._loadDataTimeout[duName] = setTimeout(resolve, 200);
-      });
-      return Promise.resolve(result);
-    }
-    catch (error) {
-      return Promise.reject(error);
-    }
-  }
   loadSelectDistinct(dataUnit, fieldName, argument) {
     const { parentRecordId, filters } = dataUnit.getLastLoadRequest() || {};
     const filteredFilters = filters.filter(f => f.name !== `${DISTINCT_FILTER_NAME_PREFIX}${fieldName}`);
@@ -189,67 +170,9 @@ export default class DataUnitFetcher {
       });
     });
   }
-  doLoadData(dataUnit, request) {
-    return new Promise((resolve, reject) => {
-      var _a;
-      const { sort, filters, limit, offset, quickFilter } = request;
-      const variables = { dataunit: dataUnit.name, sort, filters };
-      variables.limit = limit;
-      variables.offset = offset;
-      variables.parentRecordId = request.parentRecordId;
-      if (!StringUtils.isEmpty(quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.term)) {
-        if (variables.filter === undefined) {
-          variables.filter = [];
-        }
-        const quickFilterCriteria = {
-          name: "__QUICK_FILTER__",
-          expression: "__QUICK_FILTER__",
-          params: [{ name: "term", dataType: DataType.TEXT, value: quickFilter.term }]
-        };
-        if (((_a = quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.fields) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-          quickFilterCriteria.params.push({ name: "fields", dataType: DataType.OBJECT, value: quickFilter.fields });
-        }
-        variables.filter.push(quickFilterCriteria);
-      }
-      DataFetcher.get()
-        .callGraphQL({
-        values: variables,
-        query: this.templateByQuery.get("fetchData"),
-      })
-        .then((resp) => {
-        const { limit, offset, total, hasMore, records } = resp.data;
-        let paginationInfo;
-        if (limit) {
-          const firstRecord = total == 0 ? 0 : offset + 1;
-          const lastRecord = offset + Math.min(records.length, limit);
-          const currentPage = offset / limit;
-          paginationInfo = {
-            firstRecord,
-            lastRecord,
-            total,
-            currentPage,
-            hasMore
-          };
-        }
-        const processedRecords = [];
-        records.forEach((responseRecord) => {
-          const duRecord = { __record__id__: responseRecord.id, __record__label__: responseRecord.label };
-          responseRecord.fields.forEach(({ name, value }) => {
-            duRecord[name] = dataUnit.valueFromString(name, value);
-          });
-          processedRecords.push(duRecord);
-        });
-        resolve({
-          paginationInfo,
-          records: processedRecords
-        });
-      })
-        .catch((error) => {
-        reject(error);
-      });
-    });
-  }
   saveData(dataUnit, duChanges) {
+    const updatedRecordsIds = [];
+    const addedRecordsIds = [];
     const changes = duChanges.map((change) => {
       const { dataUnit: changeDU, record, updatingFields, operation } = change;
       const dataUnitInstance = DataUnitStorage.get(changeDU);
@@ -261,6 +184,14 @@ export default class DataUnitFetcher {
           return { fieldName, dataType, value: dataUnitInstance.valueToString(fieldName, value) };
         });
       }
+      if (changeDU === dataUnit.name) {
+        if (operation === ChangeOperation.INSERT || operation === ChangeOperation.COPY) {
+          addedRecordsIds.push(record.__record__id__);
+        }
+        else {
+          updatedRecordsIds.push(record.__record__id__);
+        }
+      }
       const reqChange = { dataUnit: changeDU, fields: parsedUpdatingFields, operation, recordId: record.__record__id__ };
       if (change.sourceId) {
         reqChange.sourceId = change.sourceId;
@@ -298,6 +229,7 @@ export default class DataUnitFetcher {
           });
           dataUnitRecords.push(duRecord);
         });
+        this.updateCache(dataUnit, dataUnitRecords, updatedRecordsIds, addedRecordsIds);
         resolve(dataUnitRecords);
       })
         .catch((error) => {
@@ -305,6 +237,20 @@ export default class DataUnitFetcher {
       });
     });
   }
+  updateCache(dataUnit, savedRecords, toUpdate, toInsert) {
+    const recordsById = new Map(savedRecords.map(record => [record.__old__id__ || record.__record__id__, record]));
+    const addedRecords = toInsert.map(recordId => {
+      const copy = Object.assign({}, recordsById.get(recordId));
+      delete copy.__old__id__;
+      return copy;
+    });
+    if (addedRecords.length > 0) {
+      const firstRecord = dataUnit.records[0];
+      PreloadManager.insertRecords(dataUnit, firstRecord, addedRecords);
+    }
+    const updatedRecords = toUpdate.map(recordId => (Object.assign({}, recordsById.get(recordId))));
+    PreloadManager.updateRecords(dataUnit, updatedRecords);
+  }
   getTransientInfo(dataUnit, recordID) {
     const { records } = dataUnit.getSelectionInfo();
     return Object.entries(records.filter(record => record.__record__id__ == recordID)[0]).filter(([key]) => key.startsWith(DataUnitTransient.DATA_UNIT_TRANSIENT_PREFIX_NAME)).map(([name, value]) => ({ fieldName: name, value, dataType: DataType.TEXT }));
@@ -320,6 +266,7 @@ export default class DataUnitFetcher {
         query: this.templateByQuery.get("saveData"),
       })
         .then((_resp) => {
+        PreloadManager.removeRecords(dataUnit, dataUnit.records.filter(record => recordIds.includes(record.__record__id__)));
         resolve(recordIds);
       })
         .catch((error) => {
@@ -343,6 +290,7 @@ export default class DataUnitFetcher {
           });
           dataUnitRecords.push(duRecord);
         });
+        //TODO: Chamar o worker para persistir a nova versão do registro
         resolve(dataUnitRecords);
       })
         .catch((error) => {

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/ILoadDataResult.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/ILoadDataStrategy.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/ILoadingInfo.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/IRecordField.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/interfaces/IResponseRecord.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/loadstrategy/DataUnitStrategy.js

@@ -0,0 +1,68 @@
+import { DataType, StringUtils } from "@sankhyalabs/core";
+import { DataFetcher } from "../../../DataFetcher";
+import { gql } from "graphql-request";
+const GQL_QUERY = gql `query($dataunit: String! $limit: Int $offset:Int $filters: [InputFilter!] $sort: [InputSort!] $parentRecordId: String) {
+    $queryAlias$: fetchDataUnit(name: $dataunit) {
+      data(limit: $limit offset: $offset filters: $filters sort: $sort parentRecordId: $parentRecordId) {
+        limit
+        offset
+        total
+        hasMore
+        records {
+          id
+          label
+          fields {
+            name
+            value
+          }
+        }
+      }
+    }
+  }`;
+export class DataUnitStrategy {
+  canSlice() {
+    return true;
+  }
+  getVariables(dataunit, request) {
+    var _a;
+    let { sort, filters, limit, offset, quickFilter, parentRecordId } = request;
+    if (!StringUtils.isEmpty(quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.term)) {
+      const quickFilterCriteria = {
+        name: "__QUICK_FILTER__",
+        expression: "__QUICK_FILTER__",
+        params: [{ name: "term", dataType: DataType.TEXT, value: quickFilter.term }]
+      };
+      if (((_a = quickFilter.fields) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        quickFilterCriteria.params.push({ name: "fields", dataType: DataType.OBJECT, value: quickFilter.fields });
+      }
+      if (filters === undefined) {
+        filters = [];
+      }
+      filters.push(quickFilterCriteria);
+    }
+    return { dataunit, sort, filters, limit, offset, parentRecordId };
+  }
+  async load(dataUnit, request, loadingInfo) {
+    return new Promise((accept, reject) => {
+      DataFetcher.get().callGraphQL({
+        values: this.getVariables(dataUnit.name, request),
+        query: GQL_QUERY
+      }, false)
+        .then(resp => {
+        const { hasMore, records: responseRecords, total } = resp.data;
+        const records = responseRecords.map((record) => {
+          const duRecord = { __record__id__: record.id, __record__label__: record.label };
+          record.fields.forEach(({ name, value }) => {
+            duRecord[name] = dataUnit.valueFromString(name, value);
+          });
+          return duRecord;
+        });
+        accept({
+          records,
+          loadingInfo: Object.assign(Object.assign({}, loadingInfo), { loadingInProgress: hasMore, total, count: loadingInfo.count + records.length })
+        });
+      })
+        .catch(reason => reject(reason));
+    });
+  }
+}

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/loadstrategy/DatasetStrategy.js

@@ -0,0 +1,131 @@
+import { StringUtils, UserInterface } from "@sankhyalabs/core";
+import { DataFetcher } from "../../../DataFetcher";
+import DataUnitFetcher from "../dataunit-fetcher";
+import InMemoryLoader from "../../../../../dataUnit/InMemoryLoader";
+export class DatasetStrategy {
+  canSlice() {
+    return false;
+  }
+  async load(dataUnit, request, loadingInfo) {
+    if (dataUnit.metadata == undefined) {
+      return Promise.resolve({ records: [], loadingInfo });
+    }
+    try {
+      const fields = this.getFieldsList(dataUnit);
+      const serviceName = "DatasetSP.loadRecords";
+      const requestBody = this.buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo);
+      const { result: responseRecords, pagerID: pagerId } = await DataFetcher.get().callServiceBroker(serviceName, requestBody);
+      const records = this.processRecords(dataUnit, fields, responseRecords);
+      const loadingInProgress = pagerId != undefined;
+      const count = loadingInfo.count + records.length;
+      return Promise.resolve({
+        records,
+        loadingInfo: Object.assign(Object.assign({}, loadingInfo), { pagerId,
+          loadingInProgress, total: loadingInProgress ? undefined : count, count })
+      });
+    }
+    catch (error) {
+      console.error(error);
+      return Promise.reject(error);
+    }
+  }
+  getFieldsList(dataUnit) {
+    let fields = ["__record__id__", "__record__label__"];
+    dataUnit.metadata.fields.forEach(descriptor => {
+      fields = fields.concat(this.getFieldNames(descriptor));
+    });
+    return fields;
+  }
+  getFieldNames(descriptor) {
+    const descriptionField = this.getSearchDescriptionField(descriptor);
+    if (descriptionField == undefined) {
+      return descriptor.name;
+    }
+    return [descriptor.name, descriptionField];
+  }
+  buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo) {
+    const dataSetID = dataUnit.dataUnitId;
+    const dataUnitName = dataUnit.name;
+    const entityName = DataUnitFetcher.parseDataUnitName(dataUnitName).entityName;
+    const requestBody = {
+      serviceName,
+      requestBody: {
+        dataSetID,
+        fields,
+        entityName,
+        pageNumber: loadingInfo.pageNumber,
+        totalRecordsCount: loadingInfo.count,
+        pagerID: loadingInfo.pagerId,
+        standAlone: false,
+        standAloneFieldsMD: {
+          __record__id__: { "fieldType": "S", "userType": "P" },
+          __record__label__: { "fieldType": "S", "userType": "P" }
+        },
+        tryJoinedFields: true,
+        parallelLoader: true,
+        crudListener: "br.com.sankhya.modelcore.dataset.DataUnitDatasetAdapter",
+        txProperties: this.getTxProperties(dataUnitName, request),
+        useDefaultRowsLimit: false
+      }
+    };
+    return JSON.stringify(requestBody);
+  }
+  getTxProperties(dataUnitName, request) {
+    const txProperties = {
+      "__DATA_UNIT_ADAPTER__[dataUnitName]": dataUnitName
+    };
+    const serverSideFilters = request.filters.filter(filter => !filter.name.startsWith("FILTRO_COLUNA_"));
+    if (serverSideFilters.length !== 0) {
+      txProperties["__DATA_UNIT_ADAPTER__[criteria]"] = JSON.stringify(serverSideFilters);
+    }
+    const sorting = request.sort;
+    if (sorting != undefined && sorting.length !== 0) {
+      txProperties["__DATA_UNIT_ADAPTER__[sorting]"] = JSON.stringify(sorting);
+    }
+    return txProperties;
+  }
+  processRecords(dataUnit, fields, responseRecords) {
+    return responseRecords.map((dataFrame) => {
+      const duRecord = {
+        __record__id__: dataFrame[0],
+        __record__label__: dataFrame[1]
+      };
+      dataUnit.metadata.fields.forEach(fieldDescriptor => {
+        duRecord[fieldDescriptor.name] = this.buildFieldValue(fieldDescriptor, fields, dataFrame);
+      });
+      return duRecord;
+    });
+  }
+  buildFieldValue(descriptor, allFields, dataFrame) {
+    const fieldIndex = allFields.indexOf(descriptor.name);
+    if (fieldIndex < 0) {
+      return null;
+    }
+    const strValue = dataFrame[fieldIndex];
+    if (StringUtils.isEmpty(strValue)) {
+      return null;
+    }
+    const descriptionField = this.getSearchDescriptionField(descriptor);
+    if (descriptionField != undefined) {
+      const descriptionFieldIndex = allFields.indexOf(descriptionField);
+      if (descriptionFieldIndex >= 0) {
+        return { value: strValue, label: dataFrame[descriptionFieldIndex] };
+      }
+    }
+    if (descriptor.userInterface === UserInterface.SEARCH) {
+      //Se não tem um campo de descrição (código acima)
+      //Mas é um search, tentamos parsear um numero...
+      return isNaN(Number(strValue)) ? strValue : Number(strValue);
+    }
+    return InMemoryLoader.getConvertedValue(descriptor, strValue);
+  }
+  getSearchDescriptionField(descriptor) {
+    if (descriptor.userInterface === UserInterface.SEARCH) {
+      const { ENTITYNAME, mergedFrom, DESCRIPTIONFIELD } = descriptor.properties;
+      if (!StringUtils.isEmpty(DESCRIPTIONFIELD)) {
+        return mergedFrom != undefined ? `${mergedFrom}.${ENTITYNAME}.${DESCRIPTIONFIELD}` : `${ENTITYNAME}.${DESCRIPTIONFIELD}`;
+      }
+    }
+    return undefined;
+  }
+}

package/dist/collection/lib/index.js

@@ -5,7 +5,7 @@ export { PresentationMode } from "./@types";
 export { TotalsFetcher } from './http/data-fetcher/fetchers/totals-fetcher';
 export { default as ApplicationConfigFetcher } from './http/data-fetcher/fetchers/application-config-fetcher';
 export { AttachFetcher } from './http/data-fetcher/fetchers/attach-fetcher';
-export { default as DataUnitFetcher } from './http/data-fetcher/fetchers/dataunit-fetcher';
+export { default as DataUnitFetcher } from './http/data-fetcher/fetchers/data-unit/dataunit-fetcher';
 export { default as FilterBarConfigFetcher } from './http/data-fetcher/fetchers/filter-bar-config-fetcher';
 export { FormConfigFetcher } from './http/data-fetcher/fetchers/form-config-fetcher';
 export { default as GridConfigFetcher } from './http/data-fetcher/fetchers/grid-config-fetcher';

package/dist/components/DataFetcher.js

@@ -6541,11 +6541,10 @@ class DataFetcher {
       }
     }
     this.instance.application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
-    this.instance.graphqlPath = `/${this.instance.application.getModuleName()}/graphql`;
     return this.instance;
   }
   static getGraphQLPath() {
-    if (StringUtils.isEmpty(this.instance.graphqlPath)) {
+    if (StringUtils.isEmpty(this.instance.graphqlPath) && this.instance.application != undefined) {
       this.instance.graphqlPath = `/${this.instance.application.getModuleName()}/graphql`;
     }
     return this.instance.graphqlPath;
@@ -6599,7 +6598,7 @@ class DataFetcher {
     }
     return new ErrorException(title, statusMessage, tsErrorCode);
   }
-  async callGraphQL(req) {
+  async callGraphQL(req, quietMode = false) {
     var _a;
     if (this.ready) {
       this.pause();
@@ -6617,7 +6616,7 @@ class DataFetcher {
     if (this.ready) {
       return new Promise(async (resolve, reject) => {
         let query = this.getQueryTemplate(req);
-        const res = await this.fecthGrapql([{ document: query, variables: req.values }]);
+        const res = await this.fecthGrapql([{ document: query, variables: req.values }], quietMode);
         if (res.errors.length > 0) {
           if (!this.proccesGraphQLClientEvents(res === null || res === void 0 ? void 0 : res.extensions, req, resolve, reject)) {
             const error = this.processGraphQlErrorInfo(res.errors);
@@ -6632,7 +6631,7 @@ class DataFetcher {
     }
     else {
       if (!this.watingRequestsById.has(reqKey)) {
-        this.watingRequestsById.set(reqKey, new WaitingRequest(req));
+        this.watingRequestsById.set(reqKey, new WaitingRequest(req, quietMode));
       }
       return (_a = this.watingRequestsById.get(reqKey)) === null || _a === void 0 ? void 0 : _a.promise;
     }
@@ -6848,14 +6847,16 @@ class DataFetcher {
   }
   async executePendingRequest(watingRequestsById) {
     const requestsBatch = [];
+    let quietMode = true;
     watingRequestsById.forEach(async (waitingReq) => {
       let query = this.getQueryTemplate(waitingReq.request);
       requestsBatch.push({ document: query, variables: Object.assign({}, waitingReq.request.values) });
+      quietMode = quietMode && waitingReq.quietMode;
     });
     let res = undefined;
     let dataResponse = [];
     let errorsResponse = [];
-    res = await this.fecthGrapql(requestsBatch);
+    res = await this.fecthGrapql(requestsBatch, quietMode);
     dataResponse = res.data;
     errorsResponse = res.errors;
     //Reject promises with errors from query
@@ -6873,14 +6874,18 @@ class DataFetcher {
       });
     });
   }
-  async fecthGrapql(request) {
+  async fecthGrapql(request, quietMode) {
     let res = undefined;
     let dataResponse = [];
     let errorsResponse = [];
     let url = `${this.resolveURL() + DataFetcher.getGraphQLPath()}`;
     const responseExtensions = [];
-    if (window['mgeSession']) {
-      url += `?mgeSession=${window['mgeSession']}`;
+    const mgeSession = window["mgeSession"];
+    if (mgeSession != undefined) {
+      url += `?mgeSession=${mgeSession}`;
+    }
+    if (quietMode) {
+      url += `${url.indexOf("?") > -1 ? "&" : "?"}quietMode=true`;
     }
     DataFetcher.requestListener.forEach(listener => listener.onRequestStart({ url: url, requestBody: request }));
     try {
@@ -6966,7 +6971,7 @@ DataFetcher.SERVICE_BROKER_STATUS = {
 };
 DataFetcher.clientEventsByID = new Map();
 class WaitingRequest {
-  constructor(req) {
+  constructor(req, quietMode) {
     this._resolve = () => { };
     this._reject = () => { };
     this._request = undefined;
@@ -6975,6 +6980,7 @@ class WaitingRequest {
       this._resolve = resolve;
       this._reject = reject;
     });
+    this._quietMode = quietMode;
   }
   get resolve() {
     return this._resolve;
@@ -6988,6 +6994,9 @@ class WaitingRequest {
   get request() {
     return this._request;
   }
+  get quietMode() {
+    return this._quietMode;
+  }
 }
 
 export { DataFetcher as D, UrlUtils as U, dist as d };

package/dist/components/SnkMultiSelectionListDataSource.js

@@ -1,4 +1,5 @@
 import { UserInterface, DateUtils } from '@sankhyalabs/core';
+import { a as PreloadManager } from './dataunit-fetcher.js';
 
 class TaskbarProcessor {
   constructor(defaultButtons) {
@@ -60,6 +61,16 @@ class SnkMultiSelectionListDataSource {
     }
     return String(this._dataUnit.getFormattedValue(fieldName, value));
   }
+  async getStaticOptions(fieldName) {
+    if (fieldName == undefined) {
+      return Promise.resolve(undefined);
+    }
+    const result = await PreloadManager.getDistinct(this._dataUnit, fieldName);
+    if (result == undefined) {
+      return Promise.resolve(undefined);
+    }
+    return Promise.resolve(Array.from(result.entries()).map(([label, value]) => ({ label: String(label), value, check: true })));
+  }
   fetchData(filterTerm, fieldName) {
     return new Promise(resolve => {
       this._application.executeSelectDistinct(this._dataUnit, fieldName, filterTerm).then(result => {