@teselagen/ove 0.8.9 → 0.8.11

package/index.umd.js

@@ -37808,7 +37808,7 @@ ${latestSubscriptionCallbackError.current.stack}
   };
   __name(_AbstractPointerSensor, "AbstractPointerSensor");
   let AbstractPointerSensor = _AbstractPointerSensor;
-  const events = {
+  const events$1 = {
     move: {
       name: "pointermove"
     },
@@ -37822,7 +37822,7 @@ ${latestSubscriptionCallbackError.current.stack}
         event
       } = props;
       const listenerTarget = getOwnerDocument(event.target);
-      super(props, events, listenerTarget);
+      super(props, events$1, listenerTarget);
     }
   };
   __name(_PointerSensor, "PointerSensor");
@@ -37845,7 +37845,7 @@ ${latestSubscriptionCallbackError.current.stack}
       return true;
     }, "handler")
   }];
-  const events$1 = {
+  const events$1$1 = {
     move: {
       name: "mousemove"
     },
@@ -37859,7 +37859,7 @@ ${latestSubscriptionCallbackError.current.stack}
   })(MouseButton || (MouseButton = {}));
   const _MouseSensor = class _MouseSensor extends AbstractPointerSensor {
     constructor(props) {
-      super(props, events$1, getOwnerDocument(props.event.target));
+      super(props, events$1$1, getOwnerDocument(props.event.target));
     }
   };
   __name(_MouseSensor, "MouseSensor");
@@ -44471,7 +44471,7 @@ ${latestSubscriptionCallbackError.current.stack}
     __proto__: null,
     default: __viteBrowserExternal
   }, Symbol.toStringTag, { value: "Module" }));
-  const require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
+  const require$$3$1 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
   var objectInspect;
   var hasRequiredObjectInspect;
   function requireObjectInspect() {
@@ -44529,7 +44529,7 @@ ${latestSubscriptionCallbackError.current.stack}
       return $replace.call(str, sepRegex, "$&_");
     }
     __name(addNumericSeparator, "addNumericSeparator");
-    var utilInspect = require$$0;
+    var utilInspect = require$$3$1;
     var inspectCustom = utilInspect.custom;
     var inspectSymbol = isSymbol2(inspectCustom) ? inspectCustom : null;
     objectInspect = /* @__PURE__ */ __name(function inspect_(obj, options, depth, seen) {
@@ -45994,6 +45994,9 @@ ${latestSubscriptionCallbackError.current.stack}
         } else {
           if (path2) {
             const allPaths = [path2, ...additionalSearchPaths];
+            if (allPaths.length > 1) {
+              return { _or: allPaths.map((p2) => addColumnFilters(p2)) };
+            }
             return allPaths.map((p2) => addColumnFilters(p2));
           } else {
             return addColumnFilters(filterOn);
@@ -85641,7 +85644,11 @@ ${latestSubscriptionCallbackError.current.stack}
         entities: normalizedEntities
       });
     }
-    const convertedSchema = reactExports.useMemo(() => convertSchema(_schema), [_schema]);
+    const __schema = useDeepEqualMemo(_schema);
+    const convertedSchema = reactExports.useMemo(
+      () => convertSchema(__schema),
+      [__schema]
+    );
     if (isLocalCall) {
       if (!noForm && (!formName || formName === "tgDataTable")) {
         throw new Error(
@@ -118937,6 +118944,392 @@ ${latestSubscriptionCallbackError.current.stack}
     }, chromData);
   }
   __name(convertBasePosTraceToPerBpTrace, "convertBasePosTraceToPerBpTrace");
