initial commit taken from gitlab.lrz.de

node_modules/react-native/local-cli/server/util/debugger-ui/DeltaPatcher.js

@@ -0,0 +1,130 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+/**
+ * This file is a copy of the reference `DeltaPatcher`, located in
+ * metro. The reason to not reuse that file is that in this context
+ * we cannot have flow annotations or CJS syntax (since this file is directly)
+ * injected into a static HTML page.
+ *
+ * TODO: Find a simple and lightweight way to compile `DeltaPatcher` to avoid
+ * having this duplicated file.
+ */
+(function(global) {
+  'use strict';
+
+  /**
+   * This is a reference client for the Delta Bundler: it maintains cached the
+   * last patched bundle delta and it's capable of applying new Deltas received
+   * from the Bundler.
+   */
+  class DeltaPatcher {
+    constructor() {
+      this._lastBundle = {
+        pre: new Map(),
+        post: new Map(),
+        modules: new Map(),
+        id: undefined,
+      };
+      this._initialized = false;
+      this._lastNumModifiedFiles = 0;
+      this._lastModifiedDate = new Date();
+    }
+
+    static get(id) {
+      let deltaPatcher = this._deltaPatchers.get(id);
+
+      if (!deltaPatcher) {
+        deltaPatcher = new DeltaPatcher();
+        this._deltaPatchers.set(id, deltaPatcher);
+      }
+
+      return deltaPatcher;
+    }
+
+    /**
+     * Applies a Delta Bundle to the current bundle.
+     */
+    applyDelta(deltaBundle) {
+      // Make sure that the first received delta is a fresh one.
+      if (!this._initialized && !deltaBundle.reset) {
+        throw new Error(
+          'DeltaPatcher should receive a fresh Delta when being initialized',
+        );
+      }
+
+      this._initialized = true;
+
+      // Reset the current delta when we receive a fresh delta.
+      if (deltaBundle.reset) {
+        this._lastBundle = {
+          pre: new Map(),
+          post: new Map(),
+          modules: new Map(),
+          id: undefined,
+        };
+      }
+
+      this._lastNumModifiedFiles =
+        deltaBundle.pre.size + deltaBundle.post.size + deltaBundle.delta.size;
+
+      if (this._lastNumModifiedFiles > 0) {
+        this._lastModifiedDate = new Date();
+      }
+
+      this._patchMap(this._lastBundle.pre, deltaBundle.pre);
+      this._patchMap(this._lastBundle.post, deltaBundle.post);
+      this._patchMap(this._lastBundle.modules, deltaBundle.delta);
+
+      this._lastBundle.id = deltaBundle.id;
+
+      return this;
+    }
+
+    getLastBundleId() {
+      return this._lastBundle.id;
+    }
+
+    /**
+     * Returns the number of modified files in the last received Delta. This is
+     * currently used to populate the `X-Metro-Files-Changed-Count` HTTP header
+     * when metro serves the whole JS bundle, and can potentially be removed once
+     * we only send the actual deltas to clients.
+     */
+    getLastNumModifiedFiles() {
+      return this._lastNumModifiedFiles;
+    }
+
+    getLastModifiedDate() {
+      return this._lastModifiedDate;
+    }
+
+    getAllModules() {
+      return [].concat(
+        Array.from(this._lastBundle.pre.values()),
+        Array.from(this._lastBundle.modules.values()),
+        Array.from(this._lastBundle.post.values()),
+      );
+    }
+
+    _patchMap(original, patch) {
+      for (const [key, value] of patch.entries()) {
+        if (value == null) {
+          original.delete(key);
+        } else {
+          original.set(key, value);
+        }
+      }
+    }
+  }
+
+  DeltaPatcher._deltaPatchers = new Map();
+
+  global.DeltaPatcher = DeltaPatcher;
+})(window);

