@sap/ux-ui5-tooling 1.20.4 → 1.22.0

package/dist/preview-middleware/dist/client/cpe/documentation.ts

@@ -0,0 +1,187 @@
+import { getLibrary } from './utils';
+import type { SchemaForApiJsonFiles, Ui5Metadata, Ui5Property } from './api-json';
+import type { Properties } from './utils';
+import Log from 'sap/base/Log';
+import { MessageBarType, PropertiesInfo } from '@sap-ux-private/control-property-editor-common';
+import { sendInfoCenterMessage } from '../utils/info-center-message';
+import { FetchError } from '../utils/error';
+
+export interface ControlMetadata {
+    baseType: string | undefined;
+    doc: string;
+    properties: Properties;
+}
+
+/**
+ * Get ui5 metadata of given library name.
+ *
+ * @param libName library name for eg: sap.m
+ * @returns Promise<SchemaForApiJsonFiles>
+ */
+export async function getUi5ApiDtMetadata(libName: string): Promise<SchemaForApiJsonFiles> {
+    const libUrl = '/test-resources/' + libName.split('.').join('/') + '/designtime/api.json';
+    const response = await fetch(libUrl);
+    if (!response.ok) {
+        throw new FetchError(response);
+    }
+    return response.json();
+}
+
+/**
+ * load ui5 controls design time metadata api.json for following libraries
+ * sap.m, sap.ui.comp, sap.f, sap.ui.core
+ * loading libraries(more in file size) in parallel during initialization.
+ * Others (less in file size) are loaded dynamically in getControlMetadata method
+ */
+const ui5ApiDtMetadata: Map<string, SchemaForApiJsonFiles> = new Map();
+export function loadDefaultLibraries(): void {
+    const allData = Promise.all([
+        getUi5ApiDtMetadata('sap.m'),
+        getUi5ApiDtMetadata('sap.ui.comp'),
+        getUi5ApiDtMetadata('sap.ui.core'),
+        getUi5ApiDtMetadata('sap.f')
+    ]);
+    allData
+        .then((res) => {
+            res.forEach((api: SchemaForApiJsonFiles) => {
+                if (api.library) {
+                    ui5ApiDtMetadata.set(api.library, api);
+                }
+            });
+        })
+        .catch((reason) => {
+            Log.error('Loading Library Failed: ' + reason);
+        });
+}
+
+/**
+ * Format html text.
+ *
+ * @param sHtml - html string
+ * @returns string
+ */
+function formatHtmlText(sHtml: string): string {
+    // replaced "sHtml.replace(new RegExp('<[^>]*>', 'g')" due to regex runtime vulnerability
+    const parts = (sHtml || '').split('<');
+    let result = '';
+    for (const part of parts) {
+        if (!result) {
+            result = part;
+        } else {
+            const indexClosingBracket = part.indexOf('>');
+            result += indexClosingBracket >= 0 ? part.substring(indexClosingBracket + 1) : `<${part}`;
+        }
+    }
+    return result;
+}
+
+/**
+ * Method to parse ui5 control metadata.
+ *
+ * @param controlLibMetadata control library metadata
+ * @param controlName name of the control
+ * @returns ControlMetadata
+ */
+function parseControlMetaModel(controlLibMetadata: SchemaForApiJsonFiles, controlName: string): ControlMetadata {
+    const controlInfo: ControlMetadata = {
+        baseType: '',
+        doc: '',
+        properties: {}
+    };
+    const selectedControlMetadata = (controlLibMetadata.symbols ?? []).find((control) => control.name === controlName);
+    if (selectedControlMetadata) {
+        // base type info of control is available on property 'extends'
+        controlInfo.baseType = selectedControlMetadata.extends as string | undefined;
+        controlInfo.doc = selectedControlMetadata.description ?? '';
+        const properties: (Ui5Property & PropertiesInfo)[] | undefined = (
+            selectedControlMetadata['ui5-metadata'] as Ui5Metadata
+        ).properties as (Ui5Property & PropertiesInfo)[] | undefined;
+        if (properties) {
+            properties.forEach((prop: Ui5Property & PropertiesInfo) => {
+                prop.description = formatHtmlText(prop.description || '');
+                prop.propertyName = prop.name;
+                prop.propertyType = prop.type;
+                if (prop.defaultValue === null || prop.defaultValue === '') {
+                    prop.defaultValue = '-';
+                }
+                controlInfo.properties[prop.name] = { ...prop };
+            });
+        }
+    }
+    return controlInfo;
+}
+
+/**
+ * Get control metadata for a given control.
+ *
+ * @param controlName name of the control
+ * @param contLibName library name of the control
+ * @returns Promise<ControlMetadata | undefined>
+ */
+async function getControlMetadata(controlName: string, contLibName: string): Promise<ControlMetadata | undefined> {
+    let result: ControlMetadata | undefined;
+    let controlLibMetadata = ui5ApiDtMetadata.get(contLibName);
+    if (controlLibMetadata) {
+        result = parseControlMetaModel(controlLibMetadata, controlName);
+    } else {
+        controlLibMetadata = await getUi5ApiDtMetadata(contLibName);
+        ui5ApiDtMetadata.set(contLibName, controlLibMetadata);
+        result = parseControlMetaModel(controlLibMetadata, controlName);
+    }
+    return result;
+}
+
+/**
+ * Get Control Property Documentation for a give control name and control library.
+ *
+ * @param controlName name of the control
+ * @param contLibName library name of the control
+ * @returns Promise<Properties | undefined>
+ */
+async function getControlPropertyDocumentation(
+    controlName: string,
+    contLibName: string
+): Promise<Properties | undefined> {
+    const doc = await getControlMetadata(controlName, contLibName);
+    if (doc) {
+        const baseControlType = doc.baseType;
+        if (baseControlType) {
+            const baseContLibName = await getLibrary(baseControlType);
+            if (baseContLibName) {
+                const baseControlProps = await getControlPropertyDocumentation(baseControlType, baseContLibName);
+                return { ...baseControlProps, ...doc.properties };
+            }
+        }
+        return { ...doc.properties };
+    } else {
+        return undefined;
+    }
+}
+
+/**
+ * Get documentation of a given control of a ui5 library.
+ *
+ * @param controlName name of the control.
+ * @param contLibName library name of the control
+ * @returns Promise<Properties | undefined>
+ */
+export async function getDocumentation(controlName: string, contLibName: string): Promise<Properties | undefined> {
+    let doc: Properties | undefined;
+    try {
+        doc = await getControlPropertyDocumentation(controlName, contLibName);
+    } catch (error) {
+        Log.error(`Error in getting documentation for ${contLibName}`);
+        // For some UI5 components we do not have an api.json provided instead 404, not found,
+        // response is retuned from the server. For such components we do not want to
+        // flood the info center with errors.
+        if (error instanceof FetchError && error.status === 404) {
+            return undefined;
+        }
+        await sendInfoCenterMessage({
+            title: { key: 'DOCUMENTATION_ERROR_TITLE' },
+            description: { key: 'DOCUMENTATION_ERROR_DESCRIPTION', params: [contLibName] },
+            type: MessageBarType.error
+        });
+    }
+    return doc;
+}

