react-native-external-keyboard 0.9.1 → 1.0.0

package/lib/typescript/src/utils/useKeyboardFocusContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardFocusContainer.d.ts","sourceRoot":"","sources":["../../../../src/utils/useKeyboardFocusContainer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAInD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEzD,KAAK,eAAe,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;AAE7C,MAAM,MAAM,8BAA8B,CACxC,MAAM,SAAS,eAAe,GAAG,eAAe,EAChD,aAAa,SAAS,eAAe,GAAG,eAAe,IACrD;IACF,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,mBAAmB,CAAC,EAAE,UAAU,CAAC;IACjC,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,KAAK,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IAChC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,MAAM,SAAS,eAAe,GAAG,eAAe,EAChD,aAAa,SAAS,eAAe,GAAG,eAAe,EACvD,uMAcC,8BAA8B,CAAC,MAAM,EAAE,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDurtB,CAAC;kBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAtB,CAAC;kBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAtB,CAAC;kBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAtB,CAAC;kBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAtB,CAAC;kBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADpwtB,CAAC"}

package/lib/typescript/src/utils/useKeyboardPress/useKeyboardPress.android.d.ts

@@ -1,11 +1,11 @@
 import type { GestureResponderEvent } from 'react-native';
 import type { UseKeyboardPressProps } from './useKeyboardPress.types';
-import type { OnKeyPressFn } from '../../types/BaseKeyboardView';
+import type { OnKeyPressFn } from '../../types';
 export declare const ANDROID_SPACE_KEY_CODE = 62;
 export declare const ANDROID_DPAD_CENTER_CODE = 23;
 export declare const ANDROID_ENTER_CODE = 66;
 export declare const ANDROID_TRIGGER_CODES: number[];
