@kosdev-code/kos-dispense-sdk 0.1.0-next.971 → 0.1.0-next.975

package/{pump-provider-BQmCKz7S.js → pump-provider-Ch7NOeRj.js}

@@ -1,7 +1,7 @@
 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-Da9CW_cN.js";
+import { useKosModel, getKosCompanionModel, kosAutoEffect, KosLog, whenReady, usePressGesture, TimerManager, EventBus } from "@kosdev-code/kos-ui-sdk";
 import React, { createContext, useMemo, useContext, useState, useCallback, useEffect, useRef } from "react";
+import { A as Assembly$1, a as Availability$1, B as Board$1, b as BoardContainer$1, N as Nozzle$1, e as CuiKitState, X as cuiKitId, D as DeviceAssembly, H as Holder$1, g as HolderContainer$1, I as Ingredient$1, h as IngredientContainer$1, P as PourContext, G as GenericPour, j as Pump$1 } from "./dispense-registration-manager-J59_vyyY.js";
 const useAssembly = () => {
   const modelId = Assembly$1.type;
   const result = useKosModel({
@@ -192,30 +192,39 @@ const useBrands = ({
     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: "HoldToPourIntentStrategy",
+  group: "kos-hooks"
+});
+const HoldToPourIntentStrategy = {
+  name: "HoldToPourIntentStrategy",
+  requiresHold: true,
+  async initiate(model, intent) {
+    if (!model?.canPour) {
+      logger$7.debug(`${model?.id} cannot pour.  Returning early.`);
+      return;
+    }
+    if (intent) {
+      logger$7.debug(`performing intent: ${intent}`);
+      await model?.performIntent(intent);
+    } else {
+      logger$7.debug("no intent provided.  Returning early.");
+    }
+  },
+  async initiateEnded(nozzle) {
+    await nozzle?.cancelPour();
+  }
+};
+const logger$6 = KosLog.createLogger({
   name: "HoldToPourStrategy",
   group: "kos-hooks"
 });
 const HoldToPourStrategy = {
   name: "HoldToPourStrategy",
+  requiresHold: true,
   async initiate(nozzle) {
     if (!nozzle?.canPour) {
-      logger$7.debug(`Nozzle ${nozzle?.id} cannot pour.  Returning early.`);
+      logger$6.debug(`Nozzle ${nozzle?.id} cannot pour.  Returning early.`);
       return;
     }
     await nozzle?.pour();
@@ -224,278 +233,172 @@ const HoldToPourStrategy = {
     await nozzle?.cancelPour();
   }
 };
-const logger$6 = KosLog.createLogger({
-  name: "useNozzlePour",
+const logger$5 = KosLog.createLogger({
+  name: "TapOrHoldIntentStrategy",
   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?.();
+class TapOrHoldIntentStrategy {
+  intent;
+  name = "TapOrHoldIntentStrategy";
+  isHold = false;
+  disposer = null;
+  constructor(intent) {
+    this.intent = intent;
+  }
+  async initiate(model, intent = this.intent) {
+    this.isHold = false;
+    this.disposer = setTimeout(() => {
+      this.isHold = true;
+    }, 250);
+    if (model?.isPouring && !this.isHold) {
+      logger$5.debug(`additional tap detected.  cancelling pour`);
+      await model.cancelPour();
+      return;
+    }
+    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$6.debug(
-        `[${strategy?.name}] - Did not pass onBeforePour gate for nozzle ${nozzle?.id}.  Cancelling pour.`
-      );
-      onBeforePourRejected?.();
+      logger$5.debug("no intent provided.  Returning early.");
     }
-  }, [
-    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
-  };
+  }
+  async initiateEnded(nozzle) {
+    if (this.disposer) clearTimeout(this.disposer);
+    this.disposer = null;
+    if (!this.isHold) {
+      logger$5.debug("Tap detected.  don't cancel and return.");
+      return true;
+    }
+    await nozzle?.cancelPour();
+    return false;
+  }
+}
+const logger$4 = KosLog.createLogger({
+  name: "TapToPourIntentStrategy",
+  group: "kos-hooks"
+});
+const TapToPourIntentStrategy = {
+  name: "TapToPourIntentStrategy",
+  async initiate(model, intent) {
+    if (model?.isPouring) {
+      logger$4.debug(`Nozzle ${model?.id} is already pouring.  cancelling pour`);
+      await model.cancelPour();
+      return;
+    }
+    if (!model?.canPour) {
+      logger$4.debug(`Nozzle ${model?.id} cannot pour.  Returning early.`);
+      return;
+    }
+    if (intent) {
+      logger$4.debug(`performing intent: ${intent}`);
+      await model?.performIntent(intent);
+    } else {
+      logger$4.debug("no intent provided.  Returning early.");
+    }
+  },
+  async initiateEnded(_nozzle) {
+    return true;
+  }
 };
-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?.();
+const logger$3 = KosLog.createLogger({
+  name: "HoldToPourStrategy",
+  group: "kos-hooks"
+});
+const TapToPourStrategy = {
+  name: "TapToPourStrategy",
+  async initiate(nozzle) {
+    if (nozzle?.isPouring) {
+      logger$3.debug(`Nozzle ${nozzle?.id} is already pouring.  cancelling pour`);
+      await nozzle.cancelPour();
+      return;
     }
-  }, [nozzle, onFlavorCleared]);
-  return {
-    flavors,
-    flavorCompanions: companions,
-    selectFlavor,
-    selectedFlavors,
-    clearFlavors: clear
-  };
+    if (!nozzle?.canPour) {
+      logger$3.debug(`Nozzle ${nozzle?.id} cannot pour.  Returning early.`);
+      return;
+    }
+    await nozzle?.pour();
+  },
+  async initiateEnded(_nozzle) {
+    return true;
+  }
 };
 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,
+  initialGroup,
+  steps,
   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;
+  const kit = useMemo(() => {
+    if (!nozzle) return void 0;
+    try {
+      return CuiKitState.instance(cuiKitId(nozzle.path)).options({
+        nozzlePath: nozzle.path,
+        initialGroup: steps ? initialGroup : initialGroup ?? DISPENSE_GROUP_BRAND,
+        steps,
+        companionTypes: options.companionTypes,
+        pour: { strategy: options.pour?.strategy ?? HoldToPourStrategy },
+        onPourComplete: options.onPourComplete
+      }).build();
+    } catch (error) {
+      throw new Error(
+        `The CUI Kit models are not registered: call KosModelRegistry.cuiKit.models() in the app's registration chain (${error.message})`
+      );
+    }
+  }, [nozzle]);
+  const [ready, setReady] = useState(false);
+  const [, setVersion] = useState(0);
+  useEffect(() => {
+    if (!kit) return void 0;
+    let dispose;
+    let cancelled = false;
+    let attached = false;
+    whenReady(kit).then(() => {
+      if (cancelled) return;
+      attached = true;
+      if (kit.attach()) {
+        kit.reset();
+      }
+      setReady(true);
+      dispose = kosAutoEffect(() => {
+        readKitState(kit);
+        setVersion((version) => version + 1);
+      });
+    });
+    return () => {
+      cancelled = true;
+      dispose?.();
+      if (attached) kit.detach();
+    };
+  }, [kit]);
+  const updateOnBeforePour = useCallback(
+    (callback) => {
+      kit?.setBeforePour(callback);
     },
-    [nozzle?.path]
+    [kit]
   );
-  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
+  const gesture = usePressGesture({
+    onPressed: () => void kit?.pressPour(),
+    onRelease: () => kit?.releasePour()
   });
-  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 pour = {
+    handlers: gesture.dom,
+    cancel: () => void kit?.cancelPour(),
+    start: async (pourOptions) => await kit?.startPour(pourOptions) ?? false,
+    press: async (pourOptions) => await kit?.pressPour(pourOptions) ?? false,
+    release: (pourOptions) => kit?.releasePour(pourOptions),
+    updatePourContext: (key, value) => kit?.pourContext.set(key, value),
+    removeFromPourContext: (key) => kit?.pourContext.remove(key),
+    status: nozzle
+  };
   const pauseTimers = useCallback(() => {
     if (timersRef.current.length === 0) {
       log$2.debug("No timers to pause.");
@@ -528,6 +431,7 @@ const useCuiKit = ({
     }
     timersRef.current.push(timer);
   }, []);
+  const active = ready ? kit : void 0;
   return {
     timers: {
       add: addTimer,
@@ -535,43 +439,66 @@ const useCuiKit = ({
       restart: restartTimers
     },
     nav: {
-      currentGroup,
-      back,
-      home
+      currentGroup: active?.currentGroup ?? (steps ? steps.brands ? DISPENSE_GROUP_BRAND : DISPENSE_GROUP_BEVERAGE : initialGroup ?? DISPENSE_GROUP_BRAND),
+      back: () => active?.back(),
+      home: () => active?.home(),
+      steps: active?.enabledSteps,
+      canBack: active?.canBack ?? false,
+      toPour: (pourOptions) => active?.toPour(pourOptions)
     },
     pour,
     updateOnBeforePour,
     selections: {
-      [DISPENSE_GROUP_BRAND]: selectedBrand,
-      [DISPENSE_GROUP_BEVERAGE]: selectedBeverage,
-      [DISPENSE_GROUP_FLAVOR]: selectedFlavors
+      [DISPENSE_GROUP_BRAND]: active?.selectedBrand ?? null,
+      [DISPENSE_GROUP_BEVERAGE]: active?.selectedBeverage ?? null,
+      [DISPENSE_GROUP_FLAVOR]: active?.selectedFlavors ?? []
     },
     [DISPENSE_GROUP_BRAND]: {
-      models: brands,
-      companions: brandCompanions,
-      clear: clearBrand,
+      models: active?.brands ?? [],
+      companions: active?.brandCompanions ?? [],
+      clear: () => active?.clearBrand(),
       handlers: {
-        onSelected: selectBrand
+        onSelected: async (model, context, forceUpdate) => {
+          if (forceUpdate) {
+            KosLog.warn(
+              `forceUpdate is not currently supported when setting brand`
+            );
+          }
+          active?.selectBrand(model, context);
+        }
       }
     },
     [DISPENSE_GROUP_BEVERAGE]: {
-      models: beverages,
-      companions: beverageCompanions,
-      clear: clearBeverage,
+      models: active?.beverages ?? [],
+      companions: active?.beverageCompanions ?? [],
+      clear: () => void active?.clearBeverage(),
       handlers: {
-        onSelected: selectBeverage
+        onSelected: async (model, context, forceUpdate) => active?.selectBeverage(model, context, forceUpdate)
       }
     },
     [DISPENSE_GROUP_FLAVOR]: {
-      models: flavors,
-      companions: flavorCompanions,
-      clear: clearFlavors,
+      models: active?.flavors ?? [],
+      companions: active?.flavorCompanions ?? [],
+      clear: () => void active?.clearFlavors(),
       handlers: {
-        onSelected: selectFlavor
+        onSelected: async (model, context, forceUpdate) => active?.selectFlavor(model, context, forceUpdate)
       }
     }
   };
 };
+const readKitState = (kit) => [
+  kit.currentGroup,
+  kit.canBack,
+  kit.selectedBrand,
+  kit.selectedBeverage,
+  ...kit.selectedFlavors,
+  ...kit.brands,
+  ...kit.beverages,
+  ...kit.flavors,
+  ...kit.brandCompanions,
+  ...kit.beverageCompanions,
+  ...kit.flavorCompanions
+];
 const useAmbientAttractTimers = (props) => {
   const { model: nozzle } = useNozzleContext();
   const [attractTimer, setAttractTimer] = useState(null);
@@ -1121,6 +1048,59 @@ const useDefaultCuiKitLifecycle = ({
     restartScreenTimer: ambientRestart
   };
 };
+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 useDeviceAssembly = () => {
   const modelId = DeviceAssembly.type;
   const result = useKosModel({
@@ -1175,29 +1155,7 @@ const useIngredient = () => {
   });
   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({
+const logger$2 = KosLog.createLogger({
   name: "useNozzlePour",
   group: "kos-hooks"
 });
@@ -1208,21 +1166,21 @@ const useIngredientPour = ({
   strategy = HoldToPourIntentStrategy
 }) => {
   const handlePour = useCallback(() => {
-    logger$4.debug(
+    logger$2.debug(
       `[${strategy?.name}] - Pour initiated for model ${intentContainer?.id}.`
     );
     strategy?.initiate(intentContainer);
     onPour?.();
   }, [onPour, intentContainer, strategy]);
   const handleCancelPour = useCallback(() => {
-    logger$4.debug(
+    logger$2.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}.`);
+    logger$2.debug(`Force cancelling pour for nozzle ${intentContainer?.id}.`);
     intentContainer?.cancelPour();
     onPourCancel?.();
   }, [onPourCancel, intentContainer]);
@@ -1263,7 +1221,82 @@ function withNozzle(path, WrappedComponent) {
     return /* @__PURE__ */ jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsx(WrappedComponent, { ...props, nozzle: model }) });
   };
 }
-const logger$3 = KosLog.createLogger({
+const logger$1 = 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$1.debug(
+        `[${strategy?.name}] - Pour initiated for nozzle ${nozzle?.id}.`
+      );
+      strategy?.initiate(nozzle);
+      onPour?.();
+    } else {
+      logger$1.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$1.debug(
+      `[${strategy?.name}] - Pour initiate ended called for nozzle ${nozzle?.id}.`
+    );
+    strategy?.initiateEnded?.(nozzle);
+    onPourCancel?.();
+  }, [onPourCancel, nozzle, strategy]);
+  const forceCancelPour = useCallback(() => {
+    logger$1.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 logger = KosLog.createLogger({
   name: "usePour",
   group: "kos-hooks"
 });
@@ -1280,12 +1313,12 @@ const usePourTarget = ({
     pourContext || new PourContext()
   );
   const handlePour = useCallback(async () => {
-    logger$3.debug(
+    logger.debug(
       `[${strategy?.name}] - calling before pour for pour target ${pourTarget?.id}.`
     );
     const canPour = onBeforePour ? await onBeforePour?.(context) : true;
     if (canPour) {
-      logger$3.debug(
+      logger.debug(
         `[${strategy?.name}] - Pour initiated for pour target ${pourTarget?.id}.`
       );
       await strategy?.initiate(pourTarget);
@@ -1294,14 +1327,14 @@ const usePourTarget = ({
         onPourAbort?.();
       }
     } else {
-      logger$3.debug(
+      logger.debug(
         `[${strategy?.name}] - Pour cancelled for pour target ${pourTarget?.id}.`
       );
       onPourCancel?.();
     }
   }, [onPour, onBeforePour, onPourAbort, pourTarget, strategy, context]);
   const handleCancelPour = useCallback(async () => {
-    logger$3.debug(
+    logger.debug(
       `[${strategy?.name}] - Pour initiate ended called for pour target ${pourTarget?.id}.`
     );
     const ignore = await strategy?.initiateEnded?.(pourTarget);
@@ -1310,7 +1343,7 @@ const usePourTarget = ({
     }
   }, [onPourCancel, pourTarget, strategy]);
   const forceCancelPour = useCallback(async () => {
-    logger$3.debug(`Force cancelling pour for pour target ${pourTarget?.id}.`);
+    logger.debug(`Force cancelling pour for pour target ${pourTarget?.id}.`);
     await pourTarget?.cancelPour();
     onPourCancel?.();
   }, [onPourCancel, pourTarget]);
@@ -1338,98 +1371,6 @@ const usePourTarget = ({
     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({
@@ -1567,7 +1508,19 @@ function createDispenseKitContext() {
     }
     return ctx;
   };
-  return [useCuiKitContext, CuiKitContext.Provider];
+  const useCuiPour = (options = {}) => {
+    const kit = useContext(CuiKitContext);
+    const gesture = usePressGesture({
+      onPressed: () => void kit?.pour.press(options),
+      onRelease: () => kit?.pour.release(options)
+    });
+    return {
+      handlers: gesture.dom,
+      start: async () => await kit?.pour.start(options) ?? false,
+      cancel: () => kit?.pour.cancel()
+    };
+  };
+  return [useCuiKitContext, CuiKitContext.Provider, useCuiPour];
 }
 function CuiKitWrapper({
   children,
@@ -1616,10 +1569,11 @@ function CuiKit({
   ) }) : null;
 }
 function initializeCuiKit(props) {
-  const [useCuiKitContext, DispenseKitProvider] = createDispenseKitContext();
+  const [useCuiKitContext, DispenseKitProvider, useCuiPour] = createDispenseKitContext();
   return [
     useCuiKitContext,
-    CuiKit({ provider: DispenseKitProvider, props })
+    CuiKit({ provider: DispenseKitProvider, props }),
+    useCuiPour
   ];
 }
 const Holder = createContext(void 0);
@@ -1732,47 +1686,46 @@ const usePumpContext = () => {
   return context;
 };
 export {
-  usePourTarget as $,
+  usePumpContext as $,
   AssemblyProvider as A,
   BoardContainerProvider as B,
   CuiKit as C,
   DISPENSE_GROUP_BEVERAGE as D,
-  useDefaultCuiKitLifecycle as E,
-  useDeviceAssembly as F,
-  useDeviceAssemblyContext as G,
+  useDeviceAssembly as E,
+  useDeviceAssemblyContext as F,
+  useDispenseLifecycle as G,
   HoldToPourIntentStrategy as H,
   IngredientContainerProvider as I,
-  useDispenseLifecycle as J,
-  useFlavors as K,
-  useGenericPour as L,
-  useHolder as M,
+  useFlavors as J,
+  useGenericPour as K,
+  useHolder as L,
+  useHolderContainer as M,
   NozzleProvider as N,
-  useHolderContainer as O,
-  PourContext as P,
-  useHolderContainerContext as Q,
-  useHolderContext as R,
-  useIngredient as S,
+  useHolderContainerContext as O,
+  PumpProvider as P,
+  useHolderContext as Q,
+  useIngredient as R,
+  useIngredientContainer 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 _,
+  useIngredientContainerContext as U,
+  useIngredientContext as V,
+  useIngredientPour as W,
+  useNozzle as X,
+  useNozzleContext as Y,
+  useNozzlePour as Z,
+  usePourTarget 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,
+  withAssembly as a0,
+  withBeverage as a1,
+  withBoard as a2,
+  withBoardContainer as a3,
+  withDeviceAssembly as a4,
+  withGenericPour as a5,
+  withHolder as a6,
+  withHolderContainer as a7,
+  withIngredient as a8,
+  withIngredientContainer as a9,
+  withNozzle as aa,
   BoardProvider as b,
   CuiKitWrapper as c,
   DISPENSE_GROUP_BRAND as d,
@@ -1782,21 +1735,21 @@ export {
   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,
+  TapToPourIntentStrategy as k,
+  TapToPourStrategy as l,
+  initializeCuiKit as m,
+  useAssemblyContext as n,
+  useAvailability as o,
+  useAvailabilityContext as p,
+  useBeverages as q,
+  useBoard as r,
+  useBoardContainer as s,
+  useBoardContainerContext as t,
   useAssembly as u,
-  useBoardContainerContext as v,
-  useBoardContext as w,
-  useBrands as x,
-  useCuiKit as y,
-  useCuiKitTimers as z
+  useBoardContext as v,
+  useBrands as w,
+  useCuiKit as x,
+  useCuiKitTimers as y,
+  useDefaultCuiKitLifecycle as z
 };
-//# sourceMappingURL=pump-provider-BQmCKz7S.js.map
+//# sourceMappingURL=pump-provider-Ch7NOeRj.js.map