@kosdev-code/kos-dispense-sdk 2.1.38 → 3.0.0

package/pump-provider-ntLT8vr7.js

@@ -0,0 +1,1804 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import { useKosModel, getKosCompanionModel, kosAutoEffect, KosLog, usePressGesture, EventBus, TimerManager } from "@kosdev-code/kos-ui-sdk";
+import { A as Assembly$1, a as Availability$1, B as Board$1, b as BoardContainer$1, N as Nozzle$1, D as DeviceAssembly, H as Holder$1, f as HolderContainer$1, I as Ingredient$1, g as IngredientContainer$1, G as GenericPour, h as Pump$1 } from "./dispense-registration-manager-BSKa5Oi9.js";
+import React, { createContext, useMemo, useContext, useState, useCallback, useEffect, useRef } from "react";
+const useAssembly = () => {
+  const modelId = Assembly$1.type;
+  const result = useKosModel({
+    modelId,
+    modelType: Assembly$1.type,
+    options: {}
+  });
+  return result;
+};
+function withAssembly(WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useAssembly();
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, assembly: model }) });
+  };
+}
+const useAvailability = () => {
+  const modelId = Availability$1.type;
+  const result = useKosModel({
+    modelId,
+    modelType: Availability$1.type,
+    options: {}
+  });
+  return result;
+};
+function withBeverage(WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useAvailability();
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, beverage: model }) });
+  };
+}
+const useBoard = (id) => {
+  const modelId = id;
+  const result = useKosModel({
+    modelId,
+    modelType: Board$1.type,
+    options: {}
+  });
+  return result;
+};
+function withBoard(WrappedComponent) {
+  return (id) => (props) => {
+    const { model, status, KosModelLoader } = useBoard(id);
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, board: model }) });
+  };
+}
+const useBoardContainer = () => {
+  const modelId = BoardContainer$1.type;
+  const result = useKosModel({
+    modelId,
+    modelType: BoardContainer$1.type,
+    options: {}
+  });
+  return result;
+};
+function withBoardContainer(WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useBoardContainer();
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, boardContainer: model }) });
+  };
+}
+const useNozzle = (path) => {
+  const modelId = path;
+  const result = useKosModel({
+    modelId,
+    modelType: Nozzle$1.type,
+    options: {
+      path
+    }
+  });
+  return result;
+};
+const Nozzle = createContext(void 0);
+const NozzleProvider = ({ children, path }) => {
+  const { model, ready } = useNozzle(path);
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(Nozzle.Provider, { value, children });
+};
+const useNozzleContext = () => {
+  const context = useContext(Nozzle);
+  if (!context) {
+    throw new Error("useNozzleContext must be used within a NozzleProvider");
+  }
+  return context;
+};
+const useBeverages = ({
+  onBeverageSelected,
+  onBeverageListUpdated,
+  onClearBeverage,
+  companionType
+}) => {
+  const { model: nozzle } = useNozzleContext();
+  const [beverages, setBeverages] = useState([]);
+  const [selectedBeverage, setSelectedBeverage] = useState(null);
+  const companions = useMemo(() => {
+    if (!companionType) return [];
+    return beverages.map(
+      (brand) => getKosCompanionModel(brand, companionType)
+    );
+  }, [beverages, companionType]);
+  const selectBeverage = useCallback(
+    async (beverage, context, forceUpdate) => {
+      setSelectedBeverage(beverage);
+      await nozzle?.setSelectedPourable({ beverage, context }, forceUpdate);
+      onBeverageSelected?.(beverage);
+    },
+    [nozzle, onBeverageSelected]
+  );
+  const clearBeverage = useCallback(async () => {
+    setSelectedBeverage(null);
+    await nozzle?.setSelectedPourable({ beverage: void 0 });
+    onClearBeverage?.();
+  }, [nozzle, onClearBeverage]);
+  useEffect(() => {
+    const disposer = kosAutoEffect(() => {
+      if (!nozzle) return;
+      const selectedBrand = nozzle.selectedBrand;
+      if (!selectedBrand) {
+        const allBeverages = nozzle.getGroupAvailabilityItems("beverages").filter((beverage) => beverage.visible);
+        setBeverages(allBeverages ?? []);
+        onBeverageListUpdated?.(allBeverages);
+        return;
+      }
+      const beverages2 = nozzle.getAvailabilityByParent(selectedBrand.id).filter((b) => b.visible);
+      setBeverages(beverages2 ?? []);
+      onBeverageListUpdated?.(beverages2);
+    });
+    return () => {
+      disposer();
+    };
+  }, [nozzle]);
+  return {
+    beverages,
+    beverageCompanions: companions,
+    selectBeverage,
+    selectedBeverage,
+    clearBeverage
+  };
+};
+const useBrands = ({
+  onBrandSelected,
+  onBrandCleared,
+  companionType
+}) => {
+  const { model: nozzle } = useNozzleContext();
+  const [selectedBrand, setSelectedBrand] = useState(null);
+  const [brands, setBrands] = useState([]);
+  const companions = useMemo(() => {
+    if (!companionType) return [];
+    return brands.map((brand) => getKosCompanionModel(brand, companionType));
+  }, [brands, companionType]);
+  const selectBrand = useCallback(
+    async (brand, context, forceUpdate) => {
+      setSelectedBrand(brand);
+      if (forceUpdate) {
+        KosLog.warn(
+          `forceUpdate is not currently supported when setting brand`
+        );
+      }
+      nozzle?.setSelectedBrand(brand, context);
+      onBrandSelected?.(brand);
+    },
+    [nozzle, onBrandSelected]
+  );
+  const clearBrand = useCallback(() => {
+    setSelectedBrand(null);
+    nozzle?.setSelectedBrand(void 0);
+    onBrandCleared?.();
+  }, [nozzle, onBrandCleared]);
+  useEffect(() => {
+    const disposer = kosAutoEffect(() => {
+      if (!nozzle) return;
+      setBrands(nozzle.visibleBrands);
+    });
+    return () => {
+      disposer();
+    };
+  }, [nozzle]);
+  return {
+    brands,
+    brandCompanions: companions,
+    selectedBrand,
+    selectBrand,
+    clearBrand
+  };
+};
+class PourContext {
+  _data = /* @__PURE__ */ new Map();
+  get(key) {
+    return this._data.get(key);
+  }
+  set(key, value) {
+    this._data.set(key, value);
+  }
+  remove(key) {
+    this._data.delete(key);
+  }
+  has(key) {
+    return this._data.has(key);
+  }
+}
+const logger$7 = KosLog.createLogger({
+  name: "HoldToPourStrategy",
+  group: "kos-hooks"
+});
+const HoldToPourStrategy = {
+  name: "HoldToPourStrategy",
+  async initiate(nozzle) {
+    if (!nozzle?.canPour) {
+      logger$7.debug(`Nozzle ${nozzle?.id} cannot pour.  Returning early.`);
+      return;
+    }
+    await nozzle?.pour();
+  },
+  async initiateEnded(nozzle) {
+    await nozzle?.cancelPour();
+  }
+};
+const logger$6 = KosLog.createLogger({
+  name: "useNozzlePour",
+  group: "kos-hooks"
+});
+const useNozzlePour = ({
+  onPour,
+  onPourCancel,
+  onBeforePour,
+  onBeforePourRejected,
+  pourContext,
+  strategy = HoldToPourStrategy
+}) => {
+  const { model: nozzle } = useNozzleContext();
+  const [context, _setContext] = useState(
+    pourContext || new PourContext()
+  );
+  const handlePour = useCallback(async () => {
+    const canPour = onBeforePour ? await onBeforePour?.(context) : true;
+    if (canPour) {
+      logger$6.debug(
+        `[${strategy?.name}] - Pour initiated for nozzle ${nozzle?.id}.`
+      );
+      strategy?.initiate(nozzle);
+      onPour?.();
+    } else {
+      logger$6.debug(
+        `[${strategy?.name}] - Did not pass onBeforePour gate for nozzle ${nozzle?.id}.  Cancelling pour.`
+      );
+      onBeforePourRejected?.();
+    }
+  }, [
+    onPour,
+    nozzle,
+    strategy,
+    onBeforePour,
+    onPourCancel,
+    context,
+    onBeforePourRejected
+  ]);
+  const handleCancelPour = useCallback(() => {
+    logger$6.debug(
+      `[${strategy?.name}] - Pour initiate ended called for nozzle ${nozzle?.id}.`
+    );
+    strategy?.initiateEnded?.(nozzle);
+    onPourCancel?.();
+  }, [onPourCancel, nozzle, strategy]);
+  const forceCancelPour = useCallback(() => {
+    logger$6.debug(`Force cancelling pour for nozzle ${nozzle?.id}.`);
+    nozzle?.cancelPour();
+    onPourCancel?.();
+  }, [onPourCancel, nozzle]);
+  const handleUpdateContext = useCallback(
+    (key, value) => {
+      context.set(key, value);
+    },
+    [context]
+  );
+  const handleRemoveFromContext = useCallback(
+    (key) => {
+      context.remove(key);
+    },
+    [context]
+  );
+  const handlers = usePressGesture({
+    onPressed: handlePour,
+    onRelease: handleCancelPour
+  });
+  return {
+    handlers: handlers.dom,
+    cancel: forceCancelPour,
+    updatePourContext: handleUpdateContext,
+    removeFromPourContext: handleRemoveFromContext,
+    status: nozzle
+  };
+};
+const useFlavors = ({
+  onFlavorSelected,
+  onFlavorCleared,
+  companionType
+}) => {
+  const { model: nozzle } = useNozzleContext();
+  const flavors = useMemo(
+    () => nozzle?.getGroupAvailabilityItems("flavors").filter((f) => f.visible) ?? [],
+    [nozzle]
+  );
+  const companions = useMemo(() => {
+    if (!companionType) return [];
+    return flavors.map(
+      (flavor) => getKosCompanionModel(flavor, companionType)
+    );
+  }, [flavors, companionType]);
+  const [selectedFlavors, setSelectedFlavors] = useState([]);
+  const selectFlavor = useCallback(
+    async (flavor, context, forceUpdate) => {
+      setSelectedFlavors(
+        (previous) => previous?.includes(flavor) ? [...previous.filter((p) => p !== flavor)] : [...previous ?? [], flavor]
+      );
+      if (nozzle?.selectedPourable) {
+        const { beverage } = nozzle.selectedPourable;
+        await nozzle.setSelectedPourable(
+          {
+            beverage,
+            additional: selectedFlavors ?? [],
+            context
+          },
+          forceUpdate
+        );
+      }
+      onFlavorSelected?.(flavor, selectedFlavors ?? []);
+    },
+    [nozzle, onFlavorSelected, selectedFlavors]
+  );
+  const clear = useCallback(async () => {
+    setSelectedFlavors([]);
+    if (nozzle?.selectedPourable) {
+      const { beverage } = nozzle.selectedPourable;
+      nozzle.setSelectedPourable({ beverage });
+      onFlavorCleared?.();
+    }
+  }, [nozzle, onFlavorCleared]);
+  return {
+    flavors,
+    flavorCompanions: companions,
+    selectFlavor,
+    selectedFlavors,
+    clearFlavors: clear
+  };
+};
+const DISPENSE_GROUP_BRAND = "brands";
+const DISPENSE_GROUP_BEVERAGE = "beverages";
+const DISPENSE_GROUP_FLAVOR = "flavors";
+const log$2 = KosLog.createLogger({ name: "use-cui-kit" });
+const useCuiKit = ({
+  initialGroup = DISPENSE_GROUP_BRAND,
+  options = {}
+}) => {
+  const [currentGroup, setCurrentGroup] = useState(initialGroup);
+  const { model: nozzle } = useNozzleContext();
+  const timersRef = useRef([]);
+  const updatePourContext = useRef();
+  const removeFromPourContext = useRef();
+  const onBrandSelected = useCallback(
+    (model) => {
+      setCurrentGroup(DISPENSE_GROUP_BEVERAGE);
+      const topic = `/kos/dispense/${nozzle?.path}/brand/selected/`;
+      EventBus.publish(topic, model);
+    },
+    [nozzle?.path]
+  );
+  const onBrandCleared = useCallback(() => {
+    const topic = `/kos/dispense/${nozzle?.path}/brand/cleared/`;
+    EventBus.publish(topic, {});
+  }, [nozzle?.path]);
+  const onBeverageListUpdated = useCallback(
+    (beverages2) => {
+      const topic = `/kos/dispense/${nozzle?.path}/beverage/list/updated/`;
+      EventBus.publish(topic, beverages2);
+    },
+    [nozzle?.path]
+  );
+  const onBeverageSelected = useCallback(
+    (model) => {
+      setCurrentGroup(DISPENSE_GROUP_FLAVOR);
+      updatePourContext.current?.("selectedBeverage", model);
+      const topic = `/kos/dispense/${nozzle?.path}/beverage/selected/`;
+      EventBus.publish(topic, model);
+    },
+    [nozzle?.path]
+  );
+  const onBeverageCleared = useCallback(() => {
+    const topic = `/kos/dispense/${nozzle?.path}/beverage/cleared/`;
+    removeFromPourContext.current?.("selectedBeverage");
+    EventBus.publish(topic, {});
+  }, [nozzle?.path]);
+  const onFlavorSelected = useCallback(
+    (model) => {
+      const topic = `/kos/dispense/${nozzle?.path}/flavor/selected/`;
+      EventBus.publish(topic, model);
+    },
+    [nozzle?.path]
+  );
+  const onFlavorCleared = useCallback(() => {
+    const topic = `/kos/dispense/${nozzle?.path}/flavor/cleared/`;
+    EventBus.publish(topic, {});
+  }, [nozzle?.path]);
+  const onPour = useCallback(() => {
+    const topic = `/kos/dispense/${nozzle?.path}/pour/`;
+    EventBus.publish(topic, {});
+  }, [nozzle?.path]);
+  const handleBeforePour = useCallback(
+    async (context) => {
+      const topic = `/kos/dispense/${nozzle?.path}/pre/pour/`;
+      EventBus.publish(topic, {});
+      return await onBeforePour?.(context) || true;
+    },
+    [nozzle?.path]
+  );
+  const handleBeforePourRejected = useCallback(async () => {
+    const topic = `/kos/dispense/${nozzle?.path}/pre/pour/rejected/`;
+    EventBus.publish(topic, {});
+  }, [nozzle?.path]);
+  const onPourCancel = useCallback(() => {
+    const topic = `/kos/dispense/${nozzle?.path}/pour/cancel/`;
+    EventBus.publish(topic, {});
+  }, [nozzle?.path]);
+  const { brands, selectBrand, selectedBrand, clearBrand, brandCompanions } = useBrands({
+    companionType: options.companionTypes?.brand,
+    onBrandSelected,
+    onBrandCleared
+  });
+  const {
+    beverages,
+    selectBeverage,
+    selectedBeverage,
+    clearBeverage,
+    beverageCompanions
+  } = useBeverages({
+    companionType: options.companionTypes?.beverage,
+    onBeverageSelected,
+    onClearBeverage: onBeverageCleared,
+    onBeverageListUpdated
+  });
+  const {
+    clearFlavors,
+    flavors,
+    selectFlavor,
+    selectedFlavors,
+    flavorCompanions
+  } = useFlavors({
+    companionType: options.companionTypes?.flavor,
+    onFlavorSelected,
+    onFlavorCleared
+  });
+  const [onBeforePour, setOnBeforePour] = useState();
+  const updateOnBeforePour = useCallback((callback) => {
+    setOnBeforePour(() => callback);
+  }, []);
+  const pour = useNozzlePour({
+    onPour,
+    onPourCancel,
+    onBeforePour: handleBeforePour,
+    onBeforePourRejected: handleBeforePourRejected
+  });
+  updatePourContext.current = pour.updatePourContext;
+  removeFromPourContext.current = pour.removeFromPourContext;
+  const back = useCallback(() => {
+    log$2.debug(`Navigating back from group: ${currentGroup}`);
+    switch (currentGroup) {
+      case DISPENSE_GROUP_BRAND:
+        clearBeverage();
+        clearBrand();
+        break;
+      case DISPENSE_GROUP_BEVERAGE:
+      case DISPENSE_GROUP_FLAVOR:
+        setCurrentGroup(initialGroup);
+        clearBeverage();
+        clearBrand();
+        break;
+    }
+  }, [clearBeverage, clearBrand, currentGroup, initialGroup]);
+  const home = useCallback(() => {
+    const topic = `/kos/dispense/${nozzle?.path}/home/`;
+    EventBus.publish(topic, {});
+    setCurrentGroup(initialGroup);
+    if (initialGroup === DISPENSE_GROUP_BRAND) {
+      clearBeverage();
+      clearBrand();
+    }
+    if (initialGroup === DISPENSE_GROUP_BEVERAGE) {
+      clearBeverage();
+    }
+  }, [clearBeverage, clearBrand, initialGroup]);
+  const pauseTimers = useCallback(() => {
+    if (timersRef.current.length === 0) {
+      log$2.debug("No timers to pause.");
+      return;
+    }
+    log$2.debug(`Pausing ${timersRef.current.length} timers.`);
+    timersRef.current.forEach((timer) => {
+      log$2.debug(`Pausing timer with id ${timer.id}.`);
+      timer.pause();
+    });
+  }, []);
+  const restartTimers = useCallback(() => {
+    if (timersRef.current.length === 0) {
+      log$2.debug("No timers to restart.");
+      return;
+    }
+    log$2.debug(`Restarting ${timersRef.current.length} timers.`);
+    timersRef.current.forEach((timer) => {
+      log$2.debug(`Restarting timer with id ${timer.id}.`);
+      timer.restart();
+    });
+  }, []);
+  const addTimer = useCallback((timer) => {
+    if (!timer) {
+      return;
+    }
+    if (timersRef.current.some((t) => t.id === timer.id)) {
+      log$2.debug(`Timer with id ${timer.id} already exists.`);
+      return;
+    }
+    timersRef.current.push(timer);
+  }, []);
+  return {
+    timers: {
+      add: addTimer,
+      pause: pauseTimers,
+      restart: restartTimers
+    },
+    nav: {
+      currentGroup,
+      back,
+      home
+    },
+    pour,
+    updateOnBeforePour,
+    selections: {
+      [DISPENSE_GROUP_BRAND]: selectedBrand,
+      [DISPENSE_GROUP_BEVERAGE]: selectedBeverage,
+      [DISPENSE_GROUP_FLAVOR]: selectedFlavors
+    },
+    [DISPENSE_GROUP_BRAND]: {
+      models: brands,
+      companions: brandCompanions,
+      clear: clearBrand,
+      handlers: {
+        onSelected: selectBrand
+      }
+    },
+    [DISPENSE_GROUP_BEVERAGE]: {
+      models: beverages,
+      companions: beverageCompanions,
+      clear: clearBeverage,
+      handlers: {
+        onSelected: selectBeverage
+      }
+    },
+    [DISPENSE_GROUP_FLAVOR]: {
+      models: flavors,
+      companions: flavorCompanions,
+      clear: clearFlavors,
+      handlers: {
+        onSelected: selectFlavor
+      }
+    }
+  };
+};
+const useAmbientAttractTimers = (props) => {
+  const { model: nozzle } = useNozzleContext();
+  const [attractTimer, setAttractTimer] = useState(null);
+  const {
+    onAmbientTimer,
+    onAttractTimer,
+    onResetAttractTimer,
+    onResumeAttractTimer,
+    defaultAttractTime,
+    defaultAmbientTime
+  } = props;
+  const handleAmbientTimer = useCallback(() => {
+    if (onAmbientTimer) {
+      KosLog.info("Ambient timer expired.  Calling callback");
+      onAmbientTimer?.();
+    }
+  }, [onAmbientTimer]);
+  const handleAttractTimer = useCallback(() => {
+    if (onAttractTimer) {
+      KosLog.info("Attract timer expired.  Calling callback");
+      onAttractTimer?.();
+    }
+  }, [onAttractTimer]);
+  const handleResetAttractTimer = useCallback(() => {
+    if (attractTimer) {
+      attractTimer.restart();
+      onResetAttractTimer?.();
+    }
+  }, [attractTimer, onResetAttractTimer]);
+  const handlePauseAttractTimer = useCallback(() => {
+    if (attractTimer) {
+      attractTimer.reset();
+      onResetAttractTimer?.();
+    }
+  }, [attractTimer, onResetAttractTimer]);
+  const handleResume = useCallback(() => {
+    if (attractTimer) {
+      attractTimer.pause();
+      onResumeAttractTimer?.();
+    }
+  }, [attractTimer, onResumeAttractTimer]);
+  useEffect(() => {
+    if (nozzle && defaultAttractTime) {
+      KosLog.info("Nozzle is available.  Creating timers");
+      const timer = TimerManager.createTimer(
+        "attract-timer-" + nozzle.path,
+        defaultAttractTime
+      );
+      if (defaultAttractTime) {
+        timer?.addTimeoutAction({
+          name: "attract-timer",
+          remainingTime: 0,
+          action: handleAttractTimer
+        });
+      }
+      if (defaultAmbientTime) {
+        timer?.addTimeoutAction({
+          name: "ambient-timer",
+          remainingTime: defaultAmbientTime,
+          action: handleAmbientTimer
+        });
+      }
+      if (defaultAttractTime) {
+        timer?.start();
+      }
+      setAttractTimer(timer ?? null);
+      return () => {
+        timer?.reset();
+        setAttractTimer(null);
+      };
+    }
+    return () => {
+      KosLog.info("Nozzle is not available.  No timers to clear");
+    };
+  }, [
+    defaultAmbientTime,
+    defaultAttractTime,
+    handleAmbientTimer,
+    handleAttractTimer,
+    nozzle
+  ]);
+  return {
+    attractTimer,
+    restart: handleResetAttractTimer,
+    pause: handlePauseAttractTimer,
+    resume: handleResume
+  };
+};
+const DISPENSE_EVENT_CONFIGS = [
+  { path: "brand/selected", callbackKey: "onBrandSelected" },
+  { path: "brand/cleared", callbackKey: "onBrandCleared" },
+  { path: "beverage/list/updated", callbackKey: "onBeverageListUpdated" },
+  { path: "beverage/selected", callbackKey: "onBeverageSelected" },
+  { path: "beverage/cleared", callbackKey: "onBeverageCleared" },
+  { path: "flavor/selected", callbackKey: "onFlavorSelected" },
+  { path: "flavor/cleared", callbackKey: "onFlavorCleared" },
+  { path: "pour", callbackKey: "onPour" },
+  { path: "pour/cancel", callbackKey: "onPourCancel" },
+  { path: "pre/pour/rejected", callbackKey: "onBeforePourRejected" },
+  { path: "ambient/start", callbackKey: "onAmbientTimer" },
+  { path: "attract/start", callbackKey: "onAttractTimer" },
+  { path: "attract/resume", callbackKey: "onResumeAttractTimer" },
+  { path: "idle/timeout", callbackKey: "onIdleTimeout" },
+  { path: "are-you-there/timeout", callbackKey: "onAreYouThereTimeout" },
+  { path: "init", callbackKey: "onInit" },
+  { path: "home", callbackKey: "onReturnToHome" }
+];
+function buildDispenseTopics(nozzlePath, callbacks) {
+  if (!nozzlePath) {
+    return [];
+  }
+  return DISPENSE_EVENT_CONFIGS.filter(
+    (config) => callbacks[config.callbackKey] !== void 0
+  ).map((config) => {
+    return {
+      topic: `/kos/dispense/${nozzlePath}/${config.path}/`,
+      callback: callbacks[config.callbackKey]
+    };
+  });
+}
+const subscribe = (topic, callback) => {
+  if (callback) {
+    const callbackWrapper = (args) => {
+      if (args && args.body) {
+        callback(args.body);
+      }
+    };
+    const result = EventBus.subscribe(topic, callbackWrapper);
+    return result.unsubscribe;
+  }
+  return void 0;
+};
+const useDispenseLifecycle = ({
+  onInit,
+  onBrandSelected,
+  onBrandCleared,
+  onBeverageCleared,
+  onBeverageSelected,
+  onBeverageListUpdated,
+  onFlavorCleared,
+  onFlavorSelected,
+  onReturnToHome,
+  onPour,
+  onPourCancel,
+  onBeforePourRejected,
+  onAmbientTimer,
+  onAttractTimer,
+  onResumeAttractTimer,
+  onIdleTimeout,
+  onAreYouThereTimeout
+}) => {
+  const { model: nozzle } = useNozzleContext();
+  useEffect(() => {
+    const topics = buildDispenseTopics(nozzle?.path, {
+      onBrandSelected,
+      onBrandCleared,
+      onBeverageListUpdated,
+      onBeverageSelected,
+      onBeverageCleared,
+      onFlavorSelected,
+      onFlavorCleared,
+      onPour,
+      onPourCancel,
+      onBeforePourRejected,
+      onAmbientTimer,
+      onAttractTimer,
+      onResumeAttractTimer,
+      onIdleTimeout,
+      onAreYouThereTimeout,
+      onInit,
+      onReturnToHome
+    });
+    const disposers = topics.map(
+      ({ topic, callback }) => subscribe(topic, callback)
+    );
+    return () => {
+      disposers.forEach((disposer) => disposer?.());
+    };
+  }, [
+    nozzle?.path,
+    onAmbientTimer,
+    onAttractTimer,
+    onBeverageCleared,
+    onBeverageSelected,
+    onBeverageListUpdated,
+    onBrandCleared,
+    onBrandSelected,
+    onFlavorCleared,
+    onFlavorSelected,
+    onPour,
+    onPourCancel,
+    onBeforePourRejected,
+    onResumeAttractTimer,
+    onIdleTimeout,
+    onAreYouThereTimeout,
+    onInit,
+    onReturnToHome
+  ]);
+};
+const log$1 = KosLog.createLogger({ name: "useCuiKitTimers" });
+const useCuiKitTimers = (props) => {
+  const { model: nozzle } = useNozzleContext();
+  const [idleTimer, setIdleTimer] = useState(null);
+  const {
+    onAreYouThereTimer,
+    onIdleTimer,
+    onResetIdleTimer,
+    defaultAreYouThereTime = 10,
+    defaultIdleTime = 20
+  } = props;
+  const hasAreYouThereFiredRef = useRef(false);
+  const handleAreYouThereTimer = useCallback(() => {
+    if (!hasAreYouThereFiredRef.current && onAreYouThereTimer) {
+      KosLog.info("Are you there timer expired.  Calling callback");
+      hasAreYouThereFiredRef.current = true;
+      onAreYouThereTimer?.();
+    }
+  }, [onAreYouThereTimer]);
+  const handleIdleTimer = useCallback(() => {
+    log$1.debug(
+      "handleIdleTimer called in useCuiKitTimers, onIdleTimer exists:",
+      !!onIdleTimer
+    );
+    if (onIdleTimer) {
+      log$1.debug("Idle timer expired.  Calling callback");
+      onIdleTimer?.();
+    } else {
+      log$1.debug("No onIdleTimer callback provided!");
+    }
+  }, [onIdleTimer]);
+  const handleRestartIdleTimer = useCallback(() => {
+    log$1.debug(`TIMER RESTART called for ${props.prefix ?? ""}timer`);
+    if (idleTimer) {
+      idleTimer.restart();
+      hasAreYouThereFiredRef.current = false;
+      onResetIdleTimer?.();
+    }
+  }, [idleTimer, onResetIdleTimer, props.prefix]);
+  const handlePauseIdleTimer = useCallback(() => {
+    log$1.debug(`TIMER PAUSE/RESET called for ${props.prefix ?? ""}timer`);
+    if (idleTimer) {
+      idleTimer.reset();
+      hasAreYouThereFiredRef.current = false;
+      onResetIdleTimer?.();
+    }
+  }, [idleTimer, onResetIdleTimer, props.prefix]);
+  useEffect(() => {
+    log$1.debug(
+      `useCuiKitTimers effect triggered - nozzle: ${!!nozzle}, path: ${nozzle?.path}, callbacks: handleIdle=${!!handleIdleTimer}, handleAreYouThere=${!!handleAreYouThereTimer}`
+    );
+    if (nozzle) {
+      log$1.info("Nozzle is available.  Creating timers");
+      const timer = TimerManager.createTimer(
+        `${props.prefix ?? ""}idle-timer-${nozzle.path}`,
+        defaultIdleTime
+      );
+      log$1.debug(
+        `Adding idle timer action for ${props.prefix ?? ""}idle-timer-${nozzle.path} with callback:`,
+        !!handleIdleTimer
+      );
+      timer?.addTimeoutAction({
+        name: "idle-timer",
+        remainingTime: 0,
+        action: handleIdleTimer
+      });
+      timer?.addTimeoutAction({
+        name: "are-you-there-timer",
+        remainingTime: defaultAreYouThereTime,
+        action: handleAreYouThereTimer
+      });
+      setIdleTimer(timer ?? null);
+      return () => {
+        timer?.reset();
+        setIdleTimer(null);
+      };
+    }
+    return () => {
+      log$1.info("Nozzle is not available.  No timers to clear");
+    };
+  }, [
+    defaultAreYouThereTime,
+    defaultIdleTime,
+    handleAreYouThereTimer,
+    handleIdleTimer,
+    nozzle,
+    props.prefix
+  ]);
+  return {
+    idleTimer,
+    restart: handleRestartIdleTimer,
+    pause: handlePauseIdleTimer
+  };
+};
+const log = KosLog.createLogger({ name: "useDefaultCuiKitLifecycle" });
+const useDefaultCuiKitLifecycle = ({
+  kit,
+  inactivity,
+  pour,
+  screens,
+  onBeforeAreYouThereTimer,
+  areYouThereRejectionPolicy = "pause"
+}) => {
+  const [showAmbientScreen, setShowAmbientScreen] = useState(false);
+  const [showAttractScreen, setShowAttractScreen] = useState(false);
+  const { model: nozzle } = useNozzleContext();
+  const [hasPoured, setHasPoured] = useState(false);
+  const idleTimeout = inactivity?.idleTimeout ?? 15;
+  const areYouThereTimeout = inactivity?.areYouThereTimeoutOffset ?? 10;
+  const idlePourTimeout = pour?.idleTimeout ?? inactivity?.idleTimeout ?? 10;
+  const areYouTherePourTimeout = pour?.areYouThereTimeoutOffset ?? inactivity?.areYouThereTimeoutOffset ?? 5;
+  const ambientTimeout = screens?.ambientTimeoutOffset;
+  const attractTimeout = screens?.attractTimeout;
+  const handleIdleTimeout = useCallback(() => {
+    log.info("handleIdleTimeout called - navigating home and publishing event");
+    setShowAreYouThere(false);
+    kit?.nav.home();
+    if (nozzle) {
+      const topic = `/kos/dispense/${nozzle.path}/idle/timeout/`;
+      EventBus.publish(topic, {});
+    }
+  }, [kit?.nav?.home, nozzle]);
+  const handleResetIdleTimer = useCallback(() => {
+    log.info("handleResetIdleTimer called - resetting idle timer");
+    setShowAreYouThere(false);
+  }, []);
+  const handleAmbientTimer = useCallback(() => {
+    if (ambientTimeout) {
+      setShowAmbientScreen(true);
+      setShowAttractScreen(false);
+      if (nozzle) {
+        const topic = `/kos/dispense/${nozzle.path}/ambient/start/`;
+        EventBus.publish(topic, {});
+      }
+    }
+  }, [ambientTimeout, nozzle]);
+  const handleAttractTimer = useCallback(() => {
+    if (attractTimeout) {
+      setShowAttractScreen(true);
+      setShowAmbientScreen(false);
+      if (nozzle) {
+        const topic = `/kos/dispense/${nozzle.path}/attract/start/`;
+        EventBus.publish(topic, {});
+      }
+    }
+  }, [attractTimeout, nozzle]);
+  const handleAttractResume = useCallback(() => {
+    if (attractTimeout) {
+      setShowAttractScreen(false);
+      setShowAmbientScreen(false);
+      kit?.nav.home();
+      if (nozzle) {
+        const topic = `/kos/dispense/${nozzle.path}/attract/resume/`;
+        EventBus.publish(topic, {});
+      }
+    }
+  }, [kit?.nav, attractTimeout, nozzle]);
+  const {
+    pause: ambientPause,
+    restart: ambientRestart,
+    attractTimer
+  } = useAmbientAttractTimers({
+    defaultAmbientTime: ambientTimeout,
+    defaultAttractTime: attractTimeout,
+    onAmbientTimer: handleAmbientTimer,
+    onAttractTimer: handleAttractTimer,
+    onResumeAttractTimer: handleAttractResume
+  });
+  kit?.timers?.add(attractTimer);
+  const [showAreYouThere, setShowAreYouThere] = useState(false);
+  log.info(
+    "Creating idle timer with timeout:",
+    idleTimeout,
+    "seconds and callback:",
+    !!handleIdleTimeout
+  );
+  const { pause, restart, idleTimer } = useCuiKitTimers({
+    defaultAreYouThereTime: areYouThereTimeout,
+    defaultIdleTime: idleTimeout,
+    onIdleTimer: handleIdleTimeout,
+    onResetIdleTimer: handleResetIdleTimer
+  });
+  log.info(
+    `Creating pour timer with timeout: ${idlePourTimeout} seconds and callback: ${!!handleIdleTimeout}`
+  );
+  const {
+    pause: pausePourTimer,
+    restart: restartPourTimer,
+    idleTimer: pourIdleTimer
+  } = useCuiKitTimers({
+    defaultAreYouThereTime: areYouTherePourTimeout,
+    defaultIdleTime: idlePourTimeout,
+    onIdleTimer: handleIdleTimeout,
+    prefix: "pour-"
+  });
+  const handleAreYouThereTimer = useCallback(async () => {
+    let shouldShowAreYouThere = true;
+    if (onBeforeAreYouThereTimer) {
+      try {
+        shouldShowAreYouThere = await onBeforeAreYouThereTimer();
+      } catch (error) {
+        log.error(`onBeforeAreYouThereTimer callback failed: ${error}`);
+        shouldShowAreYouThere = false;
+      }
+    }
+    if (shouldShowAreYouThere) {
+      if (nozzle) {
+        const topic = `/kos/dispense/${nozzle.path}/are-you-there/timeout/`;
+        EventBus.publish(topic, {});
+      }
+      setShowAreYouThere(true);
+      if (hasPoured) {
+        pausePourTimer();
+      } else {
+        pause();
+      }
+    } else {
+      switch (areYouThereRejectionPolicy) {
+        case "pause":
+          if (hasPoured) {
+            pausePourTimer();
+          } else {
+            pause();
+          }
+          break;
+        case "restart":
+          if (hasPoured) {
+            restartPourTimer();
+          } else {
+            restart();
+          }
+          break;
+      }
+    }
+  }, [onBeforeAreYouThereTimer, nozzle, areYouThereRejectionPolicy, hasPoured]);
+  const clearAreYouThere = useCallback(() => {
+    setShowAreYouThere(false);
+    ambientPause();
+    if (hasPoured) {
+      restartPourTimer();
+      pause();
+    } else {
+      restart();
+      pausePourTimer();
+    }
+  }, [hasPoured, pause, pausePourTimer, restart, restartPourTimer]);
+  useEffect(() => {
+    if (idleTimer) {
+      idleTimer.addTimeoutAction({
+        name: "are-you-there-timer",
+        remainingTime: areYouThereTimeout,
+        action: handleAreYouThereTimer
+      });
+    }
+  }, [idleTimer, areYouThereTimeout, handleAreYouThereTimer]);
+  useEffect(() => {
+    if (pourIdleTimer) {
+      pourIdleTimer.addTimeoutAction({
+        name: "pour-are-you-there-timer",
+        remainingTime: areYouTherePourTimeout,
+        action: handleAreYouThereTimer
+      });
+    }
+  }, [pourIdleTimer, areYouTherePourTimeout, handleAreYouThereTimer]);
+  kit?.timers?.add(idleTimer);
+  kit?.timers?.add(pourIdleTimer);
+  const handlePour = useCallback(() => {
+    setHasPoured(false);
+    pausePourTimer();
+    pause();
+    ambientPause();
+  }, [pause, pausePourTimer]);
+  const handlePourCancel = useCallback(() => {
+    setHasPoured(true);
+    log.info("restarting pour timer");
+    restartPourTimer();
+    ambientPause();
+    pause();
+  }, [pause, restartPourTimer]);
+  const handleBeforePourRejected = useCallback(() => {
+    setHasPoured(false);
+    log.info("restarting pour timer on before pour rejected");
+    pausePourTimer();
+    restart();
+  }, []);
+  const handleBrandSelected = useCallback(() => {
+    ambientPause();
+    setShowAttractScreen(false);
+    setShowAmbientScreen(false);
+    restart();
+  }, [ambientPause, restart]);
+  const handleBrandCleared = useCallback(() => {
+    setShowAttractScreen(false);
+    setShowAmbientScreen(false);
+    setHasPoured(false);
+    pausePourTimer();
+    ambientRestart();
+  }, [ambientRestart, pausePourTimer]);
+  const handleBeverageSelected = useCallback(() => {
+    setShowAttractScreen(false);
+    setShowAmbientScreen(false);
+    setHasPoured(false);
+    ambientPause();
+    restart();
+  }, [ambientPause, restart]);
+  const handleBeverageCleared = useCallback(() => {
+    setShowAttractScreen(false);
+    setShowAmbientScreen(false);
+    setHasPoured(false);
+    ambientRestart();
+    pause();
+    pausePourTimer();
+  }, [ambientRestart, pause, pausePourTimer]);
+  const handleInit = useCallback(() => {
+    setShowAttractScreen(false);
+    setShowAmbientScreen(false);
+    ambientRestart();
+    pause();
+  }, [ambientRestart, pause]);
+  useDispenseLifecycle({
+    onBrandSelected: handleBrandSelected,
+    onBrandCleared: handleBrandCleared,
+    onBeverageSelected: handleBeverageSelected,
+    onBeverageCleared: handleBeverageCleared,
+    onPour: handlePour,
+    onPourCancel: handlePourCancel,
+    onBeforePourRejected: handleBeforePourRejected,
+    onInit: handleInit
+    // Note: Timer-related handlers (onIdleTimeout, onAmbientTimer, onAttractTimer,
+    // onResumeAttractTimer, onAreYouThereTimeout) are NOT included here since this
+    // component's own timer hooks call those handlers directly. Including them would
+    // create circular event loops.
+  });
+  const areYouThereCountdown = hasPoured ? areYouTherePourTimeout : areYouThereTimeout;
+  useEffect(() => {
+    if (nozzle && attractTimer) {
+      const topic = `/kos/dispense/${nozzle?.path}/init/`;
+      EventBus.publish(topic, {});
+    }
+  }, [nozzle, attractTimer]);
+  return {
+    showAreYouThere,
+    clearAreYouThere,
+    pauseIdleTimer: pause,
+    restartIdleTimer: restart,
+    areYouThereCountdown,
+    showAmbientScreen,
+    showAttractScreen,
+    pauseScreenTimer: ambientPause,
+    restartScreenTimer: ambientRestart
+  };
+};
+const useDeviceAssembly = () => {
+  const modelId = DeviceAssembly.type;
+  const result = useKosModel({
+    modelId,
+    modelType: DeviceAssembly.type,
+    options: {}
+  });
+  return result;
+};
+function withDeviceAssembly(WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useDeviceAssembly();
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, deviceAssembly: model }) });
+  };
+}
+const useHolder = (id) => {
+  const modelId = id;
+  const result = useKosModel({
+    modelId,
+    modelType: Holder$1.type,
+    options: {}
+  });
+  return result;
+};
+function withHolder(id, WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useHolder(id);
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, holder: model }) });
+  };
+}
+const useHolderContainer = () => {
+  const modelId = HolderContainer$1.type;
+  const result = useKosModel({
+    modelId,
+    modelType: HolderContainer$1.type,
+    options: {}
+  });
+  return result;
+};
+function withHolderContainer(WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useHolderContainer();
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, holderContainer: model }) });
+  };
+}
+const useIngredient = () => {
+  const modelId = Ingredient$1.type;
+  const result = useKosModel({
+    modelId,
+    modelType: Ingredient$1.type,
+    options: {}
+  });
+  return result;
+};
+const logger$5 = KosLog.createLogger({
+  name: "HoldToPourIntentStrategy",
+  group: "kos-hooks"
+});
+const HoldToPourIntentStrategy = {
+  name: "HoldToPourIntentStrategy",
+  async initiate(model, intent) {
+    if (!model?.canPour) {
+      logger$5.debug(`${model?.id} cannot pour.  Returning early.`);
+      return;
+    }
+    if (intent) {
+      logger$5.debug(`performing intent: ${intent}`);
+      await model?.performIntent(intent);
+    } else {
+      logger$5.debug("no intent provided.  Returning early.");
+    }
+  },
+  async initiateEnded(nozzle) {
+    await nozzle?.cancelPour();
+  }
+};
+const logger$4 = KosLog.createLogger({
+  name: "useNozzlePour",
+  group: "kos-hooks"
+});
+const useIngredientPour = ({
+  onPour,
+  onPourCancel,
+  intentContainer,
+  strategy = HoldToPourIntentStrategy
+}) => {
+  const handlePour = useCallback(() => {
+    logger$4.debug(
+      `[${strategy?.name}] - Pour initiated for model ${intentContainer?.id}.`
+    );
+    strategy?.initiate(intentContainer);
+    onPour?.();
+  }, [onPour, intentContainer, strategy]);
+  const handleCancelPour = useCallback(() => {
+    logger$4.debug(
+      `[${strategy?.name}] - Pour initiate ended called for nozzle ${intentContainer?.id}.`
+    );
+    strategy?.initiateEnded?.(intentContainer);
+    onPourCancel?.();
+  }, [onPourCancel, intentContainer, strategy]);
+  const forceCancelPour = useCallback(() => {
+    logger$4.debug(`Force cancelling pour for nozzle ${intentContainer?.id}.`);
+    intentContainer?.cancelPour();
+    onPourCancel?.();
+  }, [onPourCancel, intentContainer]);
+  const handlers = usePressGesture({
+    onPressed: handlePour,
+    onRelease: handleCancelPour
+  });
+  return {
+    handlers: handlers.dom,
+    cancel: forceCancelPour,
+    status: intentContainer
+  };
+};
+function withIngredient(WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useIngredient();
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, ingredient: model }) });
+  };
+}
+const useIngredientContainer = () => {
+  const modelId = IngredientContainer$1.type;
+  const result = useKosModel({
+    modelId,
+    modelType: IngredientContainer$1.type,
+    options: {}
+  });
+  return result;
+};
+function withIngredientContainer(WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useIngredientContainer();
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, ingredientContainer: model }) });
+  };
+}
+function withNozzle(path, WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useNozzle(path);
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, nozzle: model }) });
+  };
+}
+const logger$3 = KosLog.createLogger({
+  name: "usePour",
+  group: "kos-hooks"
+});
+const usePourTarget = ({
+  onBeforePour,
+  onPour,
+  onPourCancel,
+  onPourAbort,
+  pourTarget,
+  pourContext,
+  strategy = HoldToPourStrategy
+}) => {
+  const [context, _setContext] = useState(
+    pourContext || new PourContext()
+  );
+  const handlePour = useCallback(async () => {
+    logger$3.debug(
+      `[${strategy?.name}] - calling before pour for pour target ${pourTarget?.id}.`
+    );
+    const canPour = onBeforePour ? await onBeforePour?.(context) : true;
+    if (canPour) {
+      logger$3.debug(
+        `[${strategy?.name}] - Pour initiated for pour target ${pourTarget?.id}.`
+      );
+      await strategy?.initiate(pourTarget);
+      onPour?.();
+      if (!pourTarget?.isPouring) {
+        onPourAbort?.();
+      }
+    } else {
+      logger$3.debug(
+        `[${strategy?.name}] - Pour cancelled for pour target ${pourTarget?.id}.`
+      );
+      onPourCancel?.();
+    }
+  }, [onPour, onBeforePour, onPourAbort, pourTarget, strategy, context]);
+  const handleCancelPour = useCallback(async () => {
+    logger$3.debug(
+      `[${strategy?.name}] - Pour initiate ended called for pour target ${pourTarget?.id}.`
+    );
+    const ignore = await strategy?.initiateEnded?.(pourTarget);
+    if (!ignore) {
+      onPourCancel?.();
+    }
+  }, [onPourCancel, pourTarget, strategy]);
+  const forceCancelPour = useCallback(async () => {
+    logger$3.debug(`Force cancelling pour for pour target ${pourTarget?.id}.`);
+    await pourTarget?.cancelPour();
+    onPourCancel?.();
+  }, [onPourCancel, pourTarget]);
+  const handleUpdateContext = useCallback(
+    (key, value) => {
+      context.set(key, value);
+    },
+    [context]
+  );
+  const handleRemoveFromContext = useCallback(
+    (key) => {
+      context.remove(key);
+    },
+    [context]
+  );
+  const handlers = usePressGesture({
+    onPressed: handlePour,
+    onRelease: handleCancelPour
+  });
+  return {
+    handlers: handlers.dom,
+    cancel: forceCancelPour,
+    updatePourContext: handleUpdateContext,
+    removeFromPourContext: handleRemoveFromContext,
+    status: pourTarget
+  };
+};
+const logger$2 = KosLog.createLogger({
+  name: "TapOrHoldIntentStrategy",
+  group: "kos-hooks"
+});
+class TapOrHoldIntentStrategy {
+  intent;
+  name = "TapOrHoldIntentStrategy";
+  isHold = false;
+  disposer = null;
+  constructor(intent) {
+    this.intent = intent;
+  }
+  async initiate(model, intent) {
+    this.disposer = setTimeout(() => {
+      this.isHold = true;
+    }, 250);
+    if (model?.isPouring && !this.isHold) {
+      logger$2.debug(`additional tap detected.  cancelling pour`);
+      await model.cancelPour();
+      return;
+    }
+    if (!model?.canPour) {
+      logger$2.debug(`${model?.id} cannot pour.  Returning early.`);
+      return;
+    }
+    if (intent) {
+      logger$2.debug(`performing intent: ${intent}`);
+      await model?.performIntent(intent);
+    } else {
+      logger$2.debug("no intent provided.  Returning early.");
+    }
+  }
+  async initiateEnded(nozzle) {
+    if (this.disposer) clearTimeout(this.disposer);
+    this.disposer = null;
+    if (!this.isHold) {
+      logger$2.debug("Tap detected.  don't cancel and return.");
+      return true;
+    }
+    await nozzle?.cancelPour();
+    return false;
+  }
+}
+const logger$1 = KosLog.createLogger({
+  name: "TapToPourIntentStrategy",
+  group: "kos-hooks"
+});
+const TapToPourIntentStrategy = {
+  name: "TapToPourIntentStrategy",
+  async initiate(model, intent) {
+    if (model?.isPouring) {
+      logger$1.debug(`Nozzle ${model?.id} is already pouring.  cancelling pour`);
+      await model.cancelPour();
+      return;
+    }
+    if (!model?.canPour) {
+      logger$1.debug(`Nozzle ${model?.id} cannot pour.  Returning early.`);
+      return;
+    }
+    if (intent) {
+      logger$1.debug(`performing intent: ${intent}`);
+      await model?.performIntent(intent);
+    } else {
+      logger$1.debug("no intent provided.  Returning early.");
+    }
+  },
+  async initiateEnded(_nozzle) {
+    return true;
+  }
+};
+const logger = KosLog.createLogger({
+  name: "HoldToPourStrategy",
+  group: "kos-hooks"
+});
+const TapToPourStrategy = {
+  name: "TapToPourStrategy",
+  async initiate(nozzle) {
+    if (nozzle?.isPouring) {
+      logger.debug(`Nozzle ${nozzle?.id} is already pouring.  cancelling pour`);
+      await nozzle.cancelPour();
+      return;
+    }
+    if (!nozzle?.canPour) {
+      logger.debug(`Nozzle ${nozzle?.id} cannot pour.  Returning early.`);
+      return;
+    }
+    await nozzle?.pour();
+  },
+  async initiateEnded(_nozzle) {
+    return true;
+  }
+};
+const useGenericPour = (id, servicePathFactory, itemId, data) => {
+  const modelId = id;
+  const result = useKosModel({
+    modelId,
+    modelType: GenericPour.type,
+    forceUpdate: true,
+    options: {
+      servicePathFactory,
+      selectedId: itemId,
+      initialData: data
+    }
+  });
+  return result;
+};
+function withGenericPour(WrappedComponent) {
+  return (props) => {
+    const { model, status, KosModelLoader } = useGenericPour(
+      props.id,
+      props.servicePathFactory,
+      props.itemId
+    );
+    return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, genericPour: model }) });
+  };
+}
+const Assembly = createContext(void 0);
+const AssemblyProvider = ({ children }) => {
+  const { model, ready } = useAssembly();
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(Assembly.Provider, { value, children });
+};
+const useAssemblyContext = () => {
+  const context = useContext(
+    Assembly
+  );
+  if (!context) {
+    throw new Error(
+      "useAssemblyContext must be used within a AssemblyProvider"
+    );
+  }
+  return context;
+};
+const Availability = createContext(void 0);
+const AvailabilityProvider = ({ children }) => {
+  const { model, ready } = useAvailability();
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(Availability.Provider, { value, children });
+};
+const useAvailabilityContext = () => {
+  const context = useContext(Availability);
+  if (!context) {
+    throw new Error(
+      "useAvailabilityContext must be used within a AvailabilityProvider"
+    );
+  }
+  return context;
+};
+const Board = createContext(void 0);
+const BoardProvider = ({ children, id }) => {
+  const { model, ready } = useBoard(id);
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(Board.Provider, { value, children });
+};
+const useBoardContext = () => {
+  const context = useContext(Board);
+  if (!context) {
+    throw new Error("useBoardContext must be used within a BoardProvider");
+  }
+  return context;
+};
+const BoardContainer = createContext(void 0);
+const BoardContainerProvider = ({ children }) => {
+  const { model, ready } = useBoardContainer();
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(BoardContainer.Provider, { value, children });
+};
+const useBoardContainerContext = () => {
+  const context = useContext(BoardContainer);
+  if (!context) {
+    throw new Error(
+      "useBoardContainerContext must be used within a BoardContainerProvider"
+    );
+  }
+  return context;
+};
+const DeviceAssemblyContext = createContext(
+  void 0
+);
+const DeviceAssemblyProvider = ({ children }) => {
+  const { model, ready } = useDeviceAssembly();
+  const value = useMemo(() => {
+    if (ready && model) {
+      const nozzlePaths = model.nozzlePaths;
+      return { model, nozzlePaths };
+    }
+    return {};
+  }, [ready, model]);
+  const content = ready && model ? children : null;
+  return /* @__PURE__ */ jsx(DeviceAssemblyContext.Provider, { value, children: content });
+};
+const useDeviceAssemblyContext = () => {
+  const context = useContext(DeviceAssemblyContext);
+  if (!context) {
+    throw new Error(
+      "useDeviceAssemblyContext must be used within a DeviceAssemblyProvider"
+    );
+  }
+  return context;
+};
+function createDispenseKitContext() {
+  const CuiKitContext = React.createContext(null);
+  const useCuiKitContext = () => {
+    const ctx = useContext(CuiKitContext);
+    if (ctx === void 0) {
+      throw new Error("useDispenseKitContext must be used within a Provider");
+    }
+    return ctx;
+  };
+  return [useCuiKitContext, CuiKitContext.Provider];
+}
+function CuiKitWrapper({
+  children,
+  provider: CuiKitProvider,
+  props,
+  nozzleProps
+}) {
+  const result = useCuiKit(props);
+  return /* @__PURE__ */ jsx(CuiKitProvider, { value: result, children: children(nozzleProps || {}) });
+}
+function DispenseView({
+  children,
+  provider,
+  props
+}) {
+  const { nozzlePaths } = useDeviceAssemblyContext();
+  const totalNozzles = nozzlePaths?.length || 0;
+  const nozzles = nozzlePaths?.map((path, index) => /* @__PURE__ */ jsx(NozzleProvider, { path, children: /* @__PURE__ */ jsx(
+    CuiKitWrapper,
+    {
+      provider,
+      props,
+      nozzleProps: {
+        nozzleIndex: index,
+        nozzlePath: path,
+        totalNozzles,
+        isFirstNozzle: index === 0,
+        isLastNozzle: index === totalNozzles - 1
+      },
+      children
+    }
+  ) }, path)) || [];
+  return nozzles;
+}
+function CuiKit({
+  provider,
+  props
+}) {
+  return ({ children }) => provider ? /* @__PURE__ */ jsx(DeviceAssemblyProvider, { children: /* @__PURE__ */ jsx(
+    DispenseView,
+    {
+      provider,
+      props,
+      children
+    }
+  ) }) : null;
+}
+function initializeCuiKit(props) {
+  const [useCuiKitContext, DispenseKitProvider] = createDispenseKitContext();
+  return [
+    useCuiKitContext,
+    CuiKit({ provider: DispenseKitProvider, props })
+  ];
+}
+const Holder = createContext(void 0);
+const HolderProvider = ({ children, id }) => {
+  const { model, ready } = useHolder(id || "");
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(Holder.Provider, { value, children });
+};
+const useHolderContext = () => {
+  const context = useContext(Holder);
+  if (!context) {
+    throw new Error("useHolderContext must be used within a HolderProvider");
+  }
+  return context;
+};
+const HolderContainer = createContext(
+  void 0
+);
+const HolderContainerProvider = ({ children }) => {
+  const { model, ready } = useHolderContainer();
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(HolderContainer.Provider, { value, children });
+};
+const useHolderContainerContext = () => {
+  const context = useContext(HolderContainer);
+  if (!context) {
+    throw new Error(
+      "useHolderContainerContext must be used within a HolderContainerProvider"
+    );
+  }
+  return context;
+};
+const Ingredient = createContext(void 0);
+const IngredientProvider = ({ children }) => {
+  const { model, ready } = useIngredient();
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(Ingredient.Provider, { value, children });
+};
+const useIngredientContext = () => {
+  const context = useContext(Ingredient);
+  if (!context) {
+    throw new Error(
+      "useIngredientContext must be used within a IngredientProvider"
+    );
+  }
+  return context;
+};
+const IngredientContainer = createContext(
+  void 0
+);
+const IngredientContainerProvider = ({ children }) => {
+  const { model, ready } = useIngredientContainer();
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(IngredientContainer.Provider, { value, children });
+};
+const useIngredientContainerContext = () => {
+  const context = useContext(IngredientContainer);
+  if (!context) {
+    throw new Error(
+      "useIngredientContainerContext must be used within a IngredientContainerProvider"
+    );
+  }
+  return context;
+};
+const usePump = () => {
+  const modelId = Pump$1.type;
+  const result = useKosModel({
+    modelId,
+    modelType: Pump$1.type,
+    options: {}
+  });
+  return result;
+};
+const Pump = createContext(void 0);
+const PumpProvider = ({ children }) => {
+  const { model, ready } = usePump();
+  const value = useMemo(() => {
+    if (ready && model) {
+      return { model };
+    }
+    return {};
+  }, [ready, model]);
+  return /* @__PURE__ */ jsx(Pump.Provider, { value, children });
+};
+const usePumpContext = () => {
+  const context = useContext(Pump);
+  if (!context) {
+    throw new Error("usePumpContext must be used within a PumpProvider");
+  }
+  return context;
+};
+export {
+  usePourTarget as $,
+  AssemblyProvider as A,
+  BoardContainerProvider as B,
+  CuiKit as C,
+  DISPENSE_GROUP_BEVERAGE as D,
+  useDefaultCuiKitLifecycle as E,
+  useDeviceAssembly as F,
+  useDeviceAssemblyContext as G,
+  HoldToPourIntentStrategy as H,
+  IngredientContainerProvider as I,
+  useDispenseLifecycle as J,
+  useFlavors as K,
+  useGenericPour as L,
+  useHolder as M,
+  NozzleProvider as N,
+  useHolderContainer as O,
+  PourContext as P,
+  useHolderContainerContext as Q,
+  useHolderContext as R,
+  useIngredient as S,
+  TapOrHoldIntentStrategy as T,
+  useIngredientContainer as U,
+  useIngredientContainerContext as V,
+  useIngredientContext as W,
+  useIngredientPour as X,
+  useNozzle as Y,
+  useNozzleContext as Z,
+  useNozzlePour as _,
+  AvailabilityProvider as a,
+  usePumpContext as a0,
+  withAssembly as a1,
+  withBeverage as a2,
+  withBoard as a3,
+  withBoardContainer as a4,
+  withDeviceAssembly as a5,
+  withGenericPour as a6,
+  withHolder as a7,
+  withHolderContainer as a8,
+  withIngredient as a9,
+  withIngredientContainer as aa,
+  withNozzle as ab,
+  BoardProvider as b,
+  CuiKitWrapper as c,
+  DISPENSE_GROUP_BRAND as d,
+  DISPENSE_GROUP_FLAVOR as e,
+  DeviceAssemblyProvider as f,
+  HoldToPourStrategy as g,
+  HolderContainerProvider as h,
+  HolderProvider as i,
+  IngredientProvider as j,
+  PumpProvider as k,
+  TapToPourIntentStrategy as l,
+  TapToPourStrategy as m,
+  initializeCuiKit as n,
+  useAssemblyContext as o,
+  useAvailability as p,
+  useAvailabilityContext as q,
+  useBeverages as r,
+  useBoard as s,
+  useBoardContainer as t,
+  useAssembly as u,
+  useBoardContainerContext as v,
+  useBoardContext as w,
+  useBrands as x,
+  useCuiKit as y,
+  useCuiKitTimers as z
+};
+//# sourceMappingURL=pump-provider-ntLT8vr7.js.map