@oxy.so/bloom 4.12.0 → 4.13.0

package/lib/commonjs/ai-chat/AiChatContainer.js

@@ -19,6 +19,7 @@ var _useIsomorphicLayoutEffect = require("../theme/use-isomorphic-layout-effect.
 var _AiChatControls = require("./AiChatControls.js");
 var _context = require("./context.js");
 var _shared = require("./shared.js");
+var _webViewStyle = require("../styles/web-view-style.js");
 var _jsxRuntime = require("react/jsx-runtime");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const DEFAULT_LABELS = {
@@ -29,12 +30,8 @@ const DEFAULT_LABELS = {
 
 /** The thread's own top padding: the gap between the header and the first turn. */
 const THREAD_PAD_TOP = 16;
-/**
- * `floatingChrome`: the footer's fade strip, px — the footer's top padding, so
- * the last turn at rest ends where the fade begins, and the distance over which
- * the bottom fade ramps in as the transcript slides under it.
- */
-const FOOTER_FADE = 24;
+/** The footer's top padding: the gap between the last turn at rest and the composer. */
+const FOOTER_GAP = 12;
 /** Below this many px of overlap an edge counts as clear (sub-pixel scroll noise). */
 const EDGE_THRESHOLD = 1;
 const HIDDEN_FROM_A11Y = {
@@ -68,14 +65,19 @@ const HIDDEN_FROM_A11Y = {
  *             an edge scrim of the surface (opaque at the top, gone
  *             `SCRIM_TAIL_RATIO` below the block) fades in over the first 16px
  *             of transcript scrolled under it
- *   footer    absolute at the bottom, pt 24 instead of 12: the 24px strip is a
- *             scrim ramp and the rest is solid surface, faded in over the first
- *             24px of transcript below the fold
+ *   footer    absolute at the bottom, with no band of its own: the transcript
+ *             passes behind the composer and stays in sight around it
  *
  * Both blocks are `pointerEvents="box-none"`, so the transcript under their
  * empty space still scrolls and takes clicks. The measured heights reach an
  * `AiChatThread` child through context (its content padding) and any other
  * child through `useAiChatChromeInsets()`.
+ *
+ * Under a shell with `scroll="document"` the chrome always floats, since the
+ * document is what moves: the header and the footer are `sticky` in the flow,
+ * pinned to the screen's top and bottom gutter, the `background` slot and the
+ * card's frame are layers the size of the screen, and the card grows with the
+ * conversation. At rest nothing overlaps, so the insets are zero.
  */
 function AiChatContainer({
   project,
@@ -103,6 +105,8 @@ function AiChatContainer({
     ...DEFAULT_LABELS,
     ...labels
   }), [labels]);
+  const documentScroll = (0, _context.useAiChatShell)()?.documentScroll ?? false;
+  const gutterColor = (0, _react.useContext)(_context.AiChatDocumentGutterContext);
   const hasCrumbRow = title != null || project != null || onShare || onMore || actions != null;
   const crumbRow = hasCrumbRow ? /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
     pointerEvents: "box-none",
@@ -185,6 +189,35 @@ function AiChatContainer({
     borderRadius: _shared.CONTAINER_RADIUS,
     backgroundColor: surface ? palette.secondary : 'transparent'
   }, style];
+  if (documentScroll) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(FloatingChrome, {
+      documentScroll: true,
+      testID: testID,
+      rootStyle: [{
+        // Grows with the conversation, one screen at the least; nothing
+        // clips it, so the header and composer inside can stick.
+        minHeight: (0, _webViewStyle.webViewportHeightMinus)(_shared.SHELL_GUTTER * 2),
+        minWidth: 0,
+        flex: 1,
+        flexDirection: 'column',
+        borderRadius: _shared.CONTAINER_RADIUS,
+        backgroundColor: surface ? palette.secondary : 'transparent'
+      }, style],
+      backgroundLayer: background ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+        pointerEvents: "none",
+        style: [_shared.DOCUMENT_LAYER, {
+          overflow: 'hidden'
+        }],
+        children: background
+      }) : null,
+      header: header,
+      crumbRow: crumbRow,
+      footerBody: footerBody,
+      fadeColor: surface ? palette.secondary : null,
+      gutterColor: gutterColor,
+      children: children
+    });
+  }
   if (floatingChrome) {
     return /*#__PURE__*/(0, _jsxRuntime.jsx)(FloatingChrome, {
       testID: testID,
@@ -214,17 +247,24 @@ function AiChatContainer({
     })]
   });
 }
+const NO_INSETS = {
+  top: 0,
+  bottom: 0
+};
+
 /**
- * `AiChatContainer floatingChrome`: the same parts, the chrome floated over the
- * transcript. Everything it measures lives here, so the stacked path above
- * carries none of the state.
+ * `AiChatContainer floatingChrome` (and every container under a document-
+ * scrolled shell): the same parts, the chrome floated over the transcript.
+ * Everything it measures lives here, so the stacked path above carries none of
+ * the state.
  *
- * The edge opacities are shared values written from the thread's scroll
- * reports, so a scroll frame re-renders nothing; the booleans only mount and
- * unmount the scrims, and change once per crossing. Same model as the
+ * The header's edge opacity is a shared value written from the thread's scroll
+ * reports, so a scroll frame re-renders nothing; the boolean only mounts and
+ * unmounts the scrim, and changes once per crossing. Same model as the
  * sidebar's `SidebarScrollArea`, whose scrim this reuses.
  */
 function FloatingChrome({
+  documentScroll = false,
   testID,
   rootStyle,
   backgroundLayer,
@@ -232,32 +272,30 @@ function FloatingChrome({
   crumbRow,
   footerBody,
   fadeColor,
+  gutterColor = null,
   children
 }) {
-  const [insets, setInsets] = (0, _react.useState)({
-    top: 0,
-    bottom: 0
-  });
-  const [edges, setEdges] = (0, _react.useState)({
-    top: false,
-    bottom: false
-  });
+  const [insets, setInsets] = (0, _react.useState)(NO_INSETS);
+  const [headerHeight, setHeaderHeight] = (0, _react.useState)(0);
+  const [scrolled, setScrolled] = (0, _react.useState)(false);
   const topFade = (0, _reactNativeReanimated.useSharedValue)(0);
-  const bottomFade = (0, _reactNativeReanimated.useSharedValue)(0);
   const onHeaderLayout = (0, _react.useCallback)(event => {
     const top = Math.round(event.nativeEvent.layout.height);
-    setInsets(previous => previous.top === top ? previous : {
+    setHeaderHeight(top);
+    // In the flow the header covers nothing at rest: no inset to publish.
+    if (!documentScroll) setInsets(previous => previous.top === top ? previous : {
       ...previous,
       top
     });
-  }, []);
+  }, [documentScroll]);
   const onFooterLayout = (0, _react.useCallback)(event => {
+    if (documentScroll) return;
     const bottom = Math.round(event.nativeEvent.layout.height);
     setInsets(previous => previous.bottom === bottom ? previous : {
       ...previous,
       bottom
     });
-  }, []);
+  }, [documentScroll]);
   const reportScroll = (0, _react.useCallback)(({
     offset,
     viewport,
@@ -266,18 +304,12 @@ function FloatingChrome({
     const range = Math.max(0, content - viewport);
     const y = Math.max(0, Math.min(offset, range));
     const overflow = viewport > 0 && range > EDGE_THRESHOLD;
-    // The first turn rests THREAD_PAD_TOP below the header and the last one
-    // right on the footer's fade strip, so the overlap starts at the first px
-    // scrolled and each ramp spans the gap it is closing.
-    const top = overflow && y > EDGE_THRESHOLD;
-    const bottom = overflow && range - y > EDGE_THRESHOLD;
+    // The first turn rests THREAD_PAD_TOP below the header, so the overlap
+    // starts at the first px scrolled and the ramp spans the gap it closes.
     topFade.value = overflow ? Math.min(1, y / THREAD_PAD_TOP) : 0;
-    bottomFade.value = overflow ? Math.min(1, (range - y) / FOOTER_FADE) : 0;
-    setEdges(previous => previous.top === top && previous.bottom === bottom ? previous : {
-      top,
-      bottom
-    });
-  }, [topFade, bottomFade]);
+    const next = overflow && y > EDGE_THRESHOLD;
+    setScrolled(previous => previous === next ? previous : next);
+  }, [topFade]);
   const chrome = (0, _react.useMemo)(() => ({
     insets,
     reportScroll
@@ -290,92 +322,110 @@ function FloatingChrome({
   const topStyle = (0, _reactNativeReanimated.useAnimatedStyle)(() => ({
     opacity: topFade.value * alpha
   }), [topFade, alpha]);
-  const bottomStyle = (0, _reactNativeReanimated.useAnimatedStyle)(() => ({
-    opacity: bottomFade.value * alpha
-  }), [bottomFade, alpha]);
   const prefix = testID ?? 'ai-chat';
-  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
-    testID: testID,
-    style: [rootStyle, {
-      position: 'relative'
-    }],
-    children: [backgroundLayer, /*#__PURE__*/(0, _jsxRuntime.jsx)(_context.AiChatFloatingChromeContext.Provider, {
-      value: chrome,
-      children: children
-    }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
-      testID: `${prefix}-chrome-top`,
-      pointerEvents: "box-none",
-      onLayout: onHeaderLayout,
-      style: {
+
+  // Absolute over a card of fixed height; sticky in the flow of a card that
+  // grows with the document, pinned to the screen's gutter.
+  const headerPosition = documentScroll ? {
+    position: _webViewStyle.WEB_POSITION_STICKY,
+    top: _shared.SHELL_GUTTER,
+    zIndex: 2
+  } : {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0
+  };
+  const footerPosition = documentScroll ? {
+    position: _webViewStyle.WEB_POSITION_STICKY,
+    bottom: _shared.SHELL_GUTTER,
+    zIndex: 2
+  } : {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    bottom: 0
+  };
+  const top = /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+    testID: `${prefix}-chrome-top`,
+    pointerEvents: "box-none",
+    onLayout: onHeaderLayout,
+    style: headerPosition,
+    children: [solid && scrolled && headerHeight > 0 ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNativeReanimated.default.View, {
+      testID: `${prefix}-fade-top`,
+      pointerEvents: "none",
+      ...HIDDEN_FROM_A11Y,
+      style: [{
         position: 'absolute',
         top: 0,
         left: 0,
-        right: 0
-      },
-      children: [solid && edges.top && insets.top > 0 ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNativeReanimated.default.View, {
-        testID: `${prefix}-fade-top`,
-        pointerEvents: "none",
-        ...HIDDEN_FROM_A11Y,
-        style: [{
-          position: 'absolute',
-          top: 0,
-          left: 0,
-          right: 0,
-          // Past the block's own bottom: a ramp that ends where the layout
-          // does is a line across the transcript again.
-          height: Math.round(insets.top * (1 + _EdgeScrim.SCRIM_TAIL_RATIO))
-        }, topStyle],
-        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_EdgeScrim.EdgeScrim, {
-          color: solid
-        })
-      }) : null, header, crumbRow]
-    }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
-      testID: `${prefix}-chrome-bottom`,
+        right: 0,
+        // Past the block's own bottom: a ramp that ends where the layout
+        // does is a line across the transcript again.
+        height: Math.round(headerHeight * (1 + _EdgeScrim.SCRIM_TAIL_RATIO)),
+        // The card's own corners, since nothing clips a document card.
+        borderTopLeftRadius: _shared.CONTAINER_RADIUS,
+        borderTopRightRadius: _shared.CONTAINER_RADIUS,
+        overflow: 'hidden'
+      }, topStyle],
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_EdgeScrim.EdgeScrim, {
+        color: solid
+      })
+    }) : null, header, crumbRow]
+  });
+  const bottom = /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+    testID: `${prefix}-chrome-bottom`,
+    pointerEvents: "box-none",
+    onLayout: onFooterLayout,
+    style: footerPosition,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
       pointerEvents: "box-none",
-      onLayout: onFooterLayout,
       style: {
-        position: 'absolute',
-        left: 0,
-        right: 0,
-        bottom: 0
+        width: '100%',
+        flexDirection: 'column',
+        gap: 10,
+        paddingLeft: 10,
+        paddingRight: 10,
+        paddingTop: FOOTER_GAP,
+        paddingBottom: 10
       },
-      children: [solid && edges.bottom ? /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNativeReanimated.default.View, {
-        testID: `${prefix}-fade-bottom`,
+      children: footerBody
+    })
+  });
+  const thread = /*#__PURE__*/(0, _jsxRuntime.jsx)(_context.AiChatFloatingChromeContext.Provider, {
+    value: chrome,
+    children: children
+  });
+  if (documentScroll) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+      testID: testID,
+      style: rootStyle,
+      children: [backgroundLayer, gutterColor ?
+      /*#__PURE__*/
+      // The card's frame, pinned to the screen: a ring of the gutter's
+      // colour painted over whatever of the conversation scrolls past the
+      // card's visible edge, so the card keeps its rounded corners and its
+      // gutter at the top and the bottom of the screen. Clipped to the
+      // gutter sideways (the family sheet), so it never reaches the columns
+      // beside the card.
+      (0, _jsxRuntime.jsx)(_reactNative.View, {
+        testID: `${prefix}-frame`,
         pointerEvents: "none",
         ...HIDDEN_FROM_A11Y,
-        style: [_reactNative.StyleSheet.absoluteFill, {
-          flexDirection: 'column'
-        }, bottomStyle],
-        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
-          style: {
-            height: FOOTER_FADE,
-            transform: [{
-              rotate: '180deg'
-            }]
-          },
-          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_EdgeScrim.EdgeScrim, {
-            color: solid
-          })
-        }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
-          style: {
-            flex: 1,
-            backgroundColor: solid
-          }
-        })]
-      }) : null, /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
-        pointerEvents: "box-none",
-        style: {
-          width: '100%',
-          flexDirection: 'column',
-          gap: 10,
-          paddingLeft: 10,
-          paddingRight: 10,
-          paddingTop: FOOTER_FADE,
-          paddingBottom: 10
-        },
-        children: footerBody
-      })]
-    })]
+        ...(0, _shared.dataHook)('bloomAiChatFrame'),
+        style: [_shared.DOCUMENT_LAYER, {
+          zIndex: 1,
+          boxShadow: `0 0 0 ${_shared.SHELL_GUTTER}px ${gutterColor}`
+        }]
+      }) : null, top, thread, bottom]
+    });
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+    testID: testID,
+    style: [rootStyle, {
+      position: 'relative'
+    }],
+    children: [backgroundLayer, thread, top, bottom]
   });
 }
 
