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

package/{pump-provider-uNNMh9uh.cjs → pump-provider-BSbTT-BC.cjs}

@@ -1,8 +1,8 @@
 "use strict";
 const jsxRuntime = require("@emotion/react/jsx-runtime");
 const kosUiSdk = require("@kosdev-code/kos-ui-sdk");
-const dispenseRegistrationManager = require("./dispense-registration-manager-Dtb31fcI.cjs");
 const React = require("react");
+const dispenseRegistrationManager = require("./dispense-registration-manager-OYGAiIZy.cjs");
 const useAssembly = () => {
   const modelId = dispenseRegistrationManager.Assembly.type;
   const result = kosUiSdk.useKosModel({
@@ -193,30 +193,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 = kosUiSdk.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 = kosUiSdk.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();
@@ -225,278 +234,172 @@ const HoldToPourStrategy = {
     await nozzle?.cancelPour();
   }
 };
-const logger$6 = kosUiSdk.KosLog.createLogger({
-  name: "useNozzlePour",
+const logger$5 = kosUiSdk.KosLog.createLogger({
+  name: "TapOrHoldIntentStrategy",
   group: "kos-hooks"
 });
-const useNozzlePour = ({
-  onPour,
-  onPourCancel,
-  onBeforePour,
-  onBeforePourRejected,
-  pourContext,
-  strategy = HoldToPourStrategy
-}) => {
-  const { model: nozzle } = useNozzleContext();
-  const [context, _setContext] = React.useState(
-    pourContext || new PourContext()
-  );
-  const handlePour = React.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 = React.useCallback(() => {
-    logger$6.debug(
-      `[${strategy?.name}] - Pour initiate ended called for nozzle ${nozzle?.id}.`
-    );
-    strategy?.initiateEnded?.(nozzle);
-    onPourCancel?.();
-  }, [onPourCancel, nozzle, strategy]);
-  const forceCancelPour = React.useCallback(() => {
-    logger$6.debug(`Force cancelling pour for nozzle ${nozzle?.id}.`);
-    nozzle?.cancelPour();
-    onPourCancel?.();
-  }, [onPourCancel, nozzle]);
-  const handleUpdateContext = React.useCallback(
-    (key, value) => {
-      context.set(key, value);
-    },
-    [context]
-  );
-  const handleRemoveFromContext = React.useCallback(
-    (key) => {
-      context.remove(key);
-    },
-    [context]
-  );
-  const handlers = kosUiSdk.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 = kosUiSdk.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 = React.useMemo(
-    () => nozzle?.getGroupAvailabilityItems("flavors").filter((f) => f.visible) ?? [],
-    [nozzle]
-  );
-  const companions = React.useMemo(() => {
-    if (!companionType) return [];
-    return flavors.map(
-      (flavor) => kosUiSdk.getKosCompanionModel(flavor, companionType)
-    );
-  }, [flavors, companionType]);
-  const [selectedFlavors, setSelectedFlavors] = React.useState([]);
-  const selectFlavor = React.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 = React.useCallback(async () => {
-    setSelectedFlavors([]);
-    if (nozzle?.selectedPourable) {
-      const { beverage } = nozzle.selectedPourable;
-      nozzle.setSelectedPourable({ beverage });
-      onFlavorCleared?.();
+const logger$3 = kosUiSdk.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 = kosUiSdk.KosLog.createLogger({ name: "use-cui-kit" });
 const useCuiKit = ({
-  initialGroup = DISPENSE_GROUP_BRAND,
+  initialGroup,
+  steps,
   options = {}
 }) => {
-  const [currentGroup, setCurrentGroup] = React.useState(initialGroup);
   const { model: nozzle } = useNozzleContext();
   const timersRef = React.useRef([]);
-  const updatePourContext = React.useRef();
-  const removeFromPourContext = React.useRef();
-  const onBrandSelected = React.useCallback(
-    (model) => {
-      setCurrentGroup(DISPENSE_GROUP_BEVERAGE);
-      const topic = `/kos/dispense/${nozzle?.path}/brand/selected/`;
-      kosUiSdk.EventBus.publish(topic, model);
-    },
-    [nozzle?.path]
-  );
-  const onBrandCleared = React.useCallback(() => {
-    const topic = `/kos/dispense/${nozzle?.path}/brand/cleared/`;
-    kosUiSdk.EventBus.publish(topic, {});
-  }, [nozzle?.path]);
-  const onBeverageListUpdated = React.useCallback(
-    (beverages2) => {
-      const topic = `/kos/dispense/${nozzle?.path}/beverage/list/updated/`;
-      kosUiSdk.EventBus.publish(topic, beverages2);
-    },
-    [nozzle?.path]
-  );
-  const onBeverageSelected = React.useCallback(
-    (model) => {
-      setCurrentGroup(DISPENSE_GROUP_FLAVOR);
-      updatePourContext.current?.("selectedBeverage", model);
-      const topic = `/kos/dispense/${nozzle?.path}/beverage/selected/`;
-      kosUiSdk.EventBus.publish(topic, model);
-    },
-    [nozzle?.path]
-  );
-  const onBeverageCleared = React.useCallback(() => {
-    const topic = `/kos/dispense/${nozzle?.path}/beverage/cleared/`;
-    removeFromPourContext.current?.("selectedBeverage");
-    kosUiSdk.EventBus.publish(topic, {});
-  }, [nozzle?.path]);
-  const onFlavorSelected = React.useCallback(
-    (model) => {
-      const topic = `/kos/dispense/${nozzle?.path}/flavor/selected/`;
-      kosUiSdk.EventBus.publish(topic, model);
-    },
-    [nozzle?.path]
-  );
-  const onFlavorCleared = React.useCallback(() => {
-    const topic = `/kos/dispense/${nozzle?.path}/flavor/cleared/`;
-    kosUiSdk.EventBus.publish(topic, {});
-  }, [nozzle?.path]);
-  const onPour = React.useCallback(() => {
-    const topic = `/kos/dispense/${nozzle?.path}/pour/`;
-    kosUiSdk.EventBus.publish(topic, {});
-  }, [nozzle?.path]);
-  const handleBeforePour = React.useCallback(
-    async (context) => {
-      const topic = `/kos/dispense/${nozzle?.path}/pre/pour/`;
-      kosUiSdk.EventBus.publish(topic, {});
-      return await onBeforePour?.(context) || true;
+  const kit = React.useMemo(() => {
+    if (!nozzle) return void 0;
+    try {
+      return dispenseRegistrationManager.CuiKitState.instance(dispenseRegistrationManager.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] = React.useState(false);
+  const [, setVersion] = React.useState(0);
+  React.useEffect(() => {
+    if (!kit) return void 0;
+    let dispose;
+    let cancelled = false;
+    let attached = false;
+    kosUiSdk.whenReady(kit).then(() => {
+      if (cancelled) return;
+      attached = true;
+      if (kit.attach()) {
+        kit.reset();
+      }
+      setReady(true);
+      dispose = kosUiSdk.kosAutoEffect(() => {
+        readKitState(kit);
+        setVersion((version) => version + 1);
+      });
+    });
+    return () => {
+      cancelled = true;
+      dispose?.();
+      if (attached) kit.detach();
+    };
+  }, [kit]);
+  const updateOnBeforePour = React.useCallback(
+    (callback) => {
+      kit?.setBeforePour(callback);
     },
-    [nozzle?.path]
+    [kit]
   );
-  const handleBeforePourRejected = React.useCallback(async () => {
-    const topic = `/kos/dispense/${nozzle?.path}/pre/pour/rejected/`;
-    kosUiSdk.EventBus.publish(topic, {});
-  }, [nozzle?.path]);
-  const onPourCancel = React.useCallback(() => {
-    const topic = `/kos/dispense/${nozzle?.path}/pour/cancel/`;
-    kosUiSdk.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] = React.useState();
-  const updateOnBeforePour = React.useCallback((callback) => {
-    setOnBeforePour(() => callback);
-  }, []);
-  const pour = useNozzlePour({
-    onPour,
-    onPourCancel,
-    onBeforePour: handleBeforePour,
-    onBeforePourRejected: handleBeforePourRejected
+  const gesture = kosUiSdk.usePressGesture({
+    onPressed: () => void kit?.pressPour(),
+    onRelease: () => kit?.releasePour()
   });
-  updatePourContext.current = pour.updatePourContext;
-  removeFromPourContext.current = pour.removeFromPourContext;
-  const back = React.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 = React.useCallback(() => {
-    const topic = `/kos/dispense/${nozzle?.path}/home/`;
-    kosUiSdk.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 = React.useCallback(() => {
     if (timersRef.current.length === 0) {
       log$2.debug("No timers to pause.");
@@ -529,6 +432,7 @@ const useCuiKit = ({
     }
     timersRef.current.push(timer);
   }, []);
+  const active = ready ? kit : void 0;
   return {
     timers: {
       add: addTimer,
@@ -536,43 +440,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) {
+            kosUiSdk.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] = React.useState(null);
@@ -1122,6 +1049,59 @@ const useDefaultCuiKitLifecycle = ({
     restartScreenTimer: ambientRestart
   };
 };
+const useFlavors = ({
+  onFlavorSelected,
+  onFlavorCleared,
+  companionType
+}) => {
+  const { model: nozzle } = useNozzleContext();
+  const flavors = React.useMemo(
+    () => nozzle?.getGroupAvailabilityItems("flavors").filter((f) => f.visible) ?? [],
+    [nozzle]
+  );
+  const companions = React.useMemo(() => {
+    if (!companionType) return [];
+    return flavors.map(
+      (flavor) => kosUiSdk.getKosCompanionModel(flavor, companionType)
+    );
+  }, [flavors, companionType]);
+  const [selectedFlavors, setSelectedFlavors] = React.useState([]);
+  const selectFlavor = React.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 = React.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 = dispenseRegistrationManager.DeviceAssembly.type;
   const result = kosUiSdk.useKosModel({
@@ -1176,29 +1156,7 @@ const useIngredient = () => {
   });
   return result;
 };
-const logger$5 = kosUiSdk.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 = kosUiSdk.KosLog.createLogger({
+const logger$2 = kosUiSdk.KosLog.createLogger({
   name: "useNozzlePour",
   group: "kos-hooks"
 });
@@ -1209,21 +1167,21 @@ const useIngredientPour = ({
   strategy = HoldToPourIntentStrategy
 }) => {
   const handlePour = React.useCallback(() => {
-    logger$4.debug(
+    logger$2.debug(
       `[${strategy?.name}] - Pour initiated for model ${intentContainer?.id}.`
     );
     strategy?.initiate(intentContainer);
     onPour?.();
   }, [onPour, intentContainer, strategy]);
   const handleCancelPour = React.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 = React.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]);
@@ -1264,7 +1222,82 @@ function withNozzle(path, WrappedComponent) {
     return /* @__PURE__ */ jsxRuntime.jsx(KosModelLoader, { ...status, children: /* @__PURE__ */ jsxRuntime.jsx(WrappedComponent, { ...props, nozzle: model }) });
   };
 }
-const logger$3 = kosUiSdk.KosLog.createLogger({
+const logger$1 = kosUiSdk.KosLog.createLogger({
+  name: "useNozzlePour",
+  group: "kos-hooks"
+});
+const useNozzlePour = ({
+  onPour,
+  onPourCancel,
+  onBeforePour,
+  onBeforePourRejected,
+  pourContext,
+  strategy = HoldToPourStrategy
+}) => {
+  const { model: nozzle } = useNozzleContext();
+  const [context, _setContext] = React.useState(
+    pourContext || new dispenseRegistrationManager.PourContext()
+  );
+  const handlePour = React.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 = React.useCallback(() => {
+    logger$1.debug(
+      `[${strategy?.name}] - Pour initiate ended called for nozzle ${nozzle?.id}.`
+    );
+    strategy?.initiateEnded?.(nozzle);
+    onPourCancel?.();
+  }, [onPourCancel, nozzle, strategy]);
+  const forceCancelPour = React.useCallback(() => {
+    logger$1.debug(`Force cancelling pour for nozzle ${nozzle?.id}.`);
+    nozzle?.cancelPour();
+    onPourCancel?.();
+  }, [onPourCancel, nozzle]);
+  const handleUpdateContext = React.useCallback(
+    (key, value) => {
+      context.set(key, value);
+    },
+    [context]
+  );
+  const handleRemoveFromContext = React.useCallback(
+    (key) => {
+      context.remove(key);
+    },
+    [context]
+  );
+  const handlers = kosUiSdk.usePressGesture({
+    onPressed: handlePour,
+    onRelease: handleCancelPour
+  });
+  return {
+    handlers: handlers.dom,
+    cancel: forceCancelPour,
+    updatePourContext: handleUpdateContext,
+    removeFromPourContext: handleRemoveFromContext,
+    status: nozzle
+  };
+};
+const logger = kosUiSdk.KosLog.createLogger({
   name: "usePour",
   group: "kos-hooks"
 });
@@ -1278,15 +1311,15 @@ const usePourTarget = ({
   strategy = HoldToPourStrategy
 }) => {
   const [context, _setContext] = React.useState(
-    pourContext || new PourContext()
+    pourContext || new dispenseRegistrationManager.PourContext()
   );
   const handlePour = React.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);
@@ -1295,14 +1328,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 = React.useCallback(async () => {
-    logger$3.debug(
+    logger.debug(
       `[${strategy?.name}] - Pour initiate ended called for pour target ${pourTarget?.id}.`
     );
     const ignore = await strategy?.initiateEnded?.(pourTarget);
@@ -1311,7 +1344,7 @@ const usePourTarget = ({
     }
   }, [onPourCancel, pourTarget, strategy]);
   const forceCancelPour = React.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]);
@@ -1339,98 +1372,6 @@ const usePourTarget = ({
     status: pourTarget
   };
 };
-const logger$2 = kosUiSdk.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 = kosUiSdk.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 = kosUiSdk.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 = kosUiSdk.useKosModel({
@@ -1568,7 +1509,19 @@ function createDispenseKitContext() {
     }
     return ctx;
   };
-  return [useCuiKitContext, CuiKitContext.Provider];
+  const useCuiPour = (options = {}) => {
+    const kit = React.useContext(CuiKitContext);
+    const gesture = kosUiSdk.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,
@@ -1617,10 +1570,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 = React.createContext(void 0);
@@ -1749,7 +1703,6 @@ exports.HolderProvider = HolderProvider;
 exports.IngredientContainerProvider = IngredientContainerProvider;
 exports.IngredientProvider = IngredientProvider;
 exports.NozzleProvider = NozzleProvider;
-exports.PourContext = PourContext;
 exports.PumpProvider = PumpProvider;
 exports.TapOrHoldIntentStrategy = TapOrHoldIntentStrategy;
 exports.TapToPourIntentStrategy = TapToPourIntentStrategy;
@@ -1798,4 +1751,4 @@ exports.withHolderContainer = withHolderContainer;
 exports.withIngredient = withIngredient;
 exports.withIngredientContainer = withIngredientContainer;
 exports.withNozzle = withNozzle;
-//# sourceMappingURL=pump-provider-uNNMh9uh.cjs.map
+//# sourceMappingURL=pump-provider-BSbTT-BC.cjs.map