+  var events = { exports: {} };
+  var hasRequiredEvents;
+  function requireEvents() {
+    if (hasRequiredEvents) return events.exports;
+    hasRequiredEvents = 1;
+    var R2 = typeof Reflect === "object" ? Reflect : null;
+    var ReflectApply = R2 && typeof R2.apply === "function" ? R2.apply : /* @__PURE__ */ __name(function ReflectApply2(target, receiver, args) {
+      return Function.prototype.apply.call(target, receiver, args);
+    }, "ReflectApply");
+    var ReflectOwnKeys;
+    if (R2 && typeof R2.ownKeys === "function") {
+      ReflectOwnKeys = R2.ownKeys;
+    } else if (Object.getOwnPropertySymbols) {
+      ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+      }, "ReflectOwnKeys");
+    } else {
+      ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target);
+      }, "ReflectOwnKeys");
+    }
+    function ProcessEmitWarning(warning2) {
+      if (console && console.warn) console.warn(warning2);
+    }
+    __name(ProcessEmitWarning, "ProcessEmitWarning");
+    var NumberIsNaN = Number.isNaN || /* @__PURE__ */ __name(function NumberIsNaN2(value) {
+      return value !== value;
+    }, "NumberIsNaN");
+    function EventEmitter() {
+      EventEmitter.init.call(this);
+    }
+    __name(EventEmitter, "EventEmitter");
+    events.exports = EventEmitter;
+    events.exports.once = once2;
+    EventEmitter.EventEmitter = EventEmitter;
+    EventEmitter.prototype._events = void 0;
+    EventEmitter.prototype._eventsCount = 0;
+    EventEmitter.prototype._maxListeners = void 0;
+    var defaultMaxListeners = 10;
+    function checkListener(listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+      }
+    }
+    __name(checkListener, "checkListener");
+    Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+      enumerable: true,
+      get: /* @__PURE__ */ __name(function() {
+        return defaultMaxListeners;
+      }, "get"),
+      set: /* @__PURE__ */ __name(function(arg) {
+        if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+          throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+        }
+        defaultMaxListeners = arg;
+      }, "set")
+    });
+    EventEmitter.init = function() {
+      if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      }
+      this._maxListeners = this._maxListeners || void 0;
+    };
+    EventEmitter.prototype.setMaxListeners = /* @__PURE__ */ __name(function setMaxListeners(n2) {
+      if (typeof n2 !== "number" || n2 < 0 || NumberIsNaN(n2)) {
+        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n2 + ".");
+      }
+      this._maxListeners = n2;
+      return this;
+    }, "setMaxListeners");
+    function _getMaxListeners(that) {
+      if (that._maxListeners === void 0)
+        return EventEmitter.defaultMaxListeners;
+      return that._maxListeners;
+    }
+    __name(_getMaxListeners, "_getMaxListeners");
+    EventEmitter.prototype.getMaxListeners = /* @__PURE__ */ __name(function getMaxListeners() {
+      return _getMaxListeners(this);
+    }, "getMaxListeners");
+    EventEmitter.prototype.emit = /* @__PURE__ */ __name(function emit(type2) {
+      var args = [];
+      for (var i2 = 1; i2 < arguments.length; i2++) args.push(arguments[i2]);
+      var doError = type2 === "error";
+      var events2 = this._events;
+      if (events2 !== void 0)
+        doError = doError && events2.error === void 0;
+      else if (!doError)
+        return false;
+      if (doError) {
+        var er;
+        if (args.length > 0)
+          er = args[0];
+        if (er instanceof Error) {
+          throw er;
+        }
+        var err2 = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+        err2.context = er;
+        throw err2;
+      }
+      var handler = events2[type2];
+      if (handler === void 0)
+        return false;
+      if (typeof handler === "function") {
+        ReflectApply(handler, this, args);
+      } else {
+        var len = handler.length;
+        var listeners = arrayClone(handler, len);
+        for (var i2 = 0; i2 < len; ++i2)
+          ReflectApply(listeners[i2], this, args);
+      }
+      return true;
+    }, "emit");
+    function _addListener(target, type2, listener, prepend) {
+      var m2;
+      var events2;
+      var existing;
+      checkListener(listener);
+      events2 = target._events;
+      if (events2 === void 0) {
+        events2 = target._events = /* @__PURE__ */ Object.create(null);
+        target._eventsCount = 0;
+      } else {
+        if (events2.newListener !== void 0) {
+          target.emit(
+            "newListener",
+            type2,
+            listener.listener ? listener.listener : listener
+          );
+          events2 = target._events;
+        }
+        existing = events2[type2];
+      }
+      if (existing === void 0) {
+        existing = events2[type2] = listener;
+        ++target._eventsCount;
+      } else {
+        if (typeof existing === "function") {
+          existing = events2[type2] = prepend ? [listener, existing] : [existing, listener];
+        } else if (prepend) {
+          existing.unshift(listener);
+        } else {
+          existing.push(listener);
+        }
+        m2 = _getMaxListeners(target);
+        if (m2 > 0 && existing.length > m2 && !existing.warned) {
+          existing.warned = true;
+          var w2 = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type2) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+          w2.name = "MaxListenersExceededWarning";
+          w2.emitter = target;
+          w2.type = type2;
+          w2.count = existing.length;
+          ProcessEmitWarning(w2);
+        }
+      }
+      return target;
+    }
+    __name(_addListener, "_addListener");
+    EventEmitter.prototype.addListener = /* @__PURE__ */ __name(function addListener(type2, listener) {
+      return _addListener(this, type2, listener, false);
+    }, "addListener");
+    EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+    EventEmitter.prototype.prependListener = /* @__PURE__ */ __name(function prependListener(type2, listener) {
+      return _addListener(this, type2, listener, true);
+    }, "prependListener");
+    function onceWrapper() {
+      if (!this.fired) {
+        this.target.removeListener(this.type, this.wrapFn);
+        this.fired = true;
+        if (arguments.length === 0)
+          return this.listener.call(this.target);
+        return this.listener.apply(this.target, arguments);
+      }
+    }
+    __name(onceWrapper, "onceWrapper");
+    function _onceWrap(target, type2, listener) {
+      var state2 = { fired: false, wrapFn: void 0, target, type: type2, listener };
+      var wrapped = onceWrapper.bind(state2);
+      wrapped.listener = listener;
+      state2.wrapFn = wrapped;
+      return wrapped;
+    }
+    __name(_onceWrap, "_onceWrap");
+    EventEmitter.prototype.once = /* @__PURE__ */ __name(function once3(type2, listener) {
+      checkListener(listener);
+      this.on(type2, _onceWrap(this, type2, listener));
+      return this;
+    }, "once");
+    EventEmitter.prototype.prependOnceListener = /* @__PURE__ */ __name(function prependOnceListener(type2, listener) {
+      checkListener(listener);
+      this.prependListener(type2, _onceWrap(this, type2, listener));
+      return this;
+    }, "prependOnceListener");
+    EventEmitter.prototype.removeListener = /* @__PURE__ */ __name(function removeListener(type2, listener) {
+      var list2, events2, position2, i2, originalListener;
+      checkListener(listener);
+      events2 = this._events;
+      if (events2 === void 0)
+        return this;
+      list2 = events2[type2];
+      if (list2 === void 0)
+        return this;
+      if (list2 === listener || list2.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = /* @__PURE__ */ Object.create(null);
+        else {
+          delete events2[type2];
+          if (events2.removeListener)
+            this.emit("removeListener", type2, list2.listener || listener);
+        }
+      } else if (typeof list2 !== "function") {
+        position2 = -1;
+        for (i2 = list2.length - 1; i2 >= 0; i2--) {
+          if (list2[i2] === listener || list2[i2].listener === listener) {
+            originalListener = list2[i2].listener;
+            position2 = i2;
+            break;
+          }
+        }
+        if (position2 < 0)
+          return this;
+        if (position2 === 0)
+          list2.shift();
+        else {
+          spliceOne2(list2, position2);
+        }
+        if (list2.length === 1)
+          events2[type2] = list2[0];
+        if (events2.removeListener !== void 0)
+          this.emit("removeListener", type2, originalListener || listener);
+      }
+      return this;
+    }, "removeListener");
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.removeAllListeners = /* @__PURE__ */ __name(function removeAllListeners(type2) {
+      var listeners, events2, i2;
+      events2 = this._events;
+      if (events2 === void 0)
+        return this;
+      if (events2.removeListener === void 0) {
+        if (arguments.length === 0) {
+          this._events = /* @__PURE__ */ Object.create(null);
+          this._eventsCount = 0;
+        } else if (events2[type2] !== void 0) {
+          if (--this._eventsCount === 0)
+            this._events = /* @__PURE__ */ Object.create(null);
+          else
+            delete events2[type2];
+        }
+        return this;
+      }
+      if (arguments.length === 0) {
+        var keys2 = Object.keys(events2);
+        var key;
+        for (i2 = 0; i2 < keys2.length; ++i2) {
+          key = keys2[i2];
+          if (key === "removeListener") continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners("removeListener");
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+      listeners = events2[type2];
+      if (typeof listeners === "function") {
+        this.removeListener(type2, listeners);
+      } else if (listeners !== void 0) {
+        for (i2 = listeners.length - 1; i2 >= 0; i2--) {
+          this.removeListener(type2, listeners[i2]);
+        }
+      }
+      return this;
+    }, "removeAllListeners");
+    function _listeners(target, type2, unwrap2) {
+      var events2 = target._events;
+      if (events2 === void 0)
+        return [];
+      var evlistener = events2[type2];
+      if (evlistener === void 0)
+        return [];
+      if (typeof evlistener === "function")
+        return unwrap2 ? [evlistener.listener || evlistener] : [evlistener];
+      return unwrap2 ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+    }
+    __name(_listeners, "_listeners");
+    EventEmitter.prototype.listeners = /* @__PURE__ */ __name(function listeners(type2) {
+      return _listeners(this, type2, true);
+    }, "listeners");
+    EventEmitter.prototype.rawListeners = /* @__PURE__ */ __name(function rawListeners(type2) {
+      return _listeners(this, type2, false);
+    }, "rawListeners");
+    EventEmitter.listenerCount = function(emitter, type2) {
+      if (typeof emitter.listenerCount === "function") {
+        return emitter.listenerCount(type2);
+      } else {
+        return listenerCount.call(emitter, type2);
+      }
+    };
+    EventEmitter.prototype.listenerCount = listenerCount;
+    function listenerCount(type2) {
+      var events2 = this._events;
+      if (events2 !== void 0) {
+        var evlistener = events2[type2];
+        if (typeof evlistener === "function") {
+          return 1;
+        } else if (evlistener !== void 0) {
+          return evlistener.length;
+        }
+      }
+      return 0;
+    }
+    __name(listenerCount, "listenerCount");
+    EventEmitter.prototype.eventNames = /* @__PURE__ */ __name(function eventNames() {
+      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+    }, "eventNames");
+    function arrayClone(arr, n2) {
+      var copy = new Array(n2);
+      for (var i2 = 0; i2 < n2; ++i2)
+        copy[i2] = arr[i2];
+      return copy;
+    }
+    __name(arrayClone, "arrayClone");
+    function spliceOne2(list2, index2) {
+      for (; index2 + 1 < list2.length; index2++)
+        list2[index2] = list2[index2 + 1];
+      list2.pop();
+    }
+    __name(spliceOne2, "spliceOne");
+    function unwrapListeners(arr) {
+      var ret = new Array(arr.length);
+      for (var i2 = 0; i2 < ret.length; ++i2) {
+        ret[i2] = arr[i2].listener || arr[i2];
+      }
+      return ret;
+    }
+    __name(unwrapListeners, "unwrapListeners");
+    function once2(emitter, name2) {
+      return new Promise(function(resolve, reject) {
+        function errorListener(err2) {
+          emitter.removeListener(name2, resolver2);
+          reject(err2);
+        }
+        __name(errorListener, "errorListener");
+        function resolver2() {
+          if (typeof emitter.removeListener === "function") {
+            emitter.removeListener("error", errorListener);
+          }
+          resolve([].slice.call(arguments));
+        }
+        __name(resolver2, "resolver");
+        eventTargetAgnosticAddListener(emitter, name2, resolver2, { once: true });
+        if (name2 !== "error") {
+          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+        }
+      });
+    }
+    __name(once2, "once");
+    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+      if (typeof emitter.on === "function") {
+        eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+      }
+    }
+    __name(addErrorHandlerIfEventEmitter, "addErrorHandlerIfEventEmitter");
+    function eventTargetAgnosticAddListener(emitter, name2, listener, flags) {
+      if (typeof emitter.on === "function") {
+        if (flags.once) {
+          emitter.once(name2, listener);
+        } else {
+          emitter.on(name2, listener);
+        }
+      } else if (typeof emitter.addEventListener === "function") {
+        emitter.addEventListener(name2, /* @__PURE__ */ __name(function wrapListener(arg) {
+          if (flags.once) {
+            emitter.removeEventListener(name2, wrapListener);
+          }
+          listener(arg);
+        }, "wrapListener"));
+      } else {
+        throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+      }
+    }
+    __name(eventTargetAgnosticAddListener, "eventTargetAgnosticAddListener");
+    return events.exports;
+  }
+  __name(requireEvents, "requireEvents");
   var inherits_browser = { exports: {} };
   var hasRequiredInherits_browser;
   function requireInherits_browser() {
@@ -118976,7 +119369,7 @@ ${latestSubscriptionCallbackError.current.stack}
   function requireStreamBrowser() {
     if (hasRequiredStreamBrowser) return streamBrowser;
     hasRequiredStreamBrowser = 1;
-    streamBrowser = require$$0.EventEmitter;
+    streamBrowser = requireEvents().EventEmitter;
     return streamBrowser;
   }
   __name(requireStreamBrowser, "requireStreamBrowser");
@@ -119057,7 +119450,7 @@ ${latestSubscriptionCallbackError.current.stack}
     }
     __name(_toPrimitive2, "_toPrimitive");
     var _require = requireBuffer(), Buffer2 = _require.Buffer;
