@kosdev-code/kos-freestyle-sdk 2.0.33 → 2.0.34

package/freestyle-registration-manager-CI8el36E.js

@@ -0,0 +1,1111 @@
+var Ne = Object.defineProperty;
+var Fe = (e, t, r) => t in e ? Ne(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var o = (e, t, r) => (Fe(e, typeof t != "symbol" ? t + "" : t, r), r);
+import { kosModel as f, KosModelRegistrationFactory as P, KosModelContainer as de, kosChild as X, resolveServiceUrl as L, ServiceFactory as G, createPropKey as j, kosStateProp as J, kosFuture as U, setupMinimalFutureSupport as Le, kosEffect as Ge, EventBus as w, SingletonKosModelRegistrationFactory as k, kosParentAware as ue, KosFeatureFlags as H, kosConfigProperty as p, getKosModelSync as v, KosContextManager as je, KosLog as A, FutureManager as Ue, kosAutoEffect as Be, kosAction as M, FetchError as He, KOS_MODEL_ID as m, kosModelEffect as xe, MultipleFutureHandler as Ke, kosTopicHandler as Ye, modelTypeEventTopicFactory as qe, DependencyLifecycle as Ve, RegistrationManager as h, registerCoreModels as We, Trouble as Ze, ExtensionManager as x, EXTENSION_TROUBLE_DATA_MAPPER as K } from "@kosdev-code/kos-ui-sdk";
+import { PourState as u, Assembly as ge, KosModelRegistry as Qe, registerDispenseModels as Xe, Nozzle as Je, Pump as ke, Holder as et, PumpContainer as tt, PumpIndex as rt } from "@kosdev-code/kos-dispense-sdk";
+var at = Object.defineProperty, ot = Object.getOwnPropertyDescriptor, st = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? ot(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && at(t, r, a), a;
+};
+const ce = "carb-agitator-model";
+let q = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "name");
+    o(this, "path");
+    o(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}`);
+  }
+};
+q = st([
+  f(ce)
+], q);
+const he = new P({
+  class: q,
+  type: ce
+});
+var it = Object.defineProperty, nt = Object.getOwnPropertyDescriptor, pe = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? nt(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && it(t, r, a), a;
+};
+const ye = "cartridge-agitator-container-model";
+let S = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "logger");
+    o(this, "_models");
+    this.id = e, this.logger = r.logger, this._models = new de({
+      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}`
+    );
+  }
+};
+pe([
+  X
+], S.prototype, "_models", 2);
+S = pe([
+  f(ye)
+], S);
+const { URL: fe } = L("CARTRIDGE_AGITATOR_SERVICE"), { postModel: lt } = G.build({
+  basePath: `${fe}/api/ext/freestyle/freestyle/ice`
+}), dt = async (e, t) => {
+  const r = await lt({
+    model: {},
+    tracker: t,
+    urlOverride: `${fe}/api/handle/${e}/test`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r.data;
+};
+var ut = Object.defineProperty, gt = Object.getOwnPropertyDescriptor, ee = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? gt(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && ut(t, r, a), a;
+};
+const me = "cartridge-agitator-model";
+class R {
+}
+o(R, "TOPIC_AGITATION_STARTED", "/kos/events/ddk/agitation-started"), o(R, "TOPIC_AGITATION_ENDED", "/kos/events/ddk/agitation-ended");
+const ct = j("statePath");
+let O = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "futureHandler");
+    o(this, "logger");
+    o(this, "disposer");
+    o(this, "agitating");
+    o(this, "path");
+    o(this, "statePath");
+    o(this, "name");
+    this.id = e, this.logger = r.logger, this.path = t.path, this.name = t.name, this.statePath = t.statePath, Le(this);
+  }
+  get isAgitating() {
+    return !!this.agitating.value;
+  }
+  async testAgitate(e) {
+    if (!e)
+      throw new Error("No tracker provided");
+    return this.logger.info(`agitating cartridge-agitator ${this.id}`), dt(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 = Ge(
+      () => this.isAgitating,
+      () => {
+        var e;
+        this.isAgitating ? (this.logger.info(`agitating cartridge-agitator ${this.id}`), w.publish(R.TOPIC_AGITATION_STARTED, {
+          path: this.path,
+          futureId: (e = this.futureHandler.future) == null ? void 0 : e.futureId
+        })) : w.publish(R.TOPIC_AGITATION_ENDED, {
+          path: this.path
+        });
+      },
+      {}
+    );
+  }
+};
+ee([
+  J({ path: ct, attribute: "agitating" })
+], O.prototype, "agitating", 2);
+ee([
+  U()
+], O.prototype, "testAgitate", 1);
+O = ee([
+  f(me)
+], O);
+const _e = new P({
+  class: O,
+  type: me
+}), te = new k({
+  class: S,
+  type: ye
+});
+te.addRelatedModel(_e);
+var ht = Object.defineProperty, pt = Object.getOwnPropertyDescriptor, Pe = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? pt(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && ht(t, r, a), a;
+};
+const be = "freestyle-assembly-model", yt = "iceAgitator", ft = "carbAgitator", mt = "remoteTrays";
+let D = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "logger");
+    o(this, "assembly");
+    o(this, "_remoteTrays");
+    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;
+  }
+  get remoteTrays() {
+    return this.assembly.remoteTrays;
+  }
+  get hasRemoteTrays() {
+    return this.assembly.remoteTrays ? this.assembly.remoteTrays.data.length > 0 : !1;
+  }
+  // -------------------LIFECYCLE----------------------------
+  get supportsRemoteTrays() {
+    return H.isFeatureEnabled(mt);
+  }
+  get supportsIce() {
+    return H.isFeatureEnabled(yt);
+  }
+  get supportsCarb() {
+    return H.isFeatureEnabled(ft);
+  }
+  async init() {
+    this.logger.debug(`initializing freestyle-assembly ${this.id}`);
+  }
+};
+Pe([
+  X
+], D.prototype, "_remoteTrays", 2);
+D = Pe([
+  ue(),
+  f(be)
+], D);
+const V = new k({
+  class: D,
+  type: be
+});
+var _t = Object.defineProperty, Pt = Object.getOwnPropertyDescriptor, ve = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? Pt(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && _t(t, r, a), a;
+};
+const Ie = "remote-tray-model";
+j("holderPath");
+const bt = j("configPath");
+let z = class {
+  constructor(e, t, r) {
+    /** Unique identifier for the remote tray instance */
+    o(this, "id");
+    o(this, "logger");
+    /** Path reference to the associated holder model */
+    o(this, "holderPath");
+    /** Configuration path for tray-specific settings */
+    o(this, "configPath");
+    /** Display name of the remote tray */
+    o(this, "name");
+    o(this, "remoteTrayEnabled");
+    this.id = e, this.logger = r.logger, this.holderPath = t.holderPath, this.configPath = t.configPath, this.name = t.name;
+  }
+  /**
+   * Gets the troubles from the associated holder model.
+   * Propagates trouble states from the holder to this remote tray.
+   * 
+   * @returns Array of trouble models from the holder, or empty array if no holder
+   */
+  get troubles() {
+    var e;
+    return ((e = this.holder) == null ? void 0 : e.troubles) ?? [];
+  }
+  /**
+   * Gets the highest priority trouble status.
+   * Currently returns empty string as troubles are managed by the holder.
+   * 
+   * @returns Empty string (trouble status handled by holder)
+   */
+  get troubleStatus() {
+    return "";
+  }
+  /**
+   * Gets troubles grouped by type from the associated holder.
+   * 
+   * @returns Record of troubles grouped by type from the holder, or empty object if no holder
+   */
+  get troublesByType() {
+    var e;
+    return ((e = this.holder) == null ? void 0 : e.troublesByType) ?? {};
+  }
+  /**
+   * Updates the model with new configuration options.
+   * Can be used to modify the holder path, config path, or name after initialization.
+   * 
+   * @param _options - New configuration options for the remote tray
+   */
+  updateModel(e) {
+  }
+  /**
+   * Gets the associated holder model for this remote tray.
+   * Uses synchronous model lookup to retrieve the holder by path.
+   * 
+   * @returns The HolderModel instance referenced by holderPath, or undefined if not found
+   */
+  get holder() {
+    return v(this.holderPath).model;
+  }
+  /**
+   * Determines if the remote tray is currently active.
+   * Active state is based on the remoteTrayEnabled configuration property.
+   * 
+   * @returns true if the tray is enabled, false otherwise
+   */
+  get active() {
+    return !!this.remoteTrayEnabled.value;
+  }
+  // -------------------LIFECYCLE----------------------------
+  /**
+   * Initializes the remote tray model.
+   * Called during the model lifecycle initialization phase.
+   * Sets up initial state and prepares the model for use.
+   * 
+   * @returns Promise that resolves when initialization is complete
+   */
+  async init() {
+    this.logger.debug(`initializing remote-tray ${this.id}`);
+  }
+  /**
+   * Loads the remote tray configuration and associated data.
+   * Called during the model lifecycle load phase.
+   * Typically loads configuration settings and establishes holder references.
+   * 
+   * @returns Promise that resolves when loading is complete
+   */
+  async load() {
+    this.logger.debug(`loading remote-tray ${this.id}`);
+  }
+};
+ve([
+  p({
+    path: bt,
+    attribute: "enabled"
+  })
+], z.prototype, "remoteTrayEnabled", 2);
+z = ve([
+  f(Ie)
+], z);
+const E = new P({
+  class: z,
+  type: Ie
+});
+var vt = Object.defineProperty, It = Object.getOwnPropertyDescriptor, Te = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? It(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && vt(t, r, a), a;
+};
+const Oe = "remote-tray-container-model";
+let N = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "logger");
+    o(this, "_models");
+    this.id = e, this.logger = r.logger, this._models = new de({
+      parentId: e
+    });
+  }
+  getModel(e) {
+    return this._models.getModel(e);
+  }
+  get models() {
+    return this._models;
+  }
+  get data() {
+    return this._models.data;
+  }
+  updateModel(e) {
+  }
+  addModel(e) {
+    this._models.addModel(e);
+  }
+  removeModel(e) {
+    this._models.removeModel(e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(
+      `initializing remote-tray-container container ${this.id}`
+    );
+  }
+  async load() {
+    this.logger.debug(`loading remote-tray-container container ${this.id}`);
+  }
+};
+Te([
+  X
+], N.prototype, "_models", 2);
+N = Te([
+  f(Oe)
+], N);
+const re = new k({
+  class: N,
+  type: Oe
+});
+re.addRelatedModel(E);
+var Tt = Object.defineProperty, Ot = Object.getOwnPropertyDescriptor, Et = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? Ot(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && Tt(t, r, a), a;
+};
+const Ee = "freestyle-holder-model";
+function $t(e) {
+  const t = je.getContext(e), r = t == null ? void 0 : t.get(
+    V.type
+  );
+  if (!r) {
+    A.error("Freestyle assembly not found");
+    return;
+  }
+  return r;
+}
+async function At(e, t) {
+  if (!e || !t)
+    return;
+  const r = await e[t]();
+  if (r != null && r.tracker)
+    return Ue.getFuture(r.tracker);
+}
+let W = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "logger");
+    o(this, "holder");
+    o(this, "context");
+    o(this, "future");
+    this.id = e, this.logger = r.logger, this.context = r.kosContext, 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 = $t(this.id);
+    if (!e)
+      return;
+    if (!e.defaultCartridgeAgitator) {
+      this.logger.error("Agitator not found");
+      return;
+    }
+    return this.future = await At(
+      e.defaultCartridgeAgitator,
+      "testAgitate"
+    ), this.future;
+  }
+  get isRemote() {
+    const e = `${E.type}-${this.holder.path}`, t = v(e);
+    return t != null && t.model ? !!t.model.remoteTrayEnabled.value : !1;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing freestyle-holder ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading freestyle-holder ${this.id}`);
+  }
+};
+W = Et([
+  f(Ee)
+], W);
+const se = new P({
+  class: W,
+  type: Ee
+}), { URL: Ct } = L("FREESTYLE-NOZZLE_SERVICE"), { getOne: Mt } = G.build({
+  basePath: `${Ct}/api/freestyle-nozzle`
+}), C = A.createLogger({
+  name: "freestyle-nozzle-service",
+  group: "Services"
+});
+class wt extends Error {
+  constructor(t) {
+    super(t), this.name = "NutritionInfoError";
+  }
+}
+class ie extends Error {
+  constructor(t) {
+    super(t), this.name = "InvalidRequestError";
+  }
+}
+const St = async (e, t, r, s = "http://localhost:8081") => {
+  if (C.debug("sending GET for freestyle-nozzle"), !t)
+    throw C.error("Invalid freestyle-nozzle request: beverageId is required"), new ie("No beverageId provided");
+  if (!r || r.length === 0)
+    throw C.error("Invalid freestyle-nozzle request: volumes are required"), new ie("No volumes provided");
+  const a = await Mt({
+    urlOverride: `${s}${e}/pipeline/beverage/engine/nutrition/${t}?volumes=${r.join(
+      ","
+    )}`
+  });
+  if (!(a != null && a.data))
+    throw C.error("Failed to retrieve freestyle-nozzle data"), new Error("Failed to retrieve freestyle-nozzle data");
+  if (a.data.error)
+    throw new wt(a.data.error);
+  return a.data;
+};
+var Rt = Object.defineProperty, Dt = Object.getOwnPropertyDescriptor, zt = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? Dt(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && Rt(t, r, a), a;
+};
+const $e = "freestyle-nozzle-model";
+let Z = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "logger");
+    o(this, "nozzleModel");
+    o(this, "_cupSizes");
+    o(this, "_nutritionInfo");
+    o(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 = Be(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 St(
+            t,
+            e,
+            this._cupSizes
+          );
+          M(() => {
+            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}`);
+  }
+};
+Z = zt([
+  ue(),
+  f($e)
+], Z);
+const ne = new P({
+  class: Z,
+  type: $e
+}), { URL: Ae } = L("PUMP_SERVICE"), { postModel: Nt } = G.build({
+  basePath: `${Ae}/api/ext/freestyle/microCalibration`
+}), Y = A.createLogger({
+  name: "freestyle-pump-service",
+  group: "Services"
+}), Ft = async (e, t) => {
+  var r, s, a, i, n;
+  Y.debug(
+    `replacePump - sending POST request to /api/ext/freestyle/microCalibration/cal/${e}/code/${t}`
+  );
+  try {
+    const l = await Nt({
+      model: {},
+      urlOverride: `${Ae}/api/ext/freestyle/microCalibration/cal/${e}/code/${t}`
+    });
+    return Y.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 (Y.error(
+      `replacePump - sending POST request to /api/cal/${e}/code/${t}`,
+      l
+    ), l instanceof He) {
+      const T = ((a = (s = l.payload) == null ? void 0 : s.data) == null ? void 0 : a.error) || ((i = l.payload) == null ? void 0 : i.error) || "unknownError";
+      return [T, ((n = l.payload) == null ? void 0 : n.data) || { error: T }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+};
+var Lt = Object.defineProperty, Gt = Object.getOwnPropertyDescriptor, jt = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? Gt(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && Lt(t, r, a), a;
+};
+const Ce = "freestyle-pump-model";
+let Q = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "logger");
+    o(this, "pump");
+    this.id = e, this.logger = r.logger, this.pump = t.companionParent;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async replacePump(e) {
+    const [t, r] = await Ft(this.pump.path, e);
+    return t && this.logger.error(`Failed to replace the pump, ${this.pump.id}`, t), [t, r];
+  }
+};
+Q = jt([
+  f(Ce)
+], Q);
+const le = new P({
+  class: Q,
+  type: Ce
+}), { URL: I } = L("ICE_AGITATOR_SERVICE"), { getAll: Me, postModel: B } = G.build({
+  basePath: `${I}/api/ext/freestyle/ice`
+}), we = A.createLogger({
+  name: "ice-agitator-service",
+  group: "Services"
+}), Ut = async (e) => (we.debug("sending GET for ice types"), await Me({
+  urlOverride: `${I}/api/handle/${e}/types`
+})), Bt = async (e, t) => (we.debug("sending POST for ice types"), await B({
+  urlOverride: `${I}/api/handle/${e}/type/${t}`,
+  model: {}
+})), Ht = async (e) => await Me({
+  urlOverride: `${I}/api/kos/config/details/${e}/4`
+}), xt = async (e, t) => {
+  const r = await B({
+    model: {},
+    tracker: t,
+    urlOverride: `${I}/api/handle/${e}/pour`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r == null ? void 0 : r.data;
+}, Kt = async (e, t) => {
+  const r = await B({
+    model: {},
+    tracker: t,
+    urlOverride: `${I}/api/handle/${e}/test/agitation`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r == null ? void 0 : r.data;
+}, Yt = async (e, t) => {
+  const r = await B({
+    model: {},
+    tracker: t,
+    urlOverride: `${I}/api/handle/${e}/test/gate`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r == null ? void 0 : r.data;
+};
+var qt = Object.defineProperty, Vt = Object.getOwnPropertyDescriptor, g = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? Vt(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && qt(t, r, a), a;
+};
+class F {
+}
+o(F, "TOPIC_AGITATION_STARTED", "/kos/events/ddk/ice-agitation-started"), o(F, "TOPIC_AGITATION_ENDED", "/kos/events/ddk/ice-agitation-ended");
+const Se = "ice-agitator-model", Re = j("statePath");
+let d = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "name");
+    o(this, "path");
+    o(this, "futureHandler");
+    o(this, "volWithoutIceMl");
+    o(this, "durationSec");
+    o(this, "enableIceChuteClear");
+    o(this, "iceChuteClearDurationMs");
+    o(this, "iceChuteClearIntervalSec");
+    o(this, "iceChuteClearRetryIntervalSec");
+    o(this, "maxDispenseSec");
+    o(this, "type");
+    o(this, "dilutionOffset");
+    o(this, "inactivitySec");
+    o(this, "agitating");
+    o(this, "iceChuteOpen");
+    o(this, "statePath");
+    o(this, "_allIceTypes");
+    o(this, "logger");
+    o(this, "currentState", u.IDLE);
+    o(this, "resetDefaultValues", async () => await Ht(this.path));
+    this.id = e, this.name = t.name, this.path = t.path, this.statePath = t.statePath, this._allIceTypes = [], this.logger = r.logger, this.futureHandler = new Ke(this);
+  }
+  get iceTypes() {
+    return this._allIceTypes;
+  }
+  get isAgitating() {
+    return !!this.agitating.value;
+  }
+  get isIceChuteOpen() {
+    return !!this.iceChuteOpen.value;
+  }
+  get future() {
+    return this.futureHandler.future;
+  }
+  get pourFuture() {
+    return this.futureHandler.futureMap.get("pour");
+  }
+  get agitateFuture() {
+    return this.futureHandler.futureMap.get("agitate");
+  }
+  get gateFuture() {
+    return this.futureHandler.futureMap.get("gate");
+  }
+  /**
+   * A derived value that indicates if the nozzle is currently pouring a beverage.
+   * @readonly
+   */
+  get isPouring() {
+    var e;
+    return !!(this.pourFuture && !((e = this.pourFuture) != null && e.endState)) || this.currentState === u.POUR_STARTING || this.currentState === u.POURING || this.currentState === u.POUR_CANCELING;
+  }
+  /**
+   * A derived value that indicates if it is possible to dispense ice.
+   *
+   * The value is observable and will change as the current dispense state changes
+   * @readonly
+   * */
+  get canPour() {
+    return this.currentState === u.IDLE;
+  }
+  updateIfCurrent(e, t) {
+    this.currentState === e && M(() => {
+      this.currentState = t;
+    });
+  }
+  async pourIce(e) {
+    try {
+      if (this.currentState === u.IDLE) {
+        if (this.updateIfCurrent(u.IDLE, u.POUR_STARTING), !e)
+          throw new Error("No tracker provided");
+        const t = await xt(this.path, e);
+        return this.updateIfCurrent(u.POUR_STARTING, u.POURING), t != null && t.endState && this.updateIfCurrent(u.POURING, u.IDLE), t;
+      } else
+        throw new Error(`Cannot pour in state ${this.currentState}`);
+    } catch (t) {
+      throw this.logger.error(t), this.currentState = u.IDLE, t;
+    }
+  }
+  /**
+   * An action that will cancel the ice dispense if it is currently in progress.
+   * */
+  async cancelIceDispense() {
+    var e;
+    this.currentState === u.POURING || this.currentState === u.POUR_STARTING ? (this.currentState = u.POUR_CANCELING, await ((e = this.pourFuture) == null ? void 0 : e.cancelFuture()), M(() => {
+      this.currentState = u.IDLE;
+    })) : this.logger.warn(
+      `Cannot cancel ice dispense in state ${this.currentState}`
+    );
+  }
+  async testAgitate(e) {
+    if (!e)
+      throw new Error("No tracker provided");
+    return this.logger.info(`agitating ice-agitator ${this.id}`), Kt(this.path, e);
+  }
+  async testGate(e) {
+    if (!e)
+      throw new Error("No tracker provided");
+    return this.logger.info(`testing ice gate:  ${this.id}`), Yt(this.path, e);
+  }
+  handleAgitationChange() {
+    var e;
+    this.isAgitating ? (this.logger.info(`agitating ice-agitator ${this.id}`), w.publish(F.TOPIC_AGITATION_STARTED, {
+      path: this.path,
+      futureId: (e = this.futureHandler.future) == null ? void 0 : e.futureId
+    })) : w.publish(F.TOPIC_AGITATION_ENDED, {
+      path: this.path
+    });
+  }
+  async updateIceType(e) {
+    await Bt(this.path, e);
+  }
+  async init() {
+    this.logger.debug(`initializing ice-agitator ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading ice-agitator ${this.id}`);
+    const e = await Ut(this.path);
+    (e == null ? void 0 : e.status) === 200 && M(() => {
+      this._allIceTypes = e.data || [];
+    });
+  }
+};
+g([
+  p({
+    path: m,
+    attribute: "settings.volWithoutIceMl"
+  })
+], d.prototype, "volWithoutIceMl", 2);
+g([
+  p({
+    path: m,
+    attribute: "settings.durationSec",
+    converter: {
+      to: "second"
+    }
+  })
+], d.prototype, "durationSec", 2);
+g([
+  p({
+    path: m,
+    attribute: "enableIceChuteClear"
+  })
+], d.prototype, "enableIceChuteClear", 2);
+g([
+  p({
+    path: m,
+    attribute: "iceChuteClearDurationMs"
+  })
+], d.prototype, "iceChuteClearDurationMs", 2);
+g([
+  p({
+    path: m,
+    attribute: "iceChuteClearIntervalSec"
+  })
+], d.prototype, "iceChuteClearIntervalSec", 2);
+g([
+  p({
+    path: m,
+    attribute: "iceChuteClearRetryIntervalSec"
+  })
+], d.prototype, "iceChuteClearRetryIntervalSec", 2);
+g([
+  p({
+    path: m,
+    attribute: "maxDispenseSec"
+  })
+], d.prototype, "maxDispenseSec", 2);
+g([
+  p({
+    path: m,
+    attribute: "type"
+  })
+], d.prototype, "type", 2);
+g([
+  p({
+    path: m,
+    attribute: "settings.dilutionOffset"
+  })
+], d.prototype, "dilutionOffset", 2);
+g([
+  p({
+    path: m,
+    attribute: "settings.inactivitySec",
+    converter: {
+      to: "minute"
+    }
+  })
+], d.prototype, "inactivitySec", 2);
+g([
+  J({ path: Re, attribute: "agitating" })
+], d.prototype, "agitating", 2);
+g([
+  J({ path: Re, attribute: "iceChuteOpen" })
+], d.prototype, "iceChuteOpen", 2);
+g([
+  U({ alias: "pour" })
+], d.prototype, "pourIce", 1);
+g([
+  U({ alias: "agitate" })
+], d.prototype, "testAgitate", 1);
+g([
+  U({
+    alias: "gate"
+  })
+], d.prototype, "testGate", 1);
+g([
+  xe({
+    dependencies: (e) => [e.isAgitating]
+  })
+], d.prototype, "handleAgitationChange", 1);
+d = g([
+  f(Se)
+], d);
+const De = new P({
+  class: d,
+  type: Se
+});
+var Wt = Object.defineProperty, Zt = Object.getOwnPropertyDescriptor, ae = (e, t, r, s) => {
+  for (var a = s > 1 ? void 0 : s ? Zt(t, r) : t, i = e.length - 1, n; i >= 0; i--)
+    (n = e[i]) && (a = (s ? n(t, r, a) : n(a)) || a);
+  return s && a && Wt(t, r, a), a;
+};
+const oe = "agitation-required-trouble-model", Qt = (e) => {
+  if (e.data.agitationRequired)
+    return oe;
+}, Xt = "InsufficientAgitationTrouble";
+let $ = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "logger");
+    o(this, "trouble");
+    o(this, "_deferred");
+    o(this, "_holdersLoaded", !1);
+    o(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 = v(e);
+    if (!(!this._holdersLoaded && !t.model))
+      return t == null ? void 0 : t.model;
+  }
+  updateHolder() {
+    if (!this._holdersLoaded) {
+      const e = this.trouble.data.holderPaths[0];
+      v(e).model && (this._holdersLoaded = !0);
+    }
+  }
+  get shouldDefer() {
+    var s, a;
+    if (!this.holder)
+      return !0;
+    const t = (((s = this.holder) == null ? void 0 : s.troublesByType[Xt]) || []).length > 0;
+    return !!((a = this.agitateBeforePour) != null && a.value) && t;
+  }
+  get deferred() {
+    return this._deferred;
+  }
+  defer() {
+    this._deferred = !0;
+  }
+  clearDefer() {
+    this._deferred = !1;
+  }
+};
+ae([
+  p({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.agitateBeforePour"
+  })
+], $.prototype, "agitateBeforePour", 2);
+ae([
+  Ye({
+    topic: qe(ge.type),
+    lifecycle: Ve.INIT
+  })
+], $.prototype, "updateHolder", 1);
+$ = ae([
+  f(oe)
+], $);
+const Jt = new P({
+  class: $,
+  type: oe
+}), kt = ["iceAgitator", "carbAgitator"], er = {
+  iceAgitator: De.factory,
+  carbAgitator: he.factory
+}, tr = A.createLogger({ name: "freestyle-assembly-data-mapper" }), ir = async (e) => {
+  const t = te.instance().options({}).build(), r = re.instance().options({}).build(), s = e.assemblies.reduce((n, l) => {
+    var T;
+    return kt.forEach((c) => {
+      var b;
+      const _ = l[c];
+      if (_) {
+        const ze = er[c](_.path);
+        n[c] = ze({
+          name: _.name,
+          path: _.path,
+          statePath: ((b = _.state) == null ? void 0 : b.path) || ""
+        });
+      }
+    }), (T = l.cartridgeAgitators) == null || T.forEach((c) => {
+      var b;
+      const _ = _e.instance(
+        c.path
+      ).options({
+        name: c.name,
+        path: c.path,
+        statePath: ((b = c.state) == null ? void 0 : b.path) || ""
+      }).build();
+      t.addModel(_);
+    }), l.remoteTrays && l.remoteTrays.forEach((c) => {
+      tr.info(`Found remote tray ${c.name} with path ${c.path}`);
+      const _ = `${E.type}-${c.holderPath}`, b = E.instance(_).options({
+        holderPath: c.holderPath,
+        configPath: c.path,
+        name: c.name
+      }).build();
+      r.addModel(b);
+    }), n;
+  }, {}), a = !!s.iceAgitator, i = !!s.carbAgitator;
+  return {
+    ...s,
+    cartridgeAgitators: t,
+    remoteTrays: r,
+    supportsCarb: i,
+    supportsIce: a
+  };
+}, rr = (e) => () => (We(e)(), Xe(e)(), ne.register(), V.register(), De.register(), he.register(), te.register(), le.register(), se.register(), E.register(), re.register(), h.companion.register(e)(
+  Je.type,
+  ne.type
+), h.companion.register(e)(
+  ge.type,
+  V.type
+), Jt.register(), h.companion.register(e)(
+  Ze.type,
+  Qt
+), h.companion.register(e)(ke.type, le.type), h.companion.register(e)(
+  et.type,
+  se.type
+), x[K].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 {};
+  }
+), x[K].register(
+  "SuperPumpRequiredTrouble",
+  // This is the trouble type
+  async (t) => {
+    const { model: r } = v(
+      tt.type
+    );
+    return r ? {
+      superPumps: r.models.getIndexByKey(
+        rt.byType,
+        "microSuper"
+      ).map((i) => i.name).join(", ")
+    } : {};
+  }
+), x[K].register(
+  "MicroPumpAirDetectTrouble",
+  async (t) => {
+    if (t.ifaces.includes("container"))
+      return {};
+    if (t.data.pumpPath) {
+      const { model: r } = v(
+        t.data.pumpPath
+      );
+      if (r) {
+        const s = r.ingredientId ? v(r.ingredientId).model : void 0;
+        return {
+          ingredientId: r.ingredientId,
+          ingredientName: (s == null ? void 0 : s.name) || ""
+        };
+      }
+    }
+    return {};
+  }
+), {
+  preload: h.model.preloadModel(e),
+  model: h.model.register(e),
+  companion: h.companion.register(e),
+  legacy: h.model.registerLegacyModel(e)
+}), y = {
+  ...Qe
+};
+y.freestyle = {
+  models: rr(y)
+};
+y.preload = h.model.preloadModel(y);
+y.model = h.model.register(y);
+y.companion = h.companion.register(y);
+y.legacy = h.model.registerLegacyModel(y);
+const nr = y;
+export {
+  Xt as A,
+  he as C,
+  V as F,
+  F as I,
+  nr as K,
+  wt as N,
+  re as R,
+  te as a,
+  R as b,
+  _e as c,
+  se as d,
+  ne as e,
+  le as f,
+  De as g,
+  Jt as h,
+  E as i,
+  ie as j,
+  St as k,
+  Ft as l,
+  ir as m,
+  yt as n,
+  rr as r
+};
+//# sourceMappingURL=freestyle-registration-manager-CI8el36E.js.map