react-native-keyboard-controller 1.21.0-beta.3 → 1.21.1

package/src/components/KeyboardChatScrollView/useChatKeyboard/index.ts

@@ -6,6 +6,9 @@ import useScrollState from "../../hooks/useScrollState";
 import {
   clampedScrollTarget,
   getEffectiveHeight,
+  getMinimumPaddingAbsorbed,
+  getScrollEffective,
+  getVisibleMinimumPaddingFraction,
   isScrollAtEnd,
   shouldShiftContent,
 } from "./helpers";
@@ -24,24 +27,29 @@ import type Reanimated from "react-native-reanimated";
  * @returns Shared values for padding and contentOffsetY (always `undefined`).
  * @example
  * ```tsx
- * const { padding, contentOffsetY } = useChatKeyboard(ref, {
- *   inverted: false,
- *   keyboardLiftBehavior: "always",
- * });
+ * const { padding } = useChatKeyboard(ref, { inverted: false, keyboardLiftBehavior: "always" });
  * ```
  */
 function useChatKeyboard(
   scrollViewRef: AnimatedRef<Reanimated.ScrollView>,
   options: UseChatKeyboardOptions,
 ): UseChatKeyboardReturn {
-  const { inverted, keyboardLiftBehavior, freeze, offset } = options;
+  const {
+    inverted,
+    keyboardLiftBehavior,
+    freeze,
+    offset,
+    blankSpace,
+    extraContentPadding,
+  } = options;
 
   const padding = useSharedValue(0);
   const currentHeight = useSharedValue(0);
   const offsetBeforeScroll = useSharedValue(0);
   const targetKeyboardHeight = useSharedValue(0);
   const closing = useSharedValue(false);
-
+  const minimumPaddingFractionOnOpen = useSharedValue(0);
+  const actualOpenShift = useSharedValue(0);
   const {
     layout,
     size,
@@ -49,12 +57,18 @@ function useChatKeyboard(
     onLayout,
     onContentSizeChange,
   } = useScrollState(scrollViewRef);
-
-  const clampScrollIfNeeded = (effective: number) => {
+  const clampScrollIfNeeded = (
+    effective: number,
+    totalPaddingForMaxScroll?: number,
+  ) => {
     "worklet";
 
+    const paddingForMax =
+      totalPaddingForMaxScroll !== undefined
+        ? totalPaddingForMaxScroll
+        : effective;
     const maxScroll = Math.max(
-      size.value.height - layout.value.height + effective,
+      size.value.height - layout.value.height + paddingForMax,
       0,
     );
 
@@ -93,6 +107,27 @@ function useChatKeyboard(
           inverted,
         );
 
+        // Scale minimum padding absorption by how much of it is visible.
+        // Fully visible → full absorption; fully off-screen → no absorption.
+        const visibleFraction = getVisibleMinimumPaddingFraction(
+          scroll.value,
+          layout.value.height,
+          size.value.height,
+          blankSpace.value,
+          inverted,
+        );
+        const minimumPaddingAbsorbed =
+          visibleFraction >= 1
+            ? getMinimumPaddingAbsorbed(
+                blankSpace.value,
+                extraContentPadding.value,
+              )
+            : 0;
+        const scrollEffective = getScrollEffective(
+          effective,
+          minimumPaddingAbsorbed,
+        );
+
         if (inverted && e.duration === -1) {
           // Android inverted: skip post-interactive snap-back events
           // (duration === -1 means the keyboard is re-establishing its
@@ -100,12 +135,19 @@ function useChatKeyboard(
           return;
         } else if (e.height > 0) {
           // Android: keyboard opening — set padding + capture scroll position
+          minimumPaddingFractionOnOpen.value = visibleFraction >= 1 ? 1 : 0;
           padding.value = effective;
           offsetBeforeScroll.value = scroll.value;
 
           if (!inverted && keyboardLiftBehavior === "whenAtEnd" && !atEnd) {
             // Sentinel: don't scroll in onMove (non-inverted only)
             offsetBeforeScroll.value = -1;
+          } else if (!inverted && scrollEffective === 0) {
+            // blankSpace fully absorbs the keyboard — prevent scroll
+            offsetBeforeScroll.value = -1;
+          } else if (inverted && scrollEffective === 0) {
+            // blankSpace fully absorbs the keyboard — guard for inverted
+            offsetBeforeScroll.value = scroll.value;
           }
         } else {
           // Android: keyboard closing — re-capture scroll position
@@ -114,9 +156,9 @@ function useChatKeyboard(
           } else {
             // Preserve "whenAtEnd" sentinel: if open didn't shift, close shouldn't either
             if (offsetBeforeScroll.value !== -1) {
-              // Non-inverted: subtract padding to get the "natural" position
-              // so onMove smoothly scrolls back from where the user is now
-              offsetBeforeScroll.value = scroll.value - padding.value;
+              // Use the actual displacement recorded at end of open animation
+              // (not the theoretical value) so close is symmetric with open
+              offsetBeforeScroll.value = scroll.value - actualOpenShift.value;
             }
           }
         }
@@ -142,6 +184,20 @@ function useChatKeyboard(
             offset,
           );
 
+          const minimumPaddingAbsorbed =
+            getMinimumPaddingAbsorbed(
+              blankSpace.value,
+              extraContentPadding.value,
+            ) * minimumPaddingFractionOnOpen.value;
+          const scrollEffective = getScrollEffective(
+            effective,
+            minimumPaddingAbsorbed,
+          );
+          const actualTotalPadding = Math.max(
+            blankSpace.value,
+            effective + extraContentPadding.value,
+          );
+
           // Check if we should shift content based on position when keyboard started
           const wasAtEnd = isScrollAtEnd(
             offsetBeforeScroll.value,
@@ -157,6 +213,11 @@ function useChatKeyboard(
             effective < padding.value
           ) {
             padding.value = effective;
+
+            if (scrollEffective === 0 && minimumPaddingAbsorbed > 0) {
+              return;
+            }
+
             scrollTo(scrollViewRef, 0, 0, false);
 
             return;
@@ -166,12 +227,17 @@ function useChatKeyboard(
             // Closing, not shifting: reduce padding to avoid gap
             if (closing.value && effective < padding.value) {
               padding.value = effective;
-              clampScrollIfNeeded(effective);
+              clampScrollIfNeeded(effective, actualTotalPadding);
             }
 
             return;
           }
 
+          // When blankSpace fully absorbs the keyboard, skip scroll
+          if (scrollEffective === 0 && minimumPaddingAbsorbed > 0) {
+            return;
+          }
+
           // Persistent: don't let shift decrease
           if (keyboardLiftBehavior === "persistent") {
             const currentShift =
@@ -185,14 +251,15 @@ function useChatKeyboard(
               } else if (closing.value) {
                 // Not at end: reduce padding to avoid gap
                 padding.value = effective;
-                clampScrollIfNeeded(effective);
+                clampScrollIfNeeded(effective, actualTotalPadding);
               }
 
               return;
             }
           }
 
-          const target = offsetBeforeScroll.value + padding.value - effective;
+          const target =
+            offsetBeforeScroll.value + padding.value - scrollEffective;
 
           scrollTo(scrollViewRef, 0, target, false);
         } else {
@@ -202,32 +269,27 @@ function useChatKeyboard(
             offset,
           );
 
-          // "never" closing: scroll along when at end to avoid jump
+          const minimumPaddingAbsorbed =
+            getMinimumPaddingAbsorbed(
+              blankSpace.value,
+              extraContentPadding.value,
+            ) * minimumPaddingFractionOnOpen.value;
+          const scrollEffective = getScrollEffective(
+            effective,
+            minimumPaddingAbsorbed,
+          );
+          const actualTotalPadding = Math.max(
+            blankSpace.value,
+            effective + extraContentPadding.value,
+          );
+
+          // "never" closing: clamp scroll to valid range as inset shrinks
           if (
             keyboardLiftBehavior === "never" &&
             closing.value &&
             effective < padding.value
           ) {
-            const wasAtEnd = isScrollAtEnd(
-              offsetBeforeScroll.value + padding.value,
-              layout.value.height,
-              size.value.height,
-              false,
-            );
-
-            if (wasAtEnd) {
-              const target = clampedScrollTarget(
-                offsetBeforeScroll.value,
-                effective,
-                size.value.height,
-                layout.value.height,
-              );
-
-              scrollTo(scrollViewRef, 0, target, false);
-            } else {
-              // Clamp to valid range as padding shrinks
-              clampScrollIfNeeded(effective);
-            }
+            clampScrollIfNeeded(effective, actualTotalPadding);
 
             return;
           }
@@ -236,11 +298,11 @@ function useChatKeyboard(
             return;
           }
 
-          // "whenAtEnd" sentinel check
+          // "whenAtEnd" sentinel check (also used for blankSpace full absorption)
           if (offsetBeforeScroll.value === -1) {
             if (closing.value) {
               // Keyboard didn't shift on open; ensure valid position on close
-              clampScrollIfNeeded(effective);
+              clampScrollIfNeeded(effective, actualTotalPadding);
             }
 
             return;
@@ -250,7 +312,7 @@ function useChatKeyboard(
           if (keyboardLiftBehavior === "persistent" && closing.value) {
             const keepAt = offsetBeforeScroll.value + padding.value;
             const maxScroll = Math.max(
-              size.value.height - layout.value.height + effective,
+              size.value.height - layout.value.height + actualTotalPadding,
               0,
             );
 
@@ -261,12 +323,18 @@ function useChatKeyboard(
 
           const target = clampedScrollTarget(
             offsetBeforeScroll.value,
-            effective,
+            scrollEffective,
             size.value.height,
             layout.value.height,
+            actualTotalPadding,
           );
 
           scrollTo(scrollViewRef, 0, target, false);
+
+          // Track actual (clamped) displacement during open for symmetric close
+          if (!closing.value) {
+            actualOpenShift.value = target - offsetBeforeScroll.value;
+          }
         }
       },
       onEnd: (e) => {
@@ -283,6 +351,11 @@ function useChatKeyboard(
         );
 
         padding.value = effective;
+
+        // Record actual scroll displacement so close can be symmetric
+        if (effective > 0 && offsetBeforeScroll.value !== -1) {
+          actualOpenShift.value = scroll.value - offsetBeforeScroll.value;
+        }
       },
     },
     [inverted, keyboardLiftBehavior, freeze, offset],
@@ -292,6 +365,9 @@ function useChatKeyboard(
     padding,
     currentHeight,
     contentOffsetY: undefined,
+    scroll,
+    layout,
+    size,
     onLayout,
     onContentSizeChange,
   };

package/src/components/KeyboardChatScrollView/useChatKeyboard/types.ts

@@ -8,6 +8,9 @@ type UseChatKeyboardOptions = {
   keyboardLiftBehavior: KeyboardLiftBehavior;
   freeze: boolean;
   offset: number;
+  blankSpace: SharedValue<number>;
+  /** Extra content padding shared value — needed on iOS to correctly clamp contentOffset. */
+  extraContentPadding: SharedValue<number>;
 };
 
 type UseChatKeyboardReturn = {
@@ -17,6 +20,12 @@ type UseChatKeyboardReturn = {
   currentHeight: SharedValue<number>;
   /** Absolute Y content offset for iOS (set once in onStart). `undefined` on Android. */
   contentOffsetY: SharedValue<number> | undefined;
+  /** Current vertical scroll offset. */
+  scroll: SharedValue<number>;
+  /** Visible viewport dimensions. */
+  layout: SharedValue<{ width: number; height: number }>;
+  /** Total content dimensions. */
+  size: SharedValue<{ width: number; height: number }>;
   /** Callback to attach to ScrollView's onLayout prop to capture initial viewport dimensions. */
   onLayout: (e: LayoutChangeEvent) => void;
   /** Callback to attach to ScrollView's onContentSizeChange prop to capture initial content dimensions. */

package/src/components/KeyboardChatScrollView/useExtraContentPadding/index.ts

@@ -0,0 +1,123 @@
+import { scrollTo, useAnimatedReaction } from "react-native-reanimated";
+
+import { isScrollAtEnd, shouldShiftContent } from "../useChatKeyboard/helpers";
+
+import type { KeyboardLiftBehavior } from "../useChatKeyboard/types";
+import type { AnimatedRef, SharedValue } from "react-native-reanimated";
+import type Reanimated from "react-native-reanimated";
+
+type UseExtraContentPaddingOptions = {
+  scrollViewRef: AnimatedRef<Reanimated.ScrollView>;
+  extraContentPadding: SharedValue<number>;
+  /** Keyboard-only padding from useChatKeyboard — used to compute total padding for clamping. */
+  keyboardPadding: SharedValue<number>;
+  /** Minimum inset floor — used to absorb keyboard and extraContentPadding changes. */
+  blankSpace: SharedValue<number>;
+  /** Current vertical scroll offset. */
+  scroll: SharedValue<number>;
+  /** Visible viewport dimensions. */
+  layout: SharedValue<{ width: number; height: number }>;
+  /** Total content dimensions. */
+  size: SharedValue<{ width: number; height: number }>;
+  inverted: boolean;
+  keyboardLiftBehavior: KeyboardLiftBehavior;
+  freeze: boolean;
+};
+
+/**
+ * Hook that reacts to `extraContentPadding` changes and conditionally
+ * adjusts the scroll position using `scrollTo` on both iOS and Android.
+ *
+ * Padding extension (scrollable range) is handled externally via a
+ * `useDerivedValue` that sums keyboard padding + extra content padding.
+ * This hook only handles the scroll correction.
+ *
+ * @param options - Configuration and shared values.
+ * @example
+ * ```tsx
+ * useExtraContentPadding({ scrollViewRef, extraContentPadding, ... });
+ * ```
+ */
+function useExtraContentPadding(options: UseExtraContentPaddingOptions): void {
+  const {
+    scrollViewRef,
+    extraContentPadding,
+    keyboardPadding,
+    blankSpace,
+    scroll,
+    layout,
+    size,
+    inverted,
+    keyboardLiftBehavior,
+    freeze,
+  } = options;
+
+  useAnimatedReaction(
+    () => extraContentPadding.value,
+    (current, previous) => {
+      if (freeze || previous === null) {
+        return;
+      }
+
+      const rawDelta = current - previous;
+
+      if (rawDelta === 0) {
+        return;
+      }
+
+      // Compute effective delta considering blankSpace floor
+      const previousTotal = Math.max(
+        blankSpace.value,
+        keyboardPadding.value + previous,
+      );
+      const currentTotal = Math.max(
+        blankSpace.value,
+        keyboardPadding.value + current,
+      );
+      const effectiveDelta = currentTotal - previousTotal;
+
+      if (effectiveDelta === 0) {
+        // blankSpace absorbed the change
+        return;
+      }
+
+      const atEnd = isScrollAtEnd(
+        scroll.value,
+        layout.value.height,
+        size.value.height,
+        inverted,
+      );
+
+      // "persistent": scroll on grow, hold position on shrink (unless at end)
+      if (
+        keyboardLiftBehavior === "persistent" &&
+        effectiveDelta < 0 &&
+        !atEnd
+      ) {
+        return;
+      }
+
+      if (!shouldShiftContent(keyboardLiftBehavior, atEnd)) {
+        return;
+      }
+
+      if (inverted) {
+        const target = Math.max(scroll.value - effectiveDelta, -currentTotal);
+
+        scrollTo(scrollViewRef, 0, target, false);
+      } else {
+        const maxScroll = Math.max(
+          size.value.height - layout.value.height + currentTotal,
+          0,
+        );
+        const target = Math.min(scroll.value + effectiveDelta, maxScroll);
+
+        scrollTo(scrollViewRef, 0, target, false);
+      }
+    },
+    [inverted, keyboardLiftBehavior, freeze],
+  );
+}
+
+export { useExtraContentPadding };
+export type { UseExtraContentPaddingOptions };

package/src/components/KeyboardToolbar/index.tsx

@@ -1,7 +1,10 @@
 import React, { useEffect, useMemo, useState } from "react";
 import { StyleSheet, View } from "react-native";
 
-import { FocusedInputEvents } from "../../bindings";
+import {
+  FocusedInputEvents,
+  RCTKeyboardToolbarGroupView,
+} from "../../bindings";
 import { useKeyboardState } from "../../hooks";
 import KeyboardStickyView from "../KeyboardStickyView";
 
@@ -41,6 +44,7 @@ const KeyboardToolbar: React.FC<KeyboardToolbarProps> & {
   Prev: typeof Prev;
   Next: typeof Next;
   Done: typeof Done;
+  Group: typeof RCTKeyboardToolbarGroupView;
 } = (props) => {
   const {
     children,
@@ -227,6 +231,7 @@ KeyboardToolbar.Content = Content;
 KeyboardToolbar.Prev = Prev;
 KeyboardToolbar.Next = Next;
 KeyboardToolbar.Done = Done;
+KeyboardToolbar.Group = RCTKeyboardToolbarGroupView;
 
 export { colors as DefaultKeyboardToolbarTheme, KeyboardToolbarProps };
 export default KeyboardToolbar;

package/src/components/ScrollViewWithBottomPadding/index.tsx

@@ -1,6 +1,9 @@
 import React, { forwardRef } from "react";
 import { Platform, View } from "react-native";
-import Reanimated, { useAnimatedProps } from "react-native-reanimated";
+import Reanimated, {
+  useAnimatedProps,
+  useSharedValue,
+} from "react-native-reanimated";
 
 import { ClippingScrollView } from "../../bindings";
 
@@ -28,8 +31,11 @@ type ScrollViewWithBottomPaddingProps = {
   children?: React.ReactNode;
   inverted?: boolean;
   bottomPadding: SharedValue<number>;
+  /** Padding for scroll indicator insets (excludes blankSpace). Falls back to bottomPadding when not provided. */
+  scrollIndicatorPadding?: SharedValue<number>;
   /** Absolute Y content offset (iOS only, for KeyboardChatScrollView). */
   contentOffsetY?: SharedValue<number>;
+  applyWorkaroundForContentInsetHitTestBug?: boolean;
 } & ScrollViewProps;
 
 const ScrollViewWithBottomPadding = forwardRef<
@@ -40,21 +46,33 @@ const ScrollViewWithBottomPadding = forwardRef<
     {
       ScrollViewComponent,
       bottomPadding,
+      scrollIndicatorPadding,
       contentInset,
       scrollIndicatorInsets,
       inverted,
       contentOffsetY,
+      applyWorkaroundForContentInsetHitTestBug,
       children,
       ...rest
     },
     ref,
   ) => {
+    const prevContentOffsetY = useSharedValue<number | null>(null);
+
     const animatedProps = useAnimatedProps(() => {
       const insetTop = inverted ? bottomPadding.value : 0;
       const insetBottom = !inverted ? bottomPadding.value : 0;
       const bottom = insetBottom + (contentInset?.bottom || 0);
       const top = insetTop + (contentInset?.top || 0);
 
+      const indicatorPadding = scrollIndicatorPadding ?? bottomPadding;
+      const indicatorTop =
+        (inverted ? indicatorPadding.value : 0) +
+        (scrollIndicatorInsets?.top || 0);
+      const indicatorBottom =
+        (!inverted ? indicatorPadding.value : 0) +
+        (scrollIndicatorInsets?.bottom || 0);
+
       const result: Record<string, unknown> = {
         // iOS prop
         contentInset: {
@@ -64,8 +82,8 @@ const ScrollViewWithBottomPadding = forwardRef<
           left: contentInset?.left,
         },
         scrollIndicatorInsets: {
-          bottom: bottom,
-          top: top,
+          bottom: indicatorBottom,
+          top: indicatorTop,
           right: scrollIndicatorInsets?.right,
           left: scrollIndicatorInsets?.left,
         },
@@ -75,7 +93,13 @@ const ScrollViewWithBottomPadding = forwardRef<
       };
 
       if (contentOffsetY) {
-        result.contentOffset = { x: 0, y: contentOffsetY.value };
+        const curr = contentOffsetY.value;
+
+        if (curr !== prevContentOffsetY.value) {
+          // eslint-disable-next-line react-compiler/react-compiler
+          prevContentOffsetY.value = curr;
+          result.contentOffset = { x: 0, y: curr };
+        }
       }
 
       return result;
@@ -95,6 +119,9 @@ const ScrollViewWithBottomPadding = forwardRef<
     return (
       <ReanimatedClippingScrollView
         animatedProps={animatedProps}
+        applyWorkaroundForContentInsetHitTestBug={
+          applyWorkaroundForContentInsetHitTestBug
+        }
         style={styles.container}
       >
         <ScrollViewComponent ref={ref} animatedProps={animatedProps} {...rest}>

package/src/specs/ClippingScrollViewDecoratorViewNativeComponent.ts

@@ -7,12 +7,12 @@ import type { Double } from "react-native/Libraries/Types/CodegenTypes";
 export interface NativeProps extends ViewProps {
   contentInsetBottom: Double;
   contentInsetTop: Double;
+  applyWorkaroundForContentInsetHitTestBug?: boolean;
 }
 
 export default codegenNativeComponent<NativeProps>(
   "ClippingScrollViewDecoratorView",
   {
     interfaceOnly: true,
-    excludedPlatforms: ["iOS"],
   },
 ) as HostComponent<NativeProps>;

package/src/specs/KeyboardToolbarGroupViewNativeComponent.ts

@@ -0,0 +1,10 @@
+import codegenNativeComponent from "react-native/Libraries/Utilities/codegenNativeComponent";
+
+import type { HostComponent } from "react-native";
+import type { ViewProps } from "react-native/Libraries/Components/View/ViewPropTypes";
+
+export interface NativeProps extends ViewProps {}
+
+export default codegenNativeComponent<NativeProps>("KeyboardToolbarGroupView", {
+  interfaceOnly: true,
+}) as HostComponent<NativeProps>;

package/src/specs/NativeKeyboardController.ts

@@ -11,6 +11,7 @@ export interface Spec extends TurboModule {
   preload(): void;
   dismiss(keepFocus: boolean, animated: boolean): void;
   setFocusTo(direction: string): void;
+  viewPositionInWindow(viewTag: number): Promise<object>;
 
   // event emitter
   addListener: (eventName: string) => void;

package/src/types/module.ts

@@ -109,6 +109,12 @@ export type KeyboardControllerModule = {
    */
   state: () => KeyboardEventData;
 };
+export type ViewPositionInWindowResult = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
 export type KeyboardControllerNativeModule = {
   // android only
   setDefaultMode: () => void;
@@ -118,6 +124,9 @@ export type KeyboardControllerNativeModule = {
   // all platforms
   dismiss: (keepFocus: boolean, animated: boolean) => void;
   setFocusTo: (direction: Direction) => void;
+  viewPositionInWindow: (
+    viewTag: number,
+  ) => Promise<ViewPositionInWindowResult>;
   // native event module stuff
   addListener: (eventName: string) => void;
   removeListeners: (count: number) => void;

package/src/types/views.ts

@@ -49,11 +49,13 @@ export type KeyboardExtenderProps = PropsWithChildren<{
   /** Controls whether this `KeyboardExtender` instance should take an effect. Default is `true`. */
   enabled?: boolean;
 }>;
+export type KeyboardToolbarGroupViewProps = PropsWithChildren<ViewProps>;
 export type ClippingScrollViewProps = PropsWithChildren<
   ViewProps & {
     /** An additional space that gets applied to the bottom of the `ScrollView` (inside a scrollable content). Default is `0`. */
     contentInsetBottom?: number;
     /** An additional space that gets applied to the top of the `ScrollView` (inside a scrollable content). Default is `0`. */
     contentInsetTop?: number;
+    applyWorkaroundForContentInsetHitTestBug?: boolean;
   }
 >;

package/android/.settings/org.eclipse.buildship.core.prefs

@@ -1,2 +0,0 @@
-connection.project.dir=../../../android
-eclipse.preferences.version=1

package/ios/KeyboardController.xcodeproj/xcuserdata/kirylziusko.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>SchemeUserState</key>
-	<dict>
-		<key>KeyboardController.xcscheme_^#shared#^_</key>
-		<dict>
-			<key>orderHint</key>
-			<integer>0</integer>
-		</dict>
-	</dict>
-</dict>
-</plist>

package/ios/Tests/Tests.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Workspace
-   version = "1.0">
-   <FileRef
-      location = "self:">
-   </FileRef>
-</Workspace>

package/ios/Tests/Tests.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>IDEDidComputeMac32BitWarning</key>
-	<true/>
-</dict>
-</plist>