@kosdev-code/kos-dispense-sdk 2.0.45 → 2.0.46

package/dispense-registration-manager-o2X21qmP.js

@@ -0,0 +1,1972 @@
+var gt = Object.defineProperty;
+var ht = (e, t, r) => t in e ? gt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var o = (e, t, r) => (ht(e, typeof t != "symbol" ? t + "" : t, r), r);
+import { kosModel as I, Kos as v, isKosModel as P, resolveServiceUrl as S, ServiceFactory as C, KosLog as m, KosModelContainer as R, KosExtensionUtils as T, kosChild as M, FetchError as yt, ExtensionManager as g, EXTENSION_TROUBLE_MAPPER as Me, EXTENSION_TROUBLE_DATA_MAPPER as W, getKosModelSync as N, kosDependency as ce, TroubleContainer as Be, troubleByTypeReducer as Ue, kosAction as h, kosTopicHandler as Q, DependencyLifecycle as Ge, getKosModel as Fe, FutureManager as pe, kosFuture as ue, FutureHandler as je, EXTENSION_FEATURE_FLAG_RESOLVER as It, isKosDataModel as ft, ChildModels as mt, KosFeatureFlags as bt, kosParentAware as vt, createPropKey as Pt, MultipleFutureHandler as _t, arraysEqual as Mt, getAllKosCompanionModels as E, EventBus as _, KosContextManager as ze, destroyKosModel as Ot, SingletonKosModelRegistrationFactory as Et, KosModelRegistrationFactory as wt, KosModelRegistry as $t, RegistrationManager as O, registerCoreModels as St, registerLegacyModel as Ct } from "@kosdev-code/kos-ui-sdk";
+import "react";
+var u = /* @__PURE__ */ ((e) => (e.IngredientLoader = "kos.ingredient.loader", e.IngredientMapper = "kos.ingredient.mapper", e.IngredientIndex = "kos.ingredient.index", e.IngredientTypeMapper = "kos.ingredient.type.mapper", e.HolderTypeMapper = "kos.holder.type.mapper", e.HolderMapper = "kos.holder.mapper", e.HolderIndex = "kos.holder.index", e.HolderIngredientMapper = "kos.holder.ingredient.mapper", e.AvailabilityMapper = "kos.availability.mapper", e.AvailabilityLoader = "kos.availability.loader", e.SelectedPourableMapper = "kos.selected.pourable.mapper", e.AssemblyMapper = "kos.assembly.mapper", e.BoardMapper = "kos.board.mapper", e.BoardIndex = "kos.board.index", e.PumpIndex = "kos.pump.index", e.AssemblyFeatureFlags = "kos.assembly.feature.flags", e))(u || {}), z = /* @__PURE__ */ ((e) => (e.Nozzle = "nozzle-model", e.Availability = "availability-model", e.Holder = "holder-model", e.HolderContainer = "holder-container-model", e.IngredientContainer = "ingredient-container-model", e.Ingredient = "ingredient-model", e.Pump = "pump-model", e.PumpContainer = "pump-container-model", e))(z || {}), Rt = Object.getOwnPropertyDescriptor, zt = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? Rt(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = n(i) || i);
+  return i;
+};
+const G = "ingredient-model";
+let be = class {
+  constructor(e, {
+    name: t,
+    type: r,
+    data: a,
+    ingredientId: i,
+    ...s
+  }) {
+    o(this, "id");
+    o(this, "ingredientId");
+    o(this, "name");
+    o(this, "type");
+    o(this, "data");
+    this.id = e, this.ingredientId = i, this.name = t, this.type = r, this.data = a, Object.assign(this, s);
+  }
+  updateModel({
+    name: e,
+    type: t,
+    data: r,
+    ingredientId: a,
+    ...i
+  }) {
+    this.name = e, this.type = t, this.ingredientId = a, this.data = r, Object.assign(this, i);
+  }
+  // -------------------LIFECYCLE----------------------------
+  // -------------------ENTITY----------------------------
+};
+be = zt([
+  I(G)
+], be);
+const He = {
+  registration: {
+    [G]: {
+      class: be,
+      singleton: !1
+    }
+  },
+  type: G,
+  predicate: P(G),
+  factory: v.Factory.create(G)
+}, { URL: Ke } = S("INGREDIENT_SERVICE"), { getOne: Dt } = C.build({
+  basePath: `${Ke}/api/ext/dispense/ingredients`
+}), Tt = async () => await Dt({
+  urlOverride: `${Ke}/api/ext/dispense/ingredients`
+});
+var Nt = Object.defineProperty, Lt = Object.getOwnPropertyDescriptor, Ve = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? Lt(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && Nt(t, r, i), i;
+};
+const F = "ingredient-container-model", xt = m.createLogger({ name: "ingredient-container-model" });
+let ae = class {
+  constructor(e, t) {
+    o(this, "id");
+    o(this, "ingredients");
+    this.id = e, this.ingredients = new R({
+      indexMap: {
+        ingredientType: "type"
+      },
+      extensionId: u.IngredientIndex,
+      parentId: e
+    });
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  getIngredientsByType(e) {
+    return this.ingredients.getIndexByKey("ingredientType", e);
+  }
+  async load(e) {
+    var i;
+    xt.debug(`loading ingredient container ${this.id}`);
+    const t = await Tt();
+    if ((t == null ? void 0 : t.status) !== 200)
+      throw new Error("Failed to load ingredients");
+    const r = await T.executeLoaderExtension({
+      context: e,
+      extension: u.IngredientLoader
+    }), a = (t == null ? void 0 : t.data) ?? {};
+    for (const s of Object.keys(a))
+      for (const n of ((i = t == null ? void 0 : t.data) == null ? void 0 : i[s]) || []) {
+        const l = await T.executeDataMapperExtension({
+          extension: u.IngredientMapper,
+          data: n,
+          contextData: r
+        }), c = await T.executePropertyMapperExtension({
+          extension: u.IngredientTypeMapper,
+          data: n,
+          contextData: r
+        }), p = {
+          ...n,
+          type: c || n.type,
+          ...l,
+          data: l
+        }, y = He.factory(n.id)(
+          p
+        );
+        this.ingredients.addModel(y);
+      }
+  }
+  // -------------------ENTITY----------------------------
+};
+Ve([
+  M
+], ae.prototype, "ingredients", 2);
+ae = Ve([
+  I(F)
+], ae);
+const ke = {
+  registration: {
+    [F]: {
+      class: ae,
+      singleton: !0
+    }
+  },
+  type: F,
+  predicate: P(F),
+  factory: v.Singleton.create(F)
+}, { URL: ge } = S("HOLDER_SERVICE"), { getAll: At, postModel: Ye, deleteModel: Bt } = C.build({
+  basePath: `${ge}/api/kos/holders`
+}), Ut = m.createLogger({
+  name: "holder-service",
+  group: "Services"
+}), ri = async () => await At({}), Gt = async (e, t) => {
+  if (!e || !t)
+    throw new Error("Missing holderPath or ingredientId");
+  return await Ye({
+    model: { holderPath: e, ingredientId: t },
+    urlOverride: `${ge}/api/ext/dispense/assignments`
+  });
+}, Ft = async (e) => {
+  if (!e)
+    throw new Error("Missing holderPath");
+  return await Bt({
+    id: e,
+    urlOverride: `${ge}/api/ext/dispense/assignments/${e}`
+  });
+}, jt = async (e) => {
+  if (!e)
+    throw new Error("Missing holderPath");
+  return Ut.debug(
+    `sending POST request to /api/ext/dispense/pumpEvents/replaceLine/${e}`
+  ), await Ye({
+    model: {},
+    urlOverride: `${ge}/api/ext/dispense/pumpEvents/replaceLine/${e}`
+  });
+}, { URL: se } = S("ASSIGNMENT_SERVICE"), { getAll: Ht, postModel: Ze, deleteModel: Kt } = C.build({
+  destinationAddress: "",
+  basePath: `${se}/api/ext/dispense/assignments`
+}), ne = window.kosUseFos, ii = async () => await Ht({ fos: ne }), Vt = async (e, t) => {
+  var i, s, n, l;
+  const r = JSON.stringify(t), a = `${se}/api/ext/dispense/assignments`;
+  try {
+    const c = await Ze({
+      model: { holderPath: e, factoryJson: r },
+      urlOverride: a
+    });
+    return (c == null ? void 0 : c.status) === 200 && ((i = c == null ? void 0 : c.data) != null && i.error) ? [c.data.error || "unknownError", c.data] : [void 0, c == null ? void 0 : c.data];
+  } catch (c) {
+    if (c instanceof yt)
+      return [
+        ((n = (s = c.payload) == null ? void 0 : s.data) == null ? void 0 : n.error) || "unknownError",
+        (l = c.payload) == null ? void 0 : l.data
+      ];
+  }
+  return ["unknownError", void 0];
+}, ai = async (e) => {
+  const t = ne ? `${se}/api/ingredients/assignments/${e.holderPath}` : `${se}/api/ext/dispense/assignments`;
+  return await Ze({
+    model: { ...e, fuelGauge: 680 },
+    fos: ne,
+    urlOverride: t
+  });
+}, si = async (e) => await Kt({ id: e, fos: ne });
+var kt = Object.defineProperty, Yt = Object.getOwnPropertyDescriptor, he = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? Yt(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && kt(t, r, i), i;
+};
+const j = z.Holder, De = m.createLogger({ name: "holder-model" });
+g[Me].register(
+  "holder",
+  async (e) => {
+    const t = [];
+    return t.push(...e.data.holderPaths), t;
+  }
+);
+g[W].register(
+  "pump",
+  async (e) => {
+    if (e.data.pumpPath) {
+      const { model: t } = N(
+        e.data.pumpPath
+      );
+      if (t) {
+        const r = t.ingredientId ? N(t.ingredientId).model : void 0;
+        return {
+          ingredientId: t.ingredientId,
+          ingredientName: (r == null ? void 0 : r.displayName) ?? ((r == null ? void 0 : r.name) || ""),
+          childPumpName: t.name
+        };
+      }
+    }
+    return {};
+  }
+);
+g[W].register(
+  "holder",
+  async (e) => e.data.holderNames.length > 0 ? {
+    holderName: e.data.holderNames[0] || ""
+  } : {}
+);
+g[W].register(
+  "container",
+  async (e) => {
+    if (e.data.ingredients.length > 0) {
+      const t = e.data.ingredients[0], { model: r } = N(t);
+      return {
+        ingredientName: (r == null ? void 0 : r.displayName) ?? ((r == null ? void 0 : r.name) || ""),
+        ingredients: e.data.ingredients ? e.data.ingredients : [],
+        unknonwnIngredientId: e.data.unknonwnIngredientId ?? ""
+      };
+    }
+    return {};
+  }
+);
+class Zt extends Error {
+  constructor(r, a) {
+    super(a);
+    o(this, "type");
+    this.name = "AssignmentError", this.type = r;
+  }
+}
+let L = class {
+  constructor(e, {
+    path: t,
+    name: r,
+    ingredientSource: a,
+    ingredientId: i,
+    ingredientType: s,
+    slice: n,
+    group: l,
+    data: c,
+    enjoyByDate: p
+  }, y) {
+    o(this, "id");
+    o(this, "path");
+    o(this, "name");
+    o(this, "ingredientId");
+    o(this, "ingredientType");
+    o(this, "ingredientSource");
+    o(this, "group");
+    o(this, "slice");
+    o(this, "logger");
+    o(this, "data");
+    o(this, "enjoyByDate");
+    o(this, "pumps");
+    o(this, "ingredientContainer");
+    o(this, "troubleContainer");
+    this.id = e, this.path = t, this.name = r, this.ingredientType = s, this.ingredientSource = a, this.ingredientId = i, this.group = l, this.slice = n, this.enjoyByDate = p, this.data = c, this.pumps = new R({
+      parentId: e,
+      sortKey: "path"
+    }), this.logger = y.logger;
+  }
+  updateModel({
+    path: e,
+    name: t,
+    ingredientSource: r,
+    ingredientId: a,
+    ingredientType: i,
+    group: s,
+    slice: n,
+    enjoyByDate: l,
+    data: c
+  }) {
+    this.path = e, this.name = t, this.ingredientId = a, this.ingredientType = i, this.ingredientSource = r, this.enjoyByDate = l, this.slice = n, this.group = s, this.data = c;
+  }
+  get hasEnjoyByDate() {
+    return !!this.enjoyByDate && !this.unassigned;
+  }
+  get hasEnjoyByWarning() {
+    var e;
+    return ((e = this.troublesByType.EnjoyByTrouble) == null ? void 0 : e.length) > 0;
+  }
+  get nozzlePaths() {
+    return this.pumps.data.map((e) => e.nozzlePath);
+  }
+  async cancelPour() {
+    await Promise.all(
+      this.pumps.data.filter((e) => e.isPouring).map((e) => e.cancelPour())
+    );
+  }
+  get canPour() {
+    return !this.shouldDefer && this.pumps.data.every((e) => e.canPour);
+  }
+  get isPouring() {
+    const e = this.pumps.data.some((t) => t.isPouring);
+    return this.logger.debug(`isPouring: ${!!e}`), e;
+  }
+  async performIntent(e) {
+    const t = typeof e == "string" ? e : e.intent, r = typeof e == "string" ? void 0 : e.pumpPath, a = r ? this.pumps.getModel(r) : this.pumps.data[0];
+    return a == null ? void 0 : a.performIntent({ intent: t });
+  }
+  get pourState() {
+    return this.pumps.data.reduce((t, r) => r.pouringState ? r.pouringState : t, "");
+  }
+  get nozzlePath() {
+    var e;
+    return (e = this.pumps.data[0]) == null ? void 0 : e.nozzlePath;
+  }
+  get pumpPaths() {
+    return this.pumps.data.map((e) => e.id);
+  }
+  get sortedPumps() {
+    return this.pumps.data.sort((e, t) => e.virtual && !t.virtual ? -1 : !e.virtual && t.virtual ? 1 : e.name.localeCompare(t.name));
+  }
+  get ingredient() {
+    var t;
+    return this.ingredientId ? (t = this.ingredientContainer) == null ? void 0 : t.ingredients.getModel(
+      this.ingredientId
+    ) : void 0;
+  }
+  get ingredientName() {
+    return this.ingredient ? this.ingredient.displayName ?? this.ingredient.name : this.ingredientId ? "unknown" : "";
+  }
+  get previousIngredient() {
+    var t;
+    return this.prevIngredientId ? (t = this.ingredientContainer) == null ? void 0 : t.ingredients.getModel(
+      this.prevIngredientId
+    ) : void 0;
+  }
+  get previousIngredientName() {
+    return this.previousIngredient ? this.previousIngredient.displayName ?? this.previousIngredient.name : this.prevIngredientId ? "unknown" : "";
+  }
+  get troubles() {
+    return this.troubleContainer.troubles.getIndexByKey("byIface", this.path).sort((e, t) => t.rank - e.rank);
+  }
+  get troubleStatus() {
+    return "";
+  }
+  get troublesByType() {
+    return this.troubles.reduce(
+      Ue,
+      {}
+    );
+  }
+  get prevIngredientId() {
+    var e, t;
+    return (t = (e = this.pumps.data) == null ? void 0 : e[0]) == null ? void 0 : t.prevIngredientId;
+  }
+  get unassigned() {
+    return (!this.ingredientId || this.ingredientId === "0") && (!this.prevIngredientId || this.prevIngredientId === "0");
+  }
+  get removed() {
+    return (!this.ingredientId || this.ingredientId === "0") && this.prevIngredientId !== void 0 && this.prevIngredientId !== "0";
+  }
+  get maxVolume() {
+    return this.slice.maxVolMl ?? 0;
+  }
+  get remainingVolume() {
+    return this.slice.currentVolMl ?? 0;
+  }
+  get hasMaxVolume() {
+    return this.slice.maxVolMl !== void 0;
+  }
+  get hasRemainingVolume() {
+    return this.slice.currentVolMl !== void 0;
+  }
+  get fillPercent() {
+    return this.remainingVolume <= 0 ? 0 : Math.floor((this.remainingVolume || 1) / (this.maxVolume || 1) * 100);
+  }
+  get hasFuelGuage() {
+    return this.hasMaxVolume && this.hasRemainingVolume;
+  }
+  updateIngredient(e) {
+    this.ingredientId !== e && h(() => {
+      this.ingredientId = e;
+    });
+  }
+  async resolveIntentVolume(e) {
+    const t = this.pumps.data[0];
+    return t ? t.resolveIntentVolume(e) : { volume: -1 };
+  }
+  async overrideRfidCode(e) {
+    if (!e)
+      throw new Error("Invalid override");
+    try {
+      const [t, r] = await Vt(this.path, e);
+      if (t)
+        throw new Zt(
+          t,
+          `Failed to perform rfid override on holder ${this.id}`
+        );
+      return h(() => {
+        this.ingredientId = r == null ? void 0 : r.ingredientId;
+      }), r;
+    } catch (t) {
+      throw De.error(`Failed to perform rfid override on holder ${this.id}`, t), t;
+    }
+  }
+  async assignIngredient(e) {
+    try {
+      e ? await Gt(this.path, e) : await Ft(this.path), h(() => {
+        this.ingredientId = e;
+      });
+    } catch (t) {
+      throw De.error(`Failed to perform assign ingredient to holder ${this.id}`, t), t;
+    }
+  }
+  get shouldDefer() {
+    return this.troubles.some((e) => e.shouldDefer);
+  }
+  async replaceLine() {
+    await jt(this.path);
+  }
+  // -------------------LIFECYCLE----------------------------
+  // ----------------------------------
+  // UNCOMMENT FOR TESTING FUEL GAUGE
+  // ----------------------------------
+  // async load() {
+  //   const random = Math.max(1000, Math.floor(Math.random() * 5000));
+  //   this.slice.maxVolMl = 1000;
+  //   setInterval(() => {
+  //     kosAction(() => {
+  //       if (this.remainingVolume < -100) {
+  //         this.slice.maxVolMl = 1000;
+  //         this.slice.currentVolMl = this.maxVolume;
+  //       } else {
+  //         this.slice.currentVolMl = this.remainingVolume - 50;
+  //       }
+  //     });
+  //   }, random);
+  // }
+  // -------------------ENTITY----------------------------
+};
+he([
+  M
+], L.prototype, "pumps", 2);
+he([
+  ce({ modelType: ke.type })
+], L.prototype, "ingredientContainer", 2);
+he([
+  ce({ modelType: Be.type })
+], L.prototype, "troubleContainer", 2);
+L = he([
+  I(j)
+], L);
+const Xe = {
+  registration: {
+    [j]: {
+      class: L,
+      singleton: !1
+    }
+  },
+  type: j,
+  predicate: P(j),
+  factory: v.Factory.create(j)
+}, Xt = async (e, t) => {
+  var Re;
+  const r = g.propertyMapper.executeMapper(
+    u.HolderIngredientMapper,
+    t
+  ), a = g.propertyMapper.executeMapper(
+    u.HolderTypeMapper,
+    t
+  ) || t.ingType, i = await T.executeDataMapperExtension({
+    extension: u.HolderMapper,
+    data: t,
+    contextData: {}
+  }), { name: s, path: n, ingredientId: l, ingType: c, ingSource: p, slice: y, ...U } = t, f = { ...U, ...i }, D = y || { pos: 0 }, re = {
+    name: s,
+    path: n,
+    ingredientId: r || l,
+    ingredientType: a || c,
+    ingredientSource: p,
+    enjoyByDate: (Re = t.container) != null && Re.enjoyByDate ? new Date(t.container.enjoyByDate) : void 0,
+    slice: D,
+    group: e,
+    data: f
+  };
+  return Xe.factory(t.path)(re);
+}, { URL: Jt } = S("ASSEMBLY_SERVICE"), { getOne: qt } = C.build({
+  basePath: `${Jt}/api/kos/device/assemblies`
+}), Wt = m.createLogger({
+  name: "assembly-service",
+  group: "Services"
+}), Je = async () => (Wt.debug("sending GET for assembly"), await qt({}));
+var Qt = Object.defineProperty, er = Object.getOwnPropertyDescriptor, ye = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? er(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && Qt(t, r, i), i;
+};
+const H = "board-container-model", qe = "/kos/hardware/board/linked", We = "/kos/hardware/board/unlinked";
+let x = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "logger");
+    o(this, "models");
+    this.id = e, this.logger = r.logger, this.models = new R({
+      parentId: e,
+      extensionId: u.BoardIndex
+    });
+  }
+  get boardList() {
+    return this.models.data;
+  }
+  updateModel() {
+  }
+  addModel(e) {
+    this.models.addModel(e);
+  }
+  removeModel(e) {
+    this.models.removeModel(e);
+  }
+  updateBoard(e) {
+    const t = e.path, r = this.models.getModel(t);
+    if (!r) {
+      this.logger.warn(`board ${t} not found`);
+      return;
+    }
+    r.updateModel(e);
+  }
+  handleBoardLinkEvent(e) {
+    this.logger.debug(`handling ${qe} event ${e}`), e ? this.updateBoard(e) : this.logger.debug("- boardLinkEvent is undefined");
+  }
+  handleBoardUnlinkEvent(e) {
+    this.logger.debug(
+      `handling ${We} event ${e}`
+    ), e ? this.updateBoard(e) : this.logger.debug("- boardLinkEvent is undefined");
+  }
+};
+ye([
+  M
+], x.prototype, "models", 2);
+ye([
+  Q({
+    lifecycle: Ge.INIT,
+    topic: qe,
+    websocket: !0
+  })
+], x.prototype, "handleBoardLinkEvent", 1);
+ye([
+  Q({
+    lifecycle: Ge.INIT,
+    topic: We,
+    websocket: !0
+  })
+], x.prototype, "handleBoardUnlinkEvent", 1);
+x = ye([
+  I(H)
+], x);
+const tr = async (e) => {
+  const t = e.data.boardPath, { model: r } = N(t);
+  return {
+    boardName: (r == null ? void 0 : r.name) || ""
+  };
+};
+var rr = Object.defineProperty, ir = Object.getOwnPropertyDescriptor, Qe = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? ir(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && rr(t, r, i), i;
+};
+const K = z.PumpContainer;
+var et = /* @__PURE__ */ ((e) => (e.byBoard = "byBoard", e.byType = "byType", e.byNozzle = "byNozzle", e))(et || {});
+let oe = class {
+  constructor(e, t) {
+    o(this, "id");
+    o(this, "pumps");
+    this.id = e, this.pumps = new R({
+      indexMap: {
+        byNozzle: (r) => r.nozzlePaths,
+        byBoard: (r) => r.boardPath,
+        byType: "type"
+      },
+      parentId: e,
+      extensionId: u.PumpIndex
+    });
+  }
+  /**
+   * The collection of pump models.
+   */
+  get pumpModels() {
+    return this.pumps.data;
+  }
+  /**
+   * The collection of pump paths.
+   */
+  get pumpPaths() {
+    return this.pumpModels.map((e) => e.path);
+  }
+  addModel(e) {
+    this.pumps.addModel(e);
+  }
+  removeModel(e) {
+    this.pumps.removeModel(e);
+  }
+  getModel(e) {
+    return this.pumps.getModel(e);
+  }
+  get models() {
+    return this.pumps;
+  }
+  get data() {
+    return this.pumps.data;
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  async load() {
+  }
+  // -------------------ENTITY----------------------------
+};
+Qe([
+  M
+], oe.prototype, "pumps", 2);
+oe = Qe([
+  I(K)
+], oe);
+const Oe = {
+  registration: {
+    [K]: {
+      class: oe,
+      singleton: !0
+    }
+  },
+  type: K,
+  predicate: P(K),
+  factory: v.Singleton.create(
+    K
+  )
+}, tt = async (e) => {
+  const t = [], { model: r } = await Fe(e);
+  return r && (t.push(r.boardPath), t.push(r.nozzlePath), t.push(r.holderPath)), t;
+}, ar = async (e) => {
+  const t = [], r = e.data.pumpPath;
+  t.push(r);
+  const a = await tt(r);
+  return [...t, ...a];
+}, sr = async (e) => {
+  const t = [], r = e.data.boardPath;
+  t.push(e.data.boardPath);
+  const a = await Fe(
+    Oe.type
+  );
+  if (a != null && a.model) {
+    const s = a.model.models.getIndexByKey(
+      et.byBoard,
+      r
+    ).map(
+      (l) => tt(l.path)
+    );
+    (await Promise.allSettled(s)).forEach((l) => {
+      l.status === "fulfilled" && l.value.forEach((c) => t.push(c));
+    });
+  }
+  return Array.from(new Set(t));
+};
+var nr = Object.getOwnPropertyDescriptor, or = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? nr(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = n(i) || i);
+  return i;
+};
+const V = "board-model", Te = (e, t) => {
+  const { type: r, name: a, path: i, linked: s, instanceId: n, link: l, ...c } = e;
+  t.type = r, t.name = a, t.path = i, t.linked = s, t.link = Object.freeze(l), t.instanceId = n, Object.assign(t, c);
+};
+g[Me].register(
+  "board",
+  sr
+);
+g[W].register(
+  "board",
+  tr
+);
+let ve = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "type");
+    o(this, "name");
+    o(this, "path");
+    o(this, "linked");
+    o(this, "instanceId");
+    o(this, "logger");
+    this.id = e, this.logger = r.logger, Te(t, this);
+  }
+  updateModel(e) {
+    Te(e, this);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing board ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading board ${this.id}`);
+  }
+};
+ve = or([
+  I(V)
+], ve);
+const rt = {
+  registration: {
+    [V]: {
+      class: ve,
+      singleton: !1
+    }
+  },
+  type: V,
+  predicate: P(V),
+  factory: v.Factory.create(V)
+}, it = {
+  registration: {
+    [H]: {
+      class: x,
+      singleton: !0
+    },
+    ...rt.registration
+  },
+  type: H,
+  predicate: P(H),
+  factory: v.Singleton.create(
+    H
+  )
+};
+var dr = Object.defineProperty, lr = Object.getOwnPropertyDescriptor, Ie = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? lr(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && dr(t, r, i), i;
+};
+const k = z.HolderContainer, cr = "/kos/insertion/insert/start", pr = "/kos/insertion/insert/complete", ur = "/kos/insertion/insert/update", gr = "/kos/insertion/remove", hr = "/kos/pumpEvent/replaceLine", yr = "/kos/handle/*";
+let A = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "holders");
+    o(this, "logger");
+    this.id = e, this.holders = new R({
+      indexMap: {
+        nozzle: (a) => a.nozzlePaths,
+        group: "group"
+      },
+      parentId: e,
+      extensionId: u.HolderIndex
+    }), this.logger = r.logger;
+  }
+  updateModel() {
+  }
+  handleHolderEvents(e) {
+    var r, a, i;
+    m.ifDebug(
+      () => this.logger.debug("Received holder change event", JSON.stringify(e))
+    );
+    const t = this.holders.getModel(e.path);
+    t && (this.logger.info(
+      `Received change event for holder ${t.path}.  Updating fuel gauge data.`
+    ), t.slice.currentVolMl = (r = e.slice) == null ? void 0 : r.currentVolMl, t.slice.maxVolMl = (a = e.slice) == null ? void 0 : a.maxVolMl, (i = e == null ? void 0 : e.container) != null && i.enjoyByDate ? t.enjoyByDate = new Date(e.container.enjoyByDate) : t.enjoyByDate = void 0);
+  }
+  handleInsertion(e) {
+    m.ifDebug(
+      () => this.logger.debug("Received insertion event", JSON.stringify(e))
+    ), (Array.isArray(e) ? e : [e]).forEach((r) => {
+      h(() => {
+        var s, n, l;
+        const a = r.ingredientId, i = this.holders.getModel(r.path);
+        i && (this.logger.info(
+          `Received insertion event for holder ${i.path}`
+        ), i.updateIngredient(a), i.slice.currentVolMl = (s = r.slice) == null ? void 0 : s.currentVolMl, i.slice.maxVolMl = (n = r.slice) == null ? void 0 : n.maxVolMl, (l = r == null ? void 0 : r.container) != null && l.enjoyByDate ? i.enjoyByDate = new Date(r.container.enjoyByDate) : i.enjoyByDate = void 0, r.pumps.forEach((c) => {
+          h(() => {
+            const p = i.pumps.getModel(c.path);
+            p && (p.ingredientId = c.ingredientId, p.inserted = c.inserted, p.prevIngredientId = c.prevIngredientId);
+          });
+        }));
+      });
+    });
+  }
+  // -------------------ENTITY----------------------------
+};
+Ie([
+  M
+], A.prototype, "holders", 2);
+Ie([
+  Q({
+    topic: yr,
+    websocket: !0,
+    condition: (e, t) => t.holders.getModel(e.path) !== void 0
+  })
+], A.prototype, "handleHolderEvents", 1);
+Ie([
+  Q({
+    topic: [
+      cr,
+      pr,
+      ur,
+      gr,
+      hr
+    ],
+    websocket: !0
+  })
+], A.prototype, "handleInsertion", 1);
+A = Ie([
+  I(k)
+], A);
+const at = {
+  registration: {
+    [k]: {
+      class: A,
+      singleton: !0
+    }
+  },
+  type: k,
+  predicate: P(k),
+  factory: v.Singleton.create(
+    k
+  )
+}, Ir = m.createLogger({ name: "board-utils" }), fr = async (e) => {
+  const t = await T.executeDataMapperExtension({
+    extension: u.BoardMapper,
+    data: e,
+    contextData: {}
+  }), { type: r, name: a, path: i, linked: s, instanceId: n, ...l } = e, c = { ...l, ...t }, p = {
+    type: r,
+    name: a,
+    path: i,
+    linked: s,
+    instanceId: n,
+    ...c
+  }, y = rt.factory(e.path)(p);
+  return y.updateModel(p), y;
+}, mr = (e) => async (t) => {
+  Ir.debug(`adding board ${t.name}`);
+  const r = await fr(t);
+  e.addModel(r);
+};
+var d = /* @__PURE__ */ ((e) => (e.IDLE = "IDLE", e.POURING = "POURING", e.POUR_STARTING = "POUR_STARTING", e.POUR_CANCELING = "POUR_CANCELING", e.POUR_CANCELED = "POUR_CANCELED", e.POUR_COMPLETE = "POUR_COMPLETE", e))(d || {});
+const { URL: Ee } = S("PUMP_SERVICE"), { postModel: br, getOne: vr } = C.build({
+  basePath: `${Ee}/api/kos/holders`
+});
+m.createLogger({
+  name: "pump-service",
+  group: "Services"
+});
+const Pr = async ({
+  intent: e,
+  pumpId: t,
+  tracker: r
+}) => {
+  const a = `${Ee}/api/ext/dispense/nozzle/nozzle/pipeline/ingredient/pour/${t}/${e}`, i = await br({ model: {}, urlOverride: a, tracker: r });
+  return i != null && i.data && pe.initiateFuture(i.data), i;
+}, _r = async (e, t) => {
+  const r = `${Ee}/api/ext/dispense/nozzle/nozzle/pipeline/ingredient/intent/${e}/${t}/volume`, a = await vr({ urlOverride: r });
+  return a != null && a.data ? a.data : { volume: -1 };
+};
+var Mr = Object.defineProperty, Or = Object.getOwnPropertyDescriptor, we = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? Or(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && Mr(t, r, i), i;
+};
+const Y = z.Pump;
+g[Me].register(
+  "pump",
+  ar
+);
+let q = class {
+  constructor(e, t) {
+    o(this, "id");
+    o(this, "inserted");
+    o(this, "type");
+    o(this, "virtual");
+    o(this, "ingredientId");
+    o(this, "holderPath");
+    o(this, "boardPath");
+    o(this, "nozzlePath");
+    o(this, "childPump");
+    o(this, "name");
+    o(this, "path");
+    o(this, "prevIngredientId");
+    o(this, "troubleContainer");
+    o(this, "futureHandler");
+    o(this, "currentState", d.IDLE);
+    this.id = e;
+    const {
+      inserted: r,
+      holderPath: a,
+      boardPath: i,
+      nozzlePath: s,
+      name: n,
+      path: l,
+      childPump: c,
+      virtual: p,
+      prevIngredientId: y,
+      ...U
+    } = t;
+    this.inserted = r, this.type = t.type, this.ingredientId = t.ingredientId, this.holderPath = a, this.boardPath = i, this.nozzlePath = s, this.name = n, this.path = l, this.childPump = !!c, this.virtual = !!p, this.prevIngredientId = y, Object.assign(this, U), this.futureHandler = new je(this);
+  }
+  updateModel(e) {
+    const {
+      inserted: t,
+      holderPath: r,
+      boardPath: a,
+      nozzlePath: i,
+      childPump: s,
+      name: n,
+      path: l,
+      ...c
+    } = e;
+    this.inserted = t, this.type = e.type, this.ingredientId = e.ingredientId, this.holderPath = r, this.boardPath = a, this.nozzlePath = i, this.childPump = this.childPump ? this.childPump : !!s, this.name = n, this.path = l, this.prevIngredientId = e.prevIngredientId, Object.assign(this, c);
+  }
+  // -------------------LIFECYCLE----------------------------
+  get troubles() {
+    return this.troubleContainer.troubles.getIndexByKey("byIface", this.path).sort((e, t) => t.rank - e.rank);
+  }
+  get troubleStatus() {
+    return "";
+  }
+  get troublesByType() {
+    return this.troubles.reduce(
+      Ue,
+      {}
+    );
+  }
+  get pouringState() {
+    var e;
+    return ((e = this.future) == null ? void 0 : e.endState) || "";
+  }
+  get isPouring() {
+    var e;
+    return !!(this.future && !((e = this.future) != null && e.endState)) || this.currentState === d.POUR_STARTING || this.currentState === d.POURING;
+  }
+  get canPour() {
+    return !!this.ingredientId && !this.isPouring;
+  }
+  onFutureUpdate(e) {
+    e.endState && h(() => {
+      this.currentState = d.IDLE;
+    });
+  }
+  async cancelPour() {
+    var e;
+    this.currentState === d.POURING || this.currentState === d.POUR_STARTING ? (this.currentState = d.POUR_CANCELING, await ((e = this.future) == null ? void 0 : e.cancelFuture()), h(() => {
+      this.currentState = d.IDLE;
+    })) : m.warn(`Cannot cancel pour in state ${this.currentState}`);
+  }
+  get future() {
+    return this.futureHandler.future;
+  }
+  async resolveIntentVolume(e) {
+    return await _r(this.path, e);
+  }
+  async performIntent(e, t) {
+    const r = typeof e == "string" ? e : e.intent;
+    if (!r)
+      throw new Error("No intent provided");
+    try {
+      if (this.currentState === d.IDLE) {
+        if (this.currentState = d.POUR_STARTING, !t)
+          throw new Error("No tracker provided");
+        const a = await Pr({
+          tracker: t,
+          intent: r,
+          pumpId: this.path
+        });
+        return this.currentState === d.POUR_STARTING && h(() => {
+          this.currentState = d.POURING;
+        }), a == null ? void 0 : a.data;
+      } else
+        throw new Error(`Cannot pour in state ${this.currentState}`);
+    } catch (a) {
+      throw m.error(a), this.currentState = d.IDLE, a;
+    }
+  }
+  // -------------------ENTITY----------------------------
+};
+we([
+  ce({ modelType: Be.type })
+], q.prototype, "troubleContainer", 2);
+we([
+  ue()
+], q.prototype, "performIntent", 1);
+q = we([
+  I(Y)
+], q);
+const st = {
+  registration: {
+    [Y]: {
+      class: q,
+      singleton: !1
+    }
+  },
+  type: Y,
+  predicate: P(Y),
+  factory: v.Factory.create(Y)
+}, Er = m.createLogger({ name: "pump-utils" }), wr = (e, t) => {
+  const r = (t.pumps ?? []).length > 1, a = {
+    boardPath: t.boardPath,
+    holderPath: t.holderPath,
+    ingredientId: t.ingredientId,
+    childPump: !!t.childPump,
+    virtual: r,
+    inserted: t.inserted,
+    name: t.name,
+    path: t.path,
+    type: t.type,
+    nozzlePath: e,
+    prevIngredientId: t.prevIngredientId
+  }, i = st.factory(t.path)(a);
+  return i.updateModel(a), i;
+}, nt = (e) => (t) => (r) => (a) => {
+  var l;
+  Er.debug(`adding pump ${a.name}`);
+  const i = wr(r.path, a);
+  e.addModel(i);
+  const s = i.holderPath, n = t.holders.getModel(s);
+  n == null || n.pumps.addModel(i), n != null && n.nozzlePaths.includes(r.path) || n == null || n.nozzlePaths.push(r.path), (l = a == null ? void 0 : a.pumps) == null || l.forEach((c) => {
+    const p = i.holderPath, y = {
+      ...c,
+      childPump: !0,
+      holderPath: p,
+      ingredientId: i.ingredientId
+    };
+    nt(e)(t)(r)(y);
+  });
+};
+var $r = Object.defineProperty, Sr = Object.getOwnPropertyDescriptor, ee = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? Sr(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && $r(t, r, i), i;
+};
+const Z = "assembly-model", Cr = "assembly-data", Rr = "assembly-raw-data";
+let w = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "_nozzlePaths", /* @__PURE__ */ new Set());
+    o(this, "troubleContainer");
+    o(this, "holderContainer");
+    o(this, "boardContainer");
+    o(this, "pumpContainer");
+    o(this, "logger");
+    this.id = e, this.holderContainer = at.factory({}), this.boardContainer = it.factory({}), this.pumpContainer = Oe.factory({}), this.logger = r.logger;
+  }
+  updateModel(e) {
+  }
+  get allHolders() {
+    return this.holderContainer.holders.data;
+  }
+  get holderGroups() {
+    return this.holderContainer.holders.getIndexKeys("group");
+  }
+  get nozzlePaths() {
+    return Array.from(this._nozzlePaths);
+  }
+  getHoldersByGroup(e) {
+    return this.holderContainer.holders.getIndexByKey("group", e);
+  }
+  getHoldersByNozzle(e) {
+    return this.holderContainer.holders.getIndexByKey("nozzle", e);
+  }
+  /**
+   * Returns a map of the pumps associated with each nozzle
+   *
+   * Can be used in conjunction with the nozzlePaths to get the pumps associated with each nozzle
+   * @returns Record<string, PumpModel[]>
+   */
+  get pumpsByNozzle() {
+    return this.pumpContainer.models.idx.byNozzle;
+  }
+  /**
+   * Returns a list of all fo the pumps paths across the entire assembly.
+   */
+  get pumpPaths() {
+    return this.pumpContainer.models.data.map((e) => e.path);
+  }
+  get boards() {
+    return this.boardContainer.boardList;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing assembly ${this.id}`);
+  }
+  async ready() {
+    var e;
+    (e = this.troubleContainer) == null || e.troubles.increment(), g[It].execute(
+      u.AssemblyFeatureFlags,
+      this
+    );
+  }
+  async load(e) {
+    this.logger.debug(`loading assembly ${this.id}`);
+    const t = await Je();
+    if ((t == null ? void 0 : t.status) === 200) {
+      const r = await T.executeDataMapperExtension({
+        extension: u.AssemblyMapper,
+        data: t.data,
+        contextData: {}
+      });
+      e.set(Cr, r), Object.assign(this, r), Object.entries(r).forEach(([a, i]) => {
+        ft(i) && (this.logger.debug(`adding child model ${a} from extension data`), this[mt][a] = !0);
+      }), e.set(Rr, t.data);
+      for await (const a of t.data.assemblies) {
+        const {
+          boards: i = [],
+          holders: s = {},
+          nozzles: n = [],
+          core: l,
+          name: c,
+          path: p,
+          ...y
+        } = a;
+        this.logger.debug(`adding assembly ${c}`), Object.keys(y).forEach((f) => {
+          bt.enableFeature(f);
+        });
+        for await (const f of i)
+          this.logger.debug(`adding board ${f.name}`), await mr(this.boardContainer)(f);
+        for await (const [f, D] of Object.entries(
+          s ?? {}
+        ))
+          for await (const re of D) {
+            this.logger.debug(`adding holder ${re.name}`);
+            const Ce = await Xt(f, re);
+            this.holderContainer.holders.addModel(Ce);
+          }
+        const U = nt(this.pumpContainer)(
+          this.holderContainer
+        );
+        n.forEach((f) => {
+          this._nozzlePaths.add(f.path);
+          const D = U(f);
+          f.pumps.forEach(D);
+        });
+      }
+    }
+  }
+};
+ee([
+  ce({
+    modelType: "trouble-container-model"
+  })
+], w.prototype, "troubleContainer", 2);
+ee([
+  M
+], w.prototype, "holderContainer", 2);
+ee([
+  M
+], w.prototype, "boardContainer", 2);
+ee([
+  M
+], w.prototype, "pumpContainer", 2);
+w = ee([
+  I(Z)
+], w);
+const ot = {
+  registration: {
+    [Z]: {
+      class: w,
+      singleton: !0
+    }
+  },
+  type: Z,
+  predicate: P(Z),
+  factory: v.Singleton.create(Z)
+};
+var zr = Object.getOwnPropertyDescriptor, Dr = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? zr(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = n(i) || i);
+  return i;
+};
+const X = z.Availability;
+let Pe = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "data");
+    o(this, "properties");
+    o(this, "available");
+    o(this, "visible");
+    o(this, "groupId");
+    o(this, "rawId");
+    o(this, "altId");
+    o(this, "type");
+    o(this, "note");
+    o(this, "taggedIds");
+    o(this, "parentId");
+    o(this, "logger");
+    this.id = e, this.taggedIds = t.taggedIds || [], this.logger = r.logger, this.available = t.available, this.visible = t.visible, this.groupId = t.groupId, this.rawId = t.rawId, this.altId = t.altId, this.type = t.type, this.parentId = t.kosParentId, this.data = t.data, this.note = t.note, this.properties = t.properties || {};
+  }
+  updateModel(e) {
+    this.taggedIds = e.taggedIds || [], this.available = e.available, this.visible = e.visible, this.groupId = e.groupId, this.rawId = e.rawId, this.altId = e.altId, this.type = e.type, this.data = e.data;
+  }
+  updateAvailability(e) {
+    this.available = e;
+  }
+  // -------------------LIFECYCLE----------------------------
+  // -------------------ENTITY----------------------------
+};
+Pe = Dr([
+  vt(),
+  I(X)
+], Pe);
+const _e = {
+  registration: {
+    [X]: {
+      class: Pe,
+      singleton: !1
+    }
+  },
+  type: X,
+  predicate: P(X),
+  factory: v.Factory.create(
+    X
+  )
+}, { URL: B } = S("NOZZLE_SERVICE"), { postModel: $e, deleteModel: Tr, getOne: Nr } = C.build({
+  basePath: `${B}/api/nozzle`
+}), Lr = async (e, t) => {
+  const r = await $e({
+    model: {},
+    urlOverride: `${B}/api/ext/dispense/nozzle/${e}/pipeline/beverage/pour`,
+    ordered: !0,
+    tracker: t
+  });
+  return r != null && r.data && pe.initiateFuture(r.data), r;
+}, xr = async (e, t, r) => {
+  const a = await $e({
+    model: {},
+    urlOverride: `${B}/api/ext/dispense/nozzle/${t}/pipeline/beverage/fixed/${e}`,
+    ordered: !0,
+    tracker: r
+  });
+  return a != null && a.data && pe.initiateFuture(a.data), a;
+}, Ne = async (e) => await Nr({
+  urlOverride: `${B}${e}/pipeline/beverage/availability`
+}), Ar = async (e, t) => await $e({
+  model: t,
+  urlOverride: `${B}/api/ext/dispense/nozzle/${e}/pipeline/beverage/select`
+}), Br = async (e) => await Tr({
+  id: e,
+  urlOverride: `${B}/api/ext/dispense/nozzle/${e}/pipeline/beverage/select`
+});
+var Ur = Object.defineProperty, Gr = Object.getOwnPropertyDescriptor, te = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? Gr(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && Ur(t, r, i), i;
+};
+const J = z.Nozzle, Fr = Pt(
+  "beverageTopicPrefix"
+), ie = (e) => e.onPourStart !== void 0 && e.onPourCancel !== void 0 && e.onPourProgress !== void 0, Le = "/kos/nozzle/pour/started", jr = "/kos/nozzle/pour/progress", fe = "/kos/nozzle/pour/cancel";
+let $ = class {
+  constructor(e, t, r) {
+    /** the unique identifier for this nozzle.*/
+    o(this, "id");
+    o(this, "path");
+    o(this, "logger");
+    o(this, "name");
+    o(this, "_selectedBeverage");
+    o(this, "_selectedBrand");
+    o(this, "_additionalItems");
+    o(this, "_availabilityItems");
+    o(this, "futureHandler");
+    o(this, "currentState", d.IDLE);
+    o(this, "beverageTopicPrefix");
+    o(this, "topicPrefix");
+    o(this, "urlPrefix");
+    this.id = e, this.path = t.path, this.name = t.name, this.beverageTopicPrefix = t.beverageTopicPrefix, this.topicPrefix = t.topicPrefix, this.urlPrefix = t.urlPrefix, this._selectedBeverage = void 0, this._selectedBrand = void 0, this._additionalItems = [], this.futureHandler = new _t(this), this._availabilityItems = new R({
+      indexMap: {
+        byGroup: "groupId",
+        byParent: "parentId"
+      },
+      parentId: e
+    }), this.logger = r.logger;
+  }
+  /**
+   * The availability nodes that can be dispensed from this nozzle.
+   * This is a subset of the availability for the entire dispenser
+   * and is determined by the nodes associated with a nozzle.
+   */
+  get beverages() {
+    return this._availabilityItems.getIndexByKey("byGroup", "beverages");
+  }
+  /**
+   * The availability nodes that have been grouped into the "brands" group.
+   *
+   */
+  get brands() {
+    return this._availabilityItems.getIndexByKey("byGroup", "brands");
+  }
+  get visibleBrands() {
+    return this.brands.filter((e) => e.visible);
+  }
+  get visibleBeverages() {
+    return this.beverages.filter((e) => e.visible);
+  }
+  /**
+   * A derived value that indicates if the nozzle is currently pouring a beverage.
+   * @readonly
+   */
+  get isPouring() {
+    var e;
+    return !!(this.futureHandler.getFuture() && !((e = this.futureHandler.getFuture()) != null && e.endState)) || this.currentState === d.POUR_STARTING || this.currentState === d.POURING || this.currentState === d.POUR_CANCELING;
+  }
+  /**
+   * A derived value that indicates if the nozzle is currently available to pour a beverage.
+   *
+   * This will generally be determined by whether there is a currently selected pourable AND
+   * the nozzle is not currently pouring.
+   *
+   * The value is observable and will change when the selected pourable changes or the nozzle
+   * starts or stops pouring.
+   * @readonly
+   * */
+  get canPour() {
+    return !!this._selectedBeverage && this._selectedBeverage.available && this.currentState === d.IDLE;
+  }
+  /**
+   * The selected pourable for this nozzle.  Its shape is determined by the results of the
+   * {@link ExtensionType.SelectedPourableMapper} extension.
+   * @readonly
+   *
+   * */
+  get selectedPourable() {
+    return {
+      beverage: this._selectedBeverage,
+      additional: this._additionalItems
+    };
+  }
+  get future() {
+    return this.futureHandler.getFuture();
+  }
+  get pourProgress() {
+    var e;
+    return ((e = this.future) == null ? void 0 : e.progress) ?? 0;
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  setSelectedBrand(e) {
+    this._selectedBrand = e, this._selectedBeverage = void 0;
+  }
+  get selectedBrand() {
+    return this._selectedBrand;
+  }
+  /**
+   * Set the values used to determine the selected pourable for this nozzle.
+   *
+   * @param pourable The pourable to set.
+   * @param pourable.beverage The beverage selected.
+   * @param pourable.additional The additional items such as flavors or other items that could be incorporated
+   * into the pourable.
+   * */
+  async setSelectedPourable({
+    beverage: e,
+    additional: t,
+    context: r
+  }) {
+    if (!e) {
+      const l = await Br(this.name);
+      if ((l == null ? void 0 : l.status) !== 200)
+        throw new Error("Failed to clear pourable");
+      this._selectedBeverage = void 0;
+      return;
+    }
+    if (e === this._selectedBeverage && Mt(this._additionalItems, t)) {
+      this.logger.info("No change in selected pourable");
+      return;
+    }
+    this._selectedBeverage = e, this._additionalItems = t;
+    let a = await g.dataMapper.executeMapper(
+      u.SelectedPourableMapper,
+      {
+        beverage: e,
+        additional: t,
+        context: r
+      }
+    );
+    const i = {
+      bevId: e.rawId
+    };
+    (!a || Object.keys(a).length === 0) && (this.logger.info(
+      `No selected pourable mapper defined, using the default payload ${i}`
+    ), a = i);
+    const s = a ?? i, n = await Ar(this.name, s);
+    if ((n == null ? void 0 : n.status) !== 200)
+      throw new Error("Failed to select pourable");
+  }
+  /**
+   * Utility method that will return the availability nodes that belong to the specified
+   * group as defined in the dispenser beverage graph.  For example, a dispenser
+   * implementation may group availability nodes by Brand, Beverage, or Flavors
+   *
+   * @param groupId The group to filter by.
+   * @returns The availability nodes that are available to be dispensed from this nozzle
+   * and are in the specified group.
+   * */
+  getGroupAvailabilityItems(e) {
+    return this._availabilityItems.getIndexByKey(
+      "byGroup",
+      e
+    );
+  }
+  /**
+   * Utility method that will return the availability nodes that are tagged with the specified parent id.
+   *
+   * This is useful when brandsets use the taggedIds property to associate nodes with a parent node. For example,
+   * when organizing a brandset into brands and beverages, the brand nodes will be tagged with the beverage nodes.
+   *
+   * @param parentId - The parent id to filter by.
+   * @returns the availability nodes that are tagged with the specified parent id.
+   */
+  getAvailabilityByParent(e) {
+    return this._availabilityItems.getIndexByKey(
+      "byParent",
+      e
+    );
+  }
+  updateIfCurrent(e, t) {
+    this.currentState === e && h(() => {
+      this.currentState = t;
+    });
+  }
+  onFutureUpdate(e) {
+    E(this).forEach((a) => {
+      ie(a) && a.onPourProgress(e);
+    });
+    const r = {
+      nozzleId: this.id,
+      progress: e.progress,
+      status: e.status,
+      clientData: e.clientData,
+      futureId: e.futureId,
+      remainingTimeMs: e.remainingTimeMs,
+      endState: e.endState,
+      reason: e.reason,
+      timeRemaining: e.timeRemaining
+    };
+    _.publish(jr, r), e.endState && h(() => {
+      this.currentState = d.IDLE;
+    });
+  }
+  async pour(e) {
+    var t;
+    try {
+      if (this.currentState === d.IDLE) {
+        if (this.updateIfCurrent(d.IDLE, d.POUR_STARTING), !e)
+          throw new Error("No tracker provided");
+        const r = await Lr(this.name, e);
+        this.updateIfCurrent(d.POUR_STARTING, d.POURING), E(this).forEach((i) => {
+          var s;
+          ie(i) && ((s = i.onPourStart) == null || s.call(i));
+        });
+        const a = {
+          nozzleId: this.id,
+          type: "free"
+        };
+        if (_.publish(Le, a), (t = r == null ? void 0 : r.data) != null && t.endState) {
+          this.updateIfCurrent(d.POURING, d.IDLE);
+          const i = {
+            nozzleId: this.id
+          };
+          _.publish(fe, i);
+        }
+        return r;
+      } else
+        throw new Error(`Cannot pour in state ${this.currentState}`);
+    } catch (r) {
+      throw this.logger.error(r), this.currentState = d.IDLE, r;
+    }
+  }
+  async fixedPour(e, t) {
+    var r;
+    try {
+      if (this.currentState === d.IDLE) {
+        if (this.currentState = d.POUR_STARTING, !t)
+          throw new Error("No tracker provided");
+        const a = await xr(e, this.name, t);
+        this.currentState === d.POUR_STARTING && h(() => {
+          this.currentState = d.POURING;
+        }), E(this).forEach((s) => {
+          var n;
+          ie(s) && ((n = s.onPourStart) == null || n.call(s));
+        });
+        const i = {
+          nozzleId: this.id,
+          type: "fixed"
+        };
+        if (_.publish(Le, i), (r = a == null ? void 0 : a.data) != null && r.endState) {
+          this.updateIfCurrent(d.POURING, d.IDLE);
+          const s = {
+            nozzleId: this.id
+          };
+          _.publish(fe, s);
+        }
+        return a;
+      } else
+        throw new Error(`Cannot pour in state ${this.currentState}`);
+    } catch (a) {
+      throw this.logger.error(a), this.currentState = d.IDLE, a;
+    }
+  }
+  /**
+   * An action that will cancel a pour for this nozzle.
+   * */
+  async cancelPour() {
+    var e;
+    if (this.currentState === d.POURING || this.currentState === d.POUR_STARTING) {
+      this.currentState = d.POUR_CANCELING, await ((e = this.futureHandler.getFuture()) == null ? void 0 : e.cancelFuture()), h(() => {
+        this.currentState = d.IDLE;
+      }), E(this).forEach((r) => {
+        var a;
+        ie(r) && ((a = r.onPourCancel) == null || a.call(r));
+      });
+      const t = {
+        nozzleId: this.id
+      };
+      _.publish(fe, t);
+    } else
+      this.logger.warn(`Cannot cancel pour in state ${this.currentState}`);
+  }
+  updateGroupMembers() {
+    this._availabilityItems.data.forEach((e) => {
+      (e.taggedIds || []).forEach((r) => {
+        const a = this._availabilityItems.data.find(
+          (i) => i.rawId === r
+        );
+        a && a.parentId !== e.id && (a.parentId = e.id, this._availabilityItems.updateModel(a));
+      });
+    });
+  }
+  async reload() {
+    this.logger.info(`reloading nozzle ${this.id}`);
+    const e = ze.getContext(this.id);
+    e != null && e.get(u.AvailabilityLoader);
+    const t = await Ne(this.urlPrefix);
+    if ((t == null ? void 0 : t.status) !== 200 || !(t != null && t.data)) {
+      this.logger.error("Failed to load nozzle availability");
+      return;
+    }
+    const r = t == null ? void 0 : t.data;
+    r && await this.updateAvailability(r);
+  }
+  /** @internal */
+  async load(e) {
+    var a, i;
+    this.logger.debug(`loading nozzle ${this.id}`);
+    const t = await Ne(this.urlPrefix);
+    if ((t == null ? void 0 : t.status) !== 200)
+      throw new Error("Failed to load nozzle availability");
+    const r = await g.loader.executeLoader(
+      u.AvailabilityLoader,
+      {}
+    );
+    e == null || e.set(u.AvailabilityLoader, r), e == null || e.set(Se.type, this);
+    for (const s of Object.keys((a = t.data) == null ? void 0 : a.groups) || [])
+      for (const n of ((i = t.data) == null ? void 0 : i.groups[s]) || []) {
+        const l = await g.dataMapper.executeMapper(
+          u.AvailabilityMapper,
+          { ...n, groupId: s },
+          r
+        ), c = {
+          ...n,
+          note: n.note ?? void 0,
+          kosParentId: this.id,
+          rawId: n.id,
+          groupId: s,
+          data: l,
+          properties: n.properties || {}
+        }, p = _e.factory(
+          `${this.id}-${s}-${n.id}`
+        )(c);
+        this._availabilityItems.addModel(p);
+      }
+    this.updateGroupMembers();
+  }
+  async updateAvailability(e) {
+    const t = ze.getContext(this.id), r = (t == null ? void 0 : t.get(u.AvailabilityLoader)) || {};
+    if (e.rebuild) {
+      this.logger.info(
+        `Received rebuild update for nozzle ${this.path}, rebuilding entire availability set`
+      );
+      for (const a of Object.keys(e == null ? void 0 : e.groups) || []) {
+        this._availabilityItems.getIndexByKey("group", a).filter(
+          (s) => !e.groups[a].find(
+            (n) => `${this.id}-${a}-${n.id}` === s.id
+          )
+        ).forEach((s) => {
+          this.logger.info(
+            `Removing beverage ${s.id} from nozzle ${this.path} due to rebuild update`
+          ), this._availabilityItems.removeModel(s.id), Ot(s);
+        });
+        for (const s of (e == null ? void 0 : e.groups[a]) || []) {
+          const n = await g.dataMapper.executeMapper(
+            u.AvailabilityMapper,
+            { ...s, groupId: a },
+            r
+          ), l = {
+            ...s,
+            note: s.note ?? void 0,
+            kosParentId: this.id,
+            groupId: a,
+            rawId: s.id,
+            data: n,
+            taggedIds: s.taggedIds,
+            properties: s.properties || {}
+          }, c = this._availabilityItems.getModel(
+            `${this.id}-${a}-${s.id}`
+          );
+          if (c)
+            c.available !== l.available && this.logger.info(
+              `Updating availability of beverage ${c.id} in nozzle ${this.path} to ${l.available}`
+            ), c.updateModel(l);
+          else {
+            this.logger.info(
+              `Adding beverage ${s.id} to nozzle ${this.path}`
+            );
+            const p = _e.factory(
+              `${this.id}-${a}-${s.id}`
+            )(l);
+            this._availabilityItems.addModel(p);
+          }
+        }
+      }
+    } else {
+      this.logger.info(
+        `Received delta update for nozzle ${this.path}, updating availability nodes`
+      );
+      for (const a of Object.keys(e == null ? void 0 : e.groups) || [])
+        for (const i of (e == null ? void 0 : e.groups[a]) || []) {
+          const s = await g.dataMapper.executeMapper(
+            u.AvailabilityMapper,
+            { ...i, groupId: a },
+            r
+          ), n = {
+            ...i,
+            note: i.note ?? void 0,
+            kosParentId: this.id,
+            groupId: a,
+            rawId: i.id,
+            data: s,
+            type: i.type,
+            taggedIds: i.taggedIds,
+            properties: i.properties || {}
+          }, l = this._availabilityItems.getModel(
+            `${this.id}-${a}-${i.id}`
+          );
+          l && (l.available !== n.available && this.logger.info(
+            `Updating availability of beverage ${l.id} in nozzle ${this.path} to ${n.available}`
+          ), l.updateModel(n));
+        }
+    }
+    this.updateGroupMembers();
+  }
+  // -------------------ENTITY----------------------------
+};
+te([
+  M
+], $.prototype, "_availabilityItems", 2);
+te([
+  ue()
+], $.prototype, "pour", 1);
+te([
+  ue()
+], $.prototype, "fixedPour", 1);
+te([
+  Q({
+    topic: `${Fr}/availability`,
+    websocket: !0
+  })
+], $.prototype, "updateAvailability", 1);
+$ = te([
+  I(J)
+], $);
+const Se = {
+  registration: {
+    [J]: {
+      class: $,
+      singleton: !1
+    }
+  },
+  type: J,
+  predicate: P(J),
+  factory: v.Factory.create(J)
+};
+var Hr = Object.defineProperty, Kr = Object.getOwnPropertyDescriptor, dt = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? Kr(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && Hr(t, r, i), i;
+};
+const lt = "device-assembly-model";
+let de = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "deviceNozzles");
+    o(this, "logger");
+    this.id = e, this.logger = r.logger, this.deviceNozzles = new R();
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing device-assembly ${this.id}`);
+  }
+  getNozzle(e) {
+    return this.deviceNozzles.getModel(e);
+  }
+  get nozzlePaths() {
+    return this.deviceNozzles.data.map((e) => e.path);
+  }
+  async load() {
+    this.logger.debug(`loading device-assembly ${this.id}`);
+    const e = await Je();
+    (e == null ? void 0 : e.status) === 200 && e.data.assemblies.map((r) => r.nozzles ?? []).flat().forEach((r) => {
+      var n;
+      const a = r.path, i = ((n = r.pipelines.find((l) => l.name === "beverage")) == null ? void 0 : n.topicPrefix) || "", s = Se.factory(a)({
+        path: r.path,
+        name: r.name,
+        urlPrefix: r.urlPrefix,
+        topicPrefix: r.topicPrefix,
+        beverageTopicPrefix: i
+      });
+      this.deviceNozzles.addModel(s);
+    });
+  }
+};
+dt([
+  M
+], de.prototype, "deviceNozzles", 2);
+de = dt([
+  I(lt)
+], de);
+const Vr = new Et({
+  class: de,
+  type: lt
+}), { URL: ct } = S("GENERIC_POUR_SERVICE"), { postModel: kr } = C.build({
+  basePath: `${ct}/api/nozzle`
+}), Yr = async (e, t) => {
+  const r = await kr({
+    model: {},
+    urlOverride: `${ct}${e}`,
+    ordered: !0,
+    tracker: t
+  });
+  return r != null && r.data && pe.initiateFuture(r.data), r;
+};
+var Zr = Object.defineProperty, Xr = Object.getOwnPropertyDescriptor, pt = (e, t, r, a) => {
+  for (var i = a > 1 ? void 0 : a ? Xr(t, r) : t, s = e.length - 1, n; s >= 0; s--)
+    (n = e[s]) && (i = (a ? n(t, r, i) : n(i)) || i);
+  return a && i && Zr(t, r, i), i;
+};
+const ut = "generic-pour-model", Jr = "/kos/generic/pour/started", qr = "/kos/generic/pour/progress", xe = "/kos/generic/pour/cancel", me = (e) => e.onPourStart !== void 0 && e.onPourCancel !== void 0 && e.onPourProgress !== void 0;
+let le = class {
+  constructor(e, t, r) {
+    o(this, "id");
+    o(this, "currentState", d.IDLE);
+    o(this, "servicePathFactory");
+    o(this, "pourType");
+    o(this, "logger");
+    o(this, "futureHandler");
+    o(this, "selectedId");
+    this.id = e, this.logger = r.logger, this.futureHandler = new je(this), this.servicePathFactory = t.servicePathFactory, this.pourType = t.pourType || "free", this.selectedId = t.selectedId;
+  }
+  get servicePath() {
+    return this.selectedId ? this.servicePathFactory(this.selectedId) : "";
+  }
+  async pour(e) {
+    var t;
+    try {
+      if (this.currentState === d.IDLE) {
+        if (this.updateIfCurrent(d.IDLE, d.POUR_STARTING), !e)
+          throw new Error("No tracker provided");
+        const r = await Yr(this.servicePath, e);
+        this.updateIfCurrent(d.POUR_STARTING, d.POURING), E(this).forEach((i) => {
+          var s;
+          me(i) && ((s = i.onPourStart) == null || s.call(i));
+        });
+        const a = {
+          pourTarget: this.id,
+          type: this.pourType
+        };
+        if (_.publish(Jr, a), (t = r == null ? void 0 : r.data) != null && t.endState) {
+          this.updateIfCurrent(d.POURING, d.IDLE);
+          const i = {
+            pourTarget: this.id
+          };
+          _.publish(xe, i);
+        }
+        return r;
+      } else
+        throw new Error(`Cannot pour in state ${this.currentState}`);
+    } catch (r) {
+      throw this.logger.error(r), this.currentState = d.IDLE, r;
+    }
+  }
+  async cancelPour() {
+    var e;
+    if (this.currentState === d.POURING || this.currentState === d.POUR_STARTING) {
+      this.currentState = d.POUR_CANCELING, await ((e = this.futureHandler.getFuture()) == null ? void 0 : e.cancelFuture()), h(() => {
+        this.currentState = d.IDLE;
+      }), E(this).forEach((r) => {
+        var a;
+        me(r) && ((a = r.onPourCancel) == null || a.call(r));
+      });
+      const t = {
+        pourTarget: this.id
+      };
+      _.publish(xe, t);
+    }
+    this.currentState === d.IDLE ? this.logger.info("Pour already idle, nothing to cancel.") : this.logger.warn(`Cannot cancel pour in state ${this.currentState}`);
+  }
+  updateIfCurrent(e, t) {
+    this.currentState === e && h(() => {
+      this.currentState = t;
+    });
+  }
+  /**
+   * A derived value that indicates if the nozzle is currently pouring a beverage.
+   * @readonly
+   */
+  get isPouring() {
+    var e;
+    return !!(this.futureHandler.getFuture() && !((e = this.futureHandler.getFuture()) != null && e.endState)) || this.currentState === d.POUR_STARTING || this.currentState === d.POURING || this.currentState === d.POUR_CANCELING;
+  }
+  /**
+   * A derived value that indicates if the pour target is currently available to pour a beverage.
+   *
+   * Generally this means that the pour target is currently idle and not in the process of pouring, initiating a pour, or canceling a pour.
+   * The value is observable and will change when the selected pourable changes or the pour target
+   * starts or stops pouring.
+   * @readonly
+   * */
+  get canPour() {
+    return this.currentState === d.IDLE;
+  }
+  get future() {
+    return this.futureHandler.getFuture();
+  }
+  get pourProgress() {
+    var e;
+    return ((e = this.future) == null ? void 0 : e.progress) ?? 0;
+  }
+  onFutureUpdate(e) {
+    E(this).forEach((r) => {
+      me(r) && r.onPourProgress(e);
+    });
+    const t = {
+      pourTarget: this.id,
+      progress: e.progress,
+      status: e.status,
+      clientData: e.clientData,
+      futureId: e.futureId,
+      remainingTimeMs: e.remainingTimeMs,
+      endState: e.endState,
+      reason: e.reason,
+      timeRemaining: e.timeRemaining
+    };
+    _.publish(qr, t), e.endState && h(() => {
+      this.currentState = d.IDLE;
+    });
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing generic-pour ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading generic-pour ${this.id}`);
+  }
+};
+pt([
+  ue()
+], le.prototype, "pour", 1);
+le = pt([
+  I(ut)
+], le);
+const ni = new wt({
+  class: le,
+  type: ut
+}), Ae = {
+  ...ke.registration,
+  ...He.registration,
+  ...at.registration,
+  ...Xe.registration,
+  ...Se.registration,
+  ...st.registration,
+  ...Oe.registration,
+  ..._e.registration,
+  ...ot.registration,
+  ...it.registration
+}, Wr = (e) => () => (St(e)(), Vr.register(), Object.keys(Ae).forEach((t) => {
+  const r = Ae[t];
+  Ct(e)(t, r);
+}), g[W].register(
+  "FirmwareUpdateInProgressTrouble",
+  async (t) => {
+    var r;
+    if ((r = t.data) != null && r.deviceId) {
+      const { model: a } = N(
+        ot.type
+      );
+      if (a) {
+        const i = a.boards.find(
+          (s) => s.id === t.data.deviceId
+        ) ? N(t.data.deviceId).model : void 0;
+        return {
+          devices: i ? i.name : ""
+        };
+      }
+    }
+    return {};
+  }
+), {
+  preload: O.model.preloadModel(e),
+  model: O.model.register(e),
+  companion: O.companion.register(e),
+  legacy: O.model.registerLegacyModel(e)
+}), b = {
+  ...$t
+};
+b.dispense = {
+  models: Wr(b)
+};
+b.preload = O.model.preloadModel(b);
+b.model = O.model.register(b);
+b.companion = O.companion.register(b);
+b.legacy = O.model.registerLegacyModel(b);
+const oi = b;
+export {
+  ot as A,
+  x as B,
+  Cr as C,
+  z as D,
+  u as E,
+  Ne as F,
+  ni as G,
+  Xe as H,
+  He as I,
+  xr as J,
+  oi as K,
+  Lr as L,
+  Ar as M,
+  Se as N,
+  Yr as O,
+  st as P,
+  qe as T,
+  Rr as a,
+  _e as b,
+  We as c,
+  it as d,
+  rt as e,
+  Vr as f,
+  at as g,
+  ke as h,
+  Oe as i,
+  et as j,
+  Ae as k,
+  d as l,
+  Tt as m,
+  ai as n,
+  Gt as o,
+  si as p,
+  ii as q,
+  Wr as r,
+  ri as s,
+  jt as t,
+  Vt as u,
+  Ft as v,
+  Je as w,
+  _r as x,
+  Pr as y,
+  Br as z
+};
+//# sourceMappingURL=dispense-registration-manager-o2X21qmP.js.map