package/dist/preview-middleware/dist/client/cpe/feature-service.js

@@ -0,0 +1,39 @@
+"use strict";
+
+sap.ui.define([], function () {
+  "use strict";
+
+  class FeatureService {
+    static features = {};
+    static {
+      // eslint-disable-next-line @sap-ux/fiori-tools/sap-no-dom-access, @sap-ux/fiori-tools/sap-browser-api-warning
+      const bootstrapConfig = document.getElementById('sap-ui-bootstrap');
+      const features = bootstrapConfig?.dataset.openUxPreviewFeatures;
+      if (features) {
+        const featureToggles = JSON.parse(features);
+        for (const {
+          feature,
+          isEnabled
+        } of featureToggles) {
+          this.features[feature] = isEnabled;
+        }
+      }
+    }
+
+    /**
+     * Checks if given feature is enabled.
+     *
+     * @param featureId - Id of the feature.
+     * @returns true if feature is enabled.
+     */
+    static isFeatureEnabled(featureId) {
+      return this.features[featureId] ?? false;
+    }
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.FeatureService = FeatureService;
+  return __exports;
+});
+//# sourceMappingURL=feature-service.js.map

package/dist/preview-middleware/dist/client/cpe/feature-service.ts

@@ -0,0 +1,25 @@
+export class FeatureService {
+    private static features: Record<string, boolean> = {};
+
+    static {
+        // eslint-disable-next-line @sap-ux/fiori-tools/sap-no-dom-access, @sap-ux/fiori-tools/sap-browser-api-warning
+        const bootstrapConfig = document.getElementById('sap-ui-bootstrap');
+        const features = bootstrapConfig?.dataset.openUxPreviewFeatures;
+        if (features) {
+            const featureToggles = JSON.parse(features) as { feature: string; isEnabled: boolean }[];
+            for (const { feature, isEnabled } of featureToggles) {
+                this.features[feature] = isEnabled;
+            }
+        }
+    }
+
+    /**
+     * Checks if given feature is enabled.
+     *
+     * @param featureId - Id of the feature.
+     * @returns true if feature is enabled.
+     */
+    public static isFeatureEnabled(featureId: string): boolean {
+        return this.features[featureId] ?? false;
+    }
+}

package/dist/preview-middleware/dist/client/cpe/init.js

@@ -0,0 +1,92 @@
+"use strict";
+
+sap.ui.define(["sap/base/Log", "open/ux/preview/client/thirdparty/@sap-ux-private/control-property-editor-common", "../utils/error", "./changes/service", "./communication-service", "./connector-service", "./context-menu-service", "./documentation", "./outline/service", "./quick-actions/quick-action-service", "./rta-service", "./selection", "./ui5-utils", "./odata-health/odata-health-checker", "../utils/info-center-message", "./odata-health/odata-health-status"], function (Log, ___sap_ux_private_control_property_editor_common, ___utils_error, ___changes_service, ___communication_service, ___connector_service, ___context_menu_service, ___documentation, ___outline_service, ___quick_actions_quick_action_service, ___rta_service, ___selection, ___ui5_utils, ___odata_health_odata_health_checker, ___utils_info_center_message, ___odata_health_odata_health_status) {
+  "use strict";
+
+  const appLoaded = ___sap_ux_private_control_property_editor_common["appLoaded"];
+  const enableTelemetry = ___sap_ux_private_control_property_editor_common["enableTelemetry"];
+  const iconsLoaded = ___sap_ux_private_control_property_editor_common["iconsLoaded"];
+  const MessageBarType = ___sap_ux_private_control_property_editor_common["MessageBarType"];
+  const getError = ___utils_error["getError"];
+  const ChangeService = ___changes_service["ChangeService"];
+  const CommunicationService = ___communication_service["CommunicationService"];
+  const WorkspaceConnectorService = ___connector_service["WorkspaceConnectorService"];
+  const ContextMenuService = ___context_menu_service["ContextMenuService"];
+  const loadDefaultLibraries = ___documentation["loadDefaultLibraries"];
+  const OutlineService = ___outline_service["OutlineService"];
+  const QuickActionService = ___quick_actions_quick_action_service["QuickActionService"];
+  const RtaService = ___rta_service["RtaService"];
+  const SelectionService = ___selection["SelectionService"];
+  const getIcons = ___ui5_utils["getIcons"];
+  const ODataHealthChecker = ___odata_health_odata_health_checker["ODataHealthChecker"];
+  const sendInfoCenterMessage = ___utils_info_center_message["sendInfoCenterMessage"];
+  const ODataUpStatus = ___odata_health_odata_health_status["ODataUpStatus"];
+  /**
+   * Subscribes a handler to the CommunicationService
+   *
+   * @param handler action handler
+   */
+  function subscribe(handler) {
+    CommunicationService.subscribe(handler);
+  }
+  function init(rta, registries = []) {
+    Log.info('Initializing Control Property Editor');
+
+    // enable telemetry if requested
+    const flexSettings = rta.getFlexSettings();
+    if (flexSettings.telemetry === true) {
+      enableTelemetry();
+    }
+    const rtaService = new RtaService(rta);
+    const changesService = new ChangeService({
+      rta
+    });
+    const selectionService = new SelectionService(rta, changesService);
+    const connectorService = new WorkspaceConnectorService();
+    const contextMenuService = new ContextMenuService(rta);
+    const outlineService = new OutlineService(rta, changesService);
+    const quickActionService = new QuickActionService(rta, outlineService, registries, changesService);
+    const services = [connectorService, selectionService, changesService, contextMenuService, outlineService, rtaService, quickActionService];
+
+    // Do health check to all available oData service instances.
+    const oDataHealthChecker = new ODataHealthChecker(rta);
+    oDataHealthChecker.getHealthStatus().then(healthStatus => healthStatus.map(status => status instanceof ODataUpStatus ? Promise.resolve() : sendInfoCenterMessage({
+      title: {
+        key: 'ADP_ODATA_HEALTH_CHECK_TITLE'
+      },
+      description: {
+        key: 'ADP_ODATA_SERVICE_DOWN_DESCRIPTION',
+        params: [status.serviceUrl, status.errorMessage]
+      },
+      type: MessageBarType.warning
+    }))).catch(error => sendInfoCenterMessage({
+      title: {
+        key: 'ADP_ODATA_HEALTH_CHECK_TITLE'
+      },
+      description: getError(error).message,
+      type: MessageBarType.warning
+    }));
+    try {
+      loadDefaultLibraries();
+      const allPromises = services.map(service => {
+        return service.init(CommunicationService.sendAction, subscribe)?.catch(error => {
+          Log.error('Service Initialization Failed: ', getError(error));
+        });
+      }).filter(p => p !== undefined);
+      Promise.all(allPromises).then(() => {
+        CommunicationService.sendAction(appLoaded());
+      })
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      .catch(Log.error);
+      const icons = getIcons();
+      CommunicationService.sendAction(iconsLoaded(icons));
+    } catch (error) {
+      Log.error('Error during initialization of Control Property Editor', getError(error));
+    }
+
+    //  * This is returned immediately to avoid promise deadlock, preventing services from waiting indefinitely.
+    return Promise.resolve();
+  }
+  return init;
+});
+//# sourceMappingURL=init.js.map

package/dist/preview-middleware/dist/client/cpe/init.ts

@@ -0,0 +1,114 @@
+import Log from 'sap/base/Log';
+import type RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+
+import {
+    appLoaded,
+    enableTelemetry,
+    iconsLoaded,
+    MessageBarType
+} from '@sap-ux-private/control-property-editor-common';
+
+import { getError } from '../utils/error';
+import { ChangeService } from './changes/service';
+import { CommunicationService } from './communication-service';
+import { WorkspaceConnectorService } from './connector-service';
+import { ContextMenuService } from './context-menu-service';
+import { loadDefaultLibraries } from './documentation';
+import { OutlineService } from './outline/service';
+import { QuickActionService } from './quick-actions/quick-action-service';
+import type { QuickActionDefinitionRegistry } from './quick-actions/registry';
+import { RtaService } from './rta-service';
+import { SelectionService } from './selection';
+import type { ActionHandler, Service } from './types';
+import { getIcons } from './ui5-utils';
+import { ODataHealthChecker } from './odata-health/odata-health-checker';
+import { sendInfoCenterMessage } from '../utils/info-center-message';
+import { ODataUpStatus } from './odata-health/odata-health-status';
+
+/**
+ * Subscribes a handler to the CommunicationService
+ *
+ * @param handler action handler
+ */
+function subscribe(handler: ActionHandler): void {
+    CommunicationService.subscribe(handler);
+}
+
+export default function init(
+    rta: RuntimeAuthoring,
+    registries: QuickActionDefinitionRegistry<string>[] = []
+): Promise<void> {
+    Log.info('Initializing Control Property Editor');
+
+    // enable telemetry if requested
+    const flexSettings = rta.getFlexSettings();
+    if (flexSettings.telemetry === true) {
+        enableTelemetry();
+    }
+
+    const rtaService = new RtaService(rta);
+
+    const changesService = new ChangeService({ rta });
+    const selectionService = new SelectionService(rta, changesService);
+    const connectorService = new WorkspaceConnectorService();
+    const contextMenuService = new ContextMenuService(rta);
+    const outlineService = new OutlineService(rta, changesService);
+    const quickActionService = new QuickActionService(rta, outlineService, registries, changesService);
+    const services: Service[] = [
+        connectorService,
+        selectionService,
+        changesService,
+        contextMenuService,
+        outlineService,
+        rtaService,
+        quickActionService
+    ];
+
+    // Do health check to all available oData service instances.
+    const oDataHealthChecker = new ODataHealthChecker(rta);
+    oDataHealthChecker
+        .getHealthStatus()
+        .then((healthStatus) =>
+            healthStatus.map((status) =>
+                status instanceof ODataUpStatus
+                    ? Promise.resolve()
+                    : sendInfoCenterMessage({
+                          title: { key: 'ADP_ODATA_HEALTH_CHECK_TITLE' },
+                          description: {
+                              key: 'ADP_ODATA_SERVICE_DOWN_DESCRIPTION',
+                              params: [status.serviceUrl, status.errorMessage]
+                          },
+                          type: MessageBarType.warning
+                      })
+            )
+        )
+        .catch((error) =>
+            sendInfoCenterMessage({
+                title: { key: 'ADP_ODATA_HEALTH_CHECK_TITLE' },
+                description: getError(error).message,
+                type: MessageBarType.warning
+            })
+        );
+
+    try {
+        loadDefaultLibraries();
+        const allPromises = services.map((service) => {
+            return service.init(CommunicationService.sendAction, subscribe)?.catch((error) => {
+                Log.error('Service Initialization Failed: ', getError(error));
+            });
+        }).filter((p): p is Promise<void> => p !== undefined);
+        Promise.all(allPromises)
+            .then(() => {
+                CommunicationService.sendAction(appLoaded());
+            })
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            .catch(Log.error);
+        const icons = getIcons();
+        CommunicationService.sendAction(iconsLoaded(icons));
+    } catch (error) {
+        Log.error('Error during initialization of Control Property Editor', getError(error));
+    }
+
+    //  * This is returned immediately to avoid promise deadlock, preventing services from waiting indefinitely.
+    return Promise.resolve();
+}

package/dist/preview-middleware/dist/client/cpe/logger.js

@@ -0,0 +1,32 @@
+"use strict";
+
+sap.ui.define(["sap/base/Log"], function (Log) {
+  "use strict";
+
+  function getString(message) {
+    if (typeof message === 'object') {
+      return JSON.stringify(message).toString();
+    }
+    return message;
+  }
+  const logger = {
+    info: message => {
+      Log.info(getString(message));
+    },
+    debug: message => {
+      Log.debug(getString(message));
+    },
+    warn: message => {
+      Log.warning(getString(message));
+    },
+    error: message => {
+      Log.error(getString(message));
+    }
+  };
+  var __exports = {
+    __esModule: true
+  };
+  __exports.logger = logger;
+  return __exports;
+});
+//# sourceMappingURL=logger.js.map

package/dist/preview-middleware/dist/client/cpe/logger.ts

@@ -0,0 +1,24 @@
+import Log from 'sap/base/Log';
+import type { Logger } from '@sap-ux-private/control-property-editor-common';
+
+function getString(message: string | object): string {
+    if (typeof message === 'object') {
+        return JSON.stringify(message).toString();
+    }
+    return message;
+}
+
+export const logger: Logger = {
+    info: (message: string | object) => {
+        Log.info(getString(message));
+    },
+    debug: (message: string | object) => {
+        Log.debug(getString(message));
+    },
+    warn: (message: string | object) => {
+        Log.warning(getString(message));
+    },
+    error: (message: string | object) => {
+        Log.error(getString(message));
+    }
+};

package/dist/preview-middleware/dist/client/cpe/odata-health/odata-health-checker.js

@@ -0,0 +1,136 @@
+"use strict";
+
+sap.ui.define(["sap/base/Log", "sap/ui/model/odata/v2/ODataModel", "sap/ui/model/odata/v4/ODataModel", "./odata-health-status"], function (Log, ODataModelV2, ODataModelV4, ___odata_health_status) {
+  "use strict";
+
+  const ODataDownStatus = ___odata_health_status["ODataDownStatus"];
+  const ODataUpStatus = ___odata_health_status["ODataUpStatus"];
+  /**
+   * The OData version type.
+   */
+  /**
+   * Describes an OData service instance.
+   */
+  /**
+   * Use this class to do a health check for all available OData services, supports both v2 and v4
+   * format. This health checker ensures not only that $metadata is valid, but also that the UI5 framework
+   * itself can consume the service via its models.
+   */
+  class ODataHealthChecker {
+    /**
+     * The OData type.
+     */
+    static ODATA_TYPE = 'OData';
+
+    /**
+     * The default OData version.
+     */
+    static DEFAULT_ODATA_VERSION = 'v2';
+
+    /**
+     * Use this helper function to filter the OData data source items from the manifest.
+     * @param src The service data source.
+     * @returns True if the data source represents an OData service.
+     */
+    isOdataService = src => src.type === ODataHealthChecker.ODATA_TYPE;
+
+    /**
+     * Use this helper function to map the OData data source to the internal structure
+     * used in this class.
+     * @param src The OData service data source.
+     * @returns The OData service info object.
+     */
+    toOdataServiceInfo = src => ({
+      serviceUrl: src.uri,
+      oDataVersion: src.settings?.odataVersion ?? ODataHealthChecker.DEFAULT_ODATA_VERSION
+    });
+    constructor(rta) {
+      this.rta = rta;
+    }
+
+    /**
+     * Does a health check to all available OData services.
+     *
+     * @returns Resolves with an array containing the health
+     * status for each OData service.
+     */
+    async getHealthStatus() {
+      const oDataHealthCheckStartTime = Date.now();
+      const services = this.getServices();
+      const metadataPromises = await Promise.allSettled(services.map(({
+        serviceUrl,
+        oDataVersion
+      }) => this.getServiceMetadata(serviceUrl, oDataVersion)));
+      const oDataHealthCheckDurationInSec = ((Date.now() - oDataHealthCheckStartTime) / 1000).toFixed(2);
+      Log.info(`OData service health check took ${oDataHealthCheckDurationInSec} sec.`);
+      return metadataPromises.map((metadataPromise, idx) => metadataPromise.status === 'fulfilled' ? new ODataUpStatus(services[idx].serviceUrl) : new ODataDownStatus(services[idx].serviceUrl, metadataPromise.reason));
+    }
+
+    /**
+     * This method does a strong health check (with the ODataModel). This ensures not only
+     * that the $metadata is valid, but also that the UI5 framework itself can consume the service via its models.
+     * Some services may have valid $metadata but still fail in the UI5’s ODataModel
+     * (e.g., weird annotations, CORS issues, etc.).
+     *
+     * @param serviceUrl The OData service url.
+     * @param oDataVersion The OData version.
+     * @returns Resolved with valid metadata.
+     */
+    getServiceMetadata(serviceUrl, oDataVersion) {
+      switch (oDataVersion) {
+        case 'v2':
+        case '2.0':
+          return this.getServiceV2Metadata(serviceUrl);
+        case 'v4':
+        case '4.0':
+        case '4.01':
+          return this.getServiceV4Metadata(serviceUrl);
+      }
+    }
+    getServiceV2Metadata(serviceUrl) {
+      const oModel = new ODataModelV2({
+        serviceUrl,
+        json: true,
+        // We do not want the annotations concatenated to the final result.
+        loadAnnotationsJoined: false
+      });
+      // This method actually returns promise which is resolved with the metadata.
+      return oModel.metadataLoaded(true).finally(
+      // Do clean up in case the helath check is done multiple times.
+      () => oModel.destroy());
+    }
+    getServiceV4Metadata(serviceUrl) {
+      const oModel = new ODataModelV4({
+        serviceUrl,
+        // Only metadata loaded. We only want the model to load $metadata,
+        // not fetch entity data or bind to any UI controls.
+        synchronizationMode: 'None'
+      });
+      // This method actually returns promise which is resolved with the metadata.
+      return oModel.getMetaModel().requestObject('/').finally(
+      // Do clean up in case the helath check is done multiple times.
+      () => oModel.destroy());
+    }
+    getServices() {
+      const rootControl = this.rta.getRootControlInstance();
+      const manifest = rootControl.getManifest();
+      const dataSources = manifest?.['sap.app']?.dataSources;
+      const odataServices = Object.values(dataSources ?? {}).filter(this.isOdataService);
+      const isCloudFoundry = !!this.rta.getFlexSettings().isCloudFoundry;
+      if (isCloudFoundry) {
+        const manifestObject = rootControl.getManifestObject();
+        return odataServices.map(src => ({
+          serviceUrl: manifestObject.resolveUri(src.uri),
+          oDataVersion: src.settings?.odataVersion ?? ODataHealthChecker.DEFAULT_ODATA_VERSION
+        }));
+      }
+      return odataServices.map(this.toOdataServiceInfo);
+    }
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.ODataHealthChecker = ODataHealthChecker;
+  return __exports;
+});
+//# sourceMappingURL=odata-health-checker.js.map