-export declare const useKeyboardPress: <T extends (event?: any) => void, K extends (event?: any) => void>({ onKeyUpPress, onKeyDownPress, onPressIn, onPressOut, onPress, onLongPress, triggerCodes, disabled, }: UseKeyboardPressProps<T, K>) => {
+export declare const useKeyboardPress: <T extends (event?: any) => void, K extends (event?: any) => void>({ onKeyUpPress, onKeyDownPress, onPressIn, onPressOut, onPress, onLongPress, triggerCodes, }: UseKeyboardPressProps<T, K>) => {
     onKeyUpPressHandler: OnKeyPressFn | undefined;
     onKeyDownPressHandler: OnKeyPressFn | undefined;
     onPressHandler: ((event: GestureResponderEvent) => void) | undefined;

package/lib/typescript/src/utils/useKeyboardPress/useKeyboardPress.android.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useKeyboardPress.android.d.ts","sourceRoot":"","sources":["../../../../../src/utils/useKeyboardPress/useKeyboardPress.android.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE7E,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC,eAAO,MAAM,qBAAqB,UAIjC,CAAC;AAkBF,eAAO,MAAM,gBAAgB,GAC3B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,wGASC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC;;;6BA+ClB,qBAAqB;CAYhC,CAAC"}
+{"version":3,"file":"useKeyboardPress.android.d.ts","sourceRoot":"","sources":["../../../../../src/utils/useKeyboardPress/useKeyboardPress.android.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,aAAa,CAAC;AAE5D,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC,eAAO,MAAM,qBAAqB,UAIjC,CAAC;AAkBF,eAAO,MAAM,gBAAgB,GAC3B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,8FAQC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC;;;6BA6ClB,qBAAqB;CAYhC,CAAC"}

package/lib/typescript/src/utils/useKeyboardPress/useKeyboardPress.d.ts

@@ -1,7 +1,8 @@
 import type { UseKeyboardPressProps } from './useKeyboardPress.types';
-export declare const useKeyboardPress: <T extends (event?: any) => void, K extends (event?: any) => void>({ onKeyUpPress, onKeyDownPress, onPress, onPressIn, onPressOut, triggerCodes, disabled, }: UseKeyboardPressProps<T, K>) => {
-    onKeyUpPressHandler: import("../../types/BaseKeyboardView").OnKeyPressFn | undefined;
-    onKeyDownPressHandler: import("../../types/BaseKeyboardView").OnKeyPressFn | undefined;
+import type { OnKeyPress } from '../../types';
+export declare const useKeyboardPress: <T extends (event?: any) => void, K extends (event?: any) => void>({ onKeyUpPress, onKeyDownPress, onPress, onLongPress, onPressIn, onPressOut, triggerCodes, }: UseKeyboardPressProps<T, K>) => {
+    onKeyUpPressHandler: (e: OnKeyPress) => void;
+    onKeyDownPressHandler: import("../..").OnKeyPressFn | undefined;
     onPressHandler: T | undefined;
 };
 //# sourceMappingURL=useKeyboardPress.d.ts.map

package/lib/typescript/src/utils/useKeyboardPress/useKeyboardPress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useKeyboardPress.d.ts","sourceRoot":"","sources":["../../../../../src/utils/useKeyboardPress/useKeyboardPress.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAQtE,eAAO,MAAM,gBAAgB,GAC3B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,2FAQC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC;;;;CA4B7B,CAAC"}
+{"version":3,"file":"useKeyboardPress.d.ts","sourceRoot":"","sources":["../../../../../src/utils/useKeyboardPress/useKeyboardPress.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAO9C,eAAO,MAAM,gBAAgB,GAC3B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,8FAQC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC;6BAEf,UAAU;;;CA4BxB,CAAC"}

package/lib/typescript/src/utils/useKeyboardPress/useKeyboardPress.ios.d.ts

@@ -1,8 +1,8 @@
 import type { UseKeyboardPressProps } from './useKeyboardPress.types';
-import type { OnKeyPress } from '../../types/BaseKeyboardView';
-export declare const useKeyboardPress: <T extends (event?: any) => void, K extends (event?: any) => void>({ onKeyUpPress, onKeyDownPress, onPress, onPressIn, onPressOut, onLongPress, triggerCodes, disabled, }: UseKeyboardPressProps<T, K>) => {
+import type { OnKeyPress } from '../../types';
+export declare const useKeyboardPress: <T extends (event?: any) => void, K extends (event?: any) => void>({ onKeyUpPress, onKeyDownPress, onPress, onPressIn, onPressOut, onLongPress, triggerCodes, }: UseKeyboardPressProps<T, K>) => {
     onKeyUpPressHandler: (e: OnKeyPress) => void;
-    onKeyDownPressHandler: import("../../types/BaseKeyboardView").OnKeyPressFn | undefined;
+    onKeyDownPressHandler: import("../..").OnKeyPressFn | undefined;
     onPressHandler: T | undefined;
 };
 //# sourceMappingURL=useKeyboardPress.ios.d.ts.map

package/lib/typescript/src/utils/useKeyboardPress/useKeyboardPress.ios.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useKeyboardPress.ios.d.ts","sourceRoot":"","sources":["../../../../../src/utils/useKeyboardPress/useKeyboardPress.ios.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAQ/D,eAAO,MAAM,gBAAgB,GAC3B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,wGASC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC;6BAEf,UAAU;;;CA+BxB,CAAC"}
+{"version":3,"file":"useKeyboardPress.ios.d.ts","sourceRoot":"","sources":["../../../../../src/utils/useKeyboardPress/useKeyboardPress.ios.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAQ9C,eAAO,MAAM,gBAAgB,GAC3B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,EAC/B,8FAQC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC;6BAEf,UAAU;;;CA6BxB,CAAC"}

package/lib/typescript/src/utils/useKeyboardPress/useKeyboardPress.types.d.ts

@@ -1,4 +1,4 @@
-import type { OnKeyPressFn } from '../../types/BaseKeyboardView';
+import type { OnKeyPressFn } from '../../types';
 export type UseKeyboardPressProps<T, K> = {
     triggerCodes?: number[];
     onKeyUpPress?: OnKeyPressFn;
@@ -7,6 +7,5 @@ export type UseKeyboardPressProps<T, K> = {
     onPress?: T;
     onPressIn?: K;
     onPressOut?: K;
-    disabled?: boolean;
 };
 //# sourceMappingURL=useKeyboardPress.types.d.ts.map

package/lib/typescript/src/utils/useKeyboardPress/useKeyboardPress.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useKeyboardPress.types.d.ts","sourceRoot":"","sources":["../../../../../src/utils/useKeyboardPress/useKeyboardPress.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,MAAM,MAAM,qBAAqB,CAAC,CAAC,EAAE,CAAC,IAAI;IACxC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B,WAAW,CAAC,EAAE,CAAC,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,CAAC;IACZ,SAAS,CAAC,EAAE,CAAC,CAAC;IACd,UAAU,CAAC,EAAE,CAAC,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC"}
+{"version":3,"file":"useKeyboardPress.types.d.ts","sourceRoot":"","sources":["../../../../../src/utils/useKeyboardPress/useKeyboardPress.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,MAAM,qBAAqB,CAAC,CAAC,EAAE,CAAC,IAAI;IACxC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B,WAAW,CAAC,EAAE,CAAC,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,CAAC;IACZ,SAAS,CAAC,EAAE,CAAC,CAAC;IACd,UAAU,CAAC,EAAE,CAAC,CAAC;CAChB,CAAC"}

package/lib/typescript/src/utils/useKeyboardPressState.d.ts

@@ -0,0 +1,29 @@
+type AnyPressHandler = (event?: any) => void;
+type UseKeyboardPressStateParams = {
+    enabled?: boolean;
+    onPressIn?: AnyPressHandler;
+    onPressOut?: AnyPressHandler;
+    onFocusChange?: (isFocused: boolean) => void;
+};
+/**
+ * Android only. Physical-keyboard activation (Enter / Space / DPad-center) never
+ * reaches the touch responder, so a wrapped component's `pressed` stays false.
+ * This derives a press state from the key down/up events and returns composable
+ * pieces to thread it through focus, press handlers, and function styles.
+ *
+ * Everything is a no-op unless `enabled` and running on Android, so callers can
+ * always wire the returned values unconditionally.
+ */
+export declare const useKeyboardPressState: ({ enabled, onPressIn, onPressOut, onFocusChange, }: UseKeyboardPressStateParams) => {
+    /** A keyboard-driven press is currently held. */
+    pressed: boolean;
+    /** Pass to the keyboard press hook; the original handlers when inactive. */
+    onPressIn: AnyPressHandler | undefined;
+    onPressOut: AnyPressHandler | undefined;
+    /** Wrap `onFocusChange` to clear a stuck press on blur. */
+    onFocusChange: (isFocused: boolean) => void;
+    /** Fold the keyboard press into a function style. */
+    applyPressedStyle: <S>(style: S) => S;
+};
+export {};
+//# sourceMappingURL=useKeyboardPressState.d.ts.map

package/lib/typescript/src/utils/useKeyboardPressState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardPressState.d.ts","sourceRoot":"","sources":["../../../../src/utils/useKeyboardPressState.ts"],"names":[],"mappings":"AAGA,KAAK,eAAe,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;AAG7C,KAAK,2BAA2B,GAAG;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;CAC9C,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,oDAKnC,2BAA2B;IA2C1B,iDAAiD;;IAEjD,4EAA4E;;;IAG5E,2DAA2D;+BA3B/C,OAAO;IA6BnB,qDAAqD;wBAjBpD,CAAC,SAAS,CAAC,KAAG,CAAC;CAoBnB,CAAC"}

package/lib/typescript/src/utils/useOnFocusChange.d.ts

@@ -1,9 +1,9 @@
-import type { OnFocusChangeFn } from '../types';
+import type { OnFocusChangeFn, NativeFocusChangeHandler } from '../types';
 type UseFocusChange = {
-    onFocusChange?: (f: boolean, tag?: number) => void;
+    onFocusChange?: OnFocusChangeFn;
     onFocus?: () => void;
     onBlur?: () => void;
 };
-export declare const useOnFocusChange: ({ onFocusChange, onFocus, onBlur, }: UseFocusChange) => OnFocusChangeFn;
+export declare const useOnFocusChange: ({ onFocusChange, onFocus, onBlur, }: UseFocusChange) => NativeFocusChangeHandler;
 export {};
 //# sourceMappingURL=useOnFocusChange.d.ts.map

package/lib/typescript/src/utils/useOnFocusChange.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useOnFocusChange.d.ts","sourceRoot":"","sources":["../../../../src/utils/useOnFocusChange.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,KAAK,cAAc,GAAG;IACpB,aAAa,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,qCAI9B,cAAc,oBAcd,CAAC"}
+{"version":3,"file":"useOnFocusChange.d.ts","sourceRoot":"","sources":["../../../../src/utils/useOnFocusChange.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAE1E,KAAK,cAAc,GAAG;IACpB,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,qCAI9B,cAAc,6BAWd,CAAC"}

package/lib/typescript/src/utils/useOrderValidation.d.ts

@@ -0,0 +1,8 @@
+import type { FocusOrderProps } from '../types';
+type UseOrderValidationProps = Pick<FocusOrderProps, 'orderIndex' | 'orderId' | 'orderForward' | 'orderBackward' | 'orderFirst' | 'orderLast' | 'orderLeft' | 'orderRight' | 'orderUp' | 'orderDown'> & {
+    groupId?: string;
+    orderPrefix: string;
+};
+export declare const useOrderValidation: ({ groupId, orderIndex, orderPrefix, orderId, orderForward, orderBackward, orderFirst, orderLast, orderLeft, orderRight, orderUp, orderDown, }: UseOrderValidationProps) => void;
+export {};
+//# sourceMappingURL=useOrderValidation.d.ts.map

package/lib/typescript/src/utils/useOrderValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOrderValidation.d.ts","sourceRoot":"","sources":["../../../../src/utils/useOrderValidation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,KAAK,uBAAuB,GAAG,IAAI,CACjC,eAAe,EACb,YAAY,GACZ,SAAS,GACT,cAAc,GACd,eAAe,GACf,YAAY,GACZ,WAAW,GACX,WAAW,GACX,YAAY,GACZ,SAAS,GACT,WAAW,CACd,GAAG;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,+IAahC,uBAAuB,SAwCzB,CAAC"}

package/lib/typescript/src/utils/useRenderedChildren.d.ts

@@ -0,0 +1,18 @@
+type UseRenderedChildrenProps = {
+    focused: boolean;
+    keyboardPressed?: boolean;
+    renderContent?: (state: Record<string, unknown>) => React.ReactNode;
+    renderFocusable?: (state: {
+        focused: boolean;
+    }) => React.ReactNode;
+};
+/**
+ * Resolves the `children` override for the wrapped component.
+ * - `renderContent` stays a function so the component can call it with its own state + `focused`
+ *   (keyboard activation forces `pressed` when `keyboardPressed` is set)
+ * - `renderFocusable` is evaluated immediately and returned as a static node
+ * Returns `undefined` when neither prop is provided.
+ */
+export declare const useRenderedChildren: ({ focused, keyboardPressed, renderContent, renderFocusable, }: UseRenderedChildrenProps) => string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | ((state: Record<string, unknown>) => import("react").ReactNode) | null | undefined;
+export {};
+//# sourceMappingURL=useRenderedChildren.d.ts.map

package/lib/typescript/src/utils/useRenderedChildren.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRenderedChildren.d.ts","sourceRoot":"","sources":["../../../../src/utils/useRenderedChildren.ts"],"names":[],"mappings":"AAEA,KAAK,wBAAwB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,KAAK,CAAC,SAAS,CAAC;IACpE,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,KAAK,CAAC,SAAS,CAAC;CACpE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,+DAKjC,wBAAwB,wZAIT,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,kDAgBxC,CAAC"}

package/lib/typescript/src/utils/useWrappedOrderProps.d.ts

@@ -0,0 +1,13 @@
+import type { FocusOrderProps } from '../types';
+export declare const useWrappedOrderProps: ({ orderPrefix, orderId, orderForward, orderBackward, orderFirst, orderLast, orderLeft, orderRight, orderUp, orderDown, }: FocusOrderProps) => {
+    orderId: string | undefined;
+    orderForward: string | undefined;
+    orderBackward: string | undefined;
+    orderLeft: string | undefined;
+    orderRight: string | undefined;
+    orderUp: string | undefined;
+    orderDown: string | undefined;
+    orderFirst: string | undefined;
+    orderLast: string | undefined;
+};
+//# sourceMappingURL=useWrappedOrderProps.d.ts.map

package/lib/typescript/src/utils/useWrappedOrderProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWrappedOrderProps.d.ts","sourceRoot":"","sources":["../../../../src/utils/useWrappedOrderProps.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD,eAAO,MAAM,oBAAoB,GAAI,0HAWlC,eAAe;;;;;;;;;;CAgCjB,CAAC"}

package/lib/typescript/src/utils/withKeyboardFocus.d.ts

@@ -1,10 +1,9 @@
 import React from 'react';
 import { View, type ViewProps } from 'react-native';
-import type { KeyboardFocus } from '../types/BaseKeyboardView';
-import type { WithKeyboardFocus, WithKeyboardFocusComponent } from '../types/WithKeyboardFocus';
-export declare const withKeyboardFocus: <ComponentProps extends object, ViewStyleType, ViewType = View>(Component: WithKeyboardFocusComponent<ComponentProps>) => React.NamedExoticComponent<React.PropsWithoutRef<WithKeyboardFocus<ComponentProps, ViewStyleType, ViewType>> & React.RefAttributes<((props: Omit<ViewProps, keyof {
+import type { WithKeyboardFocusProps, KeyboardFocusableComponent } from '../types';
+export declare const withKeyboardFocus: <ComponentProps extends object, ViewStyleType, ViewType = View>(Component: KeyboardFocusableComponent<ComponentProps>) => React.NamedExoticComponent<React.PropsWithoutRef<WithKeyboardFocusProps<ComponentProps, ViewStyleType, ViewType>> & React.RefAttributes<import("..").KeyboardFocus | ((props: Omit<ViewProps, keyof {
     ref?: React.Ref<React.ComponentRef<typeof import("react-native").unstable_NativeView>>;
 }> & {
     ref?: React.Ref<React.ComponentRef<typeof import("react-native").unstable_NativeView>>;
-}) => React.ReactNode) | KeyboardFocus>>;
+}) => React.ReactNode)>>;
 //# sourceMappingURL=withKeyboardFocus.d.ts.map

package/lib/typescript/src/utils/withKeyboardFocus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withKeyboardFocus.d.ts","sourceRoot":"","sources":["../../../../src/utils/withKeyboardFocus.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+C,MAAM,OAAO,CAAC;AACpE,OAAO,EAAE,IAAI,EAAc,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,2BAA2B,CAAC;AAE3E,OAAO,KAAK,EAEV,iBAAiB,EACjB,0BAA0B,EAC3B,MAAM,4BAA4B,CAAC;AAMpC,eAAO,MAAM,iBAAiB,GAC5B,cAAc,SAAS,MAAM,EAC7B,aAAa,EACb,QAAQ,GAAG,IAAI,EAEf,WAAW,0BAA0B,CAAC,cAAc,CAAC;OAFjD,CAAC;;OAGJ,CAAC;wCA8MH,CAAC"}
+{"version":3,"file":"withKeyboardFocus.d.ts","sourceRoot":"","sources":["../../../../src/utils/withKeyboardFocus.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkC,MAAM,OAAO,CAAC;AACvD,OAAO,EAA4B,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9E,OAAO,KAAK,EAIV,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,UAAU,CAAC;AAKlB,eAAO,MAAM,iBAAiB,GAC5B,cAAc,SAAS,MAAM,EAC7B,aAAa,EACb,QAAQ,GAAG,IAAI,EAEf,WAAW,0BAA0B,CAAC,cAAc,CAAC;OAK5B,CAAC;;OAEtB,CAAD;wBAkMJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-external-keyboard",
-  "version": "0.9.1",
+  "version": "1.0.0",
   "description": "Toolkit for improving physical keyboard support in React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -25,7 +25,9 @@
     "!**/__tests__",
     "!**/__fixtures__",
     "!**/__mocks__",
-    "!**/.*"
+    "!**/.*",
+    "!**/CLAUDE.md",
+    "!**/docs"
   ],
   "scripts": {
     "example": "yarn workspace react-native-external-keyboard-example",

package/src/components/BaseKeyboardView/BaseKeyboardView.tsx

@@ -10,30 +10,22 @@ import { ExternalKeyboardViewNative } from '../../nativeSpec';
 import { Commands } from '../../nativeSpec/ExternalKeyboardViewNativeComponent';
 import {
   LockFocusEnum,
+  type LockFocusType,
   type BaseKeyboardViewProps,
   type BaseKeyboardViewType,
-  type LockFocusType,
-} from '../../types/BaseKeyboardView';
+} from '../../types';
 import type { View } from 'react-native';
 import { KeyPressContext } from '../../context/BubbledKeyPressContext';
 import { useBubbledInfo } from './BaseKeyboardView.hooks';
 import { useGroupIdentifierContext } from '../../context/GroupIdentifierContext';
 import { useOnFocusChange } from '../../utils/useOnFocusChange';
 import { useOrderFocusGroup } from '../../context/OrderFocusContext';
-import { wrapOrderPrefix } from '../../utils/wrapOrderPrefix';
+import { useWrappedOrderProps } from '../../utils/useWrappedOrderProps';
 
 // @ts-ignore
 type NativeRef = React.ElementRef<ComponentType>;
 const isIOS = Platform.OS === 'ios';
 
-const DEFAULT_EXPOSE_METHODS = [
-  'blur',
-  'measure',
-  'measureInWindow',
-  'measureLayout',
-  'setNativeProps',
-];
-
 enum BITS {
   BIT_01 = 0b1,
   BIT_02 = 0b10,
@@ -41,8 +33,6 @@ enum BITS {
   BIT_04 = 0b1000,
   BIT_05 = 0b10000,
   BIT_06 = 0b100000,
-  BIT_07 = 0b1000000,
-  BIT_08 = 0b10000000,
   BIT_09 = 0b100000000,
   BIT_10 = 0b1000000000,
 }
@@ -66,7 +56,7 @@ const mapFocusValues = (values: LockFocusType[] | undefined) => {
 };
 
 export const BaseKeyboardView = React.memo(
-  React.forwardRef<BaseKeyboardViewType, BaseKeyboardViewProps>(
+  React.forwardRef<BaseKeyboardViewType | View, BaseKeyboardViewProps>(
     (
       {
         onFocusChange,
@@ -75,18 +65,14 @@ export const BaseKeyboardView = React.memo(
         onBubbledContextMenuPress,
         haloEffect,
         autoFocus,
-        canBeFocused = true,
         focusable = true,
-        group = false,
+        focusableWrapper = false,
         onFocus,
         onBlur,
-        viewRef,
         groupIdentifier,
         tintColor,
-        ignoreGroupFocusHint,
-        exposeMethods = DEFAULT_EXPOSE_METHODS,
-        enableA11yFocus = false,
-        screenAutoA11yFocusDelay = 500,
+        // TODO: revisit screenAutoA11yFocusDelay default (currently 300ms)
+        screenAutoA11yFocusDelay = 300,
         lockFocus,
         orderIndex,
         orderForward,
@@ -101,13 +87,16 @@ export const BaseKeyboardView = React.memo(
         orderId,
         enableContextMenu,
         orderPrefix: _orderPrefix,
+        tintType,
+        // Deprecated no-ops: destructured out so they never reach the native view.
+        enableA11yFocus: _enableA11yFocus,
         defaultFocusHighlightEnabled = true,
+        roundedHaloFix = false,
         ...props
       },
       ref
     ) => {
-      const localRef = useRef<View>(undefined);
-      const targetRef = viewRef ?? localRef;
+      const targetRef = useRef<View | null>(null);
       const lockFocusValue = useMemo(
         () => mapFocusValues(lockFocus),
         [lockFocus]
@@ -162,27 +151,48 @@ export const BaseKeyboardView = React.memo(
       useImperativeHandle(
         ref,
         () => {
-          const actions: Record<string, Function> = {};
-
-          exposeMethods.forEach((method) => {
-            actions[method] = (...args: any[]) => {
-              const componentActions = targetRef?.current as unknown as Record<
-                string,
-                Function
-              >;
-              return componentActions?.[method]?.(...args);
-            };
-          });
-
-          actions.focus = () => {
-            if (targetRef?.current) {
-              Commands.focus(targetRef.current as unknown as NativeRef);
-            }
+          const nativeCommands: Record<string, () => void> = {
+            keyboardFocus: () => {
+              if (targetRef?.current) {
+                Commands.rnekKeyboardFocus(
+                  targetRef.current as unknown as NativeRef
+                );
+              }
+            },
+            screenReaderFocus: () => {
+              if (targetRef?.current) {
+                Commands.rnekScreenReaderFocus(
+                  targetRef.current as unknown as NativeRef
+                );
+              }
+            },
+            focus: () => {
+              if (targetRef?.current) {
+                Commands.rnekKeyboardFocus(
+                  targetRef.current as unknown as NativeRef
+                );
+                Commands.rnekScreenReaderFocus(
+                  targetRef.current as unknown as NativeRef
+                );
+              }
+            },
           };
 
-          return actions as unknown as BaseKeyboardViewType;
+          return new Proxy({} as BaseKeyboardViewType | View, {
+            get(_target, prop: string) {
+              if (prop in nativeCommands) {
+                return nativeCommands[prop];
+              }
+              return (
+                targetRef?.current as unknown as
+                  | Record<string, unknown>
+                  | null
+                  | undefined
+              )?.[prop];
+            },
+          });
         },
-        [exposeMethods, targetRef]
+        [targetRef]
       );
 
       const bubbled = useBubbledInfo(onBubbledContextMenuPress);
@@ -193,52 +203,24 @@ export const BaseKeyboardView = React.memo(
         onBlur,
       });
 
-      const hasOnFocusChanged = onFocusChange || onFocus || onBlur;
-      const ignoreFocusHint = Platform.OS !== 'ios' || !ignoreGroupFocusHint;
-
-      const wrapPrefix = useMemo(
-        () => wrapOrderPrefix(orderPrefix),
-        [orderPrefix]
-      );
+      const hasFocusListener = onFocusChange || onFocus || onBlur;
 
-      const wrappedOrderProps = useMemo(
-        () => ({
-          orderId: wrapPrefix(orderId),
-          orderForward: wrapPrefix(orderForward),
-          orderBackward: wrapPrefix(orderBackward),
-          orderFirst: wrapPrefix(
-            orderFirst === null ? undefined : orderFirst ?? orderForward
-          ),
-          orderLast: wrapPrefix(
-            orderLast === null ? undefined : orderLast ?? orderBackward
-          ),
-          orderLeft: wrapPrefix(orderLeft),
-          orderRight: wrapPrefix(orderRight),
-          orderUp: wrapPrefix(orderUp),
-          orderDown: wrapPrefix(orderDown),
-        }),
-        [
-          wrapPrefix,
-          orderId,
-          orderForward,
-          orderBackward,
-          orderFirst,
-          orderLast,
-          orderLeft,
-          orderRight,
-          orderUp,
-          orderDown,
-        ]
-      );
+      const wrappedOrderProps = useWrappedOrderProps({
+        orderPrefix,
+        orderId,
+        orderForward,
+        orderBackward,
+        orderFirst,
+        orderLast,
+        orderLeft,
+        orderRight,
+        orderUp,
+        orderDown,
+      });
 
-      const platformSpecificHalo = useMemo(
-        () =>
-          Platform.select({
-            ios: haloEffect,
-            android: defaultFocusHighlightEnabled,
-          }) ?? true,
-        [defaultFocusHighlightEnabled, haloEffect]
-      );
+      const platformSpecificHalo =
+        tintType !== 'none' &&
+        (isIOS ? haloEffect ?? true : defaultFocusHighlightEnabled);
 
       return (
         <KeyPressContext.Provider value={bubbled.context}>
@@ -247,26 +229,24 @@ export const BaseKeyboardView = React.memo(
             haloEffect={platformSpecificHalo}
             ref={targetRef as React.RefObject<any>}
             enableContextMenu={enableContextMenu}
-            canBeFocused={ignoreFocusHint && focusable && canBeFocused}
+            canBeFocused={focusable}
             autoFocus={autoFocus}
-            onKeyDownPress={onKeyDownPress as undefined} //ToDo update types
-            onKeyUpPress={onKeyUpPress as undefined} //ToDo update types
+            onKeyDownPress={onKeyDownPress}
+            onKeyUpPress={onKeyUpPress}
             onBubbledContextMenuPress={bubbled.contextMenu}
             groupIdentifier={groupIdentifier ?? contextIdentifier}
             tintColor={isIOS ? tintColor : undefined}
-            onFocusChange={
-              (hasOnFocusChanged && onFocusChangeHandler) as undefined
-            } //ToDo update types
+            onFocusChange={hasFocusListener ? onFocusChangeHandler : undefined}
             hasKeyDownPress={Boolean(onKeyDownPress)}
             hasKeyUpPress={Boolean(onKeyUpPress)}
-            hasOnFocusChanged={Boolean(hasOnFocusChanged)}
-            group={group}
+            hasOnFocusChanged={Boolean(hasFocusListener)}
+            focusableWrapper={focusableWrapper}
             orderIndex={orderIndex ?? -1}
-            enableA11yFocus={enableA11yFocus}
             screenAutoA11yFocusDelay={screenAutoA11yFocusDelay}
             lockFocus={lockFocusValue}
             {...wrappedOrderProps}
             orderGroup={groupId}
+            roundedHaloFix={roundedHaloFix}
           />
         </KeyPressContext.Provider>
       );