@apps-in-toss/framework 0.0.4 → 0.0.6

package/dist/index.js

@@ -1,14 +1,26 @@
-// src/native-event-emitter/nativeEventEmitter.ts
-import { NativeEventEmitter } from "react-native";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/native-event-emitter/index.ts
+var native_event_emitter_exports = {};
+__export(native_event_emitter_exports, {
+  startUpdateLocation: () => startUpdateLocation
+});
+
+// src/native-event-emitter/bedrock-event.ts
+import { BedrockEvent } from "react-native-bedrock";
+
+// src/native-event-emitter/event-plugins/UpdateLocationEvent.ts
+import { BedrockEventDefinition } from "react-native-bedrock";
 
 // src/native-modules/AppsInTossModule.ts
 import { NativeModules } from "react-native";
 var AppsInTossModuleInstance = NativeModules.AppsInTossModule;
 var AppsInTossModule = AppsInTossModuleInstance;
 
-// src/native-event-emitter/nativeEventEmitter.ts
-var nativeEventEmitter = new NativeEventEmitter(AppsInTossModuleInstance);
-
 // src/native-modules/getPermission.ts
 function getPermission(permission) {
   return AppsInTossModule.getPermission(permission);
@@ -31,32 +43,56 @@ async function requestPermission(permission) {
   }
 }
 
