@sjcrh/proteinpaint-client 2.166.0 → 2.167.1

package/dist/chunk-DDOM4XYV.js

@@ -0,0 +1,1177 @@
+// rx/src/utils.ts
+function deepEqual(x, y, matched) {
+  if (x === y) {
+    return true;
+  } else if (typeof x == "object" && x != null && typeof y == "object" && y != null) {
+    if (matched?.get(x)?.has(y)) return true;
+    const xEntries = Object.entries(x);
+    const yKeys = Object.keys(y);
+    if (xEntries.length != yKeys.length) return false;
+    if (!xEntries.length && x.constructor.name !== y.constructor.name) return false;
+    for (const [key, val] of xEntries) {
+      if (!yKeys.includes(key)) return false;
+      if (!deepEqual(val, y[key], matched)) return false;
+    }
+    if (matched) {
+      Object.freeze(y);
+      if (!matched.has(x)) matched.set(x, /* @__PURE__ */ new WeakSet());
+      matched.get(x).add(y);
+    }
+    return true;
+  } else return false;
+}
+function deepFreeze(obj) {
+  Object.freeze(obj);
+  for (const value of Object.values(obj)) {
+    if (value !== null && typeof value == "object") deepFreeze(value);
+  }
+  return obj;
+}
+function deepCopyFreeze(input, ref = {}, matched = /* @__PURE__ */ new Map()) {
+  if (input === null || typeof input != "object") return input;
+  if (input.constructor.name !== "Object" && input.constructor.name !== "Array") {
+    if (!matched.has(input)) matched.set(input, /* @__PURE__ */ new WeakSet());
+    matched.get(input).add(input);
+    return deepFreeze(input);
+  }
+  if (deepEqual(input, ref, matched)) return ref;
+  const copy = Array.isArray(input) ? [] : {};
+  for (const [key, value] of Object.entries(input)) {
+    copy[key] = deepCopyFreeze(value, ref[key], matched);
+  }
+  return Object.freeze(copy);
+}
+async function notifyComponents(components, current) {
+  if (!components) return;
+  const called = [];
+  for (const name of Object.keys(components)) {
+    const component = components[name];
+    if (Array.isArray(component)) {
+      for (const c of component) called.push(c.update(current));
+    } else if (typeof component == "object") {
+      if (typeof component.update == "function") {
+        called.push(component.update(current));
+      } else if (!component.main) {
+        for (const subname of Object.keys(component)) {
+          if (typeof component[subname] == "object" && typeof component[subname]?.update == "function") {
+            called.push(component[subname].update(current));
+          }
+        }
+      }
+    }
+  }
+  return Promise.all(called);
+}
+function copyMerge(base, ...args) {
+  const target = typeof base == "string" ? fromJson(base) : base;
+  for (const arg of args) {
+    if (!arg) continue;
+    const source = typeof base == "string" ? fromJson(toJson(arg)) : arg;
+    for (const [key, value] of Object.entries(source)) {
+      if (!target[key] || Array.isArray(target[key]) || typeof target[key] !== "object" || source === null || source === void 0 || source.isAtomic || target?.isAtomic || target[key]?.isAtomic) {
+        target[key] = value;
+      } else copyMerge(target[key], value);
+    }
+  }
+  return target;
+}
+function fromJson(objStr) {
+  return JSON.parse(objStr);
+}
+function toJson(obj = null) {
+  return JSON.stringify(obj ? obj : this.state);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getComponents(components, dotSepNames) {
+  if (!dotSepNames) return Object.assign({}, components);
+  const names = dotSepNames.split(".");
+  let component = components;
+  while (names.length) {
+    let name = names.shift();
+    if (Array.isArray(component)) name = Number(name);
+    if (!names.length) component = component[name];
+    else if (component[name] && component[name].components) component = component[name].components;
+    else if (component[name] && component[name].getComponents) component = component[name].getComponents();
+    else component = component[name];
+    if (!component) break;
+  }
+  return component;
+}
+
+// rx/src/Bus.ts
+var Bus = class {
+  constructor(api, eventTypes, callbacks) {
+    this.name = api.type + (api.id === void 0 || api.id === null ? "" : "#" + api.id);
+    this.eventTypes = eventTypes;
+    this.events = {};
+    this.defaultArg = api;
+    if (callbacks) {
+      for (const [eventType, callback] of Object.entries(callbacks)) {
+        this.on(eventType, callback);
+      }
+    }
+  }
+  on(eventType, callback, opts = {}) {
+    const type = eventType.split(".").shift();
+    if (!this.eventTypes.includes(type)) {
+      throw `Unknown bus event '${type}' for component ${this.name}`;
+    } else if (!callback) {
+      delete this.events[eventType];
+    } else if (typeof callback == "function") {
+      if (eventType in this.events && !eventType.includes(".")) {
+        console.log(`Warning: replacing ${this.name} ${eventType} callback - use event.name?`);
+      }
+      this.events[eventType] = opts.wait ? (arg) => setTimeout(() => callback(arg), opts.wait) : callback;
+    } else {
+      throw `invalid callback for ${this.name} eventType=${eventType}`;
+    }
+    return this;
+  }
+  emit(eventType, arg = null, wait = 0, error = null) {
+    setTimeout(() => {
+      for (const type of Object.keys(this.events)) {
+        if (eventType == "postRender" && type.startsWith("firstRender")) {
+          this.events[type](arg || this.defaultArg, error);
+          delete this.events[type];
+        }
+        if (type == eventType || type.startsWith(eventType + ".")) {
+          this.events[type](arg || this.defaultArg, error);
+          if (eventType == "postInit") delete this.events[type];
+        }
+      }
+    }, wait);
+    return this;
+  }
+  destroy() {
+    for (const key in this.events) {
+      delete this.events[key];
+    }
+  }
+};
+
+// rx/src/AppApi.ts
+var AppApi = class _AppApi {
+  constructor(opts, __Class__) {
+    this.type = "app";
+    // only in debugmode
+    this.#middlewares = [];
+    this.#componentsByType = {};
+    const self = new __Class__(opts);
+    self.opts = opts;
+    if (!self.id) self.id = opts.id || self.opts?.id;
+    if (!self.type) self.type = __Class__.type;
+    self.api = this;
+    this.#App = self;
+    this.id = self.id;
+    this.type = self.type || __Class__.type;
+    this.opts = opts;
+    if (self.debug || self.opts && self.opts.debug) this.Inner = self;
+    if (!self.eventTypes) self.eventTypes = ["preDispatch", "postInit", "postRender", "firstRender", "error"];
+    if (self.customEvents) self.eventTypes.push(...self.customEvents);
+    self.bus = new Bus(this, self.eventTypes, opts.callbacks);
+    this.#latestActionSequenceId = 0;
+  }
+  #App;
+  #middlewares;
+  #latestActionSequenceId;
+  #abortController;
+  #componentsByType;
+  static getInitFxn(__Class__) {
+    return async (opts) => {
+      const api = new _AppApi(opts, __Class__);
+      await api.init();
+      return api;
+    };
+  }
+  async init() {
+    if (this.#App.preApiFreeze) await this.#App.preApiFreeze(this);
+    await this.#App.init();
+    if (this.#App.bus) this.#App.bus.emit("postInit");
+  }
+  async dispatch(action) {
+    const self = this.#App;
+    self.bus.emit("preDispatch");
+    if (this.#abortController) {
+      this.#abortController.abort("stale sequenceId");
+      this.#abortController = void 0;
+    }
+    try {
+      if (this.#middlewares.length) {
+        for (const fxn of this.#middlewares.slice()) {
+          const result = await fxn(action);
+          if (result) {
+            if (result.cancel) return;
+            if (result.error) throw result.error;
+            if (result.deactivate) {
+              this.#middlewares.splice(this.#middlewares.indexOf(fxn), 1);
+            }
+          }
+        }
+      }
+      if (action) self.state = await self.store.write(action);
+      this.#latestActionSequenceId = action?.sequenceId;
+      if (self.main) await self.main();
+      const current = { action, appState: self.state };
+      await notifyComponents(current.action?._notificationRoot_ || self.components, current);
+    } catch (e) {
+      if (self.wasDestroyed) return;
+      if (self.bus && this.#latestActionSequenceId == action?.sequenceId) self.bus.emit("error");
+      if (self.printError) self.printError(e);
+      else console.log(e);
+    }
+    if (self.bus && this.#latestActionSequenceId == action?.sequenceId) self.bus.emit("postRender");
+    this.#abortController = void 0;
+  }
+  // action: RxAction
+  async save(action) {
+    const self = this.#App;
+    if (self.wasDestroyed) return;
+    self.state = await self.store.write(action);
+    if (this.#componentsByType.recover) {
+      for (const id in this.#componentsByType.recover) {
+        const api = this.#componentsByType.recover[id];
+        if (api.replaceLastState) api.replaceLastState(self.state);
+      }
+    }
+  }
+  getState() {
+    return this.#App.state;
+  }
+  // fxn: RxAction => void
+  middle(fxn) {
+    if (typeof fxn !== "function") throw `a middleware must be a function`;
+    if (this.#middlewares.includes(fxn)) throw `the function is already in the #middlewares array`;
+    this.#middlewares.push(fxn);
+    return this;
+  }
+  // must not expose this.bus directly since that
+  // will also expose bus.emit() which should only
+  // be triggered by this component
+  on(eventType, callback) {
+    const self = this.#App;
+    if (!self.eventTypes) throw `no eventTypes[] for ${self.type} component`;
+    self.bus.on(eventType, callback);
+    return this;
+  }
+  getComponents(dotSepNames = "") {
+    return getComponents(this.#App.components, dotSepNames);
+  }
+  register(api) {
+    if (!this.#componentsByType[api.type]) this.#componentsByType[api.type] = {};
+    this.#componentsByType[api.type][api.id] = api;
+  }
+  deregister(api) {
+    if (this.#componentsByType[api.type]?.[api.id]) delete this.#componentsByType[api.type][api.id];
+  }
+  getAbortSignal() {
+    if (!this.#abortController) this.#abortController = new AbortController();
+    return this.#abortController?.signal;
+  }
+  triggerAbort(reason = "") {
+    const self = this.#App;
+    if (reason) {
+      if (reason) console.info(`triggerAbort()`, reason);
+    }
+    if (this.#abortController) {
+      this.#abortController.abort("stale sequenceId");
+      this.#abortController = void 0;
+    }
+    for (const name of Object.keys(self.components)) {
+      const component = self.components[name];
+      if (!component) continue;
+      if (Array.isArray(component)) {
+        for (const c of component) c.triggerAbort();
+      } else if (typeof component == "object") {
+        if (Object.keys(component).includes("triggerAbort")) {
+          component.triggerAbort();
+        } else if (!component.main) {
+          for (const subname of Object.keys(component)) {
+            if (typeof component[subname].triggerAbort == "function") {
+              component[subname].triggerAbort();
+            }
+          }
+        }
+      }
+    }
+  }
+  getSequenceId() {
+    return this.#latestActionSequenceId;
+  }
+  isStaleSequenceId(sequenceId2) {
+    return sequenceId2 != this.#latestActionSequenceId;
+  }
+  isAbortError(e) {
+    if (e instanceof DOMException) return e.name === "AbortError";
+    if (typeof e == "string") return e.includes("stale sequenceId") || e.includes("AbortError");
+    return false;
+  }
+  destroy() {
+    const self = this.#App;
+    for (const key in self.components) {
+      const component = self.components[key];
+      if (typeof component.destroy == "function") {
+        component.destroy();
+      } else if (component.holder) {
+        component.holder.selectAll("*").remove();
+      }
+      delete self.components[key];
+    }
+    if (typeof self.destroy == "function") self.destroy();
+    if (self.dom) {
+      if (self.dom.holder) self.dom.holder.selectAll("*").remove();
+      for (const key in self.dom) {
+        delete self.dom[key];
+      }
+    }
+    if (self.bus) self.bus.destroy();
+    delete self.store;
+    if (self.api) delete self.api;
+    self.wasDestroyed = true;
+  }
+  printError(e) {
+    if (this.#App.printError) this.#App.printError(e);
+    else alert(e);
+  }
+};
+
+// rx/src/StoreApi.ts
+var StoreApi = class _StoreApi {
+  #Store;
+  // only in debugmode
+  #frozenStateCopy = Object.freeze({});
+  static getInitFxn(__Class__) {
+    return async (opts) => {
+      const api = new _StoreApi(opts, __Class__);
+      await api.init();
+      return api;
+    };
+  }
+  constructor(_opts, __Class__) {
+    const opts = this.#validateOpts(_opts, __Class__);
+    const self = new __Class__(opts, this);
+    if (!self.id) self.id = opts.id || self.opts?.id;
+    if (!self.type) self.type = __Class__.type;
+    self.api = this;
+    this.#Store = self;
+    this.id = self.id;
+    this.type = self.type || __Class__.type;
+    if (self.debug || self.opts?.debug) this.Inner = self;
+  }
+  #validateOpts(opts, __Class__) {
+    const optKeys = Object.keys(opts);
+    if (!optKeys.includes("app")) throw `missing opts.app`;
+    if (!optKeys.includes("debug")) opts.debug = opts.app.debug ?? opts.app.opts?.debug ?? false;
+    return opts;
+  }
+  async init() {
+    if (this.#Store.init) await this.#Store.init();
+    if (this.#Store.validateState) this.#Store.validateState();
+    Object.freeze(this);
+  }
+  async write(action) {
+    const self = this.#Store;
+    action.sequenceId = this.#Store.sequenceId++;
+    const actions = self.constructor.prototype.actions;
+    if (!actions) {
+      throw `no store actions specified`;
+    }
+    if (!Object.keys(actions).includes(action.type)) {
+      throw `Action=${action.type} must be declared in an "actions" property of a class.`;
+    }
+    if (typeof actions[action.type] !== "function") {
+      throw `invalid action type=${action.type}`;
+    }
+    await actions[action.type].call(self, action);
+    self.state._scope_ = action._scope_;
+    if (!self.opts.debounceInterval) return this.copyState();
+    self.numPromisedWrites += 1;
+    let decrement = -1;
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        self.numPromisedWrites += decrement;
+        decrement = 0;
+        if (self.numPromisedWrites > 0) return;
+        clearInterval(interval);
+        resolve(this.copyState());
+      }, self.opts.debounceInterval);
+    });
+  }
+  async copyState() {
+    this.#frozenStateCopy = deepCopyFreeze(this.#Store.state, this.#frozenStateCopy);
+    return this.#frozenStateCopy;
+  }
+};
+
+// rx/src/ComponentApi.ts
+var ComponentApi = class _ComponentApi {
+  #Component;
+  // only in debugmode
+  #latestActionSequenceId;
+  #abortController;
+  #abortControllers;
+  // TODO: may use #incompleteUpdate property, if the shared app abortController signal is used
+  // #incompleteUpdate: boolean = true
+  #bus;
+  static getInitFxn(__Class__) {
+    return async (opts) => {
+      const api = new _ComponentApi(opts, __Class__);
+      await api.init();
+      return api;
+    };
+  }
+  constructor(_opts, __Class__) {
+    const opts = this.#validateOpts(_opts, __Class__);
+    const self = new __Class__(opts, this);
+    self.opts = opts;
+    if (!self.id) self.id = opts.id || self.opts?.id;
+    if (!self.type) self.type = __Class__.type;
+    self.app = opts.app;
+    self.api = this;
+    this.#Component = self;
+    this.id = self.id;
+    this.type = self.type || __Class__.type;
+    if (self.debug || self.opts && self.opts.debug) this.Inner = self;
+    if (!self.eventTypes) self.eventTypes = ["preDispatch", "postInit", "postRender", "firstRender", "error"];
+    if (self.customEvents) self.eventTypes.push(...self.customEvents);
+    self.bus = new Bus(this, self.eventTypes, opts.callbacks);
+    this.#latestActionSequenceId = 0;
+    this.#abortControllers = /* @__PURE__ */ new Set();
+  }
+  #validateOpts(opts, __Class__) {
+    const optKeys = Object.keys(opts);
+    if (!optKeys.includes("app")) throw `missing opts.app`;
+    if (!optKeys.includes("debug")) opts.debug = opts.app.debug ?? opts.app.opts?.debug ?? false;
+    if (__Class__.type && opts.app.opts?.[__Class__.type]) {
+      copyMerge(opts, opts.app.opts[__Class__.type]);
+    }
+    return opts;
+  }
+  async init() {
+    const self = this.#Component;
+    if (self.preApiFreeze) await self.preApiFreeze(this);
+    Object.freeze(this);
+    if (self.init) await self.init(this.#Component.app.getState());
+    if (self.state && !self.hasStatePreMain) {
+      delete self.state;
+      console.warn(
+        `${self.type}: rx deleted this.state after init()to avoid confusing behavior, such as the component not rendering initially because this.state would not have changed between init() and the first time main() is called. To skip this warning and retain this.state after init(), set this.hasStatePreMain = true in the ${self.type} constructor.`
+      );
+    }
+  }
+  // current: {action: RxAction, appState}
+  async update(current) {
+    const self = this.#Component;
+    if (
+      /*!this.#incompleteUpdate &&*/
+      current.action && self.reactsTo && !self.reactsTo(current.action)
+    ) return;
+    const componentState = self.getState ? self.getState(current.appState) : current.appState;
+    if (!componentState) return;
+    if (!current.action || !deepEqual(componentState, self.state)) {
+      if (current.action) this.#latestActionSequenceId = current.action.sequenceId;
+      if (this.#abortController) {
+        this.#abortController.abort("stale sequenceId");
+        this.#abortController = void 0;
+      }
+      if (self.mainArg == "state") {
+        try {
+          await self.main(componentState);
+          this.#abortController = void 0;
+        } catch (e) {
+          this.#abortController = void 0;
+          throw e;
+        }
+      } else {
+        self.state = componentState;
+        if (self.main) {
+          try {
+            await self.main();
+            this.#abortController = void 0;
+          } catch (e) {
+            this.#abortController = void 0;
+            if (self.app.isAbortError(e)) return;
+            if (self.bus) self.bus.emit("error");
+            throw e;
+          }
+        }
+      }
+    }
+    try {
+      await notifyComponents(self.components, current);
+      if (self.bus && (!current.action || current.action.sequenceId === this.#latestActionSequenceId))
+        self.bus.emit("postRender");
+      return this;
+    } catch (e) {
+      if (self.printError) self.printError(e);
+      else if (self.dom?.errdiv) throw { message: e.message || e.error || e, errdiv: self.dom?.errdiv };
+      else throw e;
+    }
+  }
+  getComponents(dotSepNames = "") {
+    return getComponents(this.#Component.components, dotSepNames);
+  }
+  // must not expose self.bus directly since that
+  // will also expose bus.emit() which should only
+  // be triggered by this component
+  on(eventType, callback) {
+    const self = this.#Component;
+    if (!self.eventTypes) throw `no eventTypes[] for ${self.type} component`;
+    self.bus.on(eventType, callback);
+    return this;
+  }
+  // getComponents(dotSepNames = '') {
+  // 	return getComponents(self.components, dotSepNames)
+  // }
+  //
+  // When an async function takes a while to resolve, such as for server requests,
+  // a subsequent action may trigger another request before the first one resolves,
+  // in that case should ignore the stale response/result from the async function.
+  // This is an api function so that code that has access to this component api
+  // can also tie-in a function call to the fresheness of the component action.
+  //
+  async detectStale(asyncFxn, opts = {}) {
+    const abortControllers = this.#abortControllers;
+    try {
+      const actionSequenceId = this.#latestActionSequenceId;
+      const promises = [];
+      let i, promResolve;
+      if (opts.abortCtrl) {
+        abortControllers.add(opts.abortCtrl);
+        promises.push(
+          new Promise((resolve, reject) => {
+            promResolve = resolve;
+            i = setInterval(() => {
+              if (actionSequenceId !== this.#latestActionSequenceId) {
+                clearInterval(i);
+                try {
+                  opts.abortCtrl?.abort();
+                  throw `stale sequenceId`;
+                } catch (e) {
+                  reject(e);
+                }
+              }
+            }, opts.wait || 100);
+          })
+        );
+      }
+      promises.push(asyncFxn());
+      const result = await Promise.race(promises);
+      if (i) clearInterval(i);
+      if (promResolve) promResolve();
+      if (opts.abortCtrl && abortControllers.has(opts.abortCtrl)) abortControllers.delete(opts.abortCtrl);
+      if (this.#latestActionSequenceId !== actionSequenceId) {
+        console.warn("aborted state update, the returned data corresponds to a stale action.sequenceId");
+        if (opts.abortCtrl) opts.abortCtrl.abort();
+        return [result, true];
+      }
+      return [result];
+    } catch (e) {
+      if (typeof e == "string" && e.includes("sequenceId")) console.warn(e);
+      throw e;
+    }
+  }
+  getAbortSignal() {
+    if (!this.#abortController) this.#abortController = new AbortController();
+    return this.#abortController?.signal;
+  }
+  triggerAbort(reason = "") {
+    if (reason) console.info(`triggerAbort()`, reason);
+    if (this.#abortController) {
+      this.#abortController.abort("stale sequenceId");
+      this.#abortController = void 0;
+    }
+    for (const c of this.#abortControllers.values()) {
+      try {
+        c.abort();
+        this.#abortControllers.delete(c);
+      } catch (e) {
+        console.warn("unable to cancel fetch: ", e);
+        this.#abortControllers.delete(c);
+      }
+    }
+    const self = this.#Component;
+    if (!self.components) return;
+    for (const name of Object.keys(self.components)) {
+      const component = self.components[name];
+      if (Array.isArray(component)) {
+        for (const c of component) c.triggerAbort();
+      } else if (Object.keys(component).includes("triggerAbort")) {
+        component.triggerAbort();
+      } else if (component && typeof component == "object" && !component.main) {
+        for (const subname of Object.keys(component)) {
+          if (typeof component[subname].triggerAbort == "function") {
+            component[subname].triggerAbort();
+          }
+        }
+      }
+    }
+  }
+  getSequenceId() {
+    return this.#latestActionSequenceId;
+  }
+  isStaleSequenceId(sequenceId2) {
+    return sequenceId2 != this.#latestActionSequenceId;
+  }
+  destroy() {
+    const self = this.#Component;
+    self.app.deregister(self.api);
+    for (const key in self.components) {
+      const component = self.components[key];
+      if (typeof component.destroy == "function") {
+        component.destroy();
+      } else if (component.holder) {
+        component.holder.selectAll("*").remove();
+      }
+      delete self.components[key];
+    }
+    if (typeof self.destroy == "function") self.destroy();
+    if (self.dom) {
+      if (self.dom.holder) self.dom.holder.selectAll("*").remove();
+      for (const key in self.dom) {
+        if (typeof self.dom[key]?.remove == "function") self.dom[key].remove();
+        delete self.dom[key];
+      }
+    }
+    if (self.bus) self.bus.destroy();
+    if (self.api) delete self.api;
+  }
+  // defaults for optional preApiFreeze addons
+  replaceLastState(_) {
+  }
+  getChartImages() {
+    return this.#Component.getChartImages ? this.#Component.getChartImages() : null;
+  }
+};
+
+// rx/src/legacy.ts
+function getInitFxn(_Class_) {
+  return (opts) => {
+    const self = new _Class_(opts);
+    if (!self.api && self.type) {
+      if (self.type == "app") prepApp(self, opts);
+      else if (self.type == "store") prepStore(self, opts);
+      else prepComponent(self, opts);
+    }
+    const api = self.api || self;
+    if (self.debug || self.opts && self.opts.debug) api.Inner = self;
+    if (typeof self.preApiFreeze == "function") self.preApiFreeze(api);
+    Object.freeze(api);
+    if (self.init) {
+      return self.init().then(() => {
+        if (self.bus) self.bus.emit("postInit");
+        return api;
+      }).catch((e) => {
+        if (self.printError) self.printError(e);
+        if (self.bus) self.bus.emit("postInit", null, 0, e);
+        else throw e;
+      });
+    } else {
+      if (self.bus) self.bus.emit("postInit");
+      return api;
+    }
+  };
+}
+function getAppInit(_Class_) {
+  if (_Class_.type) return AppApi.getInitFxn(_Class_);
+  return getInitPrepFxn(_Class_, prepApp);
+}
+function getStoreInit(_Class_) {
+  if (_Class_.type) return StoreApi.getInitFxn(_Class_);
+  return getInitPrepFxn(_Class_, prepStore);
+}
+function getCompInit(_Class_) {
+  if (_Class_.type) return ComponentApi.getInitFxn(_Class_);
+  return getInitPrepFxn(_Class_, prepComponent);
+}
+function getInitPrepFxn(_Class_, prepFxn) {
+  if (typeof prepFxn != "function") throw "prepFxn must be a function";
+  return async (opts) => {
+    let self;
+    try {
+      if (opts.app?.opts && "debug" in opts.app.opts && !("debug" in opts) && opts != opts.app.opts) {
+        opts.debug = opts.app.opts.debug;
+      }
+      self = new _Class_(opts);
+      prepFxn(self, opts);
+      const api = self.api || self;
+      if (self.debug || self.opts && self.opts.debug) api.Inner = self;
+      if (self.preApiFreeze) await self.preApiFreeze(api);
+      Object.freeze(api);
+      if (self.init) {
+        if (self.app && self.app != self) await self.init(self.app.getState());
+        else await self.init();
+        if (self.type != "app" && self.type != "store" && self.state && !self.hasStatePreMain) {
+          delete self.state;
+          console.warn(
+            `${self.type}: rx deleted this.state after init()to avoid confusing behavior, such as the component not rendering initially because this.state would not have changed between init() and the first time main() is called. To skip this warning and retain this.state after init(), set this.hasStatePreMain = true in the ${self.type} constructor.`
+          );
+        }
+      }
+      if (self.bus) self.bus.emit("postInit");
+      return api;
+    } catch (error) {
+      console.log("error:", error);
+      if (self?.bus) self.bus.emit("postInit", null, 0, error);
+      if (!self?.printError) throw error;
+    }
+  };
+}
+function getOpts(_opts, instance) {
+  const opts = Object.assign({}, instance.opts || {}, _opts);
+  if (!instance.app) return opts;
+  if (instance.type in instance.app.opts) {
+    const overrides = instance.app.opts[instance.type];
+    if (instance.validateOpts) instance.validateOpts(overrides);
+    copyMerge(opts, overrides);
+  }
+  if ("debug" in instance.app) opts.debug = instance.app.debug;
+  else if (instance.app.opts && "debug" in instance.app.opts) opts.debug = instance.app.opts.debug;
+  return opts;
+}
+async function multiInit(initPromises) {
+  const components = {};
+  await Promise.all(Object.values(initPromises));
+  for (const name in initPromises) {
+    components[name] = await initPromises[name];
+  }
+  return components;
+}
+function prepStore(self, opts) {
+  if (self.validateOpts) self.validateOpts(opts);
+  self.app = opts.app;
+  self.opts = getOpts(opts, self);
+  self.api = getStoreApi(self);
+  self.copyMerge = copyMerge;
+  self.deepFreeze = deepFreeze;
+  if (!self.fromJson) self.fromJson = fromJson;
+  if (!self.toJson) self.toJson = toJson;
+  self.state = copyMerge(self.toJson(self.defaultState), opts.state);
+  if (self.validateState) self.validateState();
+}
+var sequenceId = 0;
+function getStoreApi(self) {
+  self.history = [];
+  self.currIndex = -1;
+  let numPromisedWrites = 0;
+  const api = {
+    // action: RxAction
+    async write(action) {
+      action.sequenceId = sequenceId++;
+      const actions = self.constructor.prototype.actions;
+      if (!actions) {
+        throw `no store actions specified`;
+      }
+      if (!Object.keys(actions).includes(action.type)) {
+        throw `Action=${action.type} must be declared in an "actions" property of a class.`;
+      }
+      if (typeof actions[action.type] !== "function") {
+        throw `invalid action type=${action.type}`;
+      }
+      await actions[action.type].call(self, action);
+      self.state._scope_ = action._scope_;
+      if (!self.opts.debounceInterval) return api.copyState();
+      numPromisedWrites += 1;
+      let decrement = -1;
+      return new Promise((resolve) => {
+        const interval = setInterval(() => {
+          numPromisedWrites += decrement;
+          decrement = 0;
+          if (numPromisedWrites > 0) return;
+          clearInterval(interval);
+          resolve(api.copyState());
+        }, self.opts.debounceInterval);
+      });
+    },
+    async copyState() {
+      const stateCopy = self.fromJson(self.toJson(self.state));
+      self.deepFreeze(stateCopy);
+      return stateCopy;
+    }
+  };
+  return api;
+}
+function prepApp(self, opts) {
+  try {
+    if (self.validateOpts) self.validateOpts(opts);
+    if ("id" in opts) self.id = opts[self.type].id;
+    self.opts = opts;
+    self.api = getAppApi(self);
+  } catch (e) {
+    console.error(e);
+    if (self.printError) self.printError(e);
+    else alert(e);
+  }
+}
+function getAppApi(self) {
+  const componentsByType = {};
+  const middlewares = [];
+  let latestActionSequenceId;
+  const api = {
+    type: self.type,
+    opts: self.opts,
+    // action: RxAction
+    async dispatch(action) {
+      self.bus.emit("preDispatch");
+      try {
+        if (middlewares.length) {
+          for (const fxn of middlewares.slice()) {
+            const result = await fxn(action);
+            if (result) {
+              if (result.cancel) return;
+              if (result.error) throw result.error;
+              if (result.deactivate) {
+                middlewares.splice(middlewares.indexOf(fxn), 1);
+              }
+            }
+          }
+        }
+        if (action) self.state = await self.store.write(action);
+        latestActionSequenceId = action?.sequenceId;
+        if (self.main) await self.main();
+        const current = { action, appState: self.state };
+        await notifyComponents(current.action?._notificationRoot_ || self.components, current);
+      } catch (e) {
+        if (self.wasDestroyed) return;
+        if (self.bus && latestActionSequenceId == action?.sequenceId) self.bus.emit("error");
+        if (self.printError) self.printError(e);
+        else console.log(e);
+      }
+      if (self.bus && latestActionSequenceId == action?.sequenceId) self.bus.emit("postRender");
+    },
+    // action: RxAction
+    async save(action) {
+      self.state = await self.store.write(action);
+      if (componentsByType.recover) {
+        for (const id in componentsByType.recover) {
+          const api2 = componentsByType.recover[id];
+          api2.replaceLastState(self.state);
+        }
+      }
+    },
+    getState() {
+      return self.state;
+    },
+    // fxn: RxAction => void
+    middle(fxn) {
+      if (typeof fxn !== "function") throw `a middleware must be a function`;
+      if (middlewares.includes(fxn)) throw `the function is already in the middlewares array`;
+      middlewares.push(fxn);
+      return api;
+    },
+    // must not expose this.bus directly since that
+    // will also expose bus.emit() which should only
+    // be triggered by this component
+    on(eventType, callback) {
+      if (!self.eventTypes) throw `no eventTypes[] for ${self.type} component`;
+      self.bus.on(eventType, callback);
+      return api;
+    },
+    getComponents(dotSepNames = "") {
+      return getComponents(self.components, dotSepNames);
+    },
+    register(api2) {
+      if (!componentsByType[api2.type]) componentsByType[api2.type] = {};
+      componentsByType[api2.type][api2.id] = api2;
+    },
+    deregister(api2) {
+      if (componentsByType[api2.type]?.[api2.id]) delete componentsByType[api2.type][api2.id];
+    },
+    triggerAbort(reason = "") {
+      if (reason) {
+        if (reason) console.info(`triggerAbort()`, reason);
+      }
+      for (const name of Object.keys(self.components)) {
+        const component = self.components[name];
+        if (!component) continue;
+        if (Array.isArray(component)) {
+          for (const c of component) c.triggerAbort();
+        } else if (typeof component == "object") {
+          if (Object.keys(component).includes("triggerAbort")) {
+            component.triggerAbort();
+          } else if (!component.main) {
+            for (const subname of Object.keys(component)) {
+              if (typeof component[subname].triggerAbort == "function") {
+                component[subname].triggerAbort();
+              }
+            }
+          }
+        }
+      }
+    },
+    destroy() {
+      for (const key in self.components) {
+        const component = self.components[key];
+        if (typeof component.destroy == "function") {
+          component.destroy();
+        } else if (component.holder) {
+          component.holder.selectAll("*").remove();
+        }
+        delete self.components[key];
+      }
+      if (typeof self.destroy == "function") self.destroy();
+      if (self.dom) {
+        if (self.dom.holder) self.dom.holder.selectAll("*").remove();
+        for (const key in self.dom) {
+          delete self.dom[key];
+        }
+      }
+      if (self.bus) self.bus.destroy();
+      delete self.store;
+      if (self.api) delete self.api;
+      self.wasDestroyed = true;
+    }
+  };
+  if (!self.bus) {
+    if (!self.eventTypes) self.eventTypes = ["preDispatch", "postInit", "postRender", "firstRender", "error"];
+    if (self.customEvents) self.eventTypes.push(...self.customEvents);
+    const callbacks = self.opts.app && self.opts.app.callbacks || self.opts.callbacks || {};
+    self.bus = new Bus(api, self.eventTypes, callbacks);
+  }
+  return api;
+}
+function prepComponent(self, opts) {
+  if (!opts.app) throw `missing self.opts.app in prepComponent(${self.type})`;
+  self.app = opts.app;
+  self.opts = getOpts(opts, self);
+  if (self.validateOpts) self.validateOpts(opts);
+  if ("id" in opts) self.id = self.opts.id;
+  self.api = getComponentApi(self);
+}
+function getComponentApi(self) {
+  if (!("type" in self)) {
+    throw `The component's type must be set before calling this.getComponentApi(this).`;
+  }
+  const abortControllers = /* @__PURE__ */ new Set();
+  let latestActionSequenceId, abortController;
+  const api = {
+    type: self.type,
+    id: self.id,
+    // current: {action: RxAction, appState}
+    async update(current) {
+      if (current.action && self.reactsTo && !self.reactsTo(current.action)) return;
+      const componentState = self.getState ? self.getState(current.appState) : current.appState;
+      if (!componentState) return;
+      if (!current.action || !deepEqual(componentState, self.state)) {
+        if (current.action) latestActionSequenceId = current.action.sequenceId;
+        if (abortController) abortController.abort();
+        if (self.mainArg == "state") {
+          await self.main(componentState);
+        } else {
+          self.state = componentState;
+          if (self.main) {
+            try {
+              await self.main();
+            } catch (e) {
+              if (self.bus) self.bus.emit("error");
+              throw e;
+            }
+          }
+        }
+        abortController = void 0;
+      }
+      try {
+        await notifyComponents(self.components, current);
+        if (self.bus && (!current.action || current.action.sequenceId === latestActionSequenceId))
+          self.bus.emit("postRender");
+        return api;
+      } catch (e) {
+        if (self.printError) self.printError(e);
+        else if (self.dom?.errdiv) throw { message: e.message || e.error || e, errdiv: self.dom?.errdiv };
+        else throw e;
+      }
+    },
+    // must not expose self.bus directly since that
+    // will also expose bus.emit() which should only
+    // be triggered by this component
+    on(eventType, callback) {
+      if (!self.eventTypes) throw `no eventTypes[] for ${self.type} component`;
+      self.bus.on(eventType, callback);
+      return api;
+    },
+    getComponents(dotSepNames = "") {
+      return getComponents(self.components, dotSepNames);
+    },
+    //
+    // When an async function takes a while to resolve, such as for server requests,
+    // a subsequent action may trigger another request before the first one resolves,
+    // in that case should ignore the stale response/result from the async function.
+    // This is an api function so that code that has access to this component api
+    // can also tie-in a function call to the fresheness of the component action.
+    //
+    async detectStale(asyncFxn, opts = {}) {
+      try {
+        const actionSequenceId = latestActionSequenceId;
+        const promises = [];
+        let i, promResolve;
+        if (opts.abortCtrl) {
+          abortControllers.add(opts.abortCtrl);
+          promises.push(
+            new Promise((resolve, reject) => {
+              promResolve = resolve;
+              i = setInterval(() => {
+                if (actionSequenceId !== latestActionSequenceId) {
+                  clearInterval(i);
+                  try {
+                    opts.abortCtrl?.abort();
+                    throw `stale sequenceId`;
+                  } catch (e) {
+                    reject(e);
+                  }
+                }
+              }, opts.wait || 100);
+            })
+          );
+        }
+        promises.push(asyncFxn());
+        const result = await Promise.race(promises);
+        if (i) clearInterval(i);
+        if (promResolve) promResolve();
+        if (opts.abortCtrl && abortControllers.has(opts.abortCtrl)) abortControllers.delete(opts.abortCtrl);
+        if (latestActionSequenceId !== actionSequenceId) {
+          console.warn("aborted state update, the returned data corresponds to a stale action.sequenceId");
+          if (opts.abortCtrl) opts.abortCtrl.abort();
+          return [result, true];
+        }
+        return [result];
+      } catch (e) {
+        if (typeof e == "string" && e.includes("sequenceId")) console.warn(e);
+        throw e;
+      }
+    },
+    getAbortSignal() {
+      if (!abortController) abortController = new AbortController();
+      return abortController?.signal;
+    },
+    triggerAbort(reason = "") {
+      if (reason) console.info(`triggerAbort()`, reason);
+      for (const c of abortControllers.values()) {
+        try {
+          c.abort();
+          abortControllers.delete(c);
+        } catch (e) {
+          console.warn("unable to cancel fetch: ", e);
+          abortControllers.delete(c);
+        }
+      }
+      if (!self.components) return;
+      for (const name of Object.keys(self.components)) {
+        const component = self.components[name];
+        if (Array.isArray(component)) {
+          for (const c of component) c.triggerAbort();
+        } else if (Object.keys(component).includes("triggerAbort")) {
+          component.triggerAbort();
+        } else if (component && typeof component == "object" && !component.main) {
+          for (const subname of Object.keys(component)) {
+            if (typeof component[subname].triggerAbort == "function") {
+              component[subname].triggerAbort();
+            }
+          }
+        }
+      }
+    },
+    getSequenceId() {
+      return latestActionSequenceId;
+    },
+    isStaleSequenceId(sequenceId2) {
+      return sequenceId2 != latestActionSequenceId;
+    },
+    destroy() {
+      self.app.deregister(self.api);
+      for (const key in self.components) {
+        const component = self.components[key];
+        if (typeof component.destroy == "function") {
+          component.destroy();
+        } else if (component.holder) {
+          component.holder.selectAll("*").remove();
+        }
+        delete self.components[key];
+      }
+      if (typeof self.destroy == "function") self.destroy();
+      if (self.dom) {
+        if (self.dom.holder) self.dom.holder.selectAll("*").remove();
+        for (const key in self.dom) {
+          if (typeof self.dom[key]?.remove == "function") self.dom[key].remove();
+          delete self.dom[key];
+        }
+      }
+      if (self.bus) self.bus.destroy();
+      if (self.api) delete self.api;
+    }
+  };
+  if (!self.bus) {
+    if (!self.eventTypes) self.eventTypes = ["postInit", "postRender", "postPrintError", "firstRender", "error"];
+    if (self.customEvents) self.eventTypes.push(...self.customEvents);
+    self.bus = new Bus(api, self.eventTypes, self.opts && self.opts.callbacks || {});
+  }
+  return api;
+}
+
+// rx/src/StoreBase.ts
+var StoreBase = class {
+  constructor(opts) {
+    this.type = "store";
+    // dom: any
+    // config: any
+    /** use for assigning unique IDs where needed
+     * may be used later to simplify getting component state by type and id */
+    this.prevGeneratedId = 0;
+    // the action.sequenceId can be used by a chart/app
+    // to identify the state that corresponds to an async step
+    // like a server data request, so that a really late-arriving data
+    // can be rejected if the state that was associated with that requested
+    // is already stale/superseded by a subsequent state update
+    this.sequenceId = 0;
+    this.numPromisedWrites = 0;
+    this.opts = this.validateOpts(opts);
+    this.app = this.opts.app;
+    this.id = opts.id;
+  }
+  validateOpts(o = {}) {
+    return o;
+  }
+  fromJson(objStr) {
+    return JSON.parse(objStr);
+  }
+  toJson(obj = null) {
+    return JSON.stringify(obj ? obj : this.state);
+  }
+  deepFreeze(obj) {
+    Object.freeze(obj);
+    for (const value of Object.values(obj)) {
+      if (value !== null && typeof value == "object") this.deepFreeze(value);
+    }
+  }
+  copyMerge(base, ...args) {
+    const target = typeof base == "string" ? this.fromJson(base) : base;
+    for (const arg of args) {
+      if (arg) {
+        const source = typeof base == "string" ? this.fromJson(this.toJson(arg)) : arg;
+        for (const key in source) {
+          if (!target[key] || Array.isArray(target[key]) || typeof target[key] !== "object" || source === null || source === void 0 || source.isAtomic || target?.isAtomic || target[key]?.isAtomic)
+            target[key] = source[key];
+          else this.copyMerge(target[key], source[key]);
+        }
+      }
+    }
+    return target;
+  }
+};
+
+export {
+  Bus,
+  deepEqual,
+  deepFreeze,
+  copyMerge,
+  sleep,
+  AppApi,
+  StoreApi,
+  StoreBase,
+  getInitFxn,
+  getAppInit,
+  getStoreInit,
+  getCompInit,
+  multiInit
+};
+//# sourceMappingURL=chunk-DDOM4XYV.js.map