node_modules/react-native/local-cli/server/util/debugger-ui/debuggerWorker.js

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* global __fbBatchedBridge, self, importScripts, postMessage, onmessage: true */
+/* eslint no-unused-vars: 0 */
+
+'use strict';
+
+onmessage = (function() {
+  var visibilityState;
+  var showVisibilityWarning = (function() {
+    var hasWarned = false;
+    return function() {
+      // Wait until `YellowBox` gets initialized before displaying the warning.
+      if (hasWarned || console.warn.toString().includes('[native code]')) {
+        return;
+      }
+      hasWarned = true;
+      console.warn(
+        'Remote debugger is in a background tab which may cause apps to ' +
+        'perform slowly. Fix this by foregrounding the tab (or opening it in ' +
+        'a separate window).'
+      );
+    };
+  })();
+
+  var messageHandlers = {
+    'executeApplicationScript': function(message, sendReply) {
+      for (var key in message.inject) {
+        self[key] = JSON.parse(message.inject[key]);
+      }
+      var error;
+      try {
+        importScripts(message.url);
+      } catch (err) {
+        error = err.message;
+      }
+      sendReply(null /* result */, error);
+    },
+    'setDebuggerVisibility': function(message) {
+      visibilityState = message.visibilityState;
+    },
+  };
+
+  return function(message) {
+    if (visibilityState === 'hidden') {
+      showVisibilityWarning();
+    }
+
+    var object = message.data;
+
+    var sendReply = function(result, error) {
+      postMessage({replyID: object.id, result: result, error: error});
+    };
+
+    var handler = messageHandlers[object.method];
+    if (handler) {
+      // Special cased handlers
+      handler(object, sendReply);
+    } else {
+      // Other methods get called on the bridge
+      var returnValue = [[], [], [], 0];
+      var error;
+      try {
+        if (typeof __fbBatchedBridge === 'object') {
+          returnValue = __fbBatchedBridge[object.method].apply(null, object.arguments);
+        } else {
+          error = 'Failed to call function, __fbBatchedBridge is undefined';
+        }
+      } catch (err) {
+        error = err.message;
+      } finally {
+        sendReply(JSON.stringify(returnValue), error);
+      }
+    }
+  };
+})();

node_modules/react-native/local-cli/server/util/debugger-ui/deltaUrlToBlobUrl.js

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+/* global Blob, URL: true */
+
+(function(global) {
+  'use strict';
+
+  let cachedBundleUrls = new Map();
+
+  /**
+   * Converts the passed delta URL into an URL object containing already the
+   * whole JS bundle Blob.
+   */
+  async function deltaUrlToBlobUrl(deltaUrl) {
+    const client = global.DeltaPatcher.get(deltaUrl);
+
+    const deltaBundleId = client.getLastBundleId()
+      ? `&deltaBundleId=${client.getLastBundleId()}`
+      : '';
+
+    const data = await fetch(deltaUrl + deltaBundleId);
+    const bundle = await data.json();
+
+    const deltaPatcher = client.applyDelta({
+      id: bundle.id,
+      pre: new Map(bundle.pre),
+      post: new Map(bundle.post),
+      delta: new Map(bundle.delta),
+      reset: bundle.reset,
+    });
+
+    let cachedBundle = cachedBundleUrls.get(deltaUrl);
+
+    // If nothing changed, avoid recreating a bundle blob by reusing the
+    // previous one.
+    if (deltaPatcher.getLastNumModifiedFiles() === 0 && cachedBundle) {
+      return cachedBundle;
+    }
+
+    // Clean up the previous bundle URL to not leak memory.
+    if (cachedBundle) {
+      URL.revokeObjectURL(cachedBundle);
+    }
+
+    // To make Source Maps work correctly, we need to add a newline between
+    // modules.
+    const blobContent = deltaPatcher
+      .getAllModules()
+      .map(module => module + '\n');
+
+    // Build the blob with the whole JS bundle.
+    const blob = new Blob(blobContent, {
+      type: 'application/javascript',
+    });
+
+    const bundleContents = URL.createObjectURL(blob);
+    cachedBundleUrls.set(deltaUrl, bundleContents);
+
+    return bundleContents;
+  }
+
+  global.deltaUrlToBlobUrl = deltaUrlToBlobUrl;
+})(window || {});