-    var _require2 = require$$0, inspect = _require2.inspect;
+    var _require2 = require$$3$1, inspect = _require2.inspect;
     var custom = inspect && inspect.custom || "inspect";
     function copyBuffer(src2, target, offset2) {
       Buffer2.prototype.copy.call(src2, target, offset2);
@@ -120398,7 +120791,7 @@ ${latestSubscriptionCallbackError.current.stack}
     _stream_readable = Readable;
     var Duplex;
     Readable.ReadableState = ReadableState;
-    require$$0.EventEmitter;
+    requireEvents().EventEmitter;
     var EElistenerCount = /* @__PURE__ */ __name(function EElistenerCount2(emitter, type2) {
       return emitter.listeners(type2).length;
     }, "EElistenerCount");
@@ -120414,7 +120807,7 @@ ${latestSubscriptionCallbackError.current.stack}
       return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
     }
     __name(_isUint8Array, "_isUint8Array");
-    var debugUtil = require$$0;
+    var debugUtil = require$$3$1;
     var debug;
     if (debugUtil && debugUtil.debuglog) {
       debug = debugUtil.debuglog("stream");
@@ -121371,7 +121764,7 @@ ${latestSubscriptionCallbackError.current.stack}
     if (hasRequiredStreamBrowserify) return streamBrowserify;
     hasRequiredStreamBrowserify = 1;
     streamBrowserify = Stream;
-    var EE = require$$0.EventEmitter;
+    var EE = requireEvents().EventEmitter;
     var inherits = requireInherits_browser();
     inherits(Stream, EE);
     Stream.Readable = require_stream_readable();
@@ -144339,7 +144732,7 @@ Part of ${annotation.translationType} Translation from BPs ${annotation.start +
     input.click();
   }
   __name(showFileDialog, "showFileDialog");
-  const version = "0.8.8";
+  const version = "0.8.10";
   const packageJson = {
     version
   };
@@ -169943,6 +170336,7 @@ ${seqDataToCopy}\r
             isProtein: isProtein2,
             compact: true,
             isInfinite: true,
+            withDisplayOptions: true,
             schema: this.schema,
             entities: annotationsToUse
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/ove",
-  "version": "0.8.9",
+  "version": "0.8.11",
   "main": "./src/index.js",
   "type": "module",
   "exports": {
@@ -19,7 +19,7 @@
     "@teselagen/range-utils": "0.3.13",
     "@teselagen/react-list": "0.8.18",
     "@teselagen/sequence-utils": "0.3.35",
-    "@teselagen/ui": "0.10.8",
+    "@teselagen/ui": "0.10.9",
     "@use-gesture/react": "10.3.0",
     "biomsa": "^0.2.4",
     "classnames": "^2.3.2",

package/selectors/annotationSearchSelector.d.ts

@@ -1,5 +1,5 @@
 export const searchableTypes: string[];
-declare const _default: ((state: any) => any[]) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, ...args: any[]) => any[], {
+declare const _default: ((state: any) => any[][]) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, ...args: any[]) => any[][], {
     clearCache: () => void;
 }> & {
     clearCache: () => void;

package/selectors/cdsFeaturesSelector.d.ts

@@ -1,4 +1,4 @@
-declare const _default: ((state: any) => any) & import('reselect').OutputSelectorFields<(args_0: any) => any, {
+declare const _default: ((state: any) => any[]) & import('reselect').OutputSelectorFields<(args_0: any) => any[], {
     clearCache: () => void;
 }> & {
     clearCache: () => void;

package/selectors/cutsitesSelector.d.ts

@@ -1,11 +1,11 @@
 declare const _default: ((state: any) => {
     cutsitesByName: {};
     cutsitesById: {};
-    cutsitesArray: any;
+    cutsitesArray: never[];
 }) & import('reselect').OutputSelectorFields<(...args: any) => {
     cutsitesByName: {};
     cutsitesById: {};
-    cutsitesArray: any;
+    cutsitesArray: never[];
 }, {
     clearCache: () => void;
 }> & {

package/selectors/filteredFeaturesSelector.d.ts

@@ -1,4 +1,4 @@
-declare const _default: ((state: any) => any) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, args_2: any, args_3: any, args_4: any) => any, {
+declare const _default: ((state: any) => Partial<any>) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, args_2: any, args_3: any, args_4: any) => Partial<any>, {
     clearCache: () => void;
 }> & {
     clearCache: () => void;

package/selectors/filteredPartsSelector.d.ts

@@ -1,4 +1,4 @@
-declare const _default: ((state: any) => any) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, args_2: any, args_3: any, args_4: any) => any, {
+declare const _default: ((state: any) => any[]) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, args_2: any, args_3: any, args_4: any) => any[], {
     clearCache: () => void;
 }> & {
     clearCache: () => void;

package/selectors/filteredPrimersSelector.d.ts

@@ -1,4 +1,4 @@
-declare const _default: ((state: any) => any) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, args_2: any, args_3: any) => any, {
+declare const _default: ((state: any) => Partial<any>) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, args_2: any, args_3: any) => Partial<any>, {
     clearCache: () => void;
 }> & {
     clearCache: () => void;

package/selectors/searchLayersSelector.d.ts

@@ -1,4 +1,4 @@
-declare const _default: ((state: any) => any) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, args_2: any, args_3: any, args_4: any, args_5: any, args_6: any, args_7: any, args_8: any) => any, {
+declare const _default: ((state: any) => any[]) & import('reselect').OutputSelectorFields<(args_0: any, args_1: any, args_2: any, args_3: any, args_4: any, args_5: any, args_6: any, args_7: any, args_8: any) => any[], {
     clearCache: () => void;
 }> & {
     clearCache: () => void;

package/selectors/translationsSelector.d.ts

@@ -1,4 +1,14 @@
-declare const _default: ((state: any) => any) & import('reselect').OutputSelectorFields<(...args: any) => any, {
+declare const _default: ((state: any) => any) & import('reselect').OutputSelectorFields<(args_0: any, args_1: unknown, args_2: any, args_3: {
+    start: number;
+    end: number;
+    length: number;
+    internalStartCodonIndices: never[];
+    frame: number;
+    forward: any;
+    annotationTypePlural: string;
+    isOrf: boolean;
+    id: any;
+}[], args_4: any, args_5: any, args_6: any[], args_7: any, args_8: any, args_9: any, args_10: any, args_11: any, args_12: any) => any, {
     clearCache: () => void;
 }> & {
     clearCache: () => void;

package/src/helperComponents/PropertiesDialog/GenericAnnotationProperties.js

@@ -347,6 +347,7 @@ const genericAnnotationProperties = ({
           isProtein={isProtein}
           compact
           isInfinite
+          withDisplayOptions
           schema={this.schema}
           entities={annotationsToUse}
         />

package/utils/addWrappedAddons.d.ts

@@ -1 +1 @@
-export function addWrappedAddons(anns: any, seqLen: any): any;
+export function addWrappedAddons(anns: any, seqLen: any): any[];

package/utils/editorUtils.d.ts

@@ -35,4 +35,4 @@ export function getStripedPattern({ color, id }: {
     color: any;
     id: any;
 }): import("react/jsx-runtime").JSX.Element;
-export function getEnzymeAliases(enzyme: any): any;
+export function getEnzymeAliases(enzyme: any): any[];

package/withEditorInteractions/clickAndDragUtils.d.ts

@@ -41,17 +41,17 @@ export function updateSelectionOrCaret({ shiftHeld, sequenceLength, newRangeOrCa
     newRangeOrCaret: any;
     caretPosition: any;
     selectionLayer: any;
-    selectionLayerUpdate?: any;
-    caretPositionUpdate?: any;
+    selectionLayerUpdate?: ((...args: any[]) => void) | undefined;
+    caretPositionUpdate?: ((...args: any[]) => void) | undefined;
     doNotWrapOrigin: any;
-}): any;
+}): void;
 export function editorDragged({ nearestCaretPos, doNotWrapOrigin, caretPosition, easyStore, caretPositionUpdate, selectionLayerUpdate, selectionLayer, sequenceLength }: {
     nearestCaretPos: any;
     doNotWrapOrigin: any;
     caretPosition?: number | undefined;
     easyStore: any;
-    caretPositionUpdate?: any;
-    selectionLayerUpdate?: any;
+    caretPositionUpdate?: ((...args: any[]) => void) | undefined;
+    selectionLayerUpdate?: ((...args: any[]) => void) | undefined;
     selectionLayer?: {
         start: number;
         end: number;