-// src/native-event-emitter/startUpdateLocation.ts
-async function startUpdateLocation(options) {
-  const { callback, ...nativeOptions } = options;
-  const permissionStatus = await requestPermission({ name: "geolocation", access: "access" });
-  if (permissionStatus === "denied") {
-    throw new Error("\uC704\uCE58 \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694.");
+// src/native-event-emitter/nativeEventEmitter.ts
+import { NativeEventEmitter } from "react-native";
+var nativeEventEmitter = new NativeEventEmitter(AppsInTossModuleInstance);
+
+// src/native-event-emitter/event-plugins/UpdateLocationEvent.ts
+var UpdateLocationEvent = class extends BedrockEventDefinition {
+  name = "updateLocationEvent";
+  subscriptionCount = 0;
+  ref = {
+    remove: () => {
+    }
+  };
+  remove() {
+    --this.subscriptionCount === 0 && AppsInTossModuleInstance.stopUpdateLocation({});
+    this.ref.remove();
   }
-  await AppsInTossModuleInstance.startUpdateLocation(nativeOptions);
-  const subscription = nativeEventEmitter.addListener("updateLocation", callback);
-  subscriptionCount++;
-  const subscriptionProxy = new Proxy(subscription, {
-    get: (target, key, receiver) => {
-      const result = Reflect.get(target, key, receiver);
-      if (key === "remove") {
-        return async () => {
-          await (--subscriptionCount === 0 && AppsInTossModuleInstance.stopUpdateLocation({}));
-          const remove = result;
-          remove();
-        };
+  listener(options, onEvent, onError) {
+    requestPermission({ name: "geolocation", access: "access" }).then((permissionStatus) => {
+      if (permissionStatus === "denied") {
+        onError(new Error("\uC704\uCE58 \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694."));
+        return;
       }
-      return result;
-    }
-  });
-  return subscriptionProxy;
+      void AppsInTossModuleInstance.startUpdateLocation(options).catch(onError);
+      const subscription = nativeEventEmitter.addListener("updateLocation", onEvent);
+      this.ref = {
+        remove: () => subscription?.remove()
+      };
+      this.subscriptionCount++;
+    }).catch(onError);
+  }
+};
+
+// src/native-event-emitter/bedrock-event.ts
+var appsInTossEvent = new BedrockEvent([new UpdateLocationEvent()]);
+
+// src/native-event-emitter/startUpdateLocation.ts
+function startUpdateLocation(eventParams) {
+  return appsInTossEvent.addEventListener("updateLocationEvent", eventParams);
 }
-var subscriptionCount = 0;
+
+// src/native-modules/index.ts
+var native_modules_exports = {};
+__export(native_modules_exports, {
+  fetchAlbumPhotos: () => fetchAlbumPhotos,
+  fetchContacts: () => fetchContacts,
+  getClipboardText: () => getClipboardText,
+  getCurrentLocation: () => getCurrentLocation,
+  openCamera: () => openCamera,
+  setClipboardText: () => setClipboardText
+});
 
 // src/native-modules/setClipboardText.ts
 async function setClipboardText(text) {
@@ -134,56 +170,93 @@ async function openCamera(options) {
   return photo;
 }
 
+// src/components/WebView.tsx
+import {
+  WebView as OriginalWebView
+} from "@react-native-bedrock/native/react-native-webview";
+import { useMemo } from "react";
+import { useBridgeHandler } from "react-native-bedrock";
+import * as bridges from "react-native-bedrock/bridges";
+import * as constantBridges from "react-native-bedrock/constants";
+import { jsx } from "react/jsx-runtime";
+function WebView({ localhostPort = 5173, onMessage, ...props }) {
+  const uri = useMemo(() => {
+    if (__DEV__) {
+      return `http://localhost:${localhostPort}`;
+    }
+    return AppsInTossModule.getWebBundleURL({}).url;
+  }, [localhostPort]);
+  const handler = useBridgeHandler({
+    onMessage,
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    eventListenerMap: native_event_emitter_exports,
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    constantHandlerMap: constantBridges,
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    handlerMap: {
+      ...bridges,
+      ...native_modules_exports
+    }
+  });
+  return /* @__PURE__ */ jsx(
+    OriginalWebView,
+    {
+      ref: handler.ref,
+      ...props,
+      source: { uri },
+      sharedCookiesEnabled: true,
+      thirdPartyCookiesEnabled: true,
+      onMessage: handler.onMessage,
+      injectedJavaScript: handler.injectedJavaScript,
+      injectedJavaScriptBeforeContentLoaded: handler.injectedJavaScript
+    }
+  );
+}
+
 // src/hooks/useGeolocation.ts
-import { useState, useCallback, useEffect, useRef } from "react";
+import { useState, useEffect } from "react";
 import { useVisibility } from "react-native-bedrock";
 function useGeolocation({ accuracy, distanceInterval, timeInterval }) {
   const isVisible = useVisibility();
-  const subscriptionRef = useRef();
   const [location, setLocation] = useState(null);
-  const subscribe = useCallback(async () => {
-    try {
-      const subscription = await startUpdateLocation({
-        accuracy,
-        distanceInterval,
-        timeInterval,
-        callback: setLocation
-      });
-      subscriptionRef.current = subscription;
-    } catch (error) {
-      console.error("failed to subscribe location", error);
-    }
-  }, [accuracy, distanceInterval, timeInterval]);
-  const cleanup = useCallback(async () => {
-    try {
-      const prevSubscription = subscriptionRef.current;
-      subscriptionRef.current = void 0;
-      await prevSubscription?.remove();
-    } catch (error) {
-      console.error("failed to cleanup location subscription", error);
-    }
-  }, []);
   useEffect(() => {
-    if (subscriptionRef.current == null && isVisible) {
-      subscribe();
+    if (!isVisible) {
+      return;
     }
-    return () => void cleanup();
-  }, [subscribe, cleanup, isVisible]);
+    return startUpdateLocation({
+      options: {
+        accuracy,
+        distanceInterval,
+        timeInterval
+      },
+      onEvent: setLocation,
+      onError: console.error
+    });
+  }, [accuracy, distanceInterval, timeInterval, isVisible]);
   return location;
 }
 
+// src/env.ts
+var env = {
+  getDeploymentId: () => __DEV__ ? "local" : global.__appsInToss?.deploymentId
+};
+
 // src/types.ts
-var Accuracy = /* @__PURE__ */ ((Accuracy2) => {
-  Accuracy2[Accuracy2["Lowest"] = 1] = "Lowest";
-  Accuracy2[Accuracy2["Low"] = 2] = "Low";
-  Accuracy2[Accuracy2["Balanced"] = 3] = "Balanced";
-  Accuracy2[Accuracy2["High"] = 4] = "High";
-  Accuracy2[Accuracy2["Highest"] = 5] = "Highest";
-  Accuracy2[Accuracy2["BestForNavigation"] = 6] = "BestForNavigation";
-  return Accuracy2;
-})(Accuracy || {});
+var Accuracy2 = /* @__PURE__ */ ((Accuracy3) => {
+  Accuracy3[Accuracy3["Lowest"] = 1] = "Lowest";
+  Accuracy3[Accuracy3["Low"] = 2] = "Low";
+  Accuracy3[Accuracy3["Balanced"] = 3] = "Balanced";
+  Accuracy3[Accuracy3["High"] = 4] = "High";
+  Accuracy3[Accuracy3["Highest"] = 5] = "Highest";
+  Accuracy3[Accuracy3["BestForNavigation"] = 6] = "BestForNavigation";
+  return Accuracy3;
+})(Accuracy2 || {});
 export {
-  Accuracy,
+  Accuracy2 as Accuracy,
+  WebView,
+  env,
   fetchAlbumPhotos,
   fetchContacts,
   getClipboardText,