@kosdev-code/kos-freestyle-sdk 2.0.2

package/freestyle-registration-manager-pbtzJUqS.js

@@ -0,0 +1,765 @@
+var pe = Object.defineProperty;
+var he = (e, t, r) => t in e ? pe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var i = (e, t, r) => (he(e, typeof t != "symbol" ? t + "" : t, r), r);
+import { KosModelRegistry as ye, registerDispenseModels as fe, Nozzle as me, Assembly as be, Pump as _e, Holder as ve, PumpContainer as Pe, PumpIndex as Ae } from "@kosdev-code/kos-dispense-sdk";
+import { kosModel as f, KosModelRegistrationFactory as m, KosModelContainer as Ie, kosChild as $e, resolveServiceUrl as E, ServiceFactory as M, createPropKey as Oe, kosStateProp as Ee, kosFuture as Me, FutureHandler as Ce, kosEffect as Te, EventBus as K, SingletonKosModelRegistrationFactory as W, KosFeatureFlags as U, KosContextManager as we, KosLog as C, FutureManager as ze, kosParentAware as De, kosAutoEffect as Se, kosAction as Z, FetchError as Re, kosConfigProperty as p, KOS_MODEL_ID as y, getKosModelSync as A, RegistrationManager as g, registerCoreModels as Fe, Trouble as je, ExtensionManager as w, EXTENSION_TROUBLE_DATA_MAPPER as z } from "@kosdev-code/kos-ui-sdk";
+var Le = Object.defineProperty, Ne = Object.getOwnPropertyDescriptor, Be = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? Ne(t, r) : t, a = e.length - 1, n; a >= 0; a--)
+    (n = e[a]) && (s = (o ? n(t, r, s) : n(s)) || s);
+  return o && s && Le(t, r, s), s;
+};
+const Q = "carb-agitator-model";
+let S = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "name");
+    i(this, "path");
+    i(this, "logger");
+    this.id = e, this.name = t.name, this.path = t.path, this.logger = r.logger;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing carb-agitator ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading carb-agitator ${this.id}`);
+  }
+};
+S = Be([
+  f(Q)
+], S);
+const X = new m({
+  class: S,
+  type: Q
+});
+var xe = Object.defineProperty, Ge = Object.getOwnPropertyDescriptor, J = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? Ge(t, r) : t, a = e.length - 1, n; a >= 0; a--)
+    (n = e[a]) && (s = (o ? n(t, r, s) : n(s)) || s);
+  return o && s && xe(t, r, s), s;
+};
+const k = "cartridge-agitator-container-model";
+let I = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "_models");
+    this.id = e, this.logger = r.logger, this._models = new Ie({
+      parentId: e
+    });
+  }
+  getModel(e) {
+    return this._models.getModel(e);
+  }
+  get models() {
+    return this._models;
+  }
+  get data() {
+    return this._models.data;
+  }
+  addModel(e) {
+    this._models.addModel(e);
+  }
+  removeModel(e) {
+    this._models.removeModel(e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(
+      `initializing cartridge-agitator-container container ${this.id}`
+    );
+  }
+  async load() {
+    this.logger.debug(
+      `loading cartridge-agitator-container container ${this.id}`
+    );
+  }
+};
+J([
+  $e
+], I.prototype, "_models", 2);
+I = J([
+  f(k)
+], I);
+const { URL: ee } = E("CARTRIDGE_AGITATOR_SERVICE"), { postModel: Ke } = M.build({
+  basePath: `${ee}/api/ext/freestyle/freestyle/ice`
+}), Ue = async (e, t) => {
+  const r = await Ke({
+    model: {},
+    tracker: t,
+    urlOverride: `${ee}/api/handle/${e}/test`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r.data;
+};
+var He = Object.defineProperty, qe = Object.getOwnPropertyDescriptor, B = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? qe(t, r) : t, a = e.length - 1, n; a >= 0; a--)
+    (n = e[a]) && (s = (o ? n(t, r, s) : n(s)) || s);
+  return o && s && He(t, r, s), s;
+};
+const te = "cartridge-agitator-model";
+class $ {
+}
+i($, "TOPIC_AGITATION_STARTED", "/kos/events/ddk/agitation-started"), i($, "TOPIC_AGITATION_ENDED", "/kos/events/ddk/agitation-ended");
+const Ye = Oe("statePath");
+let _ = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "futureHandler");
+    i(this, "logger");
+    i(this, "disposer");
+    i(this, "agitating");
+    i(this, "path");
+    i(this, "statePath");
+    i(this, "name");
+    this.id = e, this.logger = r.logger, this.futureHandler = new Ce(this), this.path = t.path, this.name = t.name, this.statePath = t.statePath;
+  }
+  get isAgitating() {
+    return !!this.agitating.value;
+  }
+  get future() {
+    return this.futureHandler.future;
+  }
+  async testAgitate(e) {
+    if (!e)
+      throw new Error("No tracker provided");
+    return this.logger.info(`agitating cartridge-agitator ${this.id}`), Ue(this.path, e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing cartridge-agitator ${this.id}`);
+  }
+  unload() {
+    var e;
+    (e = this.disposer) == null || e.call(this);
+  }
+  async load() {
+    this.logger.debug(`loading cartridge-agitator ${this.id}`), this.disposer = Te(
+      () => this.isAgitating,
+      () => {
+        var e;
+        this.isAgitating ? (this.logger.info(`agitating cartridge-agitator ${this.id}`), K.publish($.TOPIC_AGITATION_STARTED, {
+          path: this.path,
+          futureId: (e = this.futureHandler.future) == null ? void 0 : e.futureId
+        })) : K.publish($.TOPIC_AGITATION_ENDED, {
+          path: this.path
+        });
+      },
+      {}
+    );
+  }
+};
+B([
+  Ee({ path: Ye, attribute: "agitating" })
+], _.prototype, "agitating", 2);
+B([
+  Me()
+], _.prototype, "testAgitate", 1);
+_ = B([
+  f(te)
+], _);
+const re = new m({
+  class: _,
+  type: te
+}), x = new W({
+  class: I,
+  type: k
+});
+x.addRelatedModel(re);
+var Ve = Object.defineProperty, We = Object.getOwnPropertyDescriptor, Ze = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? We(t, r) : t, a = e.length - 1, n; a >= 0; a--)
+    (n = e[a]) && (s = (o ? n(t, r, s) : n(s)) || s);
+  return o && s && Ve(t, r, s), s;
+};
+const se = "freestyle-assembly-model", Qe = "iceAgitator", Xe = "carbAgitator";
+let R = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "assembly");
+    this.id = e, this.logger = r.logger, this.assembly = t.companionParent;
+  }
+  get holderGroups() {
+    return this.assembly.holderGroups;
+  }
+  get nozzlePaths() {
+    return this.assembly.nozzlePaths;
+  }
+  get allHolders() {
+    return this.assembly.allHolders;
+  }
+  getHoldersByGroup(e) {
+    return this.assembly.getHoldersByGroup(e);
+  }
+  getHoldersByNozzle(e) {
+    return this.assembly.getHoldersByNozzle(e);
+  }
+  get pumpsByNozzle() {
+    return this.assembly.pumpsByNozzle;
+  }
+  get pumpPaths() {
+    return this.assembly.pumpPaths;
+  }
+  get boards() {
+    return this.assembly.boards;
+  }
+  updateModel(e) {
+    return this.assembly.updateModel(e);
+  }
+  get iceAgitator() {
+    return this.assembly.iceAgitator;
+  }
+  get carbAgitator() {
+    return this.assembly.carbAgitator;
+  }
+  get cartridgeAgitators() {
+    return this.assembly.cartridgeAgitators;
+  }
+  get defaultCartridgeAgitator() {
+    return this.assembly.cartridgeAgitators.data[0];
+  }
+  get cartridgeAgitatorModels() {
+    return this.assembly.cartridgeAgitators.data;
+  }
+  get hasCartridgeAgitators() {
+    return this.assembly.cartridgeAgitators.data.length > 0;
+  }
+  // -------------------LIFECYCLE----------------------------
+  get supportsIce() {
+    return U.isFeatureEnabled(Qe);
+  }
+  get supportsCarb() {
+    return U.isFeatureEnabled(Xe);
+  }
+  async init() {
+    this.logger.debug(`initializing freestyle-assembly ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading freestyle-assembly ${this.id}`);
+  }
+};
+R = Ze([
+  f(se)
+], R);
+const F = new W({
+  class: R,
+  type: se
+});
+var Je = Object.defineProperty, ke = Object.getOwnPropertyDescriptor, et = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? ke(t, r) : t, a = e.length - 1, n; a >= 0; a--)
+    (n = e[a]) && (s = (o ? n(t, r, s) : n(s)) || s);
+  return o && s && Je(t, r, s), s;
+};
+const oe = "freestyle-holder-model";
+function tt(e) {
+  const t = we.getContext(e), r = t == null ? void 0 : t.get(
+    F.type
+  );
+  if (!r) {
+    C.error("Freestyle assembly not found");
+    return;
+  }
+  return r;
+}
+async function rt(e, t) {
+  if (!e || !t)
+    return;
+  const r = await e[t]();
+  if (r != null && r.tracker)
+    return ze.getFuture(r.tracker);
+}
+let j = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "holder");
+    i(this, "future");
+    this.id = e, this.logger = r.logger, this.holder = t.companionParent;
+  }
+  get agitated() {
+    return this.holder.data.agitated;
+  }
+  async agitate() {
+    if (!this.holder.data.agitated)
+      return;
+    this.future = void 0;
+    const e = tt(this.id);
+    if (!e)
+      return;
+    if (!e.defaultCartridgeAgitator) {
+      this.logger.error("Agitator not found");
+      return;
+    }
+    return this.future = await rt(
+      e.defaultCartridgeAgitator,
+      "testAgitate"
+    ), this.future;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing freestyle-holder ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading freestyle-holder ${this.id}`);
+  }
+};
+j = et([
+  f(oe)
+], j);
+const H = new m({
+  class: j,
+  type: oe
+}), { URL: st } = E("FREESTYLE-NOZZLE_SERVICE"), { getOne: ot } = M.build({
+  basePath: `${st}/api/freestyle-nozzle`
+}), P = C.createLogger({
+  name: "freestyle-nozzle-service",
+  group: "Services"
+});
+class it extends Error {
+  constructor(t) {
+    super(t), this.name = "NutritionInfoError";
+  }
+}
+class q extends Error {
+  constructor(t) {
+    super(t), this.name = "InvalidRequestError";
+  }
+}
+const at = async (e, t, r, o = "http://localhost:8081") => {
+  if (P.debug("sending GET for freestyle-nozzle"), !t)
+    throw P.error("Invalid freestyle-nozzle request: beverageId is required"), new q("No beverageId provided");
+  if (!r || r.length === 0)
+    throw P.error("Invalid freestyle-nozzle request: volumes are required"), new q("No volumes provided");
+  const s = await ot({
+    urlOverride: `${o}${e}/pipeline/beverage/engine/nutrition/${t}?volumes=${r.join(
+      ","
+    )}`
+  });
+  if (!(s != null && s.data))
+    throw P.error("Failed to retrieve freestyle-nozzle data"), new Error("Failed to retrieve freestyle-nozzle data");
+  if (s.data.error)
+    throw new it(s.data.error);
+  return s.data;
+};
+var nt = Object.defineProperty, lt = Object.getOwnPropertyDescriptor, gt = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? lt(t, r) : t, a = e.length - 1, n; a >= 0; a--)
+    (n = e[a]) && (s = (o ? n(t, r, s) : n(s)) || s);
+  return o && s && nt(t, r, s), s;
+};
+const ie = "freestyle-nozzle-model";
+let L = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "nozzleModel");
+    i(this, "_cupSizes");
+    i(this, "_nutritionInfo");
+    i(this, "_disposer", null);
+    this.id = e, this.logger = r.logger, this.nozzleModel = t.companionParent, this._cupSizes = [100];
+  }
+  set cupSizes(e) {
+    this._cupSizes = e;
+  }
+  get nutritionInfo() {
+    return this._nutritionInfo;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing freestyle-nozzle ${this.id}`), this._disposer = Se(async () => {
+      if (this.nozzleModel.selectedPourable.beverage && this._cupSizes.length) {
+        this.logger.debug(
+          `selected beverage: ${this.nozzleModel.selectedPourable.beverage.rawId}.  Volume: ${this._cupSizes.join(", ")}`
+        );
+        const e = this.nozzleModel.selectedPourable.beverage.rawId, t = this.nozzleModel.urlPrefix;
+        try {
+          const r = await at(
+            t,
+            e,
+            this._cupSizes
+          );
+          Z(() => {
+            this._nutritionInfo = r;
+          });
+        } catch (r) {
+          this.logger.error(`Error fetching nutrition info: ${r}`);
+        }
+      }
+    });
+  }
+  unload() {
+    this.logger.debug(`unloading freestyle-nozzle ${this.id}`), this._disposer && this._disposer();
+  }
+  async load() {
+    this.logger.debug(`loading freestyle-nozzle ${this.id}`);
+  }
+};
+L = gt([
+  De(),
+  f(ie)
+], L);
+const Y = new m({
+  class: L,
+  type: ie
+}), { URL: ae } = E("PUMP_SERVICE"), { postModel: ct } = M.build({
+  basePath: `${ae}/api/ext/freestyle/microCalibration`
+}), D = C.createLogger({
+  name: "freestyle-pump-service",
+  group: "Services"
+}), dt = async (e, t) => {
+  var r, o, s, a, n;
+  D.debug(
+    `replacePump - sending POST request to /api/ext/freestyle/microCalibration/cal/${e}/code/${t}`
+  );
+  try {
+    const l = await ct({
+      model: {},
+      urlOverride: `${ae}/api/ext/freestyle/microCalibration/cal/${e}/code/${t}`
+    });
+    return D.debug("replacePump - response:", l), ((l == null ? void 0 : l.status) === 200 || (l == null ? void 0 : l.status) === 499) && ((r = l.data) != null && r.error) ? [l.data.error || "unknownError", l.data] : [void 0, l == null ? void 0 : l.data];
+  } catch (l) {
+    if (D.error(
+      `replacePump - sending POST request to /api/cal/${e}/code/${t}`,
+      l
+    ), l instanceof Re) {
+      const d = ((s = (o = l.payload) == null ? void 0 : o.data) == null ? void 0 : s.error) || ((a = l.payload) == null ? void 0 : a.error) || "unknownError";
+      return [d, ((n = l.payload) == null ? void 0 : n.data) || { error: d }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+};
+var ut = Object.defineProperty, pt = Object.getOwnPropertyDescriptor, ht = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? pt(t, r) : t, a = e.length - 1, n; a >= 0; a--)
+    (n = e[a]) && (s = (o ? n(t, r, s) : n(s)) || s);
+  return o && s && ut(t, r, s), s;
+};
+const ne = "freestyle-pump-model";
+let N = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "pump");
+    this.id = e, this.logger = r.logger, this.pump = t.companionParent;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async replacePump(e) {
+    const [t, r] = await dt(this.pump.path, e);
+    return t && this.logger.error(`Failed to replace the pump, ${this.pump.id}`, t), [t, r];
+  }
+};
+N = ht([
+  f(ne)
+], N);
+const V = new m({
+  class: N,
+  type: ne
+}), { URL: T } = E("ICE_AGITATOR_SERVICE"), { getAll: le, postModel: yt } = M.build({
+  basePath: `${T}/api/ext/freestyle/freestyle/ice`
+}), ge = C.createLogger({
+  name: "ice-agitator-service",
+  group: "Services"
+}), ft = async () => (ge.debug("sending GET for ice types"), await le({
+  urlOverride: `${T}/api/ext/freestyle/freestyle/ice/types`
+})), mt = async (e, t) => (ge.debug("sending POST for ice types"), await yt({
+  urlOverride: `${T}/api/ext/freestyle/freestyle/ice/type/${e}/${t}`,
+  model: {}
+})), bt = async () => await le({
+  urlOverride: `${T}/api/kos/config/details/assembly.core.board:macro.iceAgitator/4`
+});
+var _t = Object.defineProperty, vt = Object.getOwnPropertyDescriptor, h = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? vt(t, r) : t, a = e.length - 1, n; a >= 0; a--)
+    (n = e[a]) && (s = (o ? n(t, r, s) : n(s)) || s);
+  return o && s && _t(t, r, s), s;
+};
+const ce = "ice-agitator-model";
+let c = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "name");
+    i(this, "path");
+    i(this, "volWithoutIceMl");
+    i(this, "durationSec");
+    i(this, "enableIceChuteClear");
+    i(this, "iceChuteClearDurationMs");
+    i(this, "iceChuteClearIntervalSec");
+    i(this, "iceChuteClearRetryIntervalSec");
+    i(this, "maxDispenseSec");
+    i(this, "type");
+    i(this, "dilutionOffset");
+    i(this, "inactivitySec");
+    i(this, "_allIceTypes");
+    i(this, "logger");
+    i(this, "resetDefaultValues", async () => await bt());
+    this.id = e, this.name = t.name, this.path = t.path, this._allIceTypes = [], this.logger = r.logger;
+  }
+  get iceTypes() {
+    return this._allIceTypes;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async updateIceType(e) {
+    await mt(this.id, e);
+  }
+  async init() {
+    this.logger.debug(`initializing ice-agitator ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading ice-agitator ${this.id}`);
+    const e = await ft();
+    (e == null ? void 0 : e.status) === 200 && Z(() => {
+      this._allIceTypes = e.data || [];
+    });
+  }
+};
+h([
+  p({
+    path: y,
+    attribute: "settings.volWithoutIceMl"
+  })
+], c.prototype, "volWithoutIceMl", 2);
+h([
+  p({
+    path: y,
+    attribute: "settings.durationSec",
+    converter: {
+      to: "second"
+    }
+  })
+], c.prototype, "durationSec", 2);
+h([
+  p({
+    path: y,
+    attribute: "enableIceChuteClear"
+  })
+], c.prototype, "enableIceChuteClear", 2);
+h([
+  p({
+    path: y,
+    attribute: "iceChuteClearDurationMs"
+  })
+], c.prototype, "iceChuteClearDurationMs", 2);
+h([
+  p({
+    path: y,
+    attribute: "iceChuteClearIntervalSec"
+  })
+], c.prototype, "iceChuteClearIntervalSec", 2);
+h([
+  p({
+    path: y,
+    attribute: "iceChuteClearRetryIntervalSec"
+  })
+], c.prototype, "iceChuteClearRetryIntervalSec", 2);
+h([
+  p({
+    path: y,
+    attribute: "maxDispenseSec"
+  })
+], c.prototype, "maxDispenseSec", 2);
+h([
+  p({
+    path: y,
+    attribute: "type"
+  })
+], c.prototype, "type", 2);
+h([
+  p({
+    path: y,
+    attribute: "settings.dilutionOffset"
+  })
+], c.prototype, "dilutionOffset", 2);
+h([
+  p({
+    path: y,
+    attribute: "settings.inactivitySec",
+    converter: {
+      to: "minute"
+    }
+  })
+], c.prototype, "inactivitySec", 2);
+c = h([
+  f(ce)
+], c);
+const de = new m({
+  class: c,
+  type: ce
+});
+var Pt = Object.defineProperty, At = Object.getOwnPropertyDescriptor, ue = (e, t, r, o) => {
+  for (var s = o > 1 ? void 0 : o ? At(t, r) : t, a = e.length - 1, n; a >= 0; a--)
+    (n = e[a]) && (s = (o ? n(t, r, s) : n(s)) || s);
+  return o && s && Pt(t, r, s), s;
+};
+const G = "agitation-required-trouble-model", It = (e) => {
+  if (e.data.agitationRequired)
+    return G;
+}, $t = "InsufficientAgitationTrouble";
+let O = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "trouble");
+    i(this, "_deferred");
+    i(this, "agitateBeforePour");
+    this.id = e, this.logger = r.logger, this._deferred = !1, this.trouble = t.companionParent;
+  }
+  async resolve() {
+    return this.trouble.resolve();
+  }
+  get holder() {
+    const e = this.trouble.data.holderPaths[0], t = A(e);
+    return t == null ? void 0 : t.model;
+  }
+  get shouldDefer() {
+    var o, s;
+    const t = (((o = this.holder) == null ? void 0 : o.troublesByType[$t]) || []).length > 0;
+    return !!((s = this.agitateBeforePour) != null && s.value) && t;
+  }
+  get deferred() {
+    return this._deferred;
+  }
+  defer() {
+    this._deferred = !0;
+  }
+  clearDefer() {
+    this._deferred = !1;
+  }
+};
+ue([
+  p({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.agitateBeforePour"
+  })
+], O.prototype, "agitateBeforePour", 2);
+O = ue([
+  f(G)
+], O);
+const Ot = new m({
+  class: O,
+  type: G
+}), Et = ["iceAgitator", "carbAgitator"], Mt = {
+  iceAgitator: de.factory,
+  carbAgitator: X.factory
+}, Dt = async (e) => {
+  const t = x.instance().options({}).build(), r = e.assemblies.reduce((a, n) => {
+    var l;
+    return Et.forEach((d) => {
+      const b = n[d];
+      if (b) {
+        const v = Mt[d](b.path);
+        a[d] = v({
+          name: b.name,
+          path: b.path
+        });
+      }
+    }), (l = n.cartridgeAgitators) == null || l.forEach((d) => {
+      var v;
+      const b = re.instance(
+        d.path
+      ).options({
+        name: d.name,
+        path: d.path,
+        statePath: ((v = d.state) == null ? void 0 : v.path) || ""
+      }).build();
+      t.addModel(b);
+    }), a;
+  }, {}), o = !!r.iceAgitator, s = !!r.carbAgitator;
+  return {
+    ...r,
+    cartridgeAgitators: t,
+    supportsCarb: s,
+    supportsIce: o
+  };
+}, Ct = (e) => () => (Fe(e)(), fe(e)(), Y.register(), F.register(), de.register(), X.register(), x.register(), V.register(), H.register(), g.companion.register(e)(
+  me.type,
+  Y.type
+), g.companion.register(e)(
+  be.type,
+  F.type
+), Ot.register(), g.companion.register(e)(
+  je.type,
+  It
+), g.companion.register(e)(_e.type, V.type), g.companion.register(e)(
+  ve.type,
+  H.type
+), w[z].register(
+  "EnjoyByTrouble",
+  async (t) => {
+    if (t.data.enjoyByDate) {
+      const r = new Date(t.data.enjoyByDate);
+      return {
+        enjoyByDays: Math.floor(
+          ((/* @__PURE__ */ new Date()).getTime() - r.getTime()) / (1e3 * 60 * 60 * 24)
+        ) || ""
+      };
+    }
+    return {};
+  }
+), w[z].register(
+  "SuperPumpRequiredTrouble",
+  // This is the trouble type
+  async (t) => {
+    const { model: r } = A(
+      Pe.type
+    );
+    return r ? {
+      superPumps: r.models.getIndexByKey(
+        Ae.byType,
+        "microSuper"
+      ).map((a) => a.name).join(", ")
+    } : {};
+  }
+), w[z].register(
+  "MicroPumpAirDetectTrouble",
+  async (t) => {
+    if (t.ifaces.includes("container"))
+      return {};
+    if (t.data.pumpPath) {
+      const { model: r } = A(
+        t.data.pumpPath
+      );
+      if (r) {
+        const o = r.ingredientId ? A(r.ingredientId).model : void 0;
+        return {
+          ingredientId: r.ingredientId,
+          ingredientName: (o == null ? void 0 : o.name) || ""
+        };
+      }
+    }
+    return {};
+  }
+), {
+  preload: g.model.preloadModel(e),
+  model: g.model.register(e),
+  companion: g.companion.register(e),
+  legacy: g.model.registerLegacyModel(e)
+}), u = {
+  ...ye
+};
+u.freestyle = {
+  models: Ct(u)
+};
+u.preload = g.model.preloadModel(u);
+u.model = g.model.register(u);
+u.companion = g.companion.register(u);
+u.legacy = g.model.registerLegacyModel(u);
+const St = u;
+export {
+  $t as A,
+  X as C,
+  F,
+  de as I,
+  St as K,
+  it as N,
+  x as a,
+  $ as b,
+  re as c,
+  H as d,
+  Y as e,
+  V as f,
+  Ot as g,
+  q as h,
+  at as i,
+  dt as j,
+  Dt as k,
+  Qe as l,
+  Ct as r
+};
+//# sourceMappingURL=freestyle-registration-manager-pbtzJUqS.js.map