@@ -408,7 +458,19 @@ function FloatingChrome({
  * motion they pass under it. It also reports its position so the container
  * knows when to fade each edge. Anywhere else nothing of this exists.
  */
-const AiChatThread = exports.AiChatThread = /*#__PURE__*/(0, _react.forwardRef)(function AiChatThread({
+const AiChatThread = exports.AiChatThread = /*#__PURE__*/(0, _react.forwardRef)(function AiChatThread(props, ref) {
+  const documentScroll = (0, _context.useAiChatShell)()?.documentScroll ?? false;
+  return documentScroll ? /*#__PURE__*/(0, _jsxRuntime.jsx)(DocumentThread, {
+    ref: ref,
+    ...props
+  }) : /*#__PURE__*/(0, _jsxRuntime.jsx)(ScrollThread, {
+    ref: ref,
+    ...props
+  });
+});
+
+/** The thread inside a card of fixed height: a `ScrollView` of its own. */
+const ScrollThread = /*#__PURE__*/(0, _react.forwardRef)(function ScrollThread({
   children,
   autoFollow = true,
   followAnimated = true,
@@ -604,4 +666,216 @@ const AiChatThread = exports.AiChatThread = /*#__PURE__*/(0, _react.forwardRef)(
     children: children
   });
 });
+
+/** The window's scroll position and extent, px. */
+function readWindow() {
+  const page = document.scrollingElement ?? document.documentElement;
+  return {
+    y: window.scrollY,
+    viewport: window.innerHeight,
+    end: page.scrollHeight
+  };
+}
+function scrollWindowTo(top, animated) {
+  window.scrollTo({
+    top,
+    behavior: animated ? 'smooth' : 'auto'
+  });
+}
+
+/**
+ * The thread under a document-scrolled shell (web): no scroller of its own —
+ * the turns grow the page and the window scrolls them. Same props, same handle,
+ * same behaviour: it follows the newest turn, fires `onStartReached` near the
+ * top, holds the reader still while a page lands above, and reports its
+ * position to the container.
+ *
+ * Offsets keep the thread's own frame: `0` is the thread's top, so a row's
+ * `onLayout` y is still a `scrollToOffset` target, and `contentSize` runs to the
+ * END OF THE PAGE, so `contentSize − offset − viewport` is still the distance
+ * left to scroll. The browser's scroll anchoring is off inside the thread (the
+ * family sheet): it would move the page for growth the thread already accounts
+ * for, and only in some browsers.
+ */
+const DocumentThread = /*#__PURE__*/(0, _react.forwardRef)(function DocumentThread({
+  children,
+  autoFollow = true,
+  followAnimated = true,
+  followThreshold,
+  onStartReached,
+  onStartReachedThreshold = 300,
+  maintainStartPosition = false,
+  onScroll,
+  style,
+  testID
+}, ref) {
+  const chrome = (0, _react.useContext)(_context.AiChatFloatingChromeContext);
+  const nodeRef = (0, _react.useRef)(null);
+  const lastHeight = (0, _react.useRef)(0);
+  /** An `onStartReached` is out and its page has not landed yet. */
+  const pageOut = (0, _react.useRef)(false);
+  /** The reader has left the top zone, so the next approach may fire again. */
+  const startArmed = (0, _react.useRef)(true);
+
+  /** The thread's top, px from the top of the page. */
+  const threadTop = (0, _react.useCallback)(() => {
+    const node = nodeRef.current;
+    return node ? node.getBoundingClientRect().top + window.scrollY : 0;
+  }, []);
+  (0, _react.useImperativeHandle)(ref, () => ({
+    scrollToEnd: options => scrollWindowTo(readWindow().end, options?.animated ?? true),
+    scrollToOffset: ({
+      offset: y,
+      animated = false
+    }) => scrollWindowTo(threadTop() + y, animated),
+    getScrollView: () => null
+  }), [threadTop]);
+
+  // The latest handlers, read by one window listener that is never rebound.
+  const handlers = (0, _react.useRef)({
+    chrome,
+    onScroll,
+    onStartReached,
+    onStartReachedThreshold
+  });
+  (0, _useIsomorphicLayoutEffect.useIsomorphicLayoutEffect)(() => {
+    handlers.current = {
+      chrome,
+      onScroll,
+      onStartReached,
+      onStartReachedThreshold
+    };
+  });
+  const report = (0, _react.useCallback)(() => {
+    const {
+      chrome: frame,
+      onScroll: listener,
+      onStartReached: startReached,
+      onStartReachedThreshold: zone
+    } = handlers.current;
+    const {
+      y,
+      viewport,
+      end
+    } = readWindow();
+    frame?.reportScroll({
+      offset: y,
+      viewport,
+      content: end
+    });
+    const top = threadTop();
+    const offset = y - top;
+    if (startReached) {
+      if (offset <= zone) {
+        if (startArmed.current) {
+          startArmed.current = false;
+          pageOut.current = true;
+          startReached();
+        }
+      } else {
+        startArmed.current = true;
+      }
+    }
+    listener?.({
+      nativeEvent: {
+        contentOffset: {
+          x: 0,
+          y: offset
+        },
+        layoutMeasurement: {
+          width: window.innerWidth,
+          height: viewport
+        },
+        contentSize: {
+          width: window.innerWidth,
+          height: end - top
+        },
+        contentInset: {
+          top: 0,
+          left: 0,
+          bottom: 0,
+          right: 0
+        },
+        zoomScale: 1
+      }
+    });
+  }, [threadTop]);
+  (0, _react.useEffect)(() => {
+    let frame = 0;
+    const onWindowChange = () => {
+      if (frame !== 0) return;
+      frame = requestAnimationFrame(() => {
+        frame = 0;
+        report();
+      });
+    };
+    window.addEventListener('scroll', onWindowChange, {
+      passive: true
+    });
+    window.addEventListener('resize', onWindowChange);
+    report();
+    return () => {
+      cancelAnimationFrame(frame);
+      window.removeEventListener('scroll', onWindowChange);
+      window.removeEventListener('resize', onWindowChange);
+    };
+  }, [report]);
+  const onLayout = (0, _react.useCallback)(event => {
+    const height = event.nativeEvent.layout.height;
+    const previous = lastHeight.current;
+    lastHeight.current = height;
+    report();
+    // The page is shared with whatever was on it before — another route
+    // left it scrolled wherever it was — so a following thread opens at its
+    // newest turn rather than at that offset.
+    if (previous === 0) {
+      if (autoFollow) scrollWindowTo(readWindow().end, false);
+      return;
+    }
+    if (height <= previous + 0.5) return;
+    const growth = height - previous;
+
+    // A page landing above the reader: keep the turn they are on where it is.
+    if (maintainStartPosition && pageOut.current) {
+      pageOut.current = false;
+      window.scrollBy({
+        top: growth,
+        behavior: 'auto'
+      });
+      return;
+    }
+    pageOut.current = false;
+    if (!autoFollow) return;
+    if (followThreshold !== undefined) {
+      // Measured against the page BEFORE the growth: was the reader near the
+      // end when this arrived?
+      const {
+        y,
+        viewport,
+        end
+      } = readWindow();
+      if (end - growth - y - viewport > followThreshold) return;
+    }
+    scrollWindowTo(readWindow().end, followAnimated);
+  }, [autoFollow, followAnimated, followThreshold, maintainStartPosition, report]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+    ref: nodeRef,
+    testID: testID,
+    ...(0, _shared.dataHook)('bloomAiChatThread'),
+    onLayout: onLayout,
+    style: [{
+      // Fills the card between the header and the composer, and anchors a
+      // short exchange just above the composer, as the scroller does.
+      width: '100%',
+      flexGrow: 1,
+      flexDirection: 'column',
+      justifyContent: 'flex-end',
+      gap: 12,
+      paddingLeft: 16,
+      paddingRight: 16,
+      paddingTop: THREAD_PAD_TOP
+    }, style],
+    children: children
+  });
+});
 //# sourceMappingURL=AiChatContainer.js.map