react-crud-mobile 1.3.413 → 1.3.503

package/dist/index.mjs

@@ -0,0 +1,2556 @@
+// src/elements/UIElement.tsx
+import React9, {
+  createContext,
+  useContext,
+  useEffect as useEffect4,
+  useLayoutEffect,
+  useRef as useRef6,
+  useState as useState14
+} from "react";
+
+// src/elements/UIChildren.tsx
+import React2, { useState } from "react";
+import { ScopeUtils, Utils } from "react-crud-utils";
+import { StyleSheet, View } from "react-native";
+function UIChildren(props) {
+  let [scope] = useState(Utils.nvl(props.scope, ScopeUtils.create(props)));
+  let crud = Utils.nvl(props.crud, scope.crud);
+  let validateScope = Utils.nvl(props.validateScope, "global");
+  let name = Utils.nvl(props.part, "child");
+  if (scope.isInput()) {
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null);
+  }
+  let Paint = ({ child }) => {
+    if (!child) {
+      return /* @__PURE__ */ React2.createElement(React2.Fragment, null);
+    }
+    if (typeof child === "string") {
+      return /* @__PURE__ */ React2.createElement(React2.Fragment, null, child);
+    }
+    let Custom = child.type;
+    let pps = { ...child.props };
+    delete pps.children;
+    if (typeof Custom === "string") {
+      if (Utils.isEmpty(child.props.children)) {
+        return /* @__PURE__ */ React2.createElement(Custom, { ...pps });
+      }
+      return /* @__PURE__ */ React2.createElement(Custom, { ...pps }, /* @__PURE__ */ React2.createElement(
+        UIChildren,
+        {
+          transient: true,
+          validateScope,
+          ...child.props,
+          scope,
+          crud
+        }
+      ));
+    } else if (typeof Custom === "function") {
+      return /* @__PURE__ */ React2.createElement(
+        Custom,
+        {
+          validateScope,
+          ...child.props,
+          parent: scope,
+          crud
+        }
+      );
+    }
+    if (!Utils.isEmpty(child.props?.children)) {
+      return /* @__PURE__ */ React2.createElement(
+        UIChildren,
+        {
+          validateScope,
+          ...child.props,
+          scope,
+          crud,
+          transient: true
+        }
+      );
+    }
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null);
+  };
+  const Draw = () => {
+    if (props.elements) {
+      return /* @__PURE__ */ React2.createElement(React2.Fragment, null, Object.entries(props.elements).map((t, k) => {
+        return /* @__PURE__ */ React2.createElement(UIElement, { crud, ...t[1] });
+      }));
+    }
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, React2.Children.map(props.children, (child) => {
+      return /* @__PURE__ */ React2.createElement(Paint, { child });
+    }));
+  };
+  if (props.transient) {
+    return /* @__PURE__ */ React2.createElement(Draw, null);
+  }
+  if (Utils.isEmpty(props.children) && Utils.isEmpty(props.elements)) {
+    return /* @__PURE__ */ React2.createElement(React2.Fragment, null);
+  }
+  const getStyle = (part) => {
+    let key = Utils.nvl(part, "root");
+    let def = styles[key];
+    let css = {};
+    if (!Utils.isEmpty(props.style)) {
+      if (props.style?.push) {
+        Utils.each(props.style, (s) => {
+          if (s) {
+            css = { ...css, ...s };
+          }
+        });
+      } else {
+        css = { ...props.style };
+      }
+    }
+    return { ...def, ...css, ...scope.getStyle(part) };
+  };
+  if (props.transient) {
+    return /* @__PURE__ */ React2.createElement(Draw, null);
+  }
+  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(View, { style: getStyle(name) }, /* @__PURE__ */ React2.createElement(Draw, null)));
+}
+var styles = StyleSheet.create({
+  child: { width: "100%" },
+  inner: { width: "100%" }
+});
+
+// src/elements/tabs/ElTabs.tsx
+import React3, { useState as useState2 } from "react";
+import Ionicons from "@expo/vector-icons/Ionicons";
+import { CrudUtils, Utils as Utils2 } from "react-crud-utils";
+function ElTabs(props) {
+  let scope = props.scope;
+  let [selectedIndex, setSelectedIndex] = useState2(0);
+  let element = scope.original;
+  let items = scope.getItems();
+  let counter = 0;
+  let tabs = [];
+  let [selected, setSelected] = useState2(null);
+  const onChangeTab = (tab, validate = true) => {
+    if (tab) {
+      scope.execute({
+        event: {
+          validate,
+          validateScope: element.validateScope,
+          action: () => {
+            scope.changeValue(tab.data);
+            selected = tab;
+            selectedIndex = tab.index;
+            setSelectedIndex(selectedIndex);
+            setSelected(tab);
+          }
+        }
+      });
+    }
+  };
+  const getStyleClass = (t) => {
+    let s = "ui-tabs-item ui-click";
+    if (selected?.index === t.index) {
+      s = s + " ui-tab-selected";
+    }
+    return s;
+  };
+  const addTab = (child, item) => {
+    let original = { ...child.props };
+    if (!item) {
+      item = scope.crud.data;
+    }
+    let crudTab = CrudUtils.create("tabs", {
+      data: item,
+      changed: item,
+      parent: scope.crud
+    });
+    let element2 = Utils2.resolve(original, crudTab);
+    if (element2.rendered === false) {
+      return;
+    }
+    tabs.push({
+      ...element2,
+      child,
+      element: element2,
+      original,
+      index: counter++,
+      data: item
+    });
+  };
+  React3.Children.map(props.children, (child, index) => {
+    if (Utils2.isEmpty(items)) {
+      addTab(child, {});
+    } else {
+      for (const i in items) {
+        let o = items[i];
+        addTab(child, o);
+      }
+    }
+  });
+  if (!selected) {
+    onChangeTab(tabs[selectedIndex], false);
+  }
+  const nav = (i) => {
+    let t = tabs[selectedIndex + i];
+    onChangeTab(t);
+  };
+  const previous = () => {
+    nav(-1);
+  };
+  const next = () => {
+    nav(1);
+  };
+  let isStepper = element.layout === "stepper";
+  return /* @__PURE__ */ React3.createElement(
+    "div",
+    {
+      className: scope.getStyleClass("inner"),
+      style: scope.getStyle("inner")
+    },
+    /* @__PURE__ */ React3.createElement("div", { className: "ui-tabs-content" }, /* @__PURE__ */ React3.createElement("div", { className: "ui-tabs-items" }, tabs.map((t, i) => /* @__PURE__ */ React3.createElement(
+      "div",
+      {
+        key: Utils2.key(element.id, "tab", i),
+        className: getStyleClass(t),
+        onClick: () => {
+          onChangeTab(t);
+        }
+      },
+      isStepper && /* @__PURE__ */ React3.createElement("div", { className: "ui-tab-item-divisor" }),
+      /* @__PURE__ */ React3.createElement("div", { className: "ui-tab-item-inner" }, isStepper && /* @__PURE__ */ React3.createElement("div", { className: "ui-step-line" }), /* @__PURE__ */ React3.createElement("div", { className: "ui-tab-item-label" }, isStepper ? t.index + 1 : t.label))
+    ))), selected && /* @__PURE__ */ React3.createElement(React3.Fragment, null, isStepper && /* @__PURE__ */ React3.createElement("div", { className: "ui-tabs-label" }, selected.label), /* @__PURE__ */ React3.createElement("div", { className: "ui-tabs-area" }, /* @__PURE__ */ React3.createElement(UIChildren, { ...props, scope }, selected.child)), element.layout === "stepper" && /* @__PURE__ */ React3.createElement("div", { className: "ui-tabs-actions" }, /* @__PURE__ */ React3.createElement(UI_default.Output, { space: 6, layout: "left" }, /* @__PURE__ */ React3.createElement(
+      UI_default.Include,
+      {
+        ...props,
+        transient: true,
+        name: "left",
+        default: /* @__PURE__ */ React3.createElement(
+          UI_default.Button,
+          {
+            rendered: selectedIndex > 0,
+            icon: /* @__PURE__ */ React3.createElement(Ionicons, null),
+            click: previous
+          }
+        )
+      }
+    )), /* @__PURE__ */ React3.createElement(UI_default.Output, { space: 6, layout: "right" }, /* @__PURE__ */ React3.createElement(
+      UI_default.Include,
+      {
+        ...props,
+        transient: true,
+        name: "right",
+        default: /* @__PURE__ */ React3.createElement(
+          UI_default.Button,
+          {
+            rendered: selectedIndex < tabs.length - 1,
+            icon: /* @__PURE__ */ React3.createElement(Ionicons, null),
+            click: next
+          }
+        )
+      }
+    )))))
+  );
+}
+
+// src/elements/charts/ElChart.tsx
+import React4 from "react";
+import { Utils as Utils3 } from "react-crud-utils";
+function ElChart(props) {
+  let scope = props.scope;
+  let items = scope.getItems();
+  let columns = Utils3.asList(scope.original.columns);
+  return /* @__PURE__ */ React4.createElement("div", { className: "ui-chart-data" });
+}
+
+// src/elements/core/UIAutoComplete.tsx
+import { Text, TouchableOpacity, Linking } from "react-native";
+function UIAutoComplete(props) {
+  const handlePress = () => {
+    Linking.openURL("https://reactnative.dev/");
+  };
+  return /* @__PURE__ */ React.createElement(TouchableOpacity, { onPress: handlePress }, /* @__PURE__ */ React.createElement(Text, { style: styles2.link }, "Clique aqui para acessar o React Native"));
+}
+var styles2 = {
+  link: {}
+};
+
+// src/elements/UIComplete.tsx
+function UIComplete({
+  defaultsInput,
+  defaultsUI,
+  scope
+}) {
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(UIAutoComplete, { ...defaultsInput, ...defaultsUI }));
+}
+
+// src/elements/UIElement.tsx
+import {
+  HtmlUtils as HtmlUtils2,
+  ScopeUtils as ScopeUtils3,
+  Utils as Utils18,
+  ComponentUtils as ComponentUtils5,
+  CrudUtils as CrudUtils2,
+  ViewUtils as ViewUtils3
+} from "react-crud-utils";
+
+// src/elements/core/UILink.tsx
+import { Text as Text2, TouchableOpacity as TouchableOpacity2, Linking as Linking2 } from "react-native";
+function UILink(props) {
+  const handlePress = () => {
+    Linking2.openURL("https://reactnative.dev/");
+  };
+  return /* @__PURE__ */ React.createElement(TouchableOpacity2, { onPress: handlePress }, /* @__PURE__ */ React.createElement(Text2, { style: styles3.link }, "Clique aqui para acessar o React Native"));
+}
+var styles3 = {
+  link: {}
+};
+
+// src/elements/core/UIIcon.tsx
+import {
+  Ionicons as Ionicons2,
+  MaterialCommunityIcons,
+  AntDesign,
+  Entypo,
+  EvilIcons
+} from "@expo/vector-icons";
+import { Utils as Utils4 } from "react-crud-utils";
+function UIIcon({ scope }) {
+  let name = scope.getValue();
+  let libs = {
+    ion: Ionicons2,
+    ant: AntDesign,
+    entypo: Entypo,
+    evil: EvilIcons,
+    material: MaterialCommunityIcons
+  };
+  let library = Utils4.nvl(scope.original.library, "ion");
+  let Aux = libs[library];
+  let css = scope.getStyle("icon");
+  let fontSize = scope.part("size", 20);
+  let size = scope.part("iconSize", fontSize);
+  if (scope.original?.transient) {
+    css = { ...css, ...scope.getStyle() };
+  }
+  return /* @__PURE__ */ React.createElement(Aux, { size, name, style: css });
+}
+
+// src/elements/core/UIButton.tsx
+import { Utils as Utils5 } from "react-crud-utils";
+import { Text as Text3, TouchableHighlight } from "react-native";
+var BUTTONS_SIZE = { small: { minWidth: 30, height: 30 } };
+function UIButton(props) {
+  let scope = props.scope;
+  let element = scope.original;
+  let size = Utils5.nvl(element.size, "default");
+  let align = Utils5.nvl(element.align, "center");
+  let variant = Utils5.nvl(element.variant, "default");
+  let color = element.color;
+  let label = scope.getLabel();
+  let icon = scope.getPart("icon");
+  if (!color) color = "primaryLight";
+  const styles13 = {
+    buttonLabel: {
+      color: "#ffffff",
+      fontWeight: 400,
+      fontSize: 15
+    },
+    buttonInner: {
+      flexDirection: "row",
+      alignItems: "center",
+      justifyContent: "center",
+      height: 44,
+      minWidth: 44
+    },
+    buttonIcon: {
+      color: "#fff",
+      fontSize: 16
+    },
+    button: {
+      backgroundColor: color,
+      borderRadius: 20,
+      gap: 10,
+      justifyContent: "center",
+      alignItems: "center",
+      flexDirection: "row"
+    }
+  };
+  const onClick = (e) => {
+    scope.call("click", {});
+  };
+  const style = (part, extra2) => {
+    let css = { ...styles13[part], ...extra2 };
+    if (variant === "text" || variant === "outlined") {
+      css.backgroundColor = "transparent";
+      css.color = Utils5.nvl(color, "text");
+    }
+    if (size === "small") {
+      css.fontSize = 12;
+      css.fontWeight = 500;
+    }
+    if (size === "medium") {
+      css.fontSize = 14;
+      css.fontWeight = 500;
+    }
+    if (align === "left") {
+      css.justifyContent = "flex-start";
+    }
+    return scope.getStyle(part, css);
+  };
+  let extra = {};
+  if (icon) {
+    extra.button = { height: 40, padding: 0 };
+  } else {
+    extra.button = { height: 50 };
+  }
+  const buttonStyle = Utils5.call(() => {
+    let def = { ...extra?.button };
+    if (variant === "outlined") {
+      def.borderWidth = 1;
+      def.borderColor = Utils5.nvl(color, "text");
+    }
+    if (size) {
+      def = { ...def, ...BUTTONS_SIZE[size] };
+    }
+    if (!label) {
+      def = { ...def, borderRadius: 20 };
+    }
+    let css = style("button", def);
+    if (!css.width) {
+      let h = css.height;
+      if (typeof h === "number") {
+        css.minWidth = h;
+      }
+    }
+    return css;
+  });
+  const buttonLabel = style("buttonLabel");
+  const iconStyle = Utils5.call(() => {
+    let css = style("buttonIcon", extra.icon);
+    css.fontSize = Utils5.nvl(buttonLabel.fontSize, css.fontSize);
+    return css;
+  });
+  return /* @__PURE__ */ React.createElement(
+    TouchableHighlight,
+    {
+      underlayColor: "transparent",
+      onPress: onClick,
+      style: buttonStyle
+    },
+    /* @__PURE__ */ React.createElement(React.Fragment, null, icon && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+      UI_default.Icon,
+      {
+        size: Utils5.nvl(element.iconSize, 30),
+        style: iconStyle,
+        value: icon
+      }
+    )), label && /* @__PURE__ */ React.createElement(Text3, { style: buttonLabel }, label))
+  );
+}
+
+// src/elements/core/UISelect.tsx
+import { useRef, useState as useState3 } from "react";
+import { Utils as Utils6 } from "react-crud-utils";
+import {
+  Text as Text4,
+  TouchableOpacity as TouchableOpacity3,
+  StyleSheet as StyleSheet4,
+  Modal,
+  View as View3,
+  ScrollView
+} from "react-native";
+import { Ionicons as Ionicons3 } from "@expo/vector-icons";
+import { SafeAreaView } from "react-native-safe-area-context";
+function UISelect(props) {
+  const [modalVisible, setModalVisible] = useState3(false);
+  const scope = props.scope;
+  const original = scope.original;
+  const items = Utils6.nvl(scope.getOptions(), []);
+  const placeholder = scope.attr("placeholder", "Selecione...");
+  const value = scope.getDisplayValue();
+  const theme = scope.getTheme();
+  const headerStyle = Utils6.nvl(theme.styles?.defaults?.header, {});
+  const handlePress = () => {
+    setModalVisible(!modalVisible);
+  };
+  const scrollRef = useRef(null);
+  const iconColor = Utils6.nvl(theme.colors?.text, "#100e0e");
+  const modalColor = Utils6.nvl(headerStyle.color, "white");
+  const defaults = { color: modalColor };
+  const onClick = ({ crud, value: value2 }) => {
+    let val = value2;
+    if (original.isObject && val?.object) {
+      scope.changeValue(val?.object);
+    } else if (val?.value) {
+      scope.changeValue(val?.value);
+    } else {
+      scope.changeValue(value2);
+    }
+    setModalVisible(false);
+  };
+  const style = (part, extra) => {
+    let all = { ...styles4[part], ...extra };
+    return scope.getStyle(part, all);
+  };
+  const isModalVisible = () => {
+    return modalVisible;
+  };
+  const getLabelStyle = () => {
+    const css = style("selectLabel");
+    let fs = parseInt(css.fontSize);
+    if (!fs) {
+      fs = 14;
+    }
+    let lh = Utils6.nvl(css.lineHeight, fs + 2);
+    css.fontSize = fs;
+    css.lineHeight = lh;
+    return css;
+  };
+  const labelStyle = getLabelStyle();
+  const defIconSize = Utils6.nvl(labelStyle.fontSize, 14) + 2;
+  const iconSize = scope.getPart("iconSize", null, defIconSize);
+  return /* @__PURE__ */ React.createElement(
+    View3,
+    {
+      key: scope.getName(`${scope.getPart("modal")}_${modalVisible}`),
+      style: style("selectRoot")
+    },
+    /* @__PURE__ */ React.createElement(TouchableOpacity3, { onPress: handlePress, style: style("selectInput") }, /* @__PURE__ */ React.createElement(Text4, { style: labelStyle }, Utils6.nvl(value, placeholder)), /* @__PURE__ */ React.createElement(
+      Ionicons3,
+      {
+        name: "chevron-down-outline",
+        size: iconSize,
+        color: scope.getPart("iconColor", null, iconColor),
+        style: style("iconStyle", {})
+      }
+    )),
+    /* @__PURE__ */ React.createElement(
+      Modal,
+      {
+        animationType: "slide",
+        transparent: true,
+        visible: isModalVisible(),
+        onRequestClose: () => setModalVisible(false)
+      },
+      /* @__PURE__ */ React.createElement(SafeAreaView, { style: style("modalTop") }),
+      /* @__PURE__ */ React.createElement(SafeAreaView, { style: style("modalSafe") }, /* @__PURE__ */ React.createElement(View3, { style: scope.getStyle("header", headerStyle) }, /* @__PURE__ */ React.createElement(
+        TouchableOpacity3,
+        {
+          onPress: handlePress,
+          style: style("modalCloseButton")
+        },
+        /* @__PURE__ */ React.createElement(
+          Ionicons3,
+          {
+            name: "close",
+            size: 24,
+            color: modalColor,
+            style: style("modalCloseText", defaults)
+          }
+        )
+      ), /* @__PURE__ */ React.createElement(Text4, { style: style("modalTitle", defaults) }, placeholder)), /* @__PURE__ */ React.createElement(
+        ScrollView,
+        {
+          contentContainerStyle: { flexGrow: 1, paddingBottom: 50 },
+          style: style("modalContent"),
+          nestedScrollEnabled: true,
+          ref: scrollRef
+        },
+        /* @__PURE__ */ React.createElement(
+          View3,
+          {
+            style: {
+              flex: 1,
+              paddingLeft: 15,
+              paddingRight: 15,
+              paddingTop: 10,
+              paddingBottom: 10
+            }
+          },
+          /* @__PURE__ */ React.createElement(
+            UI_default.List,
+            {
+              data: items,
+              name: scope.getName("list"),
+              layout: "card",
+              search: original.search === true,
+              click: onClick,
+              rowStyle: {
+                paddingLeft: 15,
+                paddinRight: 15,
+                ...original?.rowStyle
+              },
+              ...original?.listProps
+            },
+            /* @__PURE__ */ React.createElement(UI_default.Value, { value: "#{@this.label}" })
+          )
+        )
+      ))
+    )
+  );
+}
+var styles4 = StyleSheet4.create({
+  selectRoot: {
+    justifyContent: "flex-start",
+    alignItems: "flex-start",
+    flex: 1
+  },
+  selectInput: {
+    width: "100%",
+    flexDirection: "row",
+    borderRadius: 5,
+    paddingHorizontal: 15,
+    borderWidth: 1,
+    borderStyle: "solid",
+    borderColor: "#dedede",
+    paddingVertical: 10
+  },
+  selectLabel: { flex: 1, fontSize: 14 },
+  modalTop: {
+    backgroundColor: "primary",
+    width: "100%"
+  },
+  modalSafe: {
+    flex: 1,
+    width: "100%",
+    backgroundColor: "background"
+  },
+  modalCloseButton: {
+    padding: 10
+  },
+  modalCloseText: {
+    fontSize: 18,
+    color: "white"
+  },
+  modalTitle: {
+    fontSize: 18,
+    fontWeight: "bold",
+    marginLeft: 10
+  },
+  modalContent: {
+    flex: 1,
+    backgroundColor: "background"
+  }
+});
+
+// src/elements/core/UISwitch.tsx
+import { useState as useState4 } from "react";
+import { Utils as Utils7 } from "react-crud-utils";
+import { Switch } from "react-native";
+function UISwitch(props) {
+  const scope = props.scope;
+  const initial = Utils7.nvl(scope.getValue(), false);
+  const [value, setValue] = useState4(initial);
+  let onChange = (v) => {
+    scope.changeValue(v);
+    setValue(v);
+  };
+  return /* @__PURE__ */ React.createElement(
+    Switch,
+    {
+      value,
+      style: scope.getStyle("element"),
+      onValueChange: onChange
+    }
+  );
+}
+
+// src/elements/core/UISlider.tsx
+import { useState as useState5 } from "react";
+import { ComponentUtils, Utils as Utils8 } from "react-crud-utils";
+import Slider from "@react-native-community/slider";
+function UISlider(props) {
+  const scope = props.scope;
+  const initial = Utils8.nvl(scope.getValue(), 0);
+  const [value, setValue] = useState5(initial);
+  let onChange = (v) => {
+    v = Utils8.nvl(v, 0);
+    console.log(v);
+    scope.changeValue(v);
+    setValue(v);
+  };
+  let step = scope.attr("step", 1);
+  let min = scope.attr("min", 0);
+  let max = scope.attr("min", 100);
+  let onSlideScroll = (scrollEnabled) => {
+    let viewScope = ComponentUtils.getViewScope();
+    if (scope.original.debug) {
+      console.log(viewScope);
+    }
+    if (viewScope) {
+      let scrollRef = viewScope.get("scrollRef");
+      if (scrollRef) scrollRef.current?.setNativeProps?.({ scrollEnabled });
+    }
+  };
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+    Slider,
+    {
+      minimumValue: min,
+      maximumValue: max,
+      step,
+      minimumTrackTintColor: "#1EB1FC",
+      maximumTrackTintColor: "#d3d3d3",
+      thumbTintColor: "#1EB1FC",
+      value,
+      onSlidingStart: () => onSlideScroll(false),
+      onSlidingComplete: () => onSlideScroll(true),
+      style: { width: "100%", height: 40, ...scope.getStyle("element") },
+      onValueChange: onChange
+    }
+  ));
+}
+
+// src/elements/core/UIOption.tsx
+import { Text as Text5, TouchableOpacity as TouchableOpacity4, Linking as Linking3 } from "react-native";
+function UIOption(props) {
+  const handlePress = () => {
+    Linking3.openURL("https://reactnative.dev/");
+  };
+  return /* @__PURE__ */ React.createElement(TouchableOpacity4, { onPress: handlePress }, /* @__PURE__ */ React.createElement(Text5, { style: styles5.link }, "Clique aqui para acessar o React Native"));
+}
+var styles5 = {
+  link: {}
+};
+
+// src/elements/core/UIRadio.tsx
+import { Text as Text6, TouchableOpacity as TouchableOpacity5, Linking as Linking4 } from "react-native";
+function UIRadio(props) {
+  const handlePress = () => {
+    Linking4.openURL("https://reactnative.dev/");
+  };
+  return /* @__PURE__ */ React.createElement(TouchableOpacity5, { onPress: handlePress }, /* @__PURE__ */ React.createElement(Text6, { style: styles6.link }, "Clique aqui para acessar o React Native"));
+}
+var styles6 = {
+  link: {}
+};
+
+// src/elements/core/UIInput.tsx
+import { useState as useState6 } from "react";
+import { Utils as Utils9 } from "react-crud-utils";
+import { StyleSheet as StyleSheet7, TextInput, View as View4 } from "react-native";
+import { Ionicons as Ionicons4 } from "@expo/vector-icons";
+function UIInput(props) {
+  let scope = props.scope;
+  let initial = Utils9.call(() => {
+    let val = Utils9.nvl(scope.getValue(), "");
+    if (val && val?.push) {
+      return val.join(", ").trim();
+    }
+    return val;
+  });
+  let label = scope.getLabel();
+  let placeholder = scope.getPart("placeholder", null, label);
+  let el = scope.original;
+  const element = scope.original;
+  const [height, setHeight] = useState6(80);
+  const [value, setValue] = useState6(initial);
+  let onChange = (v) => {
+    v = scope.changeValue(v);
+    setValue(v);
+  };
+  const style = (part, extra) => {
+    return { ...scope.getStyle(part, { ...styles7[part], ...extra }) };
+  };
+  const CustomIcon = () => {
+    let icon = el.icon;
+    if (icon) {
+      if (typeof icon === "string") {
+        return /* @__PURE__ */ React.createElement(React.Fragment, null, el.icon && /* @__PURE__ */ React.createElement(
+          Ionicons4,
+          {
+            name: el.icon,
+            size: scope.attr("iconSize", 20),
+            color: scope.attr("iconColor", "#888")
+          }
+        ));
+      }
+      return /* @__PURE__ */ React.createElement(React.Fragment, null, icon);
+    }
+    return /* @__PURE__ */ React.createElement(React.Fragment, null);
+  };
+  let type = scope.getPart("type", null, "text");
+  let decode = {
+    textarea: {
+      multiline: true,
+      autoHeight: element.autoHeight !== false,
+      textAlignVertical: "top",
+      numberOfLines: 5,
+      style: { height: Math.max(80, height) },
+      baseStyle: { paddingVertical: 10 }
+    }
+  };
+  let defs = { ...Utils9.nvl(decode[type], {}), ...element.inputProps };
+  let inputStyle = Utils9.call(() => {
+    let size = element.size;
+    let css = {};
+    if (size === "small") {
+      css.height = 30;
+      css.fontSize = 12;
+    }
+    css.fontSize = Utils9.nvl(element.fontSize, css.fontSize);
+    css = { ...style("input"), ...style(type, css) };
+    css.lineHeight = parseInt(css.fontSize) + 2;
+    return css;
+  });
+  if (defs.autoHeight) {
+    defs.onContentSizeChange = (event) => {
+      setHeight(event.nativeEvent.contentSize.height);
+    };
+    inputStyle = { ...inputStyle, ...defs.style };
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(View4, { style: style("base", defs?.baseStyle) }, scope.getPart("left"), /* @__PURE__ */ React.createElement(
+    TextInput,
+    {
+      onChangeText: onChange,
+      value,
+      placeholder,
+      ...defs,
+      style: inputStyle
+    }
+  ), /* @__PURE__ */ React.createElement(CustomIcon, null)), scope.getPart("right"));
+}
+var styles7 = StyleSheet7.create({
+  base: {
+    flex: 1,
+    width: "100%",
+    paddingBottom: 0,
+    paddingTop: 0,
+    alignItems: "center",
+    borderWidth: 1,
+    borderColor: "borderColor",
+    borderRadius: 5,
+    paddingHorizontal: 10,
+    alignSelf: "flex-start",
+    flexDirection: "row",
+    flexWrap: "wrap",
+    gap: 10
+  },
+  icon: {
+    marginRight: 10
+    // Espaço entre ícone e input
+  },
+  input: {
+    marginHorizontal: 0,
+    marginVertical: 0,
+    paddingVertical: 0,
+    height: 40,
+    width: "100%",
+    flex: 1
+    // Para o input ocupar o espaço restante
+  },
+  textarea: {
+    marginHorizontal: 0,
+    marginVertical: 0,
+    paddingVertical: 10,
+    width: "100%",
+    height: "auto",
+    alignSelf: "stretch",
+    flex: 1
+    // Para o input ocupar o espaço restante
+  }
+});
+
+// src/elements/UIElement.tsx
+import {
+  Alert,
+  Image,
+  Linking as Linking5,
+  StyleSheet as StyleSheet15,
+  Text as Text14,
+  TouchableHighlight as TouchableHighlight5,
+  View as View13
+} from "react-native";
+
+// src/elements/core/UIList.tsx
+import React6, { useState as useState9 } from "react";
+import { ComponentUtils as ComponentUtils2, Utils as Utils11 } from "react-crud-utils";
+import { StyleSheet as StyleSheet9, Text as Text7, View as View6 } from "react-native";
+
+// src/elements/core/UIListRow.tsx
+import React5, { useRef as useRef2, useState as useState8 } from "react";
+import { ScopeUtils as ScopeUtils2 } from "react-crud-utils";
+import { StyleSheet as StyleSheet8, TouchableHighlight as TouchableHighlight2, View as View5 } from "react-native";
+
+// src/hooks/useIsVisible.ts
+import { useEffect as useEffect2, useState as useState7 } from "react";
+import { Dimensions, Platform } from "react-native";
+function useIsVisible(ref, scope) {
+  const [isVisible, setIsVisible] = useState7(scope.visible === true);
+  useEffect2(() => {
+    const checkVisibility = () => {
+      if (!ref.current || isVisible || !scope.original?.useIsInView) return;
+      if (Platform.OS === "web") {
+        const rect = ref.current.getBoundingClientRect?.();
+        if (rect && typeof window !== "undefined") {
+          const windowHeight = window.innerHeight;
+          const visible = rect.top < windowHeight && rect.bottom > 0;
+          if (visible) scope.visible = visible;
+          setIsVisible(visible);
+        }
+      } else {
+        ref.current.measureInWindow?.((x, y, width, height) => {
+          const windowHeight = Dimensions.get("window").height;
+          const visible = y < windowHeight && y + height > 0;
+          if (visible) scope.visible = visible;
+          setIsVisible(visible);
+        });
+      }
+    };
+    const interval = setInterval(checkVisibility, 300);
+    return () => clearInterval(interval);
+  }, [ref]);
+  return isVisible;
+}
+
+// src/elements/core/UIListRow.tsx
+function UIListRow(props) {
+  const scope = props.scope;
+  const index = props.index;
+  const original = scope.original;
+  const item = props.item;
+  const cols = scope.getPart("cols", void 0, -1);
+  const rowWidth = Math.floor(100 / cols) + "%";
+  const styles13 = { repeat: stylesRepeat, list: stylesList }?.[original.type];
+  const name = `${scope.key("row", index, "")}`;
+  const [row] = useState8(
+    ScopeUtils2.create({
+      ...original,
+      parent: scope,
+      name,
+      crud: scope.crud,
+      index,
+      type: "row",
+      data: item
+    })
+  );
+  const targetRef = useRef2(null);
+  const isVisible = useIsVisible(targetRef, row);
+  const onClick = (item2) => {
+    row.call("click", { value: item2, item: item2, edit: true, index });
+  };
+  const Child = () => {
+    if (!isVisible && original.useIsInView && !row.visible && index > 20) {
+      return /* @__PURE__ */ React5.createElement(React5.Fragment, null);
+    }
+    return /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(UIChildren, { transient: true, scope: row, crud: row.crud }, props.children));
+  };
+  const ListItem = () => {
+    let [updateIndex, setUpdateIndex] = useState8(0);
+    let key = scope.key("item");
+    row.selected = row.getPart("isSelectedRow", void 0, false);
+    const getRowStyle = () => {
+      let css = row.getStyle("row", { ...styles13.row, minHeight: 30 });
+      if (row.selected) {
+        css = { ...css, ...row.getStyle("rowSelected", {}) };
+      } else {
+        css = { ...css, ...row.getStyle("rowUnSelected", {}) };
+      }
+      if (cols > 0) {
+        css.width = rowWidth;
+      }
+      return css;
+    };
+    row.update = () => {
+      scope.updateIndex = scope.updateIndex + 1;
+      setUpdateIndex(++updateIndex);
+    };
+    let renderedRow = row.getPart("renderedItem", void 0, true);
+    if (renderedRow === false) {
+      return /* @__PURE__ */ React5.createElement(React5.Fragment, null);
+    }
+    if (!original.click) {
+      return /* @__PURE__ */ React5.createElement(View5, { key, style: getRowStyle(), ref: targetRef }, /* @__PURE__ */ React5.createElement(Child, null));
+    }
+    return /* @__PURE__ */ React5.createElement(
+      TouchableHighlight2,
+      {
+        key,
+        style: getRowStyle(),
+        underlayColor: "transparent",
+        ref: targetRef,
+        onPress: (e) => {
+          e.stopPropagation();
+          onClick(item);
+        }
+      },
+      /* @__PURE__ */ React5.createElement(Child, null)
+    );
+  };
+  return /* @__PURE__ */ React5.createElement(ListItem, null);
+}
+var stylesList = StyleSheet8.create({
+  row: {
+    padding: 5,
+    margin: 0,
+    width: "100%",
+    backgroundColor: "background",
+    gap: 10,
+    borderRadius: 8,
+    justifyContent: "center"
+  }
+});
+var stylesRepeat = StyleSheet8.create({
+  row: {
+    padding: 0,
+    width: "100%",
+    justifyContent: "center"
+  }
+});
+
+// src/elements/core/UIList.tsx
+import { Ionicons as Ionicons5 } from "@expo/vector-icons";
+function UIList(props) {
+  const scope = props.scope;
+  const crud = scope.crud;
+  const original = scope.original;
+  const cols = Utils11.nvl(scope.getPart("cols", void 0, 1));
+  const styles13 = { repeat: stylesRepeat2, list: stylesList2 }?.[original.type];
+  const add = ComponentUtils2.getDefine(props, "add");
+  const hideAddWhenEmpty = original.hideAddWhenEmpty;
+  const hideEmpty = original.hideEmpty;
+  const getStyle = (key, extra) => {
+    return scope.getStyle(key, { ...extra, ...styles13[key] });
+  };
+  const getContainerStyle = (extra) => {
+    let row = getStyle("container", {});
+    if (cols > 1) {
+      row = { ...row, flexDirection: "row", flexWrap: "wrap" };
+    }
+    return row;
+  };
+  const LocalData = () => {
+    let [index, setIndex] = useState9(scope.updateIndex);
+    let empty = scope.attr("empty", "Sem registro");
+    scope.update = () => {
+      scope.updateIndex = ++index;
+      setIndex(index);
+    };
+    const items2 = Utils11.call(() => {
+      let list = Utils11.nvl(scope.getItems(), []);
+      if (original.search !== false && !original.list?.url) {
+        let query = crud.get("query", "").toLowerCase().trim();
+        if (query.length > 1) {
+          let filters = [];
+          let filterBy = Utils11.nvl(original.filterBy, "label");
+          Utils11.each(list, (o) => {
+            let label = Utils11.getValue(filterBy, "none", o).toLowerCase();
+            if (label) {
+              if (label.includes(query)) {
+                filters.push(o);
+              }
+            }
+          });
+          return filters;
+        }
+      }
+      return list;
+    });
+    let isEmpty = Utils11.isEmpty(items2);
+    const isShowAdd = () => {
+      if (!isEmpty) {
+        return true;
+      }
+      return hideAddWhenEmpty !== true;
+    };
+    let Empty = () => {
+      if (!isEmpty) {
+        return /* @__PURE__ */ React6.createElement(React6.Fragment, null);
+      }
+      if (!empty) {
+        return /* @__PURE__ */ React6.createElement(React6.Fragment, null);
+      }
+      if (typeof empty === "string") {
+        return /* @__PURE__ */ React6.createElement(
+          Text7,
+          {
+            style: scope.getStyle("empty", {
+              flex: 1,
+              fontWeight: 400,
+              fontSize: 18,
+              padding: 10,
+              textAlign: "center",
+              width: "100%",
+              justifyContent: "center",
+              alignItems: "center"
+            })
+          },
+          empty
+        );
+      }
+      return /* @__PURE__ */ React6.createElement(React6.Fragment, null, empty);
+    };
+    if (empty === false && isEmpty) {
+      return /* @__PURE__ */ React6.createElement(React6.Fragment, null);
+    }
+    return /* @__PURE__ */ React6.createElement(View6, { style: getContainerStyle() }, /* @__PURE__ */ React6.createElement(Empty, null), items2.map((item, i) => /* @__PURE__ */ React6.createElement(UIListRow, { index: i, item, scope }, props.children)), isShowAdd() && /* @__PURE__ */ React6.createElement(React6.Fragment, null, add));
+  };
+  let items = Utils11.nvl(scope.getItems(), []);
+  if (hideEmpty && Utils11.isEmpty(items)) {
+    return /* @__PURE__ */ React6.createElement(React6.Fragment, null);
+  }
+  return /* @__PURE__ */ React6.createElement(React6.Fragment, null, original.search !== false && /* @__PURE__ */ React6.createElement(
+    UI_default.Text,
+    {
+      placeholder: "Pesquisar...",
+      field: "query",
+      crud,
+      style: { marginBottom: 10 },
+      change: {
+        action: () => {
+          scope.search();
+        }
+      },
+      icon: /* @__PURE__ */ React6.createElement(Ionicons5, { name: "search", size: 20, color: "#888" })
+    }
+  ), /* @__PURE__ */ React6.createElement(LocalData, null));
+}
+var stylesList2 = StyleSheet9.create({
+  container: {
+    display: "flex",
+    flexWrap: "wrap",
+    gap: 10,
+    width: "100%"
+  },
+  text: {
+    fontSize: 18,
+    fontWeight: "bold"
+  }
+});
+var stylesRepeat2 = StyleSheet9.create({
+  container: {
+    display: "flex",
+    flexWrap: "wrap",
+    gap: 10,
+    width: "100%"
+  },
+  text: {
+    fontSize: 18,
+    fontWeight: "bold"
+  }
+});
+
+// src/elements/core/UIToggle.tsx
+import React7, { useState as useState10 } from "react";
+import { Utils as Utils12 } from "react-crud-utils";
+import { StyleSheet as StyleSheet10, Text as Text8, TouchableHighlight as TouchableHighlight3, View as View7 } from "react-native";
+function UIToggle(props) {
+  const scope = props.scope;
+  const options = Utils12.nvl(scope.getOptions(), []);
+  const value = scope.getInputValue();
+  let [index, setIndex] = useState10(0);
+  const isSelected = (item) => {
+    return item?.value === value;
+  };
+  const onClick = (item) => {
+    scope.changeValue(item.object);
+    setIndex(++index);
+  };
+  const Item = ({ item, index: index2 }) => {
+    let selected = isSelected(item);
+    let style = { ...styles8.text, ...scope.getStyle("text") };
+    if (selected) style.color = "#ffffff";
+    if (Utils12.isEmpty(props.children)) {
+      return /* @__PURE__ */ React7.createElement(Text8, { style }, item.label);
+    }
+    return /* @__PURE__ */ React7.createElement(UIListRow, { scope, item: item.object, index: index2 }, props.children);
+  };
+  const getItemStyle = (item) => {
+    let style = { ...styles8.item, ...scope.getStyle("item") };
+    let wPart = 100 / options.length;
+    let width = Math.floor(wPart) + "%";
+    if (isSelected(item)) {
+      let selectedColor = scope.getPart("selectedColor", void 0, "primary");
+      let st = scope.getStyle("selected", {
+        backgroundColor: selectedColor,
+        color: "#ffffff"
+      });
+      style = { ...style, ...st };
+      if (!style.color) {
+        style.color = "#ffffff";
+      }
+      const backgroundColor = item.backgroundColor;
+      const color = item.color;
+      if (item.backgroundColor) style = { ...style, backgroundColor };
+      if (item.color) style = { ...style, color };
+    } else {
+      style.backgroundColor = "#fff";
+      style.color = "#000";
+    }
+    style.width = width;
+    return style;
+  };
+  return /* @__PURE__ */ React7.createElement(View7, { style: { ...styles8.container, ...scope.getStyle("items") } }, options.map((item, i) => /* @__PURE__ */ React7.createElement(
+    TouchableHighlight3,
+    {
+      key: `k-${i}`,
+      style: getItemStyle(item),
+      onPress: (e) => {
+        onClick(item);
+      }
+    },
+    /* @__PURE__ */ React7.createElement(Item, { item, index: i })
+  )));
+}
+var styles8 = StyleSheet10.create({
+  container: {
+    flex: 1,
+    width: "100%",
+    justifyContent: "center",
+    flexDirection: "row",
+    alignItems: "center",
+    margin: 3,
+    gap: 5
+  },
+  item: {
+    backgroundColor: "background",
+    justifyContent: "center",
+    alignItems: "center",
+    width: "auto",
+    flexDirection: "row",
+    flex: 1,
+    padding: 5,
+    borderRadius: 2
+  },
+  text: {
+    fontSize: 13,
+    fontWeight: "400"
+  }
+});
+
+// src/elements/core/UIQuantity.tsx
+import { Ionicons as Ionicons6 } from "@expo/vector-icons";
+import { useState as useState11 } from "react";
+import { Utils as Utils13 } from "react-crud-utils";
+import { Text as Text9, TouchableHighlight as TouchableHighlight4 } from "react-native";
+function UIQuantity(props) {
+  const scope = props.scope;
+  const element = scope.original;
+  let [index, setIndex] = useState11(0);
+  const value = scope.getValue(0);
+  let color = element.color;
+  if (!color) color = "primary";
+  const btn = {
+    padding: 0,
+    alignItems: "center",
+    height: 30,
+    width: 30,
+    textAlign: "center",
+    verticalAling: "middle",
+    borderRadius: 24,
+    backgroundColor: color,
+    color: "#ffffff",
+    justifyContent: "center"
+  };
+  const styles13 = {
+    buttonLabel: {
+      color: "#ffffff",
+      fontWeight: "500",
+      fontSize: 16
+    },
+    value: {
+      flex: 1,
+      flexDirection: "row",
+      textAlign: "center",
+      fontWeight: "500"
+    },
+    buttonInner: {
+      flexDirection: "row",
+      alignItems: "center",
+      justifyContent: "center"
+    },
+    buttonIcon: {
+      color: "#fff",
+      fontSize: 18
+    },
+    button: btn,
+    addButton: {
+      ...btn
+    },
+    delButton: {
+      ...btn
+    }
+  };
+  const change = (val) => {
+    scope.changeValue(value + val);
+    setIndex(++index);
+  };
+  const onClickAdd = () => {
+    change(1);
+  };
+  const onClickDel = () => {
+    change(-1);
+  };
+  const style = (part, extra) => {
+    let s = { ...styles13[part], ...extra };
+    return scope.getStyle(part, s);
+  };
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+    TouchableHighlight4,
+    {
+      underlayColor: "transparent",
+      onPress: onClickDel,
+      style: style("delButton")
+    },
+    /* @__PURE__ */ React.createElement(Ionicons6, { size: 30, style: style("buttonIcon"), name: "remove" })
+  ), /* @__PURE__ */ React.createElement(Text9, { style: style("value") }, Utils13.nvl(value, 0)), /* @__PURE__ */ React.createElement(
+    TouchableHighlight4,
+    {
+      underlayColor: "transparent",
+      onPress: onClickAdd,
+      style: style("addButton")
+    },
+    /* @__PURE__ */ React.createElement(Ionicons6, { size: 30, style: style("buttonIcon"), name: "add" })
+  ));
+}
+
+// src/elements/core/UIModal.tsx
+import { useRef as useRef3, useState as useState12 } from "react";
+import { ComponentUtils as ComponentUtils3, Utils as Utils14 } from "react-crud-utils";
+import {
+  Text as Text10,
+  TouchableOpacity as TouchableOpacity6,
+  StyleSheet as StyleSheet12,
+  Modal as Modal2,
+  View as View9,
+  ScrollView as ScrollView2
+} from "react-native";
+import Ionicons7 from "@expo/vector-icons/Ionicons";
+
+// src/elements/core/UIToast.tsx
+import { StyleSheet as StyleSheet11 } from "react-native";
+import Toast, { BaseToast, ErrorToast } from "react-native-toast-message";
+function UIToast() {
+  const toastConfig = {
+    success: (props) => /* @__PURE__ */ React.createElement(
+      BaseToast,
+      {
+        ...props,
+        style: styles13.darkToast,
+        contentContainerStyle: { paddingHorizontal: 15 },
+        text1Style: styles13.text,
+        text2Style: styles13.text
+      }
+    ),
+    error: (props) => /* @__PURE__ */ React.createElement(
+      ErrorToast,
+      {
+        ...props,
+        style: styles13.darkToast,
+        text1Style: styles13.text,
+        text2Style: styles13.text
+      }
+    ),
+    info: (props) => /* @__PURE__ */ React.createElement(
+      BaseToast,
+      {
+        ...props,
+        style: styles13.darkToast,
+        text1Style: styles13.text,
+        text2Style: styles13.text
+      }
+    )
+  };
+  const styles13 = StyleSheet11.create({
+    darkToast: {
+      backgroundColor: "rgba(34, 34, 34, 0.85)",
+      borderLeftColor: "#222"
+      // borda mais escura
+    },
+    text: {
+      color: "#fff",
+      // letras brancas
+      textAlign: "center"
+    }
+  });
+  return /* @__PURE__ */ React.createElement(Toast, { config: toastConfig });
+}
+
+// src/elements/core/UIModal.tsx
+import { SafeAreaView as SafeAreaView2 } from "react-native-safe-area-context";
+function UIModal(props) {
+  const scrollRef = useRef3(null);
+  let owner = props.scope;
+  let [index, setIndex] = useState12(0);
+  let dialog = owner.currentDialog;
+  let curr = dialog?.crud;
+  if (!dialog) {
+    return /* @__PURE__ */ React.createElement(React.Fragment, null);
+  }
+  dialog.update = () => {
+    setIndex(++index);
+  };
+  if (dialog.debug) console.log(dialog);
+  const scope = dialog.scope;
+  const label = scope.getLabel();
+  const theme = scope.getTheme();
+  const headerStyle = Utils14.nvl(theme.styles?.defaults?.header, {});
+  const headerRight = ComponentUtils3.getDefine(props, "header", "right");
+  const bottom = ComponentUtils3.getDefine(props, "bottom");
+  const style = (part, extra) => {
+    let st = { ...styles9[part], ...extra };
+    return { ...scope.getStyle(part, st) };
+  };
+  const onClose = () => {
+    scope.close({ scope, crud: dialog?.crud, event: {} });
+  };
+  scope.put("scrollRef", scrollRef);
+  const original = owner.original;
+  ComponentUtils3.setViewScope(scope);
+  let color = Utils14.nvl(headerStyle.color, "white");
+  let defaults = { color };
+  let key = `${curr.name}-${index}`;
+  let ModalContent = ({ children }) => {
+    let disableScroll = scope.part("disableScroll", false);
+    let disableContent = scope.part("disableContent", false);
+    if (disableContent) {
+      return /* @__PURE__ */ React.createElement(React.Fragment, null, children);
+    }
+    if (disableScroll) {
+      return /* @__PURE__ */ React.createElement(View9, { style: style("modalContent") }, children);
+    }
+    return /* @__PURE__ */ React.createElement(
+      ScrollView2,
+      {
+        contentContainerStyle: { flexGrow: 1, paddingBottom: 50 },
+        style: style("modalContent"),
+        nestedScrollEnabled: true,
+        ref: scrollRef
+      },
+      children
+    );
+  };
+  const ModalInner = () => {
+    let Content = () => {
+      if (dialog?.component) {
+        let cprops = dialog.props;
+        let Aux = dialog.component;
+        return /* @__PURE__ */ React.createElement(Aux, { key: curr.uuid, crud: curr, ...cprops });
+      }
+      return /* @__PURE__ */ React.createElement(UIChildren, { scope, crud: curr }, props.children);
+    };
+    let content = /* @__PURE__ */ React.createElement(Content, null);
+    let area = {};
+    if (original.transient) {
+      return /* @__PURE__ */ React.createElement(SafeAreaView2, { style: style("modalSafe", area) }, content);
+    }
+    return /* @__PURE__ */ React.createElement(SafeAreaView2, { style: style("modalSafe", area) }, /* @__PURE__ */ React.createElement(View9, { style: scope.getStyle("header", headerStyle) }, /* @__PURE__ */ React.createElement(TouchableOpacity6, { onPress: onClose, style: style("modalCloseButton") }, /* @__PURE__ */ React.createElement(
+      Ionicons7,
+      {
+        name: "chevron-back-outline",
+        size: 24,
+        color,
+        style: style("modalCloseText", defaults)
+      }
+    )), /* @__PURE__ */ React.createElement(Text10, { style: style("modalTitle", defaults) }, label), !Utils14.isEmpty(headerRight) && /* @__PURE__ */ React.createElement(UIChildren, { scope, crud: curr, transient: true }, headerRight)), /* @__PURE__ */ React.createElement(ModalContent, null, content), bottom, /* @__PURE__ */ React.createElement(UIToast, null));
+  };
+  return /* @__PURE__ */ React.createElement(
+    Modal2,
+    {
+      key,
+      animationType: "slide",
+      transparent: true,
+      visible: true,
+      onRequestClose: onClose
+    },
+    /* @__PURE__ */ React.createElement(ModalInner, null)
+  );
+}
+var styles9 = StyleSheet12.create({
+  modalTop: {
+    backgroundColor: "background",
+    width: "100%"
+  },
+  modalSafe: {
+    flex: 1,
+    width: "100%",
+    backgroundColor: "background"
+  },
+  modalCloseButton: {
+    padding: 10
+  },
+  modalCloseText: {
+    fontSize: 18,
+    color: "white"
+  },
+  modalTitle: {
+    fontSize: 22,
+    fontWeight: 600,
+    marginLeft: 10
+  },
+  modalContent: {
+    flex: 1,
+    backgroundColor: "background",
+    paddingLeft: 15,
+    paddingRight: 15,
+    paddingTop: 10,
+    paddingBottom: 10
+  }
+});
+
+// src/elements/UIElement.tsx
+import { Ionicons as Ionicons8 } from "@expo/vector-icons";
+
+// src/elements/core/UIView.tsx
+import { ScrollView as ScrollView3, StyleSheet as StyleSheet13, View as View11 } from "react-native";
+import { ComponentUtils as ComponentUtils4, Utils as Utils16, ViewUtils as ViewUtils2 } from "react-crud-utils";
+import { useRef as useRef4 } from "react";
+
+// src/elements/core/UIHeader.tsx
+import { Text as Text11, View as View10 } from "react-native";
+import { HtmlUtils, Utils as Utils15 } from "react-crud-utils";
+function UIHeader({ scope }) {
+  const theme = scope.getTheme();
+  const header = scope.getPart("header", null, []);
+  const headerStyle = Utils15.nvl(theme.styles?.defaults?.header, {});
+  const headerTextStyle = Utils15.nvl(theme.styles?.defaults?.headerText, {});
+  let headerStyleFull = Utils15.call(() => {
+    let css = scope.getStyle("header", headerStyle);
+    let bg = css.backgroundColor;
+    if (bg) {
+      css.color = HtmlUtils.getTextColor(bg);
+    }
+    return css;
+  });
+  let hasHeader = !Utils15.isEmpty(header);
+  let AuxHeader = () => {
+    if (typeof header === "string") {
+      return /* @__PURE__ */ React.createElement(Text11, { style: headerTextStyle }, header);
+    }
+    return /* @__PURE__ */ React.createElement(React.Fragment, null, header);
+  };
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, hasHeader && /* @__PURE__ */ React.createElement(View10, { style: headerStyleFull }, /* @__PURE__ */ React.createElement(AuxHeader, null)));
+}
+
+// src/elements/core/UIView.tsx
+function UIView({ scope, children }) {
+  const scrollRef = useRef4(null);
+  const original = scope.original;
+  const onScroll = () => {
+    const crud = ViewUtils2.getCrud();
+    Utils16.each(crud.scroll, (s) => {
+      if (s.onScroll) {
+        s.onScroll.call(s);
+      }
+    });
+  };
+  scope.put("scrollRef", scrollRef);
+  ComponentUtils4.setViewScope(scope);
+  let Container = () => {
+    if (original.scroll === false) {
+      return /* @__PURE__ */ React.createElement(UIChildren, { scope }, children);
+    }
+    return /* @__PURE__ */ React.createElement(View11, { style: scope.getStyle("container", styles10.container) }, /* @__PURE__ */ React.createElement(
+      ScrollView3,
+      {
+        onScroll,
+        scrollEventThrottle: 16,
+        ref: scrollRef,
+        nestedScrollEnabled: true,
+        keyboardShouldPersistTaps: "handled",
+        contentContainerStyle: scope.getStyle("contentContainer", {
+          paddingBottom: 50
+        }),
+        style: scope.getStyle("scroll", styles10.scroll)
+      },
+      /* @__PURE__ */ React.createElement(UIChildren, { scope }, children)
+    ));
+  };
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(UIHeader, { scope }), /* @__PURE__ */ React.createElement(Container, null), /* @__PURE__ */ React.createElement(UIToast, null), " ");
+}
+var styles10 = StyleSheet13.create({
+  scroll: {
+    paddingTop: 10,
+    paddingBottom: 10,
+    paddingLeft: 15,
+    paddingRight: 15
+  },
+  container: {},
+  view: {}
+});
+
+// src/elements/UIElement.tsx
+import Toast2 from "react-native-toast-message";
+
+// src/elements/core/UIOrder.tsx
+import React8, { useRef as useRef5, useState as useState13, useEffect as useEffect3 } from "react";
+import { Utils as Utils17 } from "react-crud-utils";
+import {
+  View as View12,
+  Text as Text13,
+  StyleSheet as StyleSheet14,
+  Animated,
+  PanResponder,
+  TouchableOpacity as TouchableOpacity7
+} from "react-native";
+var ITEM_HEIGHT = 70;
+function UIOrder(props) {
+  const scope = props.scope;
+  const element = scope.original;
+  const initial = scope.getOptions();
+  const [items, setItems] = useState13(initial);
+  const [draggingId, setDraggingId] = useState13(null);
+  const positions = useRef5(
+    Object.fromEntries(
+      initial.map((it, i) => [it.value, new Animated.Value(i * ITEM_HEIGHT)])
+    )
+  ).current;
+  const panRespondersRef = useRef5({});
+  const activeItem = useRef5(null);
+  const activeIndex = useRef5(-1);
+  const offsetY = useRef5(0);
+  const itemsRef = useRef5(items);
+  useEffect3(() => {
+    itemsRef.current = items;
+  }, [items]);
+  useEffect3(() => {
+    items.forEach((it, idx) => {
+      if (!positions[it.value])
+        positions[it.value] = new Animated.Value(idx * ITEM_HEIGHT);
+      Animated.spring(positions[it.value], {
+        toValue: idx * ITEM_HEIGHT,
+        useNativeDriver: false
+      }).start();
+    });
+  }, [items]);
+  const onChange = (updated) => {
+    const array = [];
+    const items2 = scope.getItems();
+    items2.splice(0);
+    Utils17.each(updated, (o) => {
+      const v = o.object;
+      array.push(v);
+      items2.push(v);
+    });
+    scope.changeValue(array);
+  };
+  const createPanResponder = (item) => PanResponder.create({
+    onStartShouldSetPanResponder: () => true,
+    onPanResponderGrant: () => {
+      const currentItems = itemsRef.current;
+      if (!positions[item.value] || !currentItems.find((it) => it.value === item.value))
+        return;
+      activeItem.current = item;
+      activeIndex.current = currentItems.findIndex(
+        (it) => it.value === item.value
+      );
+      offsetY.current = positions[item.value]._value;
+      setDraggingId(item.value);
+    },
+    onPanResponderMove: (_, gesture) => {
+      const currentItems = itemsRef.current;
+      if (!positions[item.value] || !currentItems.find((it) => it.value === item.value))
+        return;
+      const y = offsetY.current + gesture.dy;
+      positions[item.value].setValue(y);
+      const targetIndex = Math.max(
+        0,
+        Math.min(
+          currentItems.length - 1,
+          Math.floor((y + ITEM_HEIGHT / 2) / ITEM_HEIGHT)
+        )
+      );
+      currentItems.forEach((other, idx) => {
+        if (other.value === item.value || !positions[other.value]) return;
+        let targetY = idx * ITEM_HEIGHT;
+        if (idx > activeIndex.current && idx <= targetIndex)
+          targetY = (idx - 1) * ITEM_HEIGHT;
+        else if (idx < activeIndex.current && idx >= targetIndex)
+          targetY = (idx + 1) * ITEM_HEIGHT;
+        Animated.timing(positions[other.value], {
+          toValue: targetY,
+          duration: 120,
+          useNativeDriver: false
+        }).start();
+      });
+    },
+    onPanResponderRelease: () => {
+      const moved = activeItem.current;
+      const currentItems = itemsRef.current;
+      if (!moved || !positions[moved.value] || !currentItems.find((it) => it.value === moved.value))
+        return;
+      const finalY = positions[moved.value]._value;
+      const newIndex = Math.max(
+        0,
+        Math.min(
+          currentItems.length - 1,
+          Math.floor((finalY + ITEM_HEIGHT / 2) / ITEM_HEIGHT)
+        )
+      );
+      const oldIndex = activeIndex.current;
+      const updated = [...currentItems];
+      const [removed] = updated.splice(oldIndex, 1);
+      updated.splice(newIndex, 0, removed);
+      setItems(updated);
+      onChange(updated);
+      setDraggingId(null);
+      activeItem.current = null;
+      activeIndex.current = -1;
+    }
+  });
+  items.forEach((it) => {
+    if (!panRespondersRef.current[it.value]) {
+      panRespondersRef.current[it.value] = createPanResponder(it);
+    }
+  });
+  const removeItem = (id) => {
+    if (draggingId === id) {
+      setDraggingId(null);
+      activeItem.current = null;
+      activeIndex.current = -1;
+    }
+    if (positions[id]) {
+      delete positions[id];
+    }
+    if (panRespondersRef.current[id]) {
+      delete panRespondersRef.current[id];
+    }
+    setItems((prev) => {
+      const updated = prev.filter((it) => it.value !== id);
+      updated.forEach((it, idx) => {
+        if (positions[it.value])
+          Animated.spring(positions[it.value], {
+            toValue: idx * ITEM_HEIGHT,
+            useNativeDriver: false
+          }).start();
+      });
+      onChange(updated);
+      return updated;
+    });
+  };
+  const Empty = () => {
+    if (Utils17.isEmpty(items)) {
+      let empty = scope.part("empty", "Sem registro");
+      if (empty !== false) return /* @__PURE__ */ React8.createElement(React8.Fragment, null, empty);
+    }
+    return /* @__PURE__ */ React8.createElement(React8.Fragment, null);
+  };
+  return /* @__PURE__ */ React8.createElement(View12, { style: styles11.container }, /* @__PURE__ */ React8.createElement(Empty, null), /* @__PURE__ */ React8.createElement(View12, { style: { height: items.length * ITEM_HEIGHT, width: "100%" } }, items.map((item) => {
+    const y = positions[item.value];
+    if (!y) return null;
+    const isDragging = draggingId === item.value;
+    const itemStyle = scope.getStyle("row", { ...styles11.item });
+    return /* @__PURE__ */ React8.createElement(
+      Animated.View,
+      {
+        key: item.value,
+        ...panRespondersRef.current[item.value]?.panHandlers ?? {},
+        style: [
+          itemStyle,
+          {
+            position: "absolute",
+            left: 0,
+            right: 0,
+            height: ITEM_HEIGHT - 8,
+            transform: [{ translateY: y }],
+            zIndex: isDragging ? 999 : 0,
+            elevation: isDragging ? 999 : 0
+          }
+        ]
+      },
+      /* @__PURE__ */ React8.createElement(View12, { style: styles11.handle }, /* @__PURE__ */ React8.createElement(Text13, { style: styles11.handleText }, "\u2261")),
+      /* @__PURE__ */ React8.createElement(Text13, { style: styles11.itemText }, item.label),
+      element.remove && /* @__PURE__ */ React8.createElement(
+        TouchableOpacity7,
+        {
+          onPress: () => removeItem(item.value),
+          style: styles11.del
+        },
+        /* @__PURE__ */ React8.createElement(Text13, { style: { color: "#fff" } }, "X")
+      )
+    );
+  })));
+}
+var styles11 = StyleSheet14.create({
+  container: { flex: 1 },
+  title: { fontSize: 18, fontWeight: "600", marginBottom: 12 },
+  item: {
+    backgroundColor: "#fff",
+    borderRadius: 10,
+    marginVertical: 4,
+    paddingHorizontal: 12,
+    alignItems: "center",
+    flexDirection: "row",
+    elevation: 3,
+    shadowColor: "#000",
+    shadowOpacity: 0.05,
+    shadowRadius: 6
+  },
+  handle: { width: 40, alignItems: "center", justifyContent: "center" },
+  handleText: { fontSize: 22, color: "#666" },
+  itemText: { fontSize: 16, flex: 1 },
+  del: {
+    backgroundColor: "#e74c3c",
+    height: 34,
+    width: 34,
+    borderRadius: 6,
+    alignItems: "center",
+    justifyContent: "center"
+  }
+});
+
+// src/elements/UIElement.tsx
+var CrudContext = createContext({});
+function UIElement(props) {
+  const ctx = useContext(CrudContext);
+  const theme = Utils18.nvl(props.theme, ctx?.theme);
+  let crud = Utils18.nvl(props.crud, ctx?.crud);
+  let [scope] = useState14(ScopeUtils3.create({ crud, ...props, theme }));
+  let [index, setIndex] = useState14(0);
+  let [error, setError] = useState14(null);
+  scope.compile(props);
+  crud = scope.crud;
+  let options = scope.getOptions();
+  let original = scope.original;
+  let ref = useRef6(null);
+  scope.update = () => {
+    setIndex(++index);
+  };
+  scope.updateElement = () => {
+    setIndex(++index);
+  };
+  scope.toast = (message, type = "info", args) => {
+    Toast2.show({
+      type,
+      // 'success' | 'error' | 'info'
+      text1: message,
+      position: "bottom",
+      // 'top' é outra opção
+      visibilityTime: 3e3,
+      // tempo que fica visível em ms
+      ...args
+    });
+  };
+  scope.prompt = (args) => {
+    let event = args.event;
+    if (event) {
+      let message = "Voc\xEA tem certeza que deseja continuar?";
+      let title = "Aten\xE7\xE3o";
+      let prompt = event.prompt;
+      if (typeof prompt === "string") {
+        message = prompt;
+      }
+      if (typeof prompt === "object") {
+        message = Utils18.nvl(prompt.message, message);
+        title = Utils18.nvl(prompt.title, title);
+      }
+      Alert.alert(
+        title,
+        message,
+        [
+          {
+            text: "Cancelar",
+            style: "cancel"
+          },
+          {
+            text: "Confirmar",
+            onPress: () => scope.execute(args)
+          }
+        ],
+        { cancelable: false }
+      );
+    }
+  };
+  const Custom = () => {
+    let c = original.custom;
+    if (c) {
+      if (typeof c === "string") {
+        return /* @__PURE__ */ React9.createElement(
+          UIElement,
+          {
+            element: { value: c, type: "dummy" },
+            crud
+          }
+        );
+      }
+      return /* @__PURE__ */ React9.createElement(
+        UIElement,
+        {
+          type: c.type,
+          tag: c.type,
+          ...c.props,
+          crud
+        }
+      );
+    }
+    return /* @__PURE__ */ React9.createElement(React9.Fragment, null);
+  };
+  if (scope.is("type", "dummy")) {
+    return /* @__PURE__ */ React9.createElement(React9.Fragment, null, scope.getDisplayValue());
+  }
+  let onCheck = () => {
+    let v = scope.getValue();
+    let check = !(v === true);
+    onChange({ target: { value: check } });
+  };
+  let onChange = (e) => {
+    let val = e.target.value;
+    if (scope.isType("integer", "int", "number")) {
+      val = parseInt(val);
+    } else if (scope.isType("decimal")) {
+      val = parseFloat(val);
+    }
+    if (scope.isType("select", "complete")) {
+      val = scope.getSelectedItem(val);
+    }
+    scope.changeValue(val);
+    scope.update();
+  };
+  let onClick = (e) => {
+    if (scope.currentDialog?.component) return;
+    scope.call("click");
+  };
+  let defaultsInput = {
+    scope,
+    crud,
+    onChange
+  };
+  if (scope.isType("password")) {
+    defaultsInput.type = "password";
+  }
+  let isChecked = () => {
+    let v = scope.getValue();
+    return v === true;
+  };
+  let hasChildren = () => {
+    if (scope.isInput()) {
+      return false;
+    }
+    return !Utils18.isEmpty(props.children) || !Utils18.isEmpty(props.elements);
+  };
+  let isInput = scope.is(
+    "type",
+    "text",
+    "textarea",
+    "number",
+    "integer",
+    "int",
+    "phone",
+    "postalCode",
+    "money",
+    "password",
+    "email"
+  );
+  const getStyle = (part, extra) => {
+    let type = Utils18.nvl(original.type, "none");
+    let key = Utils18.nvl(part, "root");
+    let def = { ...styles12[key] };
+    let hasChild = hasChildren();
+    type = Utils18.nvl(original.layout, type);
+    if (!part && !hasChild) {
+      def = { ...def };
+    }
+    if (scope.isInput()) {
+      def = { ...def, ...elementStyle.input[key] };
+    }
+    def = { ...def, ...elementStyle?.[type]?.[key] };
+    if (hasChild && part) {
+      def = { ...def, ...withChildStyles[part] };
+    }
+    return { ...def, ...scope.getStyle(part, { ...def, ...extra }) };
+  };
+  let elStyle = getStyle("element");
+  let defaultsUI = {
+    required: scope.isRequired(),
+    size: "small",
+    scope,
+    crud,
+    style: elStyle,
+    placeholder: scope.attr("placeholder", "Digite aqui")
+  };
+  scope.error = (msg) => {
+    error = msg;
+    setError(msg);
+  };
+  if (!original.list?.url && !original.load?.url) {
+    scope.start();
+  }
+  useEffect4(() => {
+    scope.start();
+  });
+  const CustomIcon = () => {
+    if (typeof original.icon === "string") {
+      return /* @__PURE__ */ React9.createElement(Ionicons8, { name: original.icon, style: scope.getStyle("icon") });
+    }
+    return /* @__PURE__ */ React9.createElement(React9.Fragment, null, original.icon);
+  };
+  scope.open = (args) => {
+    Linking5.openURL(args.url);
+  };
+  useLayoutEffect(() => {
+    if (ref?.current && scope.is("type", "card", "list", "tabs", "stepper")) {
+      let el = ref?.current;
+      if (el?.classList) {
+        let bg = HtmlUtils2.getBGColor(el);
+        if (bg === "rgb(255, 255, 255)") {
+          el.classList.add("ui-dark");
+        } else {
+          el.classList.add("ui-light");
+        }
+      }
+    }
+  });
+  const isShowLabel = () => {
+    if (typeof original.label !== "undefined" && original.label !== false && !scope.isType("button", "dialog", "modal")) {
+      return true;
+    }
+    return false;
+  };
+  const isShowInner = () => {
+    if (scope.isType("icon")) return false;
+    if (hasChildren()) {
+      return false;
+    }
+    return true;
+  };
+  if (!scope.isRendered() || scope.is("type", "define")) {
+    return /* @__PURE__ */ React9.createElement(React9.Fragment, null);
+  }
+  const isShowChild = () => {
+    if (scope.isType(
+      "tabs",
+      "view",
+      "grid",
+      "list",
+      "define",
+      "repeat",
+      "modal",
+      "dialog",
+      "chart"
+    )) {
+      return false;
+    }
+    return true;
+  };
+  let isTouch = !scope.isType("input", "grid", "list", "order", "repeat") && original.click;
+  let custom = {};
+  if (isTouch) {
+    custom.underlayColor = "transparent";
+    custom.onPress = onClick;
+  }
+  let Tag = (props2) => {
+    let Aux = View13;
+    if (isTouch) {
+      Aux = TouchableHighlight5;
+    }
+    if (scope.isType("dialog", "order") || original.transient) {
+      return /* @__PURE__ */ React9.createElement(React9.Fragment, null, props2.children);
+    }
+    return /* @__PURE__ */ React9.createElement(Aux, { ...props2 });
+  };
+  let Inner = () => {
+    return /* @__PURE__ */ React9.createElement(React9.Fragment, null, scope.getPart("render", null, /* @__PURE__ */ React9.createElement(React9.Fragment, null)), scope.is("type", "button") && /* @__PURE__ */ React9.createElement(
+      UIButton,
+      {
+        ...defaultsUI,
+        onClick,
+        variant: scope.attr("variant", "outlined")
+      },
+      original.icon && /* @__PURE__ */ React9.createElement(CustomIcon, null),
+      original.label && /* @__PURE__ */ React9.createElement(Text14, { style: scope.getPart("label", "button") }, scope.getLabel())
+    ), scope.is("type", "link") && /* @__PURE__ */ React9.createElement(
+      UILink,
+      {
+        ...defaultsUI,
+        onClick,
+        variant: scope.attr("variant", "outlined")
+      },
+      original.icon && /* @__PURE__ */ React9.createElement(CustomIcon, null),
+      original.label && /* @__PURE__ */ React9.createElement(Text14, { style: scope.getPart("label", "link") }, scope.getLabel())
+    ), isInput && /* @__PURE__ */ React9.createElement(
+      UIInput,
+      {
+        ...defaultsInput,
+        ...defaultsUI,
+        InputProps: { ...original.inputProps }
+      }
+    ), scope.is("type", "complete", "autocomplete") && /* @__PURE__ */ React9.createElement(
+      UIComplete,
+      {
+        scope,
+        defaultsInput,
+        defaultsUI
+      }
+    ), scope.is("type", "quantity") && /* @__PURE__ */ React9.createElement(
+      UIQuantity,
+      {
+        scope,
+        defaultsInput,
+        defaultsUI
+      }
+    ), scope.is("type", "checkbox", "boolean", "switch") && /* @__PURE__ */ React9.createElement(
+      UISwitch,
+      {
+        checked: isChecked(),
+        ...defaultsInput,
+        onChange: onCheck
+      }
+    ), scope.isType("slider") && /* @__PURE__ */ React9.createElement(UISlider, { ...defaultsInput, onChange: onCheck }), scope.is("type", "select") && /* @__PURE__ */ React9.createElement(
+      UISelect,
+      {
+        ...defaultsInput,
+        ...defaultsUI,
+        value: scope.getSelectedValue()
+      }
+    ), scope.is("type", "toggle") && /* @__PURE__ */ React9.createElement(
+      UIToggle,
+      {
+        ...defaultsInput,
+        ...defaultsUI,
+        value: scope.getSelectedValue()
+      }
+    ), scope.is("type", "radio") && /* @__PURE__ */ React9.createElement(UIRadio, { ...defaultsInput, ...defaultsUI, row: true }, options.map((row, i) => /* @__PURE__ */ React9.createElement(
+      UIOption,
+      {
+        key: "i" + i,
+        control: /* @__PURE__ */ React9.createElement(UIRadio, { ...defaultsUI }),
+        label: row.label,
+        value: row.value
+      }
+    ))), scope.is("type", "custom") && /* @__PURE__ */ React9.createElement(Custom, null), scope.is("type", "column") && /* @__PURE__ */ React9.createElement(React9.Fragment, null, scope.is("format", "img") && /* @__PURE__ */ React9.createElement(Image, { source: scope.getDisplayValue() }), scope.is("format", "icon") && /* @__PURE__ */ React9.createElement(UIIcon, { scope, crud }), !scope.is("format", "icon", "img") && /* @__PURE__ */ React9.createElement(Text14, null, scope.getDisplayValue())), scope.is("type", "output", "value") && /* @__PURE__ */ React9.createElement(Text14, { style: getStyle("value") }, scope.getDisplayValue()));
+  };
+  let Include = ({ name, style }) => {
+    if (props[name]) {
+      let define = ComponentUtils5.getDefine(props, name);
+      if (!Utils18.isEmpty(define)) {
+        return /* @__PURE__ */ React9.createElement(
+          UIChildren,
+          {
+            ...props,
+            scope,
+            crud,
+            style: getStyle(name, style)
+          },
+          define
+        );
+      }
+    }
+    return /* @__PURE__ */ React9.createElement(React9.Fragment, null);
+  };
+  let Container = () => {
+    return /* @__PURE__ */ React9.createElement(React9.Fragment, null, isShowLabel() && /* @__PURE__ */ React9.createElement(
+      View13,
+      {
+        style: getStyle("outerLabel", {
+          alignSelf: "flex-start",
+          flexDirection: "row",
+          display: "flex",
+          justifyContent: "space-between",
+          alignItems: "center",
+          width: "100%"
+        })
+      },
+      /* @__PURE__ */ React9.createElement(Text14, { style: getStyle("label") }, scope.getLabel()),
+      /* @__PURE__ */ React9.createElement(Include, { name: "actions", style: { width: "auto" } })
+    ), isShowInner() && /* @__PURE__ */ React9.createElement(React9.Fragment, null, /* @__PURE__ */ React9.createElement(View13, { style: getStyle("inner") }, /* @__PURE__ */ React9.createElement(Inner, null)), error && /* @__PURE__ */ React9.createElement(
+      View13,
+      {
+        style: getStyle("error", {
+          fontSize: 12,
+          paddingTop: 4,
+          color: "#e55b5b"
+        })
+      },
+      error
+    )), scope.isType("list", "repeat") && /* @__PURE__ */ React9.createElement(UIList, { ...props, scope, crud }), scope.isType("order") && /* @__PURE__ */ React9.createElement(UIOrder, { ...props, scope, crud }), scope.isType("chart") && /* @__PURE__ */ React9.createElement(ElChart, { ...props, scope, crud }), scope.isType("tabs") && /* @__PURE__ */ React9.createElement(ElTabs, { ...props, scope, crud }), scope.isType("view") && /* @__PURE__ */ React9.createElement(UIView, { ...props, scope, crud }), scope.is("type", "icon") && /* @__PURE__ */ React9.createElement(
+      UIIcon,
+      {
+        ...defaultsUI,
+        onClick,
+        variant: scope.attr("variant", "outlined")
+      },
+      scope.getDisplayValue()
+    ), isShowChild() && /* @__PURE__ */ React9.createElement(
+      UIChildren,
+      {
+        ...props,
+        scope,
+        crud,
+        style: getStyle("inner")
+      }
+    ), /* @__PURE__ */ React9.createElement(UIModal, { ...props, scope, crud }));
+  };
+  let Card = (props2) => {
+    let isCard = scope.is("type|layout", "card");
+    if (scope.isType("list")) {
+      let empty = scope.getPart("empty", null, void 0);
+      let items = scope.getItems();
+      if (empty === false && Utils18.isEmpty(items)) {
+        isCard = false;
+      }
+    }
+    if (isCard) {
+      let box2 = {
+        ...getStyle("box", { ...boxStyle.box, alignSelf: "stretch" })
+      };
+      let borderWidth = original.boxBorder;
+      if (borderWidth || borderWidth === 0) {
+        if (borderWidth === true) {
+          borderWidth = 1;
+        }
+        box2 = { ...box2, borderWidth };
+      }
+      return /* @__PURE__ */ React9.createElement(View13, { style: getStyle("card", { ...box2 }) }, /* @__PURE__ */ React9.createElement(
+        View13,
+        {
+          style: getStyle("boxInner", {
+            paddingHorizontal: 15,
+            paddingVertical: 10
+          })
+        },
+        props2.children
+      ));
+    }
+    if (scope.isInput() || original.container) {
+      return /* @__PURE__ */ React9.createElement(
+        View13,
+        {
+          style: getStyle("container", { paddingVertical: 5, width: "100%" })
+        },
+        props2.children
+      );
+    }
+    return /* @__PURE__ */ React9.createElement(React9.Fragment, null, props2.children);
+  };
+  scope.dialogShow = (args) => {
+    let event = Utils18.nvl(args?.event, {});
+    if (event?.debug) console.log(args);
+    let caller = args.caller;
+    let main = ViewUtils3.getCrud("view");
+    let parent = main.dialog;
+    let { crud: crud2 } = args;
+    let name = scope.getName("modal");
+    let edit = args.edit === true;
+    let def = {};
+    let rowItem = null;
+    let component = event?.component;
+    let elo = Utils18.nvl(caller?.original, original);
+    if (crud2.is("row")) {
+      def.parent = crud2.parent.parent;
+      def.search = crud2.parent;
+      rowItem = crud2.data;
+    } else if (crud2.is("search")) {
+      def.parent = crud2.parent;
+      def.search = crud2;
+    }
+    let crudData = crud2.data;
+    let eventData = Utils18.nvl(event.data, event.send);
+    if (typeof eventData === "function") {
+      eventData = eventData.call(this, args);
+    }
+    if (event.send === false || event.data === false) {
+      crudData = {};
+    }
+    let data = Utils18.nvl(eventData, args.item, rowItem, crudData, {});
+    let d = CrudUtils2.create("dialog", {
+      parent: crud2,
+      root: crud2,
+      name,
+      data,
+      edit,
+      scope,
+      ...def
+    });
+    let el = {
+      label: elo.label,
+      icon: elo.icon,
+      type: "dialog"
+    };
+    let close = event.dialog?.close;
+    if (typeof event.dialog === "object") {
+      el = { ...el, ...event.dialog };
+    }
+    if (event.header) el.header = event.header;
+    if (event.label) el.label = event.label;
+    if (event.title) el.title = event.title;
+    let label = Utils18.nvl(el.title, el.label);
+    el.label = label;
+    let dialogScope = ScopeUtils3.create({
+      parent: scope,
+      crud: d,
+      ...el,
+      owner: scope
+    });
+    let dialog = {
+      crud: d,
+      label,
+      parent,
+      component,
+      scope: dialogScope,
+      close,
+      props: event.props,
+      debug: event.debug
+    };
+    main.dialog = dialog;
+    scope.currentDialog = dialog;
+    if (parent) parent.update?.();
+    scope.update();
+  };
+  scope.dialogHide = (args) => {
+    let main = ViewUtils3.getCrud("view");
+    let current = main.dialog;
+    let next = Utils18.nvl(current.parent, null);
+    main.dialog = next;
+    scope.currentDialog = next;
+    let nextScope = next?.scope?.parent;
+    let currScope = current?.scope?.parent;
+    if (currScope) {
+      const close = current.close;
+      currScope.update();
+      if (close) {
+        if (close?.debug) console.log("Fechando");
+        current.scope.call("close", { close });
+      }
+    }
+    if (nextScope) {
+      nextScope.update();
+    }
+  };
+  if (original.hideEmpty && !scope.isType("list", "select", "complete")) {
+    let value = scope.getValue();
+    if (Utils18.isEmpty(value)) return /* @__PURE__ */ React9.createElement(React9.Fragment, null);
+  }
+  return /* @__PURE__ */ React9.createElement(CrudContext.Provider, { value: { crud, theme } }, /* @__PURE__ */ React9.createElement(Tag, { ref, style: getStyle(), ...custom }, /* @__PURE__ */ React9.createElement(Card, null, /* @__PURE__ */ React9.createElement(Container, null))));
+}
+var boxStyle = StyleSheet15.create({
+  box: {
+    borderWidth: 1,
+    borderColor: "#dedede",
+    borderStyle: "solid",
+    backgroundColor: "white",
+    borderRadius: 10,
+    width: "100%",
+    shadowColor: "#000",
+    shadowOpacity: 0.1,
+    shadowRadius: 4,
+    elevation: 3
+  }
+});
+var box = {
+  ...boxStyle.box
+};
+var elementStyle = {};
+elementStyle.view = {
+  inner: {
+    width: "100%",
+    alignItems: "normal",
+    flex: 1
+  },
+  container: {
+    width: "100%",
+    backgroundColor: "background",
+    flex: 1,
+    gap: 10
+  },
+  root: {
+    width: "100%",
+    flex: 1,
+    alignItems: "normal",
+    padding: 0
+  }
+};
+elementStyle.input = StyleSheet15.create({
+  label: {
+    paddingLeft: 0
+  },
+  inner: {
+    flex: 1,
+    width: "100%",
+    padding: 0,
+    gap: 10,
+    alignSelf: "flex-start",
+    flexDirection: "row",
+    flexWrap: "wrap"
+  }
+});
+elementStyle.quantity = {
+  inner: {
+    ...box,
+    backgroundColor: "primarySoft",
+    fontWeight: 600,
+    fontSize: 16,
+    borderRadius: 25,
+    borderWidth: 0,
+    paddingHorizontal: 5,
+    paddingVertical: 5,
+    flexWrap: "nowrap",
+    flex: 1,
+    flexDirection: "row",
+    justifyContent: "center",
+    alignItems: "center"
+  }
+};
+elementStyle.toggle = StyleSheet15.create({
+  root: {
+    height: "auto"
+  },
+  inner: {
+    ...box,
+    flex: 1,
+    width: "100%",
+    gap: 10,
+    borderRadius: 2,
+    justifyContent: "center",
+    flexDirection: "row",
+    alignSelf: "flex-start",
+    flexWrap: "nowrap"
+  }
+});
+var styles12 = StyleSheet15.create({
+  root: {
+    gap: 5,
+    flexDirection: "column",
+    flexWrap: "wrap",
+    width: "100%",
+    alignItems: "flex-start"
+  },
+  label: {
+    fontWeight: 600,
+    fontSize: 12,
+    paddingVertical: 3,
+    color: "labelColor"
+  },
+  inner: { width: "100%", justifyContent: "space-between" }
+});
+var withChildStyles = StyleSheet15.create({
+  root: {
+    gap: 10
+  },
+  label: {
+    width: "100%",
+    fontWeight: 500,
+    fontSize: 24
+  }
+});
+
+// src/elements/core/UIInclude.tsx
+import { ComponentUtils as ComponentUtils6, Utils as Utils19 } from "react-crud-utils";
+function UIInclude(props) {
+  if (props.rendered === false) {
+    return /* @__PURE__ */ React.createElement(React.Fragment, null);
+  }
+  let includes = ComponentUtils6.getDefine(props, props.name, props.position);
+  if (Utils19.isEmpty(includes)) {
+    includes = props.default;
+  }
+  if (!Utils19.isEmpty(includes)) {
+    let Aux = (tagProp) => {
+      let Tag = props.tag;
+      if (!Utils19.isEmpty(Tag)) {
+        return /* @__PURE__ */ React.createElement(Tag, { ...tagProp }, tagProp.children);
+      }
+      return /* @__PURE__ */ React.createElement(React.Fragment, null, tagProp.children);
+    };
+    return /* @__PURE__ */ React.createElement(Aux, { ...props.tagProps }, /* @__PURE__ */ React.createElement(
+      UIChildren,
+      {
+        transient: true,
+        ...props,
+        scope: props.scope,
+        crud: props.crud,
+        part: props.name
+      },
+      includes
+    ));
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, includes);
+}
+
+// src/elements/core/SafeView.tsx
+import {
+  Keyboard,
+  KeyboardAvoidingView,
+  Platform as Platform2,
+  StatusBar,
+  TouchableWithoutFeedback
+} from "react-native";
+import {
+  SafeAreaProvider,
+  SafeAreaView as SafeAreaContextView
+} from "react-native-safe-area-context";
+import { ThemeUtils, useTheme, Utils as Utils20 } from "react-crud-utils";
+function SafeView(props) {
+  let theme = ThemeUtils.getCurrentTheme();
+  if (Utils20.isEmpty(theme)) {
+    theme = useTheme();
+  }
+  const dismissKeyboard = () => {
+    if (Platform2.OS !== "web") {
+      Keyboard.dismiss();
+    }
+  };
+  return /* @__PURE__ */ React.createElement(SafeAreaProvider, null, /* @__PURE__ */ React.createElement(
+    SafeAreaContextView,
+    {
+      style: {
+        backgroundColor: theme.colors?.theme,
+        ...props.viewStyle,
+        flex: 1
+      }
+    },
+    /* @__PURE__ */ React.createElement(StatusBar, { barStyle: "dark-content", backgroundColor: "#f5f5f5" }),
+    /* @__PURE__ */ React.createElement(
+      KeyboardAvoidingView,
+      {
+        behavior: Platform2.OS === "ios" ? "padding" : "height",
+        style: {
+          flex: 1,
+          // 🔹 Ocupa 100% da tela
+          justifyContent: "flex-start"
+        }
+      },
+      /* @__PURE__ */ React.createElement(
+        TouchableWithoutFeedback,
+        {
+          onPress: dismissKeyboard,
+          accessible: false
+        },
+        /* @__PURE__ */ React.createElement(React.Fragment, null, props.children)
+      )
+    )
+  ));
+}
+
+// src/elements/UI.tsx
+var UI = {
+  Order: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "order" }),
+  List: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "list" }),
+  Row: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "row" }),
+  Value: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "value" }),
+  Label: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "label" }),
+  Repeat: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "repeat", props: { search: false } }),
+  Define: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "define" }),
+  Include: (props) => /* @__PURE__ */ React.createElement(UIInclude, { ...props }),
+  Column: ({ type = "column", ...props }) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "column" }),
+  Input: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props }),
+  Text: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "text" }),
+  Textarea: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "textarea" }),
+  Email: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "email" }),
+  Button: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "button" }),
+  Link: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "link" }),
+  Icon: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "icon", transient: true }),
+  Output: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "output" }),
+  Form: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "form" }),
+  Crud: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "crud" }),
+  View: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "view", transient: true }),
+  Bottom: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "bottom" }),
+  Dialog: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "dialog" }),
+  Content: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "content" }),
+  Top: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "top" }),
+  Card: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "card" }),
+  Tab: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "tab" }),
+  Tabs: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "tabs" }),
+  Step: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "tab", layout: "step" }),
+  Stepper: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "tabs", layout: "stepper" }),
+  Money: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "money" }),
+  Chart: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "chart" }),
+  Password: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "password" }),
+  Complete: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "complete" }),
+  Checkbox: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "switch" }),
+  Switch: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "switch" }),
+  Radio: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "radio" }),
+  Select: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "select" }),
+  Toggle: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "toggle" }),
+  Entity: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "entity" }),
+  Element: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "element" }),
+  Quantity: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "quantity" }),
+  Slider: (props) => /* @__PURE__ */ React.createElement(UIElement, { ...props, type: "slider" }),
+  SafeView
+};
+var UI_default = UI;
+export {
+  UI_default as UI
+};
+//# sourceMappingURL=index.mjs.map