native-pytech 1.0.1

package/dist/libs/table/src/components/Delete/index.js

@@ -0,0 +1,141 @@
+import { batch } from '@legendapp/state';
+import { useSelector } from '@legendapp/state/react';
+import React, { memo, useCallback, useMemo, useRef, useState } from 'react';
+import { Animated, Easing, Platform, Pressable, StyleSheet, Text, View } from 'react-native';
+import Reanimated, { Easing as Reasing, SlideOutLeft } from 'react-native-reanimated';
+import { useLayoutEffectWithoutFirstRender } from '../../../../../libs/constants/hooks';
+import { isLowTier } from '../../../../../libs/constants/consts';
+import colors from '../../constants';
+import { useStore } from '../../context/table';
+import { DeleteProvider } from '../../context/delete';
+const anim = {
+    duration: 600,
+    easing: Easing.bezier(0.2, 0.2, 0, 1),
+    useNativeDriver: true,
+};
+export default memo(({ children, ...props }) => {
+    const [deleted, setDeleted] = useState(false);
+    if (deleted)
+        return null;
+    return <Component {...props} setDeleted={setDeleted}>{children}</Component>;
+});
+const Component = memo(({ children, id, removeWidth, onDelete, onDeleteShown, setDeleted, }) => {
+    const store = useStore();
+    const is_deleted = useSelector(() => store.deleted.id.get() === id);
+    useLayoutEffectWithoutFirstRender(() => {
+        if (is_deleted)
+            return;
+        onDeleteShown?.(id, false);
+        removeStateValue.stopAnimation();
+        Animated.timing(removeStateValue, { toValue: 0, ...anim }).start();
+    }, [is_deleted]);
+    const removeStateValue = useRef(new Animated.Value(0)).current;
+    const [widthRemove, setWidthRemove] = useState(removeWidth ? removeWidth + (12 * 2) : 0);
+    const animatedRemoveStyle = {
+        opacity: removeStateValue.interpolate({
+            inputRange: [0, 1],
+            outputRange: [0, 1]
+        }),
+        transform: [
+            {
+                translateX: removeStateValue.interpolate({
+                    inputRange: [0, 1],
+                    outputRange: [-widthRemove, 0]
+                })
+            },
+            {
+                scale: removeStateValue.interpolate({
+                    inputRange: [0, 1],
+                    outputRange: [0, 1]
+                }),
+            }
+        ]
+    };
+    const animatedStyle = {
+        transform: [{
+                translateX: removeStateValue.interpolate({
+                    inputRange: [0, 1],
+                    outputRange: [0, -widthRemove]
+                })
+            }]
+    };
+    const onLayputProps = removeWidth ? {} : { onLayout: (e) => setWidthRemove(e.nativeEvent.layout.width) };
+    const styleWidthRemove = removeWidth ? { width: removeWidth } : {};
+    // Función que los children pueden llamar para iniciar el delete
+    const startDelete = useCallback(() => {
+        if (store.deleted.setted.peek())
+            return;
+        store.deleted.id.set(id);
+        removeStateValue.stopAnimation();
+        Animated.timing(removeStateValue, { toValue: 1, ...anim }).start();
+        onDeleteShown?.(id, true);
+    }, []);
+    const exitingAnimation = isLowTier ? SlideOutLeft.duration(200) : SlideOutLeft.easing(Reasing.bezier(0.2, 0.2, 0, 1)).duration(300);
+    // Valor del contexto
+    const contextValue = useMemo(() => startDelete, [startDelete]);
+    const start = useCallback(() => {
+        if (store.deleted.id.peek() === null)
+            return;
+        store.deleted.setted.set(true);
+        store.deleted.id.set(null);
+    }, []);
+    const end = useCallback(() => { store.deleted.setted.set(false); }, []);
+    const viewProps = useMemo(() => (Platform.OS === 'web' ?
+        {
+            onPointerDown: start,
+            onPointerUp: end,
+        } : {
+        onTouchStart: start,
+        onTouchEnd: end,
+    }), []);
+    return (<>
+        <Pressable style={[styles.pressableRemove]} {...onLayputProps} onPress={() => {
+            removeStateValue.stopAnimation();
+            setDeleted(true);
+            onDelete?.(id);
+            const oldKeys = store.deleted.keys.peek();
+            const newKeys = oldKeys?.filter((key) => key !== id);
+            batch(() => {
+                store.deleted.keys.set(newKeys);
+                store.deleted.id.set(null);
+            });
+        }}>
+            <Animated.View style={[animatedRemoveStyle, styles.containerRemove, styleWidthRemove]}>
+                <Text style={styles.text}>Eliminar</Text>
+            </Animated.View>
+        </Pressable>
+
+        <Animated.View style={[{ position: 'relative' }, animatedStyle]}>
+            <Reanimated.View exiting={exitingAnimation}>
+                <View {...viewProps}>
+                    <DeleteProvider value={contextValue}>
+                        {children}
+                    </DeleteProvider>
+                </View>
+            </Reanimated.View>
+        </Animated.View>
+    </>);
+}, (prev, next) => prev.id === next.id);
+const styles = StyleSheet.create({
+    pressableRemove: {
+        position: 'absolute',
+        right: 0,
+        top: 0,
+        bottom: 0,
+        flex: 1
+    },
+    containerRemove: {
+        paddingHorizontal: 12,
+        backgroundColor: colors.especiales.rojo,
+        margin: 6,
+        marginHorizontal: 10,
+        flex: 1,
+        borderRadius: 16,
+        justifyContent: 'center',
+        alignItems: 'center'
+    },
+    text: {
+        fontSize: 13,
+        color: 'white'
+    }
+});

