@pushframe/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,758 @@
+import React4, { createContext, forwardRef, useState, useRef, useCallback, useEffect, useImperativeHandle, useContext, useMemo } from 'react';
+import { ScrollView as ScrollView$1, Animated, View as View$1, Text as Text$1, StyleSheet, Dimensions, Modal as Modal$1, Pressable as Pressable$1, Image as Image$1, TextInput as TextInput$1, FlatList as FlatList$1, ActivityIndicator as ActivityIndicator$1, Switch as Switch$1, KeyboardAvoidingView as KeyboardAvoidingView$1, StatusBar as StatusBar$1 } from 'react-native';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var PushFrameContext = createContext(null);
+function usePushFrameContext() {
+  const ctx = useContext(PushFrameContext);
+  if (!ctx) {
+    throw new Error("[PushFrame] usePushFrameContext must be called inside <PushFrame.Provider>");
+  }
+  return ctx;
+}
+function Text({ if: _if, actions: _actions, value, children, ...rest }) {
+  return /* @__PURE__ */ jsx(Text$1, { ...rest, children: value !== void 0 ? value : children });
+}
+function View({ if: _if, actions: _actions, ...rest }) {
+  return /* @__PURE__ */ jsx(View$1, { ...rest });
+}
+var ScrollView = forwardRef(function ScrollView2({ if: _if, actions: _actions, ...rest }, ref) {
+  return /* @__PURE__ */ jsx(ScrollView$1, { ref, ...rest });
+});
+function Image({ if: _if, actions: _actions, src, source, ...rest }) {
+  const resolvedSource = src ? { uri: src } : source ?? { uri: "" };
+  return /* @__PURE__ */ jsx(Image$1, { source: resolvedSource, ...rest });
+}
+function Pressable({ if: _if, actions: _actions, ...rest }) {
+  return /* @__PURE__ */ jsx(Pressable$1, { ...rest });
+}
+function TextInput({
+  if: _if,
+  actions: _actions,
+  onChange,
+  onSubmit,
+  ...rest
+}) {
+  return /* @__PURE__ */ jsx(
+    TextInput$1,
+    {
+      onChangeText: onChange,
+      onSubmitEditing: onSubmit ? () => onSubmit() : void 0,
+      ...rest
+    }
+  );
+}
+function FlatList({
+  if: _if,
+  actions: _actions,
+  items,
+  direction,
+  numColumns,
+  ...rest
+}) {
+  return /* @__PURE__ */ jsx(
+    FlatList$1,
+    {
+      data: items,
+      horizontal: direction === "horizontal",
+      numColumns,
+      ...rest
+    }
+  );
+}
+function Modal({ if: _if, actions: _actions, ...rest }) {
+  return /* @__PURE__ */ jsx(Modal$1, { ...rest });
+}
+function ActivityIndicator({
+  if: _if,
+  actions: _actions,
+  ...rest
+}) {
+  return /* @__PURE__ */ jsx(ActivityIndicator$1, { ...rest });
+}
+function Switch({ if: _if, actions: _actions, onChange, ...rest }) {
+  return /* @__PURE__ */ jsx(Switch$1, { onValueChange: onChange, ...rest });
+}
+function KeyboardAvoidingView({
+  if: _if,
+  actions: _actions,
+  ...rest
+}) {
+  return /* @__PURE__ */ jsx(KeyboardAvoidingView$1, { ...rest });
+}
+var NativeSafeAreaView;
+try {
+  NativeSafeAreaView = __require("react-native-safe-area-context").SafeAreaView;
+} catch {
+  NativeSafeAreaView = __require("react-native").SafeAreaView;
+}
+function SafeAreaView({ if: _if, actions: _actions, ...rest }) {
+  return /* @__PURE__ */ jsx(NativeSafeAreaView, { ...rest });
+}
+function StatusBar({ if: _if, actions: _actions, ...rest }) {
+  return /* @__PURE__ */ jsx(StatusBar$1, { ...rest });
+}
+
+// src/registry/ComponentRegistry.ts
+var BUILT_IN_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "view",
+  "scrollview",
+  "image",
+  "pressable",
+  "textinput",
+  "flatlist",
+  "modal",
+  "activityindicator",
+  "switch",
+  "keyboardavoidingview",
+  "safeareaview",
+  "statusbar"
+]);
+var BUILT_IN_COMPONENTS = /* @__PURE__ */ new Map([
+  ["text", Text],
+  ["view", View],
+  ["scrollview", ScrollView],
+  ["image", Image],
+  ["pressable", Pressable],
+  ["textinput", TextInput],
+  ["flatlist", FlatList],
+  ["modal", Modal],
+  ["activityindicator", ActivityIndicator],
+  ["switch", Switch],
+  ["keyboardavoidingview", KeyboardAvoidingView],
+  ["safeareaview", SafeAreaView],
+  ["statusbar", StatusBar]
+]);
+var ComponentRegistry = class {
+  constructor(developerComponents) {
+    this.components = new Map(BUILT_IN_COMPONENTS);
+    if (developerComponents) {
+      for (const [type, component] of Object.entries(developerComponents)) {
+        if (BUILT_IN_TYPES.has(type)) {
+          console.warn(
+            `[PushFrame] ComponentRegistry: "${type}" is a built-in type and cannot be overridden. Registration skipped.`
+          );
+          continue;
+        }
+        this.components.set(type, component);
+      }
+    }
+  }
+  /**
+   * Resolve a type string to its React component.
+   * Returns null if no component is registered for the type.
+   */
+  resolve(type) {
+    return this.components.get(type) ?? null;
+  }
+  /**
+   * Returns all registered type strings (useful for debugging).
+   */
+  types() {
+    return Array.from(this.components.keys());
+  }
+};
+var TYPE_COLORS = {
+  success: "#22c55e",
+  error: "#ef4444",
+  info: "#3b82f6",
+  warning: "#f59e0b"
+};
+var ToastHost = forwardRef(function ToastHost2(_props, ref) {
+  const [toast, setToast] = useState(null);
+  const opacity = useRef(new Animated.Value(0)).current;
+  const idRef = useRef(0);
+  const hide = useCallback(() => {
+    Animated.timing(opacity, {
+      toValue: 0,
+      duration: 200,
+      useNativeDriver: true
+    }).start(() => {
+      setToast(null);
+    });
+  }, [opacity]);
+  useEffect(() => {
+    if (!toast) return;
+    Animated.timing(opacity, {
+      toValue: 1,
+      duration: 200,
+      useNativeDriver: true
+    }).start();
+    const timer = setTimeout(() => {
+      hide();
+    }, toast.duration);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [toast, opacity, hide]);
+  useImperativeHandle(
+    ref,
+    () => ({
+      show(payload) {
+        idRef.current += 1;
+        setToast({
+          id: idRef.current,
+          message: payload.message,
+          duration: payload.duration ?? 3e3,
+          type: payload.type ?? "info"
+        });
+        opacity.setValue(0);
+      }
+    }),
+    [opacity]
+  );
+  if (!toast) return null;
+  const backgroundColor = TYPE_COLORS[toast.type ?? "info"] ?? TYPE_COLORS.info;
+  return /* @__PURE__ */ jsx(View$1, { style: styles.container, pointerEvents: "none", children: /* @__PURE__ */ jsx(Animated.View, { style: [styles.toast, { backgroundColor, opacity }], children: /* @__PURE__ */ jsx(Text$1, { style: styles.message, children: toast.message }) }) });
+});
+var styles = StyleSheet.create({
+  container: {
+    position: "absolute",
+    bottom: 60,
+    left: 16,
+    right: 16,
+    alignItems: "center",
+    zIndex: 9999
+  },
+  toast: {
+    paddingVertical: 12,
+    paddingHorizontal: 20,
+    borderRadius: 8,
+    maxWidth: 400,
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: 2 },
+    shadowOpacity: 0.2,
+    shadowRadius: 4,
+    elevation: 6
+  },
+  message: {
+    color: "#fff",
+    fontSize: 14,
+    fontWeight: "500",
+    textAlign: "center"
+  }
+});
+var SCREEN_HEIGHT = Dimensions.get("window").height;
+var BottomSheetHost = forwardRef(
+  function BottomSheetHost2({ renderContent }, ref) {
+    const [visible, setVisible] = useState(false);
+    const [payload, setPayload] = useState(null);
+    const translateY = useRef(new Animated.Value(SCREEN_HEIGHT)).current;
+    const animateIn = useCallback(() => {
+      Animated.spring(translateY, {
+        toValue: 0,
+        useNativeDriver: true,
+        bounciness: 4
+      }).start();
+    }, [translateY]);
+    const animateOut = useCallback(
+      (onDone) => {
+        Animated.timing(translateY, {
+          toValue: SCREEN_HEIGHT,
+          duration: 250,
+          useNativeDriver: true
+        }).start(() => {
+          onDone?.();
+        });
+      },
+      [translateY]
+    );
+    useEffect(() => {
+      if (visible) {
+        translateY.setValue(SCREEN_HEIGHT);
+        animateIn();
+      }
+    }, [visible, translateY, animateIn]);
+    const dismiss = useCallback(() => {
+      animateOut(() => {
+        setVisible(false);
+        setPayload(null);
+      });
+    }, [animateOut]);
+    useImperativeHandle(
+      ref,
+      () => ({
+        show(p) {
+          setPayload(p);
+          setVisible(true);
+        },
+        dismiss() {
+          dismiss();
+        }
+      }),
+      [dismiss]
+    );
+    if (!visible || !payload) return null;
+    return /* @__PURE__ */ jsxs(
+      Modal$1,
+      {
+        visible,
+        transparent: true,
+        animationType: "none",
+        onRequestClose: dismiss,
+        statusBarTranslucent: true,
+        children: [
+          /* @__PURE__ */ jsx(Pressable$1, { style: styles2.backdrop, onPress: dismiss }),
+          /* @__PURE__ */ jsxs(Animated.View, { style: [styles2.sheet, { transform: [{ translateY }] }], children: [
+            /* @__PURE__ */ jsx(View$1, { style: styles2.handle }),
+            /* @__PURE__ */ jsx(View$1, { style: styles2.content, children: renderContent(payload.schema, payload.context) })
+          ] })
+        ]
+      }
+    );
+  }
+);
+var styles2 = StyleSheet.create({
+  backdrop: {
+    ...StyleSheet.absoluteFillObject,
+    backgroundColor: "rgba(0,0,0,0.5)"
+  },
+  sheet: {
+    position: "absolute",
+    bottom: 0,
+    left: 0,
+    right: 0,
+    backgroundColor: "#fff",
+    borderTopLeftRadius: 16,
+    borderTopRightRadius: 16,
+    paddingBottom: 34,
+    // safe-area approximation
+    minHeight: 200,
+    maxHeight: "80%",
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: -4 },
+    shadowOpacity: 0.15,
+    shadowRadius: 12,
+    elevation: 20
+  },
+  handle: {
+    alignSelf: "center",
+    width: 36,
+    height: 4,
+    borderRadius: 2,
+    backgroundColor: "#d1d5db",
+    marginTop: 12,
+    marginBottom: 8
+  },
+  content: {
+    flex: 1,
+    paddingHorizontal: 16,
+    paddingTop: 8
+  }
+});
+
+// src/renderer/bindingResolver.ts
+var FULL_BINDING_RE = /^\{\{(.+)\}\}$/;
+var INLINE_BINDING_RE = /\{\{([^}]+)\}\}/g;
+function evaluateExpression(expr, context) {
+  try {
+    const keys = Object.keys(context);
+    const values = keys.map((k) => context[k]);
+    const fn = new Function(...keys, `"use strict"; try { return (${expr}); } catch(e) { return undefined; }`);
+    return fn(...values);
+  } catch {
+    return void 0;
+  }
+}
+function resolveValue(value, context) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const fullMatch = FULL_BINDING_RE.exec(value);
+  if (fullMatch?.[1] !== void 0) {
+    return evaluateExpression(fullMatch[1].trim(), context);
+  }
+  if (INLINE_BINDING_RE.test(value)) {
+    INLINE_BINDING_RE.lastIndex = 0;
+    return value.replace(INLINE_BINDING_RE, (_, expr) => {
+      const resolved = evaluateExpression(expr.trim(), context);
+      return resolved !== void 0 && resolved !== null ? String(resolved) : "";
+    });
+  }
+  return value;
+}
+function resolveProps(props, context) {
+  if (!props) return {};
+  const resolved = {};
+  for (const [key, value] of Object.entries(props)) {
+    resolved[key] = resolveDeep(value, context);
+  }
+  return resolved;
+}
+function resolveDeep(value, context) {
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveDeep(item, context));
+  }
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = resolveDeep(v, context);
+    }
+    return result;
+  }
+  return resolveValue(value, context);
+}
+
+// src/renderer/conditionalEvaluator.ts
+function evaluateIf(ifExpr, context) {
+  if (ifExpr === void 0) return true;
+  const resolved = resolveValue(ifExpr, context);
+  return Boolean(resolved);
+}
+function buildActionProps(actions, context, dispatchAction) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    const existing = grouped.get(action.trigger);
+    if (existing) {
+      existing.push(action);
+    } else {
+      grouped.set(action.trigger, [action]);
+    }
+  }
+  const result = {};
+  for (const [trigger, triggerActions] of grouped) {
+    result[trigger] = (..._args) => {
+      for (const action of triggerActions) {
+        const resolvedPayload = action.payload !== void 0 ? resolveDeep(action.payload, context) : void 0;
+        dispatchAction(action.action, resolvedPayload);
+      }
+    };
+  }
+  return result;
+}
+function renderFlatListNode(node, context, registry, dispatchAction, fallbackComponent) {
+  const resolvedProps = resolveProps(node.props, context);
+  const items = Array.isArray(resolvedProps["items"]) ? resolvedProps["items"] : [];
+  const actionProps = node.actions ? buildActionProps(node.actions, context, dispatchAction) : {};
+  const { items: _items, keyExtractor: keyExtractorExpr, direction, numColumns, ...restProps } = resolvedProps;
+  let keyExtractorFn;
+  if (typeof keyExtractorExpr === "string") {
+    const extractorExpr = keyExtractorExpr;
+    keyExtractorFn = (item, index) => {
+      const itemContext = { ...context, item, index };
+      const resolved = resolveValue(extractorExpr, itemContext);
+      return resolved !== void 0 && resolved !== null ? String(resolved) : String(index);
+    };
+  }
+  const renderItemFn = ({ item, index }) => {
+    const itemContext = { ...context, item, index };
+    return /* @__PURE__ */ jsx(
+      RecursiveRenderer,
+      {
+        node: node.renderItem,
+        context: itemContext,
+        registry,
+        dispatchAction,
+        fallbackComponent
+      },
+      keyExtractorFn ? keyExtractorFn(item, index) : index
+    );
+  };
+  const FlatListComponent = registry.resolve("flatlist");
+  if (!FlatListComponent) {
+    console.warn('[PushFrame] RecursiveRenderer: "flatlist" not found in registry.');
+    return fallbackComponent ? fallbackComponent : null;
+  }
+  return React4.createElement(FlatListComponent, {
+    ...restProps,
+    ...actionProps,
+    items,
+    direction,
+    numColumns,
+    keyExtractor: keyExtractorFn,
+    renderItem: renderItemFn
+  });
+}
+function RecursiveRenderer({
+  node,
+  context,
+  registry,
+  dispatchAction,
+  fallbackComponent
+}) {
+  if (!evaluateIf(node.if, context)) {
+    return null;
+  }
+  if (node.type === "flatlist") {
+    return renderFlatListNode(
+      node,
+      context,
+      registry,
+      dispatchAction,
+      fallbackComponent
+    );
+  }
+  const resolvedProps = resolveProps(node.props, context);
+  const actionProps = node.actions ? buildActionProps(node.actions, context, dispatchAction) : {};
+  const Component = registry.resolve(node.type);
+  if (!Component) {
+    console.warn(
+      `[PushFrame] RecursiveRenderer: Unknown component type "${node.type}". Registered types: ${registry.types().join(", ")}`
+    );
+    return fallbackComponent ? fallbackComponent : null;
+  }
+  const children = node.children && node.children.length > 0 ? node.children.map((child, index) => /* @__PURE__ */ jsx(
+    RecursiveRenderer,
+    {
+      node: child,
+      context,
+      registry,
+      dispatchAction,
+      fallbackComponent
+    },
+    `${child.type}-${index}`
+  )) : void 0;
+  return React4.createElement(Component, {
+    ...resolvedProps,
+    ...actionProps,
+    children
+  });
+}
+var DEFAULT_BASE_URL = "https://api.pushframe.io";
+function PushFrameProvider({
+  apiKey,
+  context = {},
+  baseUrl = DEFAULT_BASE_URL,
+  appVersion,
+  components,
+  loadingComponent,
+  fallbackComponent,
+  onAction,
+  onError,
+  children
+}) {
+  const registry = useMemo(
+    () => new ComponentRegistry(components),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const toastRef = useRef(null);
+  const bottomSheetRef = useRef(null);
+  const showToast = useCallback((payload) => {
+    toastRef.current?.show(payload);
+  }, []);
+  const showBottomSheet = useCallback((payload) => {
+    bottomSheetRef.current?.show(payload);
+  }, []);
+  const dismissBottomSheet = useCallback(() => {
+    bottomSheetRef.current?.dismiss();
+  }, []);
+  const renderBottomSheetContent = useCallback(
+    (schema, sheetContext) => {
+      const mergedContext = sheetContext ? { ...context, ...sheetContext } : context;
+      const dispatchAction = (action, payload) => {
+        if (action === "dismiss-bottom-sheet") {
+          dismissBottomSheet();
+          return;
+        }
+        if (action === "show-toast") {
+          showToast(payload);
+          return;
+        }
+        onAction?.(action, payload);
+      };
+      return /* @__PURE__ */ jsx(
+        RecursiveRenderer,
+        {
+          node: schema,
+          context: mergedContext,
+          registry,
+          dispatchAction,
+          fallbackComponent
+        }
+      );
+    },
+    [context, registry, fallbackComponent, onAction, dismissBottomSheet, showToast]
+  );
+  const contextValue = useMemo(
+    () => ({
+      apiKey,
+      baseUrl,
+      appVersion,
+      globalContext: context,
+      registry,
+      loadingComponent,
+      fallbackComponent,
+      onAction,
+      onError,
+      showToast,
+      showBottomSheet,
+      dismissBottomSheet
+    }),
+    [
+      apiKey,
+      baseUrl,
+      appVersion,
+      context,
+      registry,
+      loadingComponent,
+      fallbackComponent,
+      onAction,
+      onError,
+      showToast,
+      showBottomSheet,
+      dismissBottomSheet
+    ]
+  );
+  return /* @__PURE__ */ jsxs(PushFrameContext.Provider, { value: contextValue, children: [
+    children,
+    /* @__PURE__ */ jsx(ToastHost, { ref: toastRef }),
+    /* @__PURE__ */ jsx(BottomSheetHost, { ref: bottomSheetRef, renderContent: renderBottomSheetContent })
+  ] });
+}
+async function fetchSchema(baseUrl, apiKey, path) {
+  const url = new URL(path, baseUrl + "/").toString();
+  const headers = {
+    Accept: "application/json",
+    Authorization: `Bearer ${apiKey}`,
+    "x-project-key": apiKey
+  };
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    throw new Error(`[PushFrame] HTTP ${res.status} fetching "${path}"`);
+  }
+  const envelope = await res.json();
+  return envelope.schema ?? envelope;
+}
+function PushFrameComponentInternal({
+  id,
+  resourceType,
+  context: slotContext,
+  isLoading: externalLoading,
+  loadingComponent: slotLoading,
+  fallbackComponent: slotFallback,
+  onAction: slotOnAction,
+  fullscreen
+}) {
+  const {
+    apiKey,
+    baseUrl,
+    appVersion,
+    globalContext,
+    registry,
+    loadingComponent: providerLoading,
+    fallbackComponent: providerFallback,
+    onAction: providerOnAction,
+    onError,
+    showToast,
+    showBottomSheet,
+    dismissBottomSheet
+  } = usePushFrameContext();
+  const [schema, setSchema] = useState(null);
+  const [fetchError, setFetchError] = useState(null);
+  const [isFetching, setIsFetching] = useState(true);
+  const fetchPath = `${resourceType}/${encodeURIComponent(id)}/${encodeURIComponent(appVersion ?? "null")}`;
+  const mergedContext = slotContext ? { ...globalContext, ...slotContext } : globalContext;
+  const loadingUI = slotLoading !== void 0 ? slotLoading : providerLoading;
+  const fallbackUI = slotFallback !== void 0 ? slotFallback : providerFallback;
+  useEffect(() => {
+    let cancelled = false;
+    setSchema(null);
+    setFetchError(null);
+    setIsFetching(true);
+    fetchSchema(baseUrl, apiKey, fetchPath).then((s) => {
+      if (!cancelled) {
+        setSchema(s);
+        setIsFetching(false);
+      }
+    }).catch((err) => {
+      if (!cancelled) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        setFetchError(error);
+        setIsFetching(false);
+        onError?.(error);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [fetchPath, baseUrl, apiKey, onError]);
+  const dispatchAction = useCallback(
+    (action, payload) => {
+      if (action === "show-toast") {
+        showToast(payload);
+        return;
+      }
+      if (action === "show-bottom-sheet") {
+        showBottomSheet(payload);
+        return;
+      }
+      if (action === "dismiss-bottom-sheet") {
+        dismissBottomSheet();
+        return;
+      }
+      if (action === "scroll-to") {
+        return;
+      }
+      const stopped = slotOnAction?.(action, payload);
+      if (stopped) return;
+      providerOnAction?.(action, payload);
+    },
+    [showToast, showBottomSheet, dismissBottomSheet, slotOnAction, providerOnAction]
+  );
+  const isShowingLoader = externalLoading || isFetching;
+  if (isShowingLoader) {
+    return loadingUI ?? null;
+  }
+  if (fetchError || !schema) {
+    return fallbackUI ?? null;
+  }
+  const rendered = /* @__PURE__ */ jsx(
+    RecursiveRenderer,
+    {
+      node: schema,
+      context: mergedContext,
+      registry,
+      dispatchAction,
+      fallbackComponent: fallbackUI
+    }
+  );
+  if (fullscreen) {
+    return /* @__PURE__ */ jsx(Fragment, { children: rendered });
+  }
+  return rendered;
+}
+function PushFrameComponent(props) {
+  return /* @__PURE__ */ jsx(PushFrameComponentInternal, { ...props, resourceType: "components" });
+}
+function PushFrameScreen(props) {
+  return /* @__PURE__ */ jsx(View$1, { style: styles3.container, children: /* @__PURE__ */ jsx(PushFrameComponentInternal, { ...props, resourceType: "screens", fullscreen: true }) });
+}
+var styles3 = StyleSheet.create({
+  container: {
+    flex: 1
+  }
+});
+
+// src/index.ts
+var PushFrame = {
+  // Slot components
+  Provider: PushFrameProvider,
+  Screen: PushFrameScreen,
+  Component: PushFrameComponent,
+  // Primitives
+  Text,
+  View,
+  ScrollView,
+  Image,
+  Pressable,
+  TextInput,
+  FlatList,
+  Modal,
+  ActivityIndicator,
+  Switch,
+  KeyboardAvoidingView,
+  SafeAreaView,
+  StatusBar
+};
+
+export { ActivityIndicator, ComponentRegistry, FlatList, Image, KeyboardAvoidingView, Modal, Pressable, PushFrame, PushFrameComponent, PushFrameContext, PushFrameProvider, PushFrameScreen, RecursiveRenderer, SafeAreaView, ScrollView, StatusBar, Switch, Text, TextInput, View, evaluateIf, resolveDeep, resolveProps, resolveValue, usePushFrameContext };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map