realm-flipper-plugin/dist/bundle.js

A Flipper Plugin to debug Realm applications.

var __BUNDLE_START_TIME__=this.nativePerformanceNow?nativePerformanceNow():Date.now(),__DEV__=true,process=this.process||{},__METRO_GLOBAL_PREFIX__='';process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||"development";
(function (global) {
  "use strict";

  global.__r = metroRequire;
  global[`${__METRO_GLOBAL_PREFIX__}__d`] = define;
  global.__c = clear;
  global.__registerSegment = registerSegment;
  var modules = clear();
  const EMPTY = {};
  const {
    hasOwnProperty
  } = {};

  if (__DEV__) {
    global.$RefreshReg$ = () => {};

    global.$RefreshSig$ = () => type => type;
  }

  function clear() {
    modules = Object.create(null);
    return modules;
  }

  if (__DEV__) {
    var verboseNamesToModuleIds = Object.create(null);
    var initializingModuleIds = [];
  }

  function define(factory, moduleId, dependencyMap) {
    if (modules[moduleId] != null) {
      if (__DEV__) {
        const inverseDependencies = arguments[4];

        if (inverseDependencies) {
          global.__accept(moduleId, factory, dependencyMap, inverseDependencies);
        }
      }

      return;
    }

    const mod = {
      dependencyMap,
      factory,
      hasError: false,
      importedAll: EMPTY,
      importedDefault: EMPTY,
      isInitialized: false,
      publicModule: {
        exports: {}
      }
    };
    modules[moduleId] = mod;

    if (__DEV__) {
      mod.hot = createHotReloadingObject();
      const verboseName = arguments[3];

      if (verboseName) {
        mod.verboseName = verboseName;
        verboseNamesToModuleIds[verboseName] = moduleId;
      }
    }
  }

  function metroRequire(moduleId) {
    if (__DEV__ && typeof moduleId === "string") {
      const verboseName = moduleId;
      moduleId = verboseNamesToModuleIds[verboseName];

      if (moduleId == null) {
        throw new Error(`Unknown named module: "${verboseName}"`);
      } else {
        console.warn(`Requiring module "${verboseName}" by name is only supported for ` + "debugging purposes and will BREAK IN PRODUCTION!");
      }
    }

    const moduleIdReallyIsNumber = moduleId;

    if (__DEV__) {
      const initializingIndex = initializingModuleIds.indexOf(moduleIdReallyIsNumber);

      if (initializingIndex !== -1) {
        const cycle = initializingModuleIds.slice(initializingIndex).map(id => modules[id] ? modules[id].verboseName : "[unknown]");
        cycle.push(cycle[0]);
        console.warn(`Require cycle: ${cycle.join(" -> ")}\n\n` + "Require cycles are allowed, but can result in uninitialized values. " + "Consider refactoring to remove the need for a cycle.");
      }
    }

    const module = modules[moduleIdReallyIsNumber];
    return module && module.isInitialized ? module.publicModule.exports : guardedLoadModule(moduleIdReallyIsNumber, module);
  }

  function metroImportDefault(moduleId) {
    if (__DEV__ && typeof moduleId === "string") {
      const verboseName = moduleId;
      moduleId = verboseNamesToModuleIds[verboseName];
    }

    const moduleIdReallyIsNumber = moduleId;

    if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedDefault !== EMPTY) {
      return modules[moduleIdReallyIsNumber].importedDefault;
    }

    const exports = metroRequire(moduleIdReallyIsNumber);
    const importedDefault = exports && exports.__esModule ? exports.default : exports;
    return modules[moduleIdReallyIsNumber].importedDefault = importedDefault;
  }

  metroRequire.importDefault = metroImportDefault;

  function metroImportAll(moduleId) {
    if (__DEV__ && typeof moduleId === "string") {
      const verboseName = moduleId;
      moduleId = verboseNamesToModuleIds[verboseName];
    }

    const moduleIdReallyIsNumber = moduleId;

    if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedAll !== EMPTY) {
      return modules[moduleIdReallyIsNumber].importedAll;
    }

    const exports = metroRequire(moduleIdReallyIsNumber);
    let importedAll;

    if (exports && exports.__esModule) {
      importedAll = exports;
    } else {
      importedAll = {};

      if (exports) {
        for (const key in exports) {
          if (hasOwnProperty.call(exports, key)) {
            importedAll[key] = exports[key];
          }
        }
      }

      importedAll.default = exports;
    }

    return modules[moduleIdReallyIsNumber].importedAll = importedAll;
  }

  metroRequire.importAll = metroImportAll;
  let inGuard = false;

  function guardedLoadModule(moduleId, module) {
    if (!inGuard && global.ErrorUtils) {
      inGuard = true;
      let returnValue;

      try {
        returnValue = loadModuleImplementation(moduleId, module);
      } catch (e) {
        global.ErrorUtils.reportFatalError(e);
      }

      inGuard = false;
      return returnValue;
    } else {
      return loadModuleImplementation(moduleId, module);
    }
  }

  const ID_MASK_SHIFT = 16;
  const LOCAL_ID_MASK = ~0 >>> ID_MASK_SHIFT;

  function unpackModuleId(moduleId) {
    const segmentId = moduleId >>> ID_MASK_SHIFT;
    const localId = moduleId & LOCAL_ID_MASK;
    return {
      segmentId,
      localId
    };
  }

  metroRequire.unpackModuleId = unpackModuleId;

  function packModuleId(value) {
    return (value.segmentId << ID_MASK_SHIFT) + value.localId;
  }

  metroRequire.packModuleId = packModuleId;
  const moduleDefinersBySegmentID = [];
  const definingSegmentByModuleID = new Map();

  function registerSegment(segmentId, moduleDefiner, moduleIds) {
    moduleDefinersBySegmentID[segmentId] = moduleDefiner;

    if (__DEV__) {
      if (segmentId === 0 && moduleIds) {
        throw new Error("registerSegment: Expected moduleIds to be null for main segment");
      }

      if (segmentId !== 0 && !moduleIds) {
        throw new Error("registerSegment: Expected moduleIds to be passed for segment #" + segmentId);
      }
    }

    if (moduleIds) {
      moduleIds.forEach(moduleId => {
        if (!modules[moduleId] && !definingSegmentByModuleID.has(moduleId)) {
          definingSegmentByModuleID.set(moduleId, segmentId);
        }
      });
    }
  }

  function loadModuleImplementation(moduleId, module) {
    if (!module && moduleDefinersBySegmentID.length > 0) {
      var _definingSegmentByMod;

      const segmentId = (_definingSegmentByMod = definingSegmentByModuleID.get(moduleId)) !== null && _definingSegmentByMod !== void 0 ? _definingSegmentByMod : 0;
      const definer = moduleDefinersBySegmentID[segmentId];

      if (definer != null) {
        definer(moduleId);
        module = modules[moduleId];
        definingSegmentByModuleID.delete(moduleId);
      }
    }

    const nativeRequire = global.nativeRequire;

    if (!module && nativeRequire) {
      const {
        segmentId,
        localId
      } = unpackModuleId(moduleId);
      nativeRequire(localId, segmentId);
      module = modules[moduleId];
    }

    if (!module) {
      throw unknownModuleError(moduleId);
    }

    if (module.hasError) {
      throw moduleThrewError(moduleId, module.error);
    }

    if (__DEV__) {
      var Systrace = requireSystrace();
      var Refresh = requireRefresh();
    }

    module.isInitialized = true;
    const {
      factory,
      dependencyMap
    } = module;

    if (__DEV__) {
      initializingModuleIds.push(moduleId);
    }

    try {
      if (__DEV__) {
        Systrace.beginEvent("JS_require_" + (module.verboseName || moduleId));
      }

      const moduleObject = module.publicModule;

      if (__DEV__) {
        moduleObject.hot = module.hot;
        var prevRefreshReg = global.$RefreshReg$;
        var prevRefreshSig = global.$RefreshSig$;

        if (Refresh != null) {
          const RefreshRuntime = Refresh;

          global.$RefreshReg$ = (type, id) => {
            RefreshRuntime.register(type, moduleId + " " + id);
          };

          global.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
        }
      }

      moduleObject.id = moduleId;
      factory(global, metroRequire, metroImportDefault, metroImportAll, moduleObject, moduleObject.exports, dependencyMap);

      if (!__DEV__) {
        module.factory = undefined;
        module.dependencyMap = undefined;
      }

      if (__DEV__) {
        Systrace.endEvent();

        if (Refresh != null) {
          registerExportsForReactRefresh(Refresh, moduleObject.exports, moduleId);
        }
      }

      return moduleObject.exports;
    } catch (e) {
      module.hasError = true;
      module.error = e;
      module.isInitialized = false;
      module.publicModule.exports = undefined;
      throw e;
    } finally {
      if (__DEV__) {
        if (initializingModuleIds.pop() !== moduleId) {
          throw new Error("initializingModuleIds is corrupt; something is terribly wrong");
        }

        global.$RefreshReg$ = prevRefreshReg;
        global.$RefreshSig$ = prevRefreshSig;
      }
    }
  }

  function unknownModuleError(id) {
    let message = 'Requiring unknown module "' + id + '".';

    if (__DEV__) {
      message += " If you are sure the module exists, try restarting Metro. " + "You may also want to run `yarn` or `npm install`.";
    }

    return Error(message);
  }

  function moduleThrewError(id, error) {
    const displayName = __DEV__ && modules[id] && modules[id].verboseName || id;
    return Error('Requiring module "' + displayName + '", which threw an exception: ' + error);
  }

  if (__DEV__) {
    metroRequire.Systrace = {
      beginEvent: () => {},
      endEvent: () => {}
    };

    metroRequire.getModules = () => {
      return modules;
    };

    var createHotReloadingObject = function () {
      const hot = {
        _acceptCallback: null,
        _disposeCallback: null,
        _didAccept: false,
        accept: callback => {
          hot._didAccept = true;
          hot._acceptCallback = callback;
        },
        dispose: callback => {
          hot._disposeCallback = callback;
        }
      };
      return hot;
    };

    let reactRefreshTimeout = null;

    const metroHotUpdateModule = function (id, factory, dependencyMap, inverseDependencies) {
      const mod = modules[id];

      if (!mod) {
        if (factory) {
          return;
        }

        throw unknownModuleError(id);
      }

      if (!mod.hasError && !mod.isInitialized) {
        mod.factory = factory;
        mod.dependencyMap = dependencyMap;
        return;
      }

      const Refresh = requireRefresh();
      const refreshBoundaryIDs = new Set();
      let didBailOut = false;
      const updatedModuleIDs = topologicalSort([id], pendingID => {
        const pendingModule = modules[pendingID];

        if (pendingModule == null) {
          return [];
        }

        const pendingHot = pendingModule.hot;

        if (pendingHot == null) {
          throw new Error("[Refresh] Expected module.hot to always exist in DEV.");
        }

        let canAccept = pendingHot._didAccept;

        if (!canAccept && Refresh != null) {
          const isBoundary = isReactRefreshBoundary(Refresh, pendingModule.publicModule.exports);

          if (isBoundary) {
            canAccept = true;
            refreshBoundaryIDs.add(pendingID);
          }
        }

        if (canAccept) {
          return [];
        }

        const parentIDs = inverseDependencies[pendingID];

        if (parentIDs.length === 0) {
          performFullRefresh("No root boundary", {
            source: mod,
            failed: pendingModule
          });
          didBailOut = true;
          return [];
        }

        return parentIDs;
      }, () => didBailOut).reverse();

      if (didBailOut) {
        return;
      }

      const seenModuleIDs = new Set();

      for (let i = 0; i < updatedModuleIDs.length; i++) {
        const updatedID = updatedModuleIDs[i];

        if (seenModuleIDs.has(updatedID)) {
          continue;
        }

        seenModuleIDs.add(updatedID);
        const updatedMod = modules[updatedID];

        if (updatedMod == null) {
          throw new Error("[Refresh] Expected to find the updated module.");
        }

        const prevExports = updatedMod.publicModule.exports;
        const didError = runUpdatedModule(updatedID, updatedID === id ? factory : undefined, updatedID === id ? dependencyMap : undefined);
        const nextExports = updatedMod.publicModule.exports;

        if (didError) {
          return;
        }

        if (refreshBoundaryIDs.has(updatedID)) {
          const isNoLongerABoundary = !isReactRefreshBoundary(Refresh, nextExports);
          const didInvalidate = shouldInvalidateReactRefreshBoundary(Refresh, prevExports, nextExports);

          if (isNoLongerABoundary || didInvalidate) {
            const parentIDs = inverseDependencies[updatedID];

            if (parentIDs.length === 0) {
              performFullRefresh(isNoLongerABoundary ? "No longer a boundary" : "Invalidated boundary", {
                source: mod,
                failed: updatedMod
              });
              return;
            }

            for (let j = 0; j < parentIDs.length; j++) {
              const parentID = parentIDs[j];
              const parentMod = modules[parentID];

              if (parentMod == null) {
                throw new Error("[Refresh] Expected to find parent module.");
              }

              const canAcceptParent = isReactRefreshBoundary(Refresh, parentMod.publicModule.exports);

              if (canAcceptParent) {
                refreshBoundaryIDs.add(parentID);
                updatedModuleIDs.push(parentID);
              } else {
                performFullRefresh("Invalidated boundary", {
                  source: mod,
                  failed: parentMod
                });
                return;
              }
            }
          }
        }
      }

      if (Refresh != null) {
        if (reactRefreshTimeout == null) {
          reactRefreshTimeout = setTimeout(() => {
            reactRefreshTimeout = null;
            Refresh.performReactRefresh();
          }, 30);
        }
      }
    };

    const topologicalSort = function (roots, getEdges, earlyStop) {
      const result = [];
      const visited = new Set();

      function traverseDependentNodes(node) {
        visited.add(node);
        const dependentNodes = getEdges(node);

        if (earlyStop(node)) {
          return;
        }

        dependentNodes.forEach(dependent => {
          if (visited.has(dependent)) {
            return;
          }

          traverseDependentNodes(dependent);
        });
        result.push(node);
      }

      roots.forEach(root => {
        if (!visited.has(root)) {
          traverseDependentNodes(root);
        }
      });
      return result;
    };

    const runUpdatedModule = function (id, factory, dependencyMap) {
      const mod = modules[id];

      if (mod == null) {
        throw new Error("[Refresh] Expected to find the module.");
      }

      const {
        hot
      } = mod;

      if (!hot) {
        throw new Error("[Refresh] Expected module.hot to always exist in DEV.");
      }

      if (hot._disposeCallback) {
        try {
          hot._disposeCallback();
        } catch (error) {
          console.error(`Error while calling dispose handler for module ${id}: `, error);
        }
      }

      if (factory) {
        mod.factory = factory;
      }

      if (dependencyMap) {
        mod.dependencyMap = dependencyMap;
      }

      mod.hasError = false;
      mod.error = undefined;
      mod.importedAll = EMPTY;
      mod.importedDefault = EMPTY;
      mod.isInitialized = false;
      const prevExports = mod.publicModule.exports;
      mod.publicModule.exports = {};
      hot._didAccept = false;
      hot._acceptCallback = null;
      hot._disposeCallback = null;
      metroRequire(id);

      if (mod.hasError) {
        mod.hasError = false;
        mod.isInitialized = true;
        mod.error = null;
        mod.publicModule.exports = prevExports;
        return true;
      }

      if (hot._acceptCallback) {
        try {
          hot._acceptCallback();
        } catch (error) {
          console.error(`Error while calling accept handler for module ${id}: `, error);
        }
      }

      return false;
    };

    const performFullRefresh = (reason, modules) => {
      if (typeof window !== "undefined" && window.location != null && typeof window.location.reload === "function") {
        window.location.reload();
      } else {
        const Refresh = requireRefresh();

        if (Refresh != null) {
          var _modules$source$verbo, _modules$source, _modules$failed$verbo, _modules$failed;

          const sourceName = (_modules$source$verbo = (_modules$source = modules.source) === null || _modules$source === void 0 ? void 0 : _modules$source.verboseName) !== null && _modules$source$verbo !== void 0 ? _modules$source$verbo : "unknown";
          const failedName = (_modules$failed$verbo = (_modules$failed = modules.failed) === null || _modules$failed === void 0 ? void 0 : _modules$failed.verboseName) !== null && _modules$failed$verbo !== void 0 ? _modules$failed$verbo : "unknown";
          Refresh.performFullRefresh(`Fast Refresh - ${reason} <${sourceName}> <${failedName}>`);
        } else {
          console.warn("Could not reload the application after an edit.");
        }
      }
    };

    var isReactRefreshBoundary = function (Refresh, moduleExports) {
      if (Refresh.isLikelyComponentType(moduleExports)) {
        return true;
      }

      if (moduleExports == null || typeof moduleExports !== "object") {
        return false;
      }

      let hasExports = false;
      let areAllExportsComponents = true;

      for (const key in moduleExports) {
        hasExports = true;

        if (key === "__esModule") {
          continue;
        }

        const desc = Object.getOwnPropertyDescriptor(moduleExports, key);

        if (desc && desc.get) {
          return false;
        }

        const exportValue = moduleExports[key];

        if (!Refresh.isLikelyComponentType(exportValue)) {
          areAllExportsComponents = false;
        }
      }

      return hasExports && areAllExportsComponents;
    };

    var shouldInvalidateReactRefreshBoundary = (Refresh, prevExports, nextExports) => {
      const prevSignature = getRefreshBoundarySignature(Refresh, prevExports);
      const nextSignature = getRefreshBoundarySignature(Refresh, nextExports);

      if (prevSignature.length !== nextSignature.length) {
        return true;
      }

      for (let i = 0; i < nextSignature.length; i++) {
        if (prevSignature[i] !== nextSignature[i]) {
          return true;
        }
      }

      return false;
    };

    var getRefreshBoundarySignature = (Refresh, moduleExports) => {
      const signature = [];
      signature.push(Refresh.getFamilyByType(moduleExports));

      if (moduleExports == null || typeof moduleExports !== "object") {
        return signature;
      }

      for (const key in moduleExports) {
        if (key === "__esModule") {
          continue;
        }

        const desc = Object.getOwnPropertyDescriptor(moduleExports, key);

        if (desc && desc.get) {
          continue;
        }

        const exportValue = moduleExports[key];
        signature.push(key);
        signature.push(Refresh.getFamilyByType(exportValue));
      }

      return signature;
    };

    var registerExportsForReactRefresh = (Refresh, moduleExports, moduleID) => {
      Refresh.register(moduleExports, moduleID + " %exports%");

      if (moduleExports == null || typeof moduleExports !== "object") {
        return;
      }

      for (const key in moduleExports) {
        const desc = Object.getOwnPropertyDescriptor(moduleExports, key);

        if (desc && desc.get) {
          continue;
        }

        const exportValue = moduleExports[key];
        const typeID = moduleID + " %exports% " + key;
        Refresh.register(exportValue, typeID);
      }
    };

    global.__accept = metroHotUpdateModule;
  }

  if (__DEV__) {
    var requireSystrace = function requireSystrace() {
      return global[__METRO_GLOBAL_PREFIX__ + "__SYSTRACE"] || metroRequire.Systrace;
    };

    var requireRefresh = function requireRefresh() {
      return global[__METRO_GLOBAL_PREFIX__ + "__ReactRefresh"] || metroRequire.Refresh;
    };
  }
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.Component = Component;
  exports.plugin = plugin;
  var _flipperPlugin = global.FlipperPlugin;

  var _react = _interopRequireWildcard(global.React);

  var _CommonHeader = _$$_REQUIRE(_dependencyMap[0], "./components/common/CommonHeader");

  var _DataVisualizerWrapper = _$$_REQUIRE(_dependencyMap[1], "./components/DataVisualizerWrapper");

  var _Query = _$$_REQUIRE(_dependencyMap[2], "./components/Query");

  var _SchemaSelect = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./components/SchemaSelect"));

  var _SchemaGraph = _$$_REQUIRE(_dependencyMap[4], "./pages/SchemaGraph");

  var _SchemaVisualizer = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./pages/SchemaVisualizer"));

  var _ConvertFunctions = _$$_REQUIRE(_dependencyMap[6], "./utils/ConvertFunctions");

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

  function plugin(client) {
    const pluginState = (0, _flipperPlugin.createState)({
      deviceSerial: '',
      realms: [],
      selectedRealm: '',
      objects: [],
      schemas: [],
      schemaHistory: [],
      schemaHistoryIndex: 0,
      cursor: null,
      totalObjects: 0,
      sortingColumn: null,
      sortingDirection: null,
      hasMore: false,
      currentSchema: null,
      loading: false,
      query: ''
    });
    client.onMessage('getCurrentQuery', () => {
      const state = pluginState.get();
      client.send('receivedCurrentQuery', {
        schemaName: state.currentSchema ? state.currentSchema.name : null,
        realm: state.selectedRealm,
        sortingColumn: state.sortingColumn,
        sortingDirection: state.sortingDirection
      });
    });

    const sortSchemaProperties = schema => {
      const sortedPropKeys = Object.keys(schema.properties).sort(function (a, b) {
        return a.toLowerCase().localeCompare(b.toLowerCase());
      });
      const primKeyIndex = sortedPropKeys.findIndex(key => schema.primaryKey === key);

      if (primKeyIndex >= 0) {
        const primKey = sortedPropKeys[primKeyIndex];
        sortedPropKeys.splice(primKeyIndex, 1);
        sortedPropKeys.splice(0, 0, primKey);
      }

      const newSchemaObj = { ...schema,
        order: sortedPropKeys
      };
      Object.defineProperty(newSchemaObj, 'order', {
        enumerable: false,
        writable: true
      });
      return newSchemaObj;
    };

    client.onMessage('liveObjectAdded', data => {
      var _state$currentSchema;

      const state = pluginState.get();
      const {
        index,
        schemaName,
        newObject
      } = data;

      if (schemaName !== ((_state$currentSchema = state.currentSchema) === null || _state$currentSchema === void 0 ? void 0 : _state$currentSchema.name)) {
        return;
      }

      if (index < state.objects.length && state.objects[index].objectKey == newObject.objectKey) {
        return;
      }

      const clone = structuredClone(newObject);
      const copyOfObjects = state.objects;
      const addedObject = (0, _ConvertFunctions.deserializeRealmObject)(clone, state.currentSchema);
      copyOfObjects.splice(index, 0, addedObject);
      const newLastObject = copyOfObjects[copyOfObjects.length - 1];
      pluginState.set({ ...state,
        objects: [...copyOfObjects],
        totalObjects: state.totalObjects + 1,
        cursor: newLastObject.objectKey
      });
    });
    client.onMessage('liveObjectDeleted', data => {
      var _state$currentSchema2;

      const state = pluginState.get();
      const {
        index,
        schemaName
      } = data;

      if (schemaName !== ((_state$currentSchema2 = state.currentSchema) === null || _state$currentSchema2 === void 0 ? void 0 : _state$currentSchema2.name)) {
        return;
      }

      if (index > state.objects.length) {
        return;
      }

      state.objects.splice(index, 1);
      const newLastObject = state.objects[state.objects.length - 1];
      pluginState.set({ ...state,
        objects: state.objects,
        totalObjects: state.totalObjects - 1,
        cursor: newLastObject ? newLastObject.objectKey : null
      });
    });
    client.onMessage('liveObjectEdited', data => {
      var _state$currentSchema3;

      const state = pluginState.get();
      const {
        index,
        schemaName,
        newObject
      } = data;

      if (schemaName !== ((_state$currentSchema3 = state.currentSchema) === null || _state$currentSchema3 === void 0 ? void 0 : _state$currentSchema3.name)) {
        return;
      }

      if (index > state.objects.length) {
        return;
      }

      if (state.objects[index].objectKey != data.newObject.objectKey) {
        return;
      }

      const clone = structuredClone(newObject);
      const copyOfObjects = state.objects;
      const addedObject = (0, _ConvertFunctions.deserializeRealmObject)(clone, state.currentSchema);
      copyOfObjects.splice(index, 1, addedObject);
      const newLastObject = copyOfObjects[copyOfObjects.length - 1];
      pluginState.set({ ...state,
        objects: [...copyOfObjects],
        cursor: newLastObject.objectKey
      });
    });
    client.addMenuEntry({
      action: 'clear',
      handler: async () => {}
    });

    const getRealms = () => {
      client.send('getRealms', undefined).then(realms => {
        const state = pluginState.get();
        pluginState.set({ ...state,
          realms: realms.realms,
          selectedRealm: realms.realms[0]
        });
        getSchemas(realms.realms[0]);
      });
    };

    const requestObjects = (schemaName, realm, toRestore, cursor, query) => {
      var _state$currentSchema4;

      const state = pluginState.get();

      if (!state.currentSchema) {
        return Promise.reject();
      }

      return client.send('getObjects', {
        schemaName: schemaName !== null && schemaName !== void 0 ? schemaName : (_state$currentSchema4 = state.currentSchema) === null || _state$currentSchema4 === void 0 ? void 0 : _state$currentSchema4.name,
        realm: realm !== null && realm !== void 0 ? realm : state.selectedRealm,
        cursor: cursor === undefined ? null : cursor,
        sortingColumn: state.sortingColumn,
        sortingDirection: state.sortingDirection ? state.sortingDirection : null,
        query: query ? query : state.query
      });
    };

    const getObject = (realm, schemaName, objectKey) => {
      const state = pluginState.get();
      pluginState.set({ ...state,
        loading: true
      });
      return client.send('getObject', {
        realm,
        schemaName,
        objectKey
      }).then(serializedObject => {
        const actualSchema = state.schemas.find(schema => schema.name === schemaName);

        if (!actualSchema) {
          return null;
        }

        const deserializedObject = (0, _ConvertFunctions.deserializeRealmObject)(serializedObject, actualSchema);
        return deserializedObject;
      }, reason => {
        pluginState.set({ ...state,
          errorMessage: reason.message
        });
        return null;
      }).catch(error => {
        pluginState.set({ ...state,
          errorMessage: error.message
        });
        return null;
      });
    };

    const getObjects = (schemaName, realm, toRestore, cursor) => {
      var _schemaName, _realm, _cursor;

      const state = pluginState.get();

      if (!state.currentSchema || state.currentSchema.embedded) {
        return;
      }

      schemaName = (_schemaName = schemaName) !== null && _schemaName !== void 0 ? _schemaName : state.currentSchema.name;
      realm = (_realm = realm) !== null && _realm !== void 0 ? _realm : state.selectedRealm;
      cursor = (_cursor = cursor) !== null && _cursor !== void 0 ? _cursor : state.cursor;
      pluginState.set({ ...state,
        loading: true
      });
      requestObjects(schemaName, realm, toRestore, cursor).then(response => {
        var _state$currentSchema5;

        if (response.objects && !response.objects.length) {
          pluginState.set({ ...state,
            hasMore: false,
            loading: false,
            totalObjects: response.total,
            cursor: null
          });
          return;
        }

        const nextCursor = response.nextCursor;

        if (!state.currentSchema || ((_state$currentSchema5 = state.currentSchema) === null || _state$currentSchema5 === void 0 ? void 0 : _state$currentSchema5.name) !== schemaName) {
          return;
        }

        const objects = (0, _ConvertFunctions.deserializeRealmObjects)(response.objects, state.currentSchema);
        pluginState.set({ ...state,
          objects: [...state.objects, ...objects],
          cursor: nextCursor,
          totalObjects: response.total,
          hasMore: response.hasMore,
          errorMessage: '',
          loading: false
        });
      }, reason => {
        pluginState.set({ ...state,
          errorMessage: reason.message,
          objects: [],
          loading: false
        });
      }).catch(error => {
        pluginState.set({ ...state,
          errorMessage: error.message,
          objects: [],
          loading: false
        });
      });
    };

    const downloadData = (schemaName, objectKey, propertyName) => {
      const state = pluginState.get();
      return client.send('downloadData', {
        schemaName,
        realm: state.selectedRealm,
        objectKey,
        propertyName
      });
    };

    const getSchemas = realm => {
      client.send('getSchemas', {
        realm: realm
      }).then(schemaResult => {
        const newSchemas = schemaResult.schemas.map(schema => sortSchemaProperties(schema));
        const state = pluginState.get();
        pluginState.set({ ...state,
          schemas: newSchemas
        });

        if (newSchemas.length) {
          setSelectedSchema(newSchemas[0]);
          getObjects(newSchemas[0].name, state.selectedRealm);
        }
      });
    };

    const executeQuery = async query => {
      const state = pluginState.get();
      (0, _Query.addToHistory)(query);
      pluginState.set({ ...state,
        cursor: null,
        sortingColumn: null,
        query: query,
        objects: []
      });
      getObjects();
    };

    const addObject = object => {
      var _state$currentSchema6;

      const state = pluginState.get();

      if (!state.currentSchema) {
        return;
      }

      client.send('addObject', {
        realm: state.selectedRealm,
        schemaName: (_state$currentSchema6 = state.currentSchema) === null || _state$currentSchema6 === void 0 ? void 0 : _state$currentSchema6.name,
        object
      }).catch(reason => {
        pluginState.set({ ...state,
          errorMessage: reason.error
        });
      });
    };

    const setSelectedSchema = schema => {
      var _state$currentSchema7;

      const state = pluginState.get();

      if (((_state$currentSchema7 = state.currentSchema) === null || _state$currentSchema7 === void 0 ? void 0 : _state$currentSchema7.name) === schema.name) {
        return;
      }

      const newHistory = Array.from(state.schemaHistory);
      const index = state.schemaHistoryIndex;
      newHistory.splice(index + 1);
      newHistory.push(schema);
      const length = newHistory.length - 1;
      pluginState.set({ ...state,
        schemaHistory: [...newHistory],
        schemaHistoryIndex: length,
        cursor: null,
        objects: [],
        sortingColumn: null,
        currentSchema: schema,
        query: '',
        errorMessage: ''
      });
    };

    const goBackSchemaHistory = schema => {
      const state = pluginState.get();
      pluginState.set({ ...state,
        schemaHistoryIndex: state.schemaHistoryIndex - 1,
        cursor: null,
        objects: [],
        sortingColumn: null,
        currentSchema: schema
      });
    };

    const goForwardSchemaHistory = schema => {
      const state = pluginState.get();
      pluginState.set({ ...state,
        schemaHistoryIndex: state.schemaHistoryIndex + 1,
        cursor: null,
        objects: [],
        sortingColumn: null,
        currentSchema: schema
      });
    };

    const setSelectedRealm = realm => {
      const state = pluginState.get();
      pluginState.set({ ...state,
        selectedRealm: realm,
        objects: [],
        cursor: null
      });
    };

    client.onConnect(() => {
      const state = pluginState.get();
      pluginState.set({ ...state,
        deviceSerial: client.device.serial
      });
      getRealms();
    });

    const modifyObject = (newObject, propsChanged) => {
      var _state$currentSchema8;

      if (newObject.realmObject == undefined) {
        return;
      }

      const state = pluginState.get();
      client.send('modifyObject', {
        realm: state.selectedRealm,
        schemaName: (_state$currentSchema8 = state.currentSchema) === null || _state$currentSchema8 === void 0 ? void 0 : _state$currentSchema8.name,
        object: newObject.realmObject,
        objectKey: newObject.objectKey,
        propsChanged: Array.from(propsChanged.values())
      }).catch(e => {
        pluginState.set({ ...state,
          errorMessage: e.message
        });
      });
    };

    const removeObject = removedObject => {
      if (removedObject.realmObject == undefined) {
        return;
      }

      const state = pluginState.get();
      const schema = state.currentSchema;

      if (!schema) {
        return;
      }

      client.send('removeObject', {
        realm: state.selectedRealm,
        schemaName: schema.name,
        object: removedObject.realmObject,
        objectKey: removedObject.objectKey
      });
    };

    const setSortingColumn = sortingColumn => {
      const state = pluginState.get();
      pluginState.set({ ...state,
        objects: [],
        sortingColumn: sortingColumn,
        cursor: null
      });
    };

    const toggleSortingDirection = () => {
      let state = pluginState.get();
      let newSortingDirection = null;

      if (state.sortingDirection === null) {
        newSortingDirection = 'ascend';
      } else if (state.sortingDirection === 'ascend') {
        newSortingDirection = 'descend';
      } else {
        newSortingDirection = null;
        setSortingColumn(null);
      }

      state = pluginState.get();
      pluginState.set({ ...state,
        sortingDirection: newSortingDirection,
        cursor: null,
        objects: []
      });
    };

    const setSortingDirection = direction => {
      const state = pluginState.get();
      pluginState.set({ ...state,
        sortingDirection: direction
      });
    };

    const refreshState = () => {
      const state = pluginState.get();
      pluginState.set({ ...state,
        cursor: null,
        sortingColumn: null,
        sortingDirection: null,
        loading: false,
        query: '',
        errorMessage: '',
        objects: []
      });
      getObjects();
    };

    const clearError = () => {
      const state = pluginState.get();
      pluginState.set({ ...state,
        errorMessage: undefined
      });
    };

    return {
      state: pluginState,
      getObject,
      getObjects,
      getSchemas,
      executeQuery,
      addObject,
      setSelectedSchema,
      setSelectedRealm,
      modifyObject,
      removeObject,
      goBackSchemaHistory,
      goForwardSchemaHistory,
      setSortingColumn,
      toggleSortingDirection,
      setSortingDirection,
      refreshState,
      clearError,
      requestObjects,
      downloadData
    };
  }

  function Component() {
    const {
      state,
      getObjects
    } = (0, _flipperPlugin.usePlugin)(plugin);
    const {
      realms,
      objects,
      schemas,
      sortingDirection,
      sortingColumn,
      currentSchema,
      hasMore,
      selectedRealm,
      totalObjects
    } = (0, _flipperPlugin.useValue)(state);
    const [viewMode, setViewMode] = (0, _react.useState)('data');
    return _react.default.createElement(_react.default.Fragment, null, _react.default.createElement(_CommonHeader.CommonHeader, {
      viewMode: viewMode,
      setViewMode: setViewMode,
      realms: realms
    }), viewMode === 'data' && currentSchema ? _react.default.createElement(_DataVisualizerWrapper.DataVisualizerWrapper, {
      schemas: schemas,
      objects: objects,
      hasMore: hasMore,
      currentSchema: currentSchema,
      sortingDirection: sortingDirection,
      sortingColumn: sortingColumn,
      totalObjects: totalObjects,
      fetchMore: getObjects
    }) : null, viewMode === 'schemas' ? _react.default.createElement(_react.default.Fragment, null, _react.default.createElement(_SchemaSelect.default, {
      schemas: schemas
    }), _react.default.createElement(_SchemaVisualizer.default, {
      schemas: schemas,
      currentSchema: currentSchema
    })) : null, viewMode === 'schemaGraph' ? _react.default.createElement(_SchemaGraph.SchemaGraph, {
      schemas: schemas,
      selectedRealm: selectedRealm
    }) : null);
  }
},0,[1,6,55,3,56,1403,48],"src/index.tsx");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.CommonHeader = void 0;
  var _flipperPlugin = global.FlipperPlugin;

  var _react = _interopRequireDefault(global.React);

  var _RealmSelect = _$$_REQUIRE(_dependencyMap[0], "./RealmSelect");

  var _ViewModeTabs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./ViewModeTabs"));

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  const CommonHeader = ({
    viewMode,
    setViewMode,
    realms
  }) => {
    return _react.default.createElement(_flipperPlugin.Toolbar, {
      position: "top",
      right: _react.default.createElement(_RealmSelect.RealmSelect, {
        realms: realms
      })
    }, _react.default.createElement(_ViewModeTabs.default, {
      viewMode: viewMode,
      setViewMode: setViewMode
    }));
  };

  exports.CommonHeader = CommonHeader;
},1,[2,5],"src/components/common/CommonHeader.tsx");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.RealmSelect = void 0;
  var _antd = global.antd;
  var _flipperPlugin = global.FlipperPlugin;

  var _react = _interopRequireWildcard(global.React);

  var _ = _$$_REQUIRE(_dependencyMap[0], "../..");

  var _SchemaSelect = _$$_REQUIRE(_dependencyMap[1], "../SchemaSelect");

  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

  const RealmSelect = ({
    realms
  }) => {
    const instance = (0, _flipperPlugin.usePlugin)(_.plugin);
    const state = (0, _flipperPlugin.useValue)(instance.state);

    const realmName = (realmPath, serial) => {
      const firstIndexOfSerial = realmPath.indexOf(serial);
      return realmPath.substring(firstIndexOfSerial + serial.length);
    };

    const onRealmSelected = (0, _react.useCallback)(selected => {
      instance.getSchemas(selected);
      instance.setSelectedRealm(selected);
    }, [instance]);
    const realmOptions = realms.map(realm => _react.default.createElement(_antd.Select.Option, {
      key: realm,
      value: realm
    }, realmName(realm, state.deviceSerial)));
    return _react.default.createElement("div", null, _react.default.createElement(_SchemaSelect.BoldSpan, null, "Realm "), _react.default.createElement(_antd.Select, {
      showSearch: true,
      value: state.selectedRealm,
      onChange: onRealmSelected,
      style: {
        maxWidth: '400px'
      },
      dropdownMatchSelectWidth: false
    }, realmOptions));
  };

  exports.RealmSelect = RealmSelect;
},2,[0,3],"src/components/common/RealmSelect.tsx");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = exports.BoldSpan = void 0;
  var _antd = global.antd;
  var _flipperPlugin = global.FlipperPlugin;

  var _react = _interopRequireDefault(global.React);

  var _index = _$$_REQUIRE(_dependencyMap[0], "../index");

  var _SchemaHistoryActions = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./SchemaHistoryActions"));

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  const {
    Option
  } = _antd.Select;

  const BoldSpan = _flipperPlugin.styled.span({
    fontSize: 12,
    color: '#90949c',
    fontWeight: 'bold',
    textTransform: 'uppercase'
  });

  exports.BoldSpan = BoldSpan;

  const SchemaSelect = ({
    schemas
  }) => {
    var _state$currentSchema;

    const instance = (0, _flipperPlugin.usePlugin)(_index.plugin);
    const state = (0, _flipperPlugin.useValue)(instance.state);

    const onSchemaSelected = selected => {
      let selectedObjectSchema = schemas.find(schema => schema.name === selected);

      if (!selectedObjectSchema) {
        return;
      }

      instance.setSelectedSchema(selectedObjectSchema);

      if (selectedObjectSchema && !selectedObjectSchema.embedded) {
        instance.getObjects();
      } else {
        instance.state.set({ ...instance.state.get(),
          totalObjects: 0,
          objects: []
        });
      }
    };

    const schemaOptions = schemas.map(schema => _react.default.createElement(Option, {
      key: schema.name,
      value: schema.name
    }, schema.name));
    return _react.default.createElement(_flipperPlugin.Toolbar, {
      position: "top"
    }, _react.default.createElement(_SchemaHistoryActions.default, null), _react.default.createElement(BoldSpan, null, "Object type"), _react.default.createElement(_antd.Select, {
      showSearch: true,
      value: (_state$currentSchema = state.currentSchema) === null || _state$currentSchema === void 0 ? void 0 : _state$currentSchema.name,
      onChange: onSchemaSelected,
      style: {
        flex: 1
      },
      dropdownMatchSelectWidth: false
    }, schemaOptions), _react.default.createElement(_antd.Button, {
      onClick: () => instance.refreshState(),
      type: "default"
    }, "Refresh"));
  };

  var _default = _react.default.memo(SchemaSelect);

  exports.default = _default;
},3,[0,4],"src/components/SchemaSelect.tsx");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  var _icons = global.antdesign_icons;
  var _antd = global.antd;
  var _flipperPlugin = global.FlipperPlugin;

  var _react = _interopRequireWildcard(global.React);

  var _ = _$$_REQUIRE(_dependencyMap[0], "..");

  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

  const SchemaHistoryActions = () => {
    const instance = (0, _flipperPlugin.usePlugin)(_.plugin);
    const state = (0, _flipperPlugin.useValue)(instance.state);
    const goBack = (0, _react.useCallback)(() => {
      const newSelectedSchema = state.schemaHistory[state.schemaHistoryIndex - 1];

      if (!newSelectedSchema) {
        return;
      }

      instance.goBackSchemaHistory(newSelectedSchema);
      instance.getObjects();
    }, [state.currentSchema]);
    const goForward = (0, _react.useCallback)(() => {
      const newSelectedSchema = state.schemaHistory[state.schemaHistoryIndex + 1];

      if (!newSelectedSchema) {
        return;
      }

      instance.goForwardSchemaHistory(newSelectedSchema);
      instance.getObjects();
    }, [state.currentSchema]);
    return _react.default.createElement("span", {
      style: {
        display: 'flex',
        justifyContent: 'flex-end',
        gap: '5px',
        padding: '5px'
      }
    }, _react.default.createElement(_antd.Button, {
      disabled: !state.realms.length || !state.schemas.length || !state.currentSchema || state.schemaHistoryIndex === 0,
      value: "table",
      onClick: goBack
    }, _react.default.createElement(_icons.ArrowLeftOutlined, {
      style: {
        marginRight: 5
      }
    })), _react.default.createElement(_antd.Button, {
      disabled: !state.realms.length || !state.schemas.length || !state.currentSchema || state.schemaHistoryIndex === state.schemaHistory.length - 1,
      onClick: goForward,
      value: "object"
    }, _react.default.createElement(_icons.ArrowRightOutlined, {
      style: {
        marginRight: 5
      }
    })));
  };

  var _default = _react.default.memo(SchemaHistoryActions);

  exports.default = _default;
},4,[0],"src/components/SchemaHistoryActions.tsx");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  var _icons = global.antdesign_icons;
  var _antd = global.antd;

  var _react = _interopRequireDefault(global.React);

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  const ViewModeTabs = props => {
    return _react.default.createElement(_antd.Radio.Group, {
      value: props.viewMode
    }, _react.default.createElement(_antd.Radio.Button, {
      value: "data",
      onClick: () => props.setViewMode('data')
    }, _react.default.createElement(_icons.TableOutlined, {
      style: {
        marginRight: 5
      }
    }), _react.default.createElement(_antd.Typography.Text, null, "Data")), _react.default.createElement(_antd.Radio.Button, {
      onClick: () => props.setViewMode('schemas'),
      value: "schemas"
    }, _react.default.createElement(_icons.SettingOutlined, {
      style: {
        marginRight: 5
      }
    }), _react.default.createElement(_antd.Typography.Text, null, "Schema")), _react.default.createElement(_antd.Radio.Button, {
      onClick: () => props.setViewMode('schemaGraph'),
      value: "schemaGraph"
    }, _react.default.createElement(_icons.RadarChartOutlined, {
      style: {
        marginRight: 5
      }