codeapp-js 0.1.1 → 0.2.2

package/examples/kanban/dist/power-apps-data.js

@@ -2,6 +2,325 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// node_modules/@microsoft/power-apps/lib/internal/plugins/DefaultPowerAppsBridge.js
+var DefaultPowerAppsBridge = class {
+  constructor() {
+    __publicField(this, "_antiCSRFToken");
+    __publicField(this, "_callbacks", {});
+    __publicField(this, "_currentCallbackId", 0);
+    __publicField(this, "_instanceId", Date.now().toString());
+    __publicField(this, "_messageChannel", new window.MessageChannel());
+    __publicField(this, "_postMessageQueue", []);
+    __publicField(this, "_postMessageSource");
+    __publicField(this, "_handleMessageEvent", (messageEvent) => {
+      const message = messageEvent.data;
+      if (message && typeof message.isPluginCall === "boolean") {
+        if (message.isPluginCall) {
+          const callbackId = message.callbackId;
+          const status = message.status;
+          const args = message.args;
+          const keepCallback = message.keepCallback;
+          try {
+            const callback = this._callbacks[callbackId];
+            if (keepCallback) {
+              if (callback && callback.onUpdate) {
+                callback.onUpdate(message.args?.[0]);
+              }
+            } else {
+              if (callback) {
+                if (status === 1) {
+                  callback.resolve(args[0]);
+                } else if (status !== 0) {
+                  callback.reject(args);
+                }
+              }
+              if (!keepCallback) {
+                delete this._callbacks[callbackId];
+              }
+            }
+          } catch (error) {
+            console.error(error);
+          }
+        }
+      } else if (message && message.messageType === "initCommunication") {
+        this._antiCSRFToken = message.antiCSRFToken;
+        this._postMessageSource = this._messageChannel.port1;
+        if (this._postMessageSource) {
+          for (let i = 0; i < this._postMessageQueue.length; i++) {
+            this._postMessageQueue[i].antiCSRFToken = this._antiCSRFToken;
+            this._postMessageSource.postMessage(this._postMessageQueue[i]);
+          }
+        }
+      }
+    });
+  }
+  async initialize() {
+    this._messageChannel.port1.onmessage = this._handleMessageEvent;
+    window.parent.postMessage({
+      messageType: "initCommunicationWithPort",
+      instanceId: this._instanceId
+    }, "*", [this._messageChannel.port2]);
+  }
+  async executePluginAsync(pluginName, pluginAction, params = [], onUpdate) {
+    return new Promise((resolve, reject) => {
+      const callbackId = this._getCallbackId(pluginName);
+      this._callbacks[callbackId] = { resolve, reject, onUpdate };
+      this._sendMessage({
+        isPluginCall: true,
+        callbackId,
+        service: pluginName,
+        action: pluginAction,
+        actionArgs: params,
+        antiCSRFToken: this._antiCSRFToken
+      });
+    });
+  }
+  _sendMessage(message) {
+    if (!this._postMessageSource) {
+      this._postMessageQueue.push(message);
+    } else {
+      this._postMessageSource.postMessage(message);
+    }
+  }
+  _getCallbackId(pluginName) {
+    return "instanceId=" + this._instanceId + "_" + pluginName + this._currentCallbackId++;
+  }
+};
+
+// node_modules/@microsoft/power-apps/lib/internal/plugins/PluginBridge.js
+var bridgePromise;
+async function executePluginAsync(pluginName, pluginAction, params = [], update) {
+  const powerAppsBridge = await getBridge();
+  return powerAppsBridge.executePluginAsync(pluginName, pluginAction, params, update);
+}
+async function getBridge() {
+  if (!bridgePromise) {
+    bridgePromise = new Promise(async (resolve, reject) => {
+      try {
+        const bridge = window && window.powerAppsBridge ? window.powerAppsBridge : new DefaultPowerAppsBridge();
+        await bridge.initialize();
+        resolve(bridge);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  return bridgePromise;
+}
+
+// node_modules/@microsoft/power-apps/lib/app/ContextProvider.js
+var context;
+async function getContext() {
+  if (context) {
+    return context;
+  }
+  context = await executePluginAsync("AppLifecycle", "getContext");
+  return context;
+}
+
+// node_modules/@microsoft/power-apps/lib/internal/plugins/SendMessage/IncompatibleMessageReceiver.js
+var IncompatibleMessageReceiver = class {
+  constructor(versionInfo, incompatibilityDescription) {
+    __publicField(this, "versionInfo");
+    __publicField(this, "incompatibilityDescription");
+    __publicField(this, "isCompatible", false);
+    this.versionInfo = versionInfo;
+    this.incompatibilityDescription = incompatibilityDescription;
+  }
+};
+
+// node_modules/@microsoft/power-apps/lib/internal/plugins/SendMessage/SendMessageOperation.js
+var SendMessageOperation = class {
+  constructor(resultPromise, sendUpdate) {
+    __publicField(this, "resultPromise");
+    __publicField(this, "sendUpdate");
+    /**
+     * When completed is false onMessageReceived and sendUpdate will be visible.
+     * When completed is true then these are hidden.
+     */
+    __publicField(this, "completed", false);
+    __publicField(this, "onMessageReceived");
+    this.resultPromise = resultPromise;
+    this.sendUpdate = sendUpdate;
+  }
+};
+
+// node_modules/@microsoft/power-apps/lib/internal/plugins/SendMessage/CompatibleMessageReceiver.js
+var CompatibleMessageReceiver = class {
+  constructor(_receiverName, versionInfo) {
+    __publicField(this, "_receiverName");
+    __publicField(this, "versionInfo");
+    __publicField(this, "isCompatible", true);
+    this._receiverName = _receiverName;
+    this.versionInfo = versionInfo;
+  }
+  async sendMessage(message, onMessageReceived) {
+    let resolveOperationPromise;
+    let rejectOperationPromise;
+    const operationPromise = new Promise((resolve, reject) => {
+      resolveOperationPromise = resolve;
+      rejectOperationPromise = reject;
+    });
+    const correlationId = crypto.randomUUID();
+    const handleMessage = (compatibleReceiverMessage) => {
+      try {
+        if (sendMessageOperation.completed) {
+          return;
+        }
+        if (compatibleReceiverMessage) {
+          if (compatibleReceiverMessage.isUpdate) {
+            if (sendMessageOperation.onMessageReceived) {
+              try {
+                sendMessageOperation.onMessageReceived(compatibleReceiverMessage.message);
+              } catch (error) {
+                sendMessageOperation.completed = true;
+                rejectOperationPromise(error);
+              }
+            } else {
+              sendMessageOperation.completed = true;
+              rejectOperationPromise(new Error(`Native receiver expected a message handler, but no handler was supplied. Message: ${compatibleReceiverMessage.message}`));
+            }
+          } else {
+            sendMessageOperation.completed = true;
+            resolveOperationPromise(compatibleReceiverMessage.message);
+          }
+          return;
+        }
+      } catch {
+      }
+      sendMessageOperation.completed = true;
+      resolveOperationPromise(compatibleReceiverMessage.message);
+    };
+    const handleError = (error) => {
+      sendMessageOperation.completed = true;
+      rejectOperationPromise(error);
+    };
+    const sendUpdate = (updateMessage) => {
+      if (sendMessageOperation.completed) {
+        throw new Error("Tried to send update for completed operation.");
+      }
+      executePluginAsync("SendMessagePlugin", "sendMessage", [
+        this._receiverName,
+        updateMessage,
+        correlationId
+      ]);
+    };
+    const sendMessageOperation = new SendMessageOperation(operationPromise, sendUpdate);
+    sendMessageOperation.onMessageReceived = onMessageReceived;
+    try {
+      await executePluginAsync("SendMessagePlugin", "sendMessage", [this._receiverName, message, correlationId], (response) => {
+        handleMessage(response);
+      });
+    } catch (error) {
+      handleError(error);
+    }
+    return sendMessageOperation;
+  }
+};
+
+// node_modules/@microsoft/power-apps/lib/internal/plugins/SendMessage/SendMessage.js
+var SendMessage = class _SendMessage {
+  static createInstanceAsync() {
+    return Promise.resolve(new _SendMessage());
+  }
+  async getMessageReceiverAsync(receiverName, isCompatibleChecker) {
+    const versionInfo = await this._getVersionInfo(receiverName);
+    if (versionInfo) {
+      const compatibilityCheckerResult = isCompatibleChecker(versionInfo);
+      if (compatibilityCheckerResult.isCompatible === false) {
+        return new IncompatibleMessageReceiver(versionInfo, compatibilityCheckerResult.incompatibilityDescription || "");
+      } else {
+        return new CompatibleMessageReceiver(receiverName, versionInfo);
+      }
+    } else {
+      return new IncompatibleMessageReceiver(void 0, `No receiver ${receiverName} registered.`);
+    }
+  }
+  async _getVersionInfo(receiverName) {
+    const result = await executePluginAsync("SendMessagePlugin", "getVersionInfo", [receiverName]);
+    return result;
+  }
+};
+
+// node_modules/@microsoft/power-apps/lib/telemetry/LoggerManager.js
+var loggerInstance;
+async function initializeLogger(logger) {
+  loggerInstance = logger;
+  const sendMessagePlugin = await SendMessage.createInstanceAsync();
+  const receiver = await sendMessagePlugin.getMessageReceiverAsync("PowerApps.AppMonitorReceiver", (versionInfo) => {
+    let isCompatible = false;
+    if (versionInfo === "1.0.0") {
+      isCompatible = true;
+    }
+    return { isCompatible };
+  });
+  if (receiver.isCompatible) {
+    await receiver.sendMessage("initialize", (message) => {
+      const parsedMessage = JSON.parse(message);
+      if (parsedMessage.metrics) {
+        for (const metric of parsedMessage.metrics) {
+          loggerInstance.logMetric?.(metric);
+        }
+      }
+    });
+  }
+}
+
+// node_modules/@microsoft/power-apps/lib/telemetry/Performance.js
+function getAppLoadedPerformanceData() {
+  const performanceApi = new PerformanceApi();
+  const perfData = {
+    appTimeOrigin: performanceApi.timeOrigin
+  };
+  const navigationTimingEntries = performanceApi.getEntriesByType("navigation");
+  const navigationTiming = navigationTimingEntries[0];
+  if (navigationTiming) {
+    perfData.appNavigateType = navigationTiming.type;
+    perfData.appNavigationStart = navigationTiming.startTime;
+    perfData.appNavigationDuration = navigationTiming.duration;
+    perfData.appEncodedBodySize = navigationTiming.encodedBodySize;
+    perfData.appNextHopProtocol = navigationTiming.nextHopProtocol;
+    perfData.appDomainLookupStart = navigationTiming.domainLookupStart;
+    perfData.appDomainLookupEnd = navigationTiming.domainLookupEnd;
+    perfData.appConnectStart = navigationTiming.connectStart;
+    perfData.appConnectEnd = navigationTiming.connectEnd;
+    perfData.appSecureConnectionStart = navigationTiming.secureConnectionStart;
+    perfData.appFetchStart = navigationTiming.fetchStart;
+    perfData.appRequestStart = navigationTiming.requestStart;
+    perfData.appResponseStart = navigationTiming.responseStart;
+    perfData.appResponseEnd = navigationTiming.responseEnd;
+    perfData.appLoadEventEnd = navigationTiming.loadEventEnd;
+    perfData.appDomInteractive = navigationTiming.domInteractive;
+    perfData.appDomContentLoadedEventStart = navigationTiming.domContentLoadedEventStart;
+  }
+  return perfData;
+}
+var PerformanceApi = class {
+  constructor(targetWindow = window) {
+    __publicField(this, "_performance");
+    this._performance = targetWindow.performance;
+  }
+  get timeOrigin() {
+    return this._performance?.timeOrigin;
+  }
+  getEntriesByType(type) {
+    if (!this._performance?.getEntriesByType) {
+      return [];
+    }
+    return this._performance.getEntriesByType(type);
+  }
+};
+
+// node_modules/@microsoft/power-apps/lib/telemetry/index.js
+executePluginAsync("AppLifecycle", "notifyAppSdkLoaded", [getAppLoadedPerformanceData()]);
+
+// node_modules/@microsoft/power-apps/lib/app/Config.js
+function setConfig(config) {
+  if (config.logger) {
+    initializeLogger(config.logger);
+  }
+}
+
 // node_modules/@microsoft/power-apps/lib/internal/data/core/common/types.js
 var HttpMethod;
 (function(HttpMethod2) {
@@ -496,18 +815,18 @@ var RuntimeMetadataOperations = class {
     __publicField(this, "_clientProvider");
     this._clientProvider = _clientProvider;
   }
-  async getConnections(context) {
+  async getConnections(context2) {
     const client = await this._clientProvider.getMetadataClientAsync();
-    const response = await client.getAppConnectionConfigsAsync(context);
+    const response = await client.getAppConnectionConfigsAsync(context2);
     return {
       success: response.success,
       data: response.data ? [response.data] : [],
       error: response.error
     };
   }
-  async getConnectionApis(_connectionId, context) {
+  async getConnectionApis(_connectionId, context2) {
     const client = await this._clientProvider.getMetadataClientAsync();
-    const response = await client.getAppDataSourceConfigsAsync(context);
+    const response = await client.getAppDataSourceConfigsAsync(context2);
     return {
       success: response.success,
       data: response.data ? [response.data] : [],
@@ -566,7 +885,7 @@ var _RuntimeDataClient = class _RuntimeDataClient {
    * @throws Error if the request fails or the response is invalid
    * @throws Error if the request body is invalid
    */
-  async createDataAsync(url, apiId, tableName, body, context) {
+  async createDataAsync(url, apiId, tableName, body, context2) {
     try {
       if (!body) {
         throw new Error(`${DataOperationErrorMessages.InvalidRequest}: ${DataOperationErrorMessages.MissingRequestBody}`);
@@ -578,8 +897,8 @@ var _RuntimeDataClient = class _RuntimeDataClient {
         tableName,
         body: JSON.stringify(body)
       };
-      context = this._ensureContext(context, "runtimeDataClient.createDataAsync");
-      return await this._executeRequest(config, context);
+      context2 = this._ensureContext(context2, "runtimeDataClient.createDataAsync");
+      return await this._executeRequest(config, context2);
     } catch (error) {
       if (isOperationResult(error)) {
         return error;
@@ -599,7 +918,7 @@ var _RuntimeDataClient = class _RuntimeDataClient {
    * @throws Error if the request fails or the response is invalid
    * @throws Error if the request body is invalid
    */
-  async updateDataAsync(url, apiId, tableName, body, context) {
+  async updateDataAsync(url, apiId, tableName, body, context2) {
     try {
       if (!body) {
         throw new Error(`${DataOperationErrorMessages.InvalidRequest}: ${DataOperationErrorMessages.MissingRequestBody}`);
@@ -611,8 +930,8 @@ var _RuntimeDataClient = class _RuntimeDataClient {
         tableName,
         body: JSON.stringify(body)
       };
-      context = this._ensureContext(context, "runtimeDataClient.updateDataAsync");
-      return await this._executeRequest(config, context);
+      context2 = this._ensureContext(context2, "runtimeDataClient.updateDataAsync");
+      return await this._executeRequest(config, context2);
     } catch (error) {
       if (isOperationResult(error)) {
         return error;
@@ -630,7 +949,7 @@ var _RuntimeDataClient = class _RuntimeDataClient {
    * @return Promise resolving to the response data
    * @throws Error if the request fails or the response is invalid
    */
-  async deleteDataAsync(url, connectionApi, serviceNamespace, context) {
+  async deleteDataAsync(url, connectionApi, serviceNamespace, context2) {
     try {
       const config = {
         url,
@@ -638,8 +957,8 @@ var _RuntimeDataClient = class _RuntimeDataClient {
         apiId: connectionApi,
         tableName: serviceNamespace
       };
-      context = this._ensureContext(context, "runtimeDataClient.deleteDataAsync");
-      return await this._executeRequest(config, context);
+      context2 = this._ensureContext(context2, "runtimeDataClient.deleteDataAsync");
+      return await this._executeRequest(config, context2);
     } catch (error) {
       if (isOperationResult(error)) {
         return error;
@@ -660,7 +979,7 @@ var _RuntimeDataClient = class _RuntimeDataClient {
    * @return Promise resolving to the response data
    * @throws Error if the request fails or the response is invalid
    */
-  async retrieveDataAsync(url, apiId, tableName, method, headers, body, context) {
+  async retrieveDataAsync(url, apiId, tableName, method, headers, body, context2) {
     try {
       const config = {
         url,
@@ -670,8 +989,8 @@ var _RuntimeDataClient = class _RuntimeDataClient {
         headers,
         body: body ? typeof body === "string" ? body : JSON.stringify(body) : void 0
       };
-      context = this._ensureContext(context, "runtimeDataClient.retrieveDataAsync");
-      return await this._executeRequest(config, context);
+      context2 = this._ensureContext(context2, "runtimeDataClient.retrieveDataAsync");
+      return await this._executeRequest(config, context2);
     } catch (error) {
       if (isOperationResult(error)) {
         return error;
@@ -728,7 +1047,7 @@ var _RuntimeDataClient = class _RuntimeDataClient {
    * @return The headers for the request
    * @throws Error if header creation fails
    */
-  _createHeaders(token, config, context) {
+  _createHeaders(token, config, context2) {
     const baseHeaders = {
       Accept: "application/json",
       "x-ms-protocol-semantics": "cdp",
@@ -736,14 +1055,14 @@ var _RuntimeDataClient = class _RuntimeDataClient {
       Authorization: `paauth ${token}`,
       "x-ms-pa-client-custom-headers-options": '{"addCustomHeaders":true}',
       "x-ms-enable-selects": "true",
-      "x-ms-pa-client-telemetry-options": `paclient-telemetry {"operationName":"${context?.operationName ?? "runtimeDataClient.executeRequest"}"}`,
+      "x-ms-pa-client-telemetry-options": `paclient-telemetry {"operationName":"${context2?.operationName ?? "runtimeDataClient.executeRequest"}"}`,
       "x-ms-pa-client-telemetry-additional-data": `{"apiId":"${config.apiId}"}`
     };
     if (config.apiId === DataSources.Dataverse) {
       baseHeaders["x-ms-protocol-semantics"] = DataSources.Dataverse;
       baseHeaders.Authorization = `dynamicauth ${token}`;
       const { baseUrl, encodedPath } = extractDataverseUrlParts(config.url);
-      const batchId = context?.batchId || "";
+      const batchId = context2?.batchId || "";
       const preferHeader = this._mergePreferHeaders(config.headers, config.method);
       baseHeaders.BatchInfo = JSON.stringify({
         baseUrl,
@@ -769,9 +1088,9 @@ var _RuntimeDataClient = class _RuntimeDataClient {
    * @throws Error if the request fails or the response is invalid
    * @throws Error if the response content type is invalid
    */
-  async _executeRequest(config, context) {
-    const token = await this._getAccessToken(config.apiId, context?.datasetName);
-    const headers = this._createHeaders(token, config, context);
+  async _executeRequest(config, context2) {
+    const token = await this._getAccessToken(config.apiId, context2?.datasetName);
+    const headers = this._createHeaders(token, config, context2);
     const requestBody = config.body ? new Blob([config.body], { type: "application/json" }) : "";
     let result;
     try {
@@ -809,12 +1128,12 @@ var _RuntimeDataClient = class _RuntimeDataClient {
         text = "{}";
       }
       const parsedResult = JSON.parse(text);
-      if (context?.isDataVerseOperation || this._isDataverseCall(config.url)) {
+      if (context2?.isDataVerseOperation || this._isDataverseCall(config.url)) {
         return {
           success: true,
           data: parsedResult
         };
-      } else if (!context?.isExecuteAsync && "value" in parsedResult && Array.isArray(parsedResult.value)) {
+      } else if (!context2?.isExecuteAsync && "value" in parsedResult && Array.isArray(parsedResult.value)) {
         return {
           success: true,
           data: parsedResult.value,
@@ -844,7 +1163,7 @@ var _RuntimeDataClient = class _RuntimeDataClient {
       if (buffer instanceof ArrayBuffer) {
         const value = convertArrayBufferToString(buffer);
         const status = responseData[0].status;
-        const responseType = context?.responseInfo?.[status];
+        const responseType = context2?.responseInfo?.[status];
         if (responseType) {
           let parsedValue;
           try {
@@ -888,14 +1207,14 @@ var _RuntimeDataClient = class _RuntimeDataClient {
       };
     }
   }
-  _ensureContext(context, defaultOperationName) {
-    if (!context) {
-      context = {};
+  _ensureContext(context2, defaultOperationName) {
+    if (!context2) {
+      context2 = {};
     }
-    if (!context.operationName) {
-      context.operationName = defaultOperationName;
+    if (!context2.operationName) {
+      context2.operationName = defaultOperationName;
     }
-    return context;
+    return context2;
   }
   /**
    * Checks if the given URL is a Dataverse API call
@@ -2305,112 +2624,6 @@ __publicField(_PowerDataSourcesInfoProvider, "instance", null);
 var PowerDataSourcesInfoProvider = _PowerDataSourcesInfoProvider;
 var powerDataSourcesInfoProvider_default = PowerDataSourcesInfoProvider;
 
-// node_modules/@microsoft/power-apps/lib/internal/plugins/DefaultPowerAppsBridge.js
-var DefaultPowerAppsBridge = class {
-  constructor() {
-    __publicField(this, "_antiCSRFToken");
-    __publicField(this, "_callbacks", {});
-    __publicField(this, "_currentCallbackId", 0);
-    __publicField(this, "_instanceId", Date.now().toString());
-    __publicField(this, "_messageChannel", new window.MessageChannel());
-    __publicField(this, "_postMessageQueue", []);
-    __publicField(this, "_postMessageSource");
-    __publicField(this, "_handleMessageEvent", (messageEvent) => {
-      const message = messageEvent.data;
-      if (message && typeof message.isPluginCall === "boolean") {
-        if (message.isPluginCall) {
-          const callbackId = message.callbackId;
-          const status = message.status;
-          const args = message.args;
-          const keepCallback = message.keepCallback;
-          try {
-            const callback = this._callbacks[callbackId];
-            if (keepCallback) {
-              if (callback && callback.onUpdate) {
-                callback.onUpdate(message.args?.[0]);
-              }
-            } else {
-              if (callback) {
-                if (status === 1) {
-                  callback.resolve(args[0]);
-                } else if (status !== 0) {
-                  callback.reject(args);
-                }
-              }
-              if (!keepCallback) {
-                delete this._callbacks[callbackId];
-              }
-            }
-          } catch (error) {
-            console.error(error);
-          }
-        }
-      } else if (message && message.messageType === "initCommunication") {
-        this._antiCSRFToken = message.antiCSRFToken;
-        this._postMessageSource = this._messageChannel.port1;
-        if (this._postMessageSource) {
-          for (let i = 0; i < this._postMessageQueue.length; i++) {
-            this._postMessageQueue[i].antiCSRFToken = this._antiCSRFToken;
-            this._postMessageSource.postMessage(this._postMessageQueue[i]);
-          }
-        }
-      }
-    });
-  }
-  async initialize() {
-    this._messageChannel.port1.onmessage = this._handleMessageEvent;
-    window.parent.postMessage({
-      messageType: "initCommunicationWithPort",
-      instanceId: this._instanceId
-    }, "*", [this._messageChannel.port2]);
-  }
-  async executePluginAsync(pluginName, pluginAction, params = [], onUpdate) {
-    return new Promise((resolve, reject) => {
-      const callbackId = this._getCallbackId(pluginName);
-      this._callbacks[callbackId] = { resolve, reject, onUpdate };
-      this._sendMessage({
-        isPluginCall: true,
-        callbackId,
-        service: pluginName,
-        action: pluginAction,
-        actionArgs: params,
-        antiCSRFToken: this._antiCSRFToken
-      });
-    });
-  }
-  _sendMessage(message) {
-    if (!this._postMessageSource) {
-      this._postMessageQueue.push(message);
-    } else {
-      this._postMessageSource.postMessage(message);
-    }
-  }
-  _getCallbackId(pluginName) {
-    return "instanceId=" + this._instanceId + "_" + pluginName + this._currentCallbackId++;
-  }
-};
-
-// node_modules/@microsoft/power-apps/lib/internal/plugins/PluginBridge.js
-var bridgePromise;
-async function executePluginAsync(pluginName, pluginAction, params = [], update) {
-  const powerAppsBridge = await getBridge();
-  return powerAppsBridge.executePluginAsync(pluginName, pluginAction, params, update);
-}
-async function getBridge() {
-  if (!bridgePromise) {
-    bridgePromise = new Promise(async (resolve, reject) => {
-      try {
-        const bridge = window && window.powerAppsBridge ? window.powerAppsBridge : new DefaultPowerAppsBridge();
-        await bridge.initialize();
-        resolve(bridge);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  return bridgePromise;
-}
-
 // node_modules/@microsoft/power-apps/lib/internal/data/ConnectionUtils.js
 var connectionsLoaded = false;
 async function loadConnections() {
@@ -2504,6 +2717,9 @@ var _dataOperationExecutor;
 function getDataOperationExecutor() {
   return _dataOperationExecutor;
 }
+function setDataOperationExecutor(dataOperationExecutorOverride) {
+  _dataOperationExecutor = dataOperationExecutorOverride;
+}
 function getClient(dataSourcesInfo) {
   return {
     createRecordAsync: (tableName, record) => {
@@ -2526,6 +2742,212 @@ function getClient(dataSourcesInfo) {
     }
   };
 }
+
+// node_modules/@microsoft/power-apps/lib/internal/data/core/data/executors/mockDataOperationExecutor.js
+var MockDataOperationExecutor = class {
+  constructor(data) {
+    __publicField(this, "_dataStore");
+    this._dataStore = data;
+  }
+  async createRecordAsync(tableName, data) {
+    return {
+      success: false,
+      error: { message: "createRecordAsync is not supported by MockDataOperationExecutor" },
+      data: null
+    };
+  }
+  async updateRecordAsync(tableName, id, data) {
+    return {
+      success: false,
+      error: { message: "updateRecordAsync is not supported by MockDataOperationExecutor" },
+      data: null
+    };
+  }
+  async deleteRecordAsync(tableName, id) {
+    return {
+      success: false,
+      error: { message: "deleteRecordAsync is not supported by MockDataOperationExecutor" },
+      data: void 0
+    };
+  }
+  async retrieveRecordAsync(tableName, id, options) {
+    if (!this._dataStore[tableName]) {
+      return {
+        success: false,
+        error: { message: `table <${tableName}> not found` },
+        data: null
+      };
+    }
+    const record = this._dataStore[tableName][id];
+    if (!record) {
+      return {
+        success: false,
+        error: { message: `record with id "${id}" not found in table <${tableName}>` },
+        data: null
+      };
+    }
+    return {
+      success: true,
+      data: record
+    };
+  }
+  async retrieveMultipleRecordsAsync(tableName, options) {
+    if (!this._dataStore[tableName]) {
+      return {
+        success: false,
+        error: { message: `table <${tableName}> not found` },
+        data: []
+      };
+    }
+    return {
+      success: true,
+      data: Object.values(this._dataStore[tableName])
+    };
+  }
+  async executeAsync(operation) {
+    return {
+      success: false,
+      error: { message: "executeAsync is not supported by MockDataOperationExecutor" },
+      data: null
+    };
+  }
+};
+function createMockDataExecutor(data) {
+  return new MockDataOperationExecutor(data);
+}
+
+// node_modules/@microsoft/power-apps/lib/internal/data/core/types/dataverseMetadata.js
+var entityClusterModeEnum = {
+  0: "Partitioned",
+  1: "Replicated",
+  2: "Local"
+};
+function getEntityClusterModeName(value) {
+  return entityClusterModeEnum[value];
+}
+var ownershipTypeEnum = {
+  0: "None",
+  1: "UserOwned",
+  2: "TeamOwned",
+  4: "BusinessOwned",
+  8: "OrganizationOwned",
+  16: "BusinessParented",
+  32: "Filtered"
+};
+function getOwnershipTypeName(value) {
+  return ownershipTypeEnum[value];
+}
+var privilegeTypeEnum = {
+  0: "None",
+  1: "Create",
+  2: "Read",
+  3: "Write",
+  4: "Delete",
+  5: "Assign",
+  6: "Share",
+  7: "Append",
+  8: "AppendTo"
+};
+function getPrivilegeTypeName(value) {
+  return privilegeTypeEnum[value];
+}
+var attributeTypeCodeEnum = {
+  0: "Boolean",
+  1: "Customer",
+  2: "DateTime",
+  3: "Decimal",
+  4: "Double",
+  5: "Integer",
+  6: "Lookup",
+  7: "Memo",
+  8: "Money",
+  9: "Owner",
+  10: "PartyList",
+  11: "Picklist",
+  12: "State",
+  13: "Status",
+  14: "String",
+  15: "Uniqueidentifier",
+  16: "CalendarRules",
+  17: "Virtual",
+  18: "BigInt",
+  19: "ManagedProperty",
+  20: "EntityName"
+};
+function getAttributeTypeCodeName(value) {
+  return attributeTypeCodeEnum[value];
+}
+var attributeRequiredLevelEnum = {
+  0: "None",
+  1: "SystemRequired",
+  2: "ApplicationRequired",
+  3: "Recommended"
+};
+function getAttributeRequiredLevelName(value) {
+  return attributeRequiredLevelEnum[value];
+}
+var relationshipTypeEnum = {
+  0: "OneToManyRelationship",
+  1: "ManyToManyRelationship"
+};
+function getRelationshipTypeName(value) {
+  return relationshipTypeEnum[value];
+}
+var securityTypesEnum = {
+  0: "None",
+  1: "Append",
+  2: "ParentChild",
+  8: "Pointer",
+  16: "Inheritance"
+  // The referencing entity record inherits security from the referenced security record.
+};
+function getSecurityTypesName(value) {
+  return securityTypesEnum[value];
+}
+var associatedMenuBehaviorEnum = {
+  0: "UseCollectionName",
+  1: "UseLabel",
+  2: "DoNotDisplay"
+};
+function getAssociatedMenuBehaviorName(value) {
+  return associatedMenuBehaviorEnum[value];
+}
+var associatedMenuGroupEnum = {
+  0: "Details",
+  1: "Sales",
+  2: "Service",
+  3: "Marketing"
+};
+function getAssociatedMenuGroupName(value) {
+  return associatedMenuGroupEnum[value];
+}
+var cascadeTypeEnum = {
+  0: "NoCascade",
+  1: "Cascade",
+  2: "Active",
+  3: "UserOwned",
+  4: "RemoveLink",
+  5: "Restrict"
+  // Prevent the Referenced entity record from being deleted when referencing entities exist.
+};
+function getCascadeTypeName(value) {
+  return cascadeTypeEnum[value];
+}
 export {
-  getClient
+  createMockDataExecutor,
+  getAssociatedMenuBehaviorName,
+  getAssociatedMenuGroupName,
+  getAttributeRequiredLevelName,
+  getAttributeTypeCodeName,
+  getCascadeTypeName,
+  getClient,
+  getContext,
+  getEntityClusterModeName,
+  getOwnershipTypeName,
+  getPrivilegeTypeName,
+  getRelationshipTypeName,
+  getSecurityTypesName,
+  initializeLogger,
+  setConfig,
+  setDataOperationExecutor
 };