package/dist/libs/table/src/components/Delete/types.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+export interface DeleteProps {
+    /**
+        Opcion que se renderiza dentro del context.
+    */
+    children: React.ReactElement | React.ReactElement[] | null;
+    /**
+        Id de la opción.
+    */
+    id: string;
+    /**
+        Ancho del botón de eliminar.
+    */
+    removeWidth?: number;
+    /**
+        Función que se ejecuta al eliminar la opción.
+    */
+    onDelete?: ((key: string) => void) | undefined;
+    /**
+        Función que se ejecuta para indicar que el componente se ha eliminado.
+    */
+    onDeleteShown?: ((id: string, isDeleted: boolean) => void) | undefined;
+    /**
+        Función que se ejecuta para indicar que el componente se ha eliminado.
+    */
+    setDeleted: (deleted: boolean) => void;
+}

package/dist/libs/table/src/components/Delete/types.js

@@ -0,0 +1 @@
+export {};

package/dist/libs/table/src/components/Detail.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("react").MemoExoticComponent<({ text }: {
+    text?: string;
+}) => import("react").JSX.Element>;
+export default _default;

package/dist/libs/table/src/components/Detail.js

@@ -0,0 +1,11 @@
+import { memo } from "react";
+import { Text } from "react-native";
+import { useApp } from '../../../../libs/providers/App';
+import colors from "../constants";
+export default memo(({ text }) => {
+    const { colorScheme } = useApp();
+    const Theme = colors.theme[colorScheme];
+    return (<Text style={{ color: Theme.text2, fontSize: 13, lineHeight: 16 }}>
+            {text}
+        </Text>);
+});

package/dist/libs/table/src/components/Option/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import Props from './types';
+export declare const left = 16;
+export declare const right = 16;
+declare const _default: React.MemoExoticComponent<({ children, childrenLeft, childrenRight, onPress, style, backgroundColorPressed, LinearGradientProps, colorScheme, hasTextView, }: Props) => React.JSX.Element>;
+export default _default;

package/dist/libs/table/src/components/Option/index.js

@@ -0,0 +1,106 @@
+import { LinearGradient } from 'expo-linear-gradient';
+import React, { memo, useCallback, useMemo } from 'react';
+import { Pressable, StyleSheet, View } from 'react-native';
+import colors from '../../constants';
+import Table from '../Table';
+import { useTable } from '../../context/table';
+export const left = 16;
+export const right = 16;
+const flattenChildren = (children) => {
+    return React.Children.toArray(children).flatMap((child) => {
+        if (React.isValidElement(child) && child.type === React.Fragment) {
+            const props = child.props;
+            return flattenChildren(props.children);
+        }
+        return [child];
+    });
+};
+const AddTextView = memo(({ children, hasTextView }) => {
+    const hasTextView_ = hasTextView ?? flattenChildren(children).some((child) => React.isValidElement(child) && child.type === Table.Option.Components.TextView);
+    const viewChildren = useCallback((children) => <View style={styles.izq}>{children}</View>, []);
+    if (hasTextView_)
+        return viewChildren(children);
+    return (viewChildren(<Table.Option.Components.TextView>
+                {children}
+            </Table.Option.Components.TextView>));
+});
+export default memo(({ children, childrenLeft, childrenRight, onPress, style, backgroundColorPressed, LinearGradientProps, colorScheme, hasTextView, }) => {
+    // Component
+    const content = <>
+        {childrenLeft && <AddTextView hasTextView={hasTextView}>{childrenLeft}</AddTextView>}
+        {childrenRight && <View style={styles.der}>{childrenRight}</View>}
+        {children}
+    </>;
+    const styleView = useMemo(() => [styles.Item_View, style], [style]);
+    const childrenOption = onPress === undefined ? <View style={styleView}>{content}</View>
+        : (backgroundColorPressed ? (<Pressable onPress={onPress} style={({ pressed }) => !pressed ? styleView : [styleView, { backgroundColor: backgroundColorPressed }]}>
+                {content}
+            </Pressable>) : (<PressableView onPress={onPress} colorScheme={colorScheme} styleView={styleView}>
+                {content}
+            </PressableView>));
+    return (LinearGradientProps ?
+        <LinearGradient {...LinearGradientProps}>
+                {childrenOption}
+            </LinearGradient>
+        : childrenOption);
+});
+const PressableView = memo(({ children, onPress, colorScheme, styleView }) => {
+    const { colorThemeType } = useTable();
+    const backgroundColorPressed = colors.table[colorThemeType][colorScheme].background_pressed;
+    return (<Pressable onPress={onPress} style={({ pressed }) => !pressed ? styleView : [styleView, { backgroundColor: backgroundColorPressed }]}>
+            {children}
+        </Pressable>);
+});
+/*
+ const pressableChildren = useCallback(({ pressed }: { pressed: boolean }) => (
+        <>
+            {!pressed ?
+                <NotPressedView /> :
+                <OnPressView backgroundColorPressed={backgroundColorPressed} colorScheme={colorScheme} />
+            }
+            {content}
+        </>
+    ), [backgroundColorPressed, content, colorScheme])
+
+const NotPressedView = memo(() => <View style={styles.onPressView} />)
+const OnPressView = memo(({ backgroundColorPressed, colorScheme }: { backgroundColorPressed: OptionProps['backgroundColorPressed'], colorScheme: ColorSchemeType }) => {
+    const { colorThemeType } = useTable()
+    return <View style={[styles.onPressView, { backgroundColor: backgroundColorPressed ? backgroundColorPressed : Colors.table[colorThemeType][colorScheme].background_pressed }]} />
+
+})
+*/
+//(20.3 - 0.5) / 2 = 9.9
+//const paddingVertical = (24.1 - paddingTopItem - gap) / 2
+const styles = StyleSheet.create({
+    Item_View: {
+        flex: 1,
+        paddingLeft: left,
+        paddingRight: right,
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'center',
+        gap: 10
+    },
+    izq: {
+        marginRight: 'auto',
+        flex: 1,
+        flexDirection: 'row',
+        alignItems: 'center',
+        gap: 11,
+        //paddingBottom: 2,
+    },
+    der: {
+        marginLeft: 'auto',
+        flexDirection: 'row',
+        alignItems: 'center',
+        gap: 11
+    },
+    onPressView: {
+        position: 'absolute',
+        top: -1,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: 'transparent'
+    }
+});

package/dist/libs/table/src/components/Option/types.d.ts

@@ -0,0 +1,61 @@
+import { LinearGradientProps } from 'expo-linear-gradient';
+import React from "react";
+import { GestureResponderEvent, StyleProp, ViewStyle } from "react-native";
+import { LinearTransition } from "react-native-reanimated";
+import { type ColorSchemeType } from "../../constants";
+type Props = {
+    /**
+        Lo que se va a renderizar dentro de la opción.
+    */
+    children?: React.ReactElement;
+    /**
+        Lo que se va a renderizar dentro de la view de la izquierda.
+    */
+    childrenLeft?: React.ReactElement | null;
+    /**
+        Lo que se va a renderizar dentro de la view de la derecha.
+    */
+    childrenRight?: React.ReactElement | null;
+    /**
+        Función que se ejecuta al presionar la opción.
+    */
+    onPress?: ((event: GestureResponderEvent) => void) | undefined;
+    /**
+        Función que se ejecuta al eliminar la opción.
+    */
+    onDelete?: ((key: string) => void) | undefined;
+    /**
+        Función que se ejecuta para indicar que el componente se ha eliminado.
+    */
+    onDeleteShown?: ((id: string, isDeleted: boolean) => void) | undefined;
+    /**
+        Ancho del botón de eliminar.
+    */
+    removeWidth?: number;
+    /**
+        Estilos de la opción.
+        Es un Animated.View.
+    */
+    style?: StyleProp<ViewStyle>;
+    /**
+        Color de fondo de la opción cuando está presionada.
+    */
+    backgroundColorPressed?: string;
+    /**
+        Props para el LinearGradient.
+    */
+    LinearGradientProps?: LinearGradientProps;
+    /**
+        LayoutAnimation de la opción.
+    */
+    layoutAnimation?: LinearTransition;
+    /**
+        Indica si la opción tiene un TextView en el childrenLeft.
+    */
+    hasTextView?: boolean;
+    /**
+     * Color del tema de la opción.
+    */
+    colorScheme: ColorSchemeType;
+};
+export default Props;

package/dist/libs/table/src/components/Option/types.js

@@ -0,0 +1 @@
+export {};

package/dist/libs/table/src/components/OptionComponents/deleteIcon.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+/**
+    Icono de eliminar.
+*/
+declare const _default: React.MemoExoticComponent<() => React.JSX.Element>;
+export default _default;

package/dist/libs/table/src/components/OptionComponents/deleteIcon.js

@@ -0,0 +1,14 @@
+import React, { memo } from 'react';
+import { Pressable } from 'react-native';
+import { useDelete } from '../../context/delete';
+import RemoveCircle from '../../../../../libs/assets/components/RemoveCircle';
+import colors from '../../constants';
+/**
+    Icono de eliminar.
+*/
+export default memo(() => {
+    const startDelete = useDelete();
+    return (<Pressable onPress={() => startDelete()}>
+			<RemoveCircle size={30} color={colors.especiales.rojo} insideColor='white'/>
+		</Pressable>);
+});

package/dist/libs/table/src/components/OptionComponents/dragIcon.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+/**
+    Icono de drag.
+*/
+declare const _default: React.MemoExoticComponent<() => React.JSX.Element>;
+export default _default;

package/dist/libs/table/src/components/OptionComponents/dragIcon.js

@@ -0,0 +1,18 @@
+import { Ionicons } from '@expo/vector-icons';
+import React, { memo } from 'react';
+import { Pressable } from 'react-native';
+//import { useDrag } from 'libs/ReorderableList'
+import colors from '../../constants';
+import { useApp } from '../../../../../libs/providers/App';
+/**
+    Icono de drag.
+*/
+export default memo(() => {
+    const { colorScheme } = useApp();
+    const Theme = colors.theme[colorScheme];
+    //const pressableProps = useDrag() as unknown as PressableProps
+    const pressableProps = {};
+    return (<Pressable {...pressableProps}>
+			<Ionicons name='menu-outline' size={28} color={Theme.borderColorContCliente}/>
+		</Pressable>);
+});

package/dist/libs/table/src/components/OptionComponents/icon.d.ts

@@ -0,0 +1,10 @@
+import { Ionicons } from '@expo/vector-icons';
+import React from 'react';
+/**
+    Pone el color según el tema.
+*/
+declare const _default: React.MemoExoticComponent<({ name, size }: {
+    name: keyof typeof Ionicons.glyphMap;
+    size: number;
+}) => React.JSX.Element>;
+export default _default;

package/dist/libs/table/src/components/OptionComponents/icon.js

@@ -0,0 +1,12 @@
+import { Ionicons } from '@expo/vector-icons';
+import React, { memo } from 'react';
+import colors from '../../constants';
+import { useApp } from '../../../../../libs/providers/App';
+/**
+    Pone el color según el tema.
+*/
+export default memo(({ name, size = 30 }) => {
+    const { colorScheme } = useApp();
+    const Theme = colors.theme[colorScheme];
+    return (<Ionicons name={name} size={size} color={Theme.icon}/>);
+});

package/dist/libs/table/src/components/OptionComponents/image.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ImageSourcePropType } from 'react-native';
+/**
+    Pone el tintColor según el tema.
+*/
+declare const _default: React.MemoExoticComponent<({ source }: {
+    source: ImageSourcePropType;
+}) => React.JSX.Element>;
+export default _default;

package/dist/libs/table/src/components/OptionComponents/image.js

@@ -0,0 +1,12 @@
+import React, { memo } from 'react';
+import { Image } from 'react-native';
+import colors from '../../constants';
+import { useApp } from '../../../../../libs/providers/App';
+/**
+    Pone el tintColor según el tema.
+*/
+export default memo(({ source }) => {
+    const { colorScheme } = useApp();
+    const Theme = colors.theme[colorScheme];
+    return (<Image source={source} style={{ width: 12.1, height: 12.1 }} tintColor={Theme.icon}/>);
+});

package/dist/libs/table/src/components/OptionComponents/index.d.ts

@@ -0,0 +1,8 @@
+export { default as DeleteIcon } from './deleteIcon';
+export { default as DragIcon } from './dragIcon';
+export { default as Icon } from './icon';
+export { default as Image } from './image';
+export { default as Text } from './text';
+export { default as TextInput } from './textInput';
+export { default as TextInputCurrency } from './textInputCurrency';
+export { default as TextView } from './textView';

package/dist/libs/table/src/components/OptionComponents/index.js

@@ -0,0 +1,8 @@
+export { default as DeleteIcon } from './deleteIcon';
+export { default as DragIcon } from './dragIcon';
+export { default as Icon } from './icon';
+export { default as Image } from './image';
+export { default as Text } from './text';
+export { default as TextInput } from './textInput';
+export { default as TextInputCurrency } from './textInputCurrency';
+export { default as TextView } from './textView';

package/dist/libs/table/src/components/OptionComponents/text.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { StyleProp, TextProps, TextStyle } from 'react-native';
+import { type ColorSchemeType } from '../../constants';
+/**
+    Pone el color del texto según el tema.
+*/
+type Props = {
+    text: string;
+    enabled: boolean;
+    fontScale?: string;
+    style: StyleProp<TextStyle>;
+};
+declare const _default: React.MemoExoticComponent<({ ...props }: Props & {
+    colorScheme?: ColorSchemeType;
+} & TextProps) => React.JSX.Element>;
+export default _default;

package/dist/libs/table/src/components/OptionComponents/text.js

@@ -0,0 +1,20 @@
+import React, { memo, useMemo } from 'react';
+import { StyleSheet } from 'react-native';
+import colors from '../../constants';
+import Text$ from '../../../../../libs/components/Text';
+import ThemeComponent from '../../../../../libs/components/Theme';
+export default memo(({ ...props }) => {
+    return <ThemeComponent component={Component} {...props}/>;
+});
+const Component = memo(({ text, enabled = true, style = {}, colorScheme, fontScale, ...props }) => {
+    const Theme = colors.theme[colorScheme];
+    const textStyle = useMemo(() => [styles.text, { color: enabled ? Theme.text : Theme.text2 }, style], [enabled, Theme, style]);
+    return (<Text$ fontScale={fontScale} style={textStyle} {...props}>
+            {text}
+        </Text$>);
+});
+const styles = StyleSheet.create({
+    text: {
+        fontSize: 17,
+    }
+});

package/dist/libs/table/src/components/OptionComponents/textInput.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { BlurEvent, FocusEvent, TextInput, TextInputProps } from 'react-native';
+export declare const selectAll: (input: TextInput | any, value: string | null) => void;
+/**
+    Pone el color del texto según el tema y agrega unos estilos para que ocupen todo el ancho.
+*/
+declare const _default: React.MemoExoticComponent<({ value, numberOfLines, onFocus, onBlur, onChangeText, mask, ...props }: {
+    /**
+        Valor inicial del input.
+    */
+    value?: any;
+    /**
+        Por default es 1.
+    */
+    numberOfLines?: number;
+    onFocus?: ((e: FocusEvent) => void) | undefined;
+    onBlur?: ((e: BlurEvent) => void) | undefined;
+    onChangeText?: ((text: string) => void) | undefined;
+    /**
+        Función para aplicar una máscara al valor del input.
+        Ejemplo: {(value) => value ? formatPeso(value) : formatPeso(0)}
+    */
+    mask?: ((value: any) => string) | undefined;
+} & TextInputProps) => React.JSX.Element>;
+export default _default;

package/dist/libs/table/src/components/OptionComponents/textInput.js

@@ -0,0 +1,49 @@
+import React, { memo, useEffect, useRef, useState } from 'react';
+import { Platform, StyleSheet, TextInput } from 'react-native';
+import colors from '../../constants';
+import { useApp } from '../../../../../libs/providers/App';
+export const selectAll = (input, value) => {
+    if (value === null)
+        return;
+    if (Platform.OS !== 'web')
+        input.setSelection(0, value.toString().length);
+    else
+        input.select();
+};
+/**
+    Pone el color del texto según el tema y agrega unos estilos para que ocupen todo el ancho.
+*/
+export default memo(({ value, numberOfLines = 1, onFocus, onBlur, onChangeText, mask, ...props }) => {
+    const { colorScheme } = useApp();
+    const Theme = colors.theme[colorScheme];
+    const inputRef = useRef(null);
+    const [isFocused, setIsFocused] = useState(false);
+    const [rawValue, setRawValue] = useState(value);
+    // Determinar el valor visual basado en el estado de foco
+    const displayValue = rawValue == null ? null :
+        isFocused || !mask
+            ? rawValue.toString()
+            : mask(rawValue);
+    useEffect(() => {
+        if (isFocused)
+            selectAll(inputRef.current, rawValue);
+    }, [isFocused]);
+    return (<TextInput style={[styles.textInput, { color: Theme.text }]} ref={inputRef} numberOfLines={numberOfLines} multiline={Platform.OS === 'android'} value={displayValue == null ? '' : displayValue} selectTextOnFocus={true} onFocus={(e) => {
+            setIsFocused(true);
+            onFocus?.(e);
+        }} onBlur={(e) => {
+            setIsFocused(false);
+            onBlur?.(e);
+        }} onChangeText={(text) => {
+            setRawValue(text === '' ? null : text);
+            onChangeText?.(text);
+        }} clearButtonMode='while-editing' {...props}/>);
+});
+const styles = StyleSheet.create({
+    textInput: {
+        fontSize: 17,
+        flex: 1,
+        outlineStyle: 'none', // Le tuve que poner el "as any" porque no existe esta propiedad en dispositivos.
+        textAlign: 'right',
+    },
+});

package/dist/libs/table/src/components/OptionComponents/textInputCurrency.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { TextInputProps } from 'react-native';
+export declare function formatPeso(value: number): string;
+/**
+    Se utiliza específicamente para formatear el valor del input a pesos.
+    Utiliza el componente de TextInputOption.
+*/
+declare const _default: React.MemoExoticComponent<({ ...props }: TextInputProps) => React.JSX.Element>;
+export default _default;

package/dist/libs/table/src/components/OptionComponents/textInputCurrency.js

@@ -0,0 +1,17 @@
+import React, { memo } from 'react';
+import TextInputOption from './textInput';
+export function formatPeso(value) {
+    return new Intl.NumberFormat('es-AR', {
+        style: 'currency',
+        currency: 'ARS',
+        minimumFractionDigits: 0, // <- no obliga decimales
+        maximumFractionDigits: 2 // <- si vienen, los respeta
+    }).format(Number(value));
+}
+/**
+    Se utiliza específicamente para formatear el valor del input a pesos.
+    Utiliza el componente de TextInputOption.
+*/
+export default memo(({ ...props }) => {
+    return (<TextInputOption keyboardType='numeric' autoCapitalize='none' autoCorrect={false} placeholder={'$0'} mask={(value) => value ? formatPeso(value) : formatPeso(0)} {...props}/>);
+});

package/dist/libs/table/src/components/OptionComponents/textView.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { StyleProp, ViewStyle, ViewProps } from 'react-native';
+import Text from './text';
+type TextType = (React.ReactElement<typeof Text>);
+type Props = {
+    children: TextType | TextType[] | React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    isSingleLine?: boolean;
+};
+/**
+    Pone el padding según el typeOption.
+*/
+declare const _default: React.MemoExoticComponent<({ children, style, isSingleLine, ...props }: Props & ViewProps) => React.JSX.Element>;
+export default _default;