expo-permissions-store 0.1.0

package/dist/createApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createApi.d.ts","sourceRoot":"","sources":["../src/createApi.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,cAAc,EACf,MAAM,SAAS,CAAC;AAIjB,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuElE;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/foreground.d.ts

@@ -0,0 +1,7 @@
+import type { PermissionsApi } from "./createApi";
+/**
+ * Sets up a listener to invalidate permission cache when app returns to foreground
+ * This handles the case where users change permissions in device settings
+ */
+export declare function setupForegroundListener(api: PermissionsApi): () => void;
+//# sourceMappingURL=foreground.d.ts.map

package/dist/foreground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreground.d.ts","sourceRoot":"","sources":["../src/foreground.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,IAAI,CAYvE"}

package/dist/index.cjs

@@ -0,0 +1,322 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALL_PERMISSIONS: () => ALL_PERMISSIONS,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  createPermissionsApi: () => createPermissionsApi,
+  permissionsApi: () => permissionsApi,
+  setupForegroundListener: () => setupForegroundListener,
+  store: () => store,
+  useGetPermissionQuery: () => useGetPermissionQuery,
+  useLazyGetPermissionQuery: () => useLazyGetPermissionQuery,
+  usePrefetch: () => usePrefetch,
+  useRequestPermissionMutation: () => useRequestPermissionMutation
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var ALL_PERMISSIONS = [
+  "camera",
+  "microphone",
+  "mediaLibrary",
+  "locationForeground",
+  "locationBackground",
+  "notifications",
+  "contacts",
+  "calendar",
+  "tracking"
+];
+var DEFAULT_CONFIG = {
+  permissions: ALL_PERMISSIONS,
+  recheckOnForeground: true,
+  autoCheckOnMount: false,
+  cacheTime: Infinity
+};
+
+// src/createApi.ts
+var import_react = require("@reduxjs/toolkit/query/react");
+
+// src/permissions/handlers.ts
+function normalizeResponse(response) {
+  const status = response.status;
+  return {
+    status: status === "granted" || status === "denied" || status === "limited" ? status : "undetermined",
+    canAskAgain: response.canAskAgain ?? true,
+    expires: response.expires ?? "never"
+  };
+}
+async function tryImport(moduleName) {
+  try {
+    return await import(moduleName);
+  } catch {
+    return null;
+  }
+}
+async function getPermission(type) {
+  switch (type) {
+    case "camera": {
+      const Camera = await tryImport("expo-camera");
+      if (!Camera) throw new Error("expo-camera is not installed");
+      const response = await Camera.Camera.getCameraPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "microphone": {
+      const Camera = await tryImport("expo-camera");
+      if (!Camera) throw new Error("expo-camera is not installed");
+      const response = await Camera.Camera.getMicrophonePermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "mediaLibrary": {
+      const MediaLibrary = await tryImport(
+        "expo-media-library"
+      );
+      if (!MediaLibrary) throw new Error("expo-media-library is not installed");
+      const response = await MediaLibrary.getPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "locationForeground": {
+      const Location = await tryImport("expo-location");
+      if (!Location) throw new Error("expo-location is not installed");
+      const response = await Location.getForegroundPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "locationBackground": {
+      const Location = await tryImport("expo-location");
+      if (!Location) throw new Error("expo-location is not installed");
+      const response = await Location.getBackgroundPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "notifications": {
+      const Notifications = await tryImport(
+        "expo-notifications"
+      );
+      if (!Notifications)
+        throw new Error("expo-notifications is not installed");
+      const response = await Notifications.getPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "contacts": {
+      const Contacts = await tryImport("expo-contacts");
+      if (!Contacts) throw new Error("expo-contacts is not installed");
+      const response = await Contacts.getPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "calendar": {
+      const Calendar = await tryImport("expo-calendar");
+      if (!Calendar) throw new Error("expo-calendar is not installed");
+      const response = await Calendar.getCalendarPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "tracking": {
+      const Tracking = await tryImport("expo-tracking-transparency");
+      if (!Tracking)
+        throw new Error("expo-tracking-transparency is not installed");
+      const response = await Tracking.getTrackingPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    default: {
+      const _exhaustive = type;
+      throw new Error(`Unknown permission type: ${_exhaustive}`);
+    }
+  }
+}
+async function requestPermission(type) {
+  switch (type) {
+    case "camera": {
+      const Camera = await tryImport("expo-camera");
+      if (!Camera) throw new Error("expo-camera is not installed");
+      const response = await Camera.Camera.requestCameraPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "microphone": {
+      const Camera = await tryImport("expo-camera");
+      if (!Camera) throw new Error("expo-camera is not installed");
+      const response = await Camera.Camera.requestMicrophonePermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "mediaLibrary": {
+      const MediaLibrary = await tryImport(
+        "expo-media-library"
+      );
+      if (!MediaLibrary) throw new Error("expo-media-library is not installed");
+      const response = await MediaLibrary.requestPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "locationForeground": {
+      const Location = await tryImport("expo-location");
+      if (!Location) throw new Error("expo-location is not installed");
+      const response = await Location.requestForegroundPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "locationBackground": {
+      const Location = await tryImport("expo-location");
+      if (!Location) throw new Error("expo-location is not installed");
+      const response = await Location.requestBackgroundPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "notifications": {
+      const Notifications = await tryImport(
+        "expo-notifications"
+      );
+      if (!Notifications)
+        throw new Error("expo-notifications is not installed");
+      const response = await Notifications.requestPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "contacts": {
+      const Contacts = await tryImport("expo-contacts");
+      if (!Contacts) throw new Error("expo-contacts is not installed");
+      const response = await Contacts.requestPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "calendar": {
+      const Calendar = await tryImport("expo-calendar");
+      if (!Calendar) throw new Error("expo-calendar is not installed");
+      const response = await Calendar.requestCalendarPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "tracking": {
+      const Tracking = await tryImport("expo-tracking-transparency");
+      if (!Tracking)
+        throw new Error("expo-tracking-transparency is not installed");
+      const response = await Tracking.requestTrackingPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    default: {
+      const _exhaustive = type;
+      throw new Error(`Unknown permission type: ${_exhaustive}`);
+    }
+  }
+}
+
+// src/createApi.ts
+function createPermissionsApi(config = {}) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  const api = (0, import_react.createApi)({
+    reducerPath: "permissionsApi",
+    baseQuery: (0, import_react.fakeBaseQuery)(),
+    tagTypes: ["Permission"],
+    endpoints: (builder) => ({
+      getPermission: builder.query({
+        queryFn: async (permissionType) => {
+          if (!mergedConfig.permissions.includes(permissionType)) {
+            return {
+              error: {
+                status: "CUSTOM_ERROR",
+                error: `Permission "${permissionType}" is not configured`
+              }
+            };
+          }
+          try {
+            const data = await getPermission(permissionType);
+            return { data };
+          } catch (error) {
+            return {
+              error: {
+                status: "CUSTOM_ERROR",
+                error: error instanceof Error ? error.message : "Unknown error"
+              }
+            };
+          }
+        },
+        providesTags: (_, __, permissionType) => [
+          { type: "Permission", id: permissionType }
+        ],
+        keepUnusedDataFor: mergedConfig.cacheTime
+      }),
+      requestPermission: builder.mutation({
+        queryFn: async (permissionType) => {
+          if (!mergedConfig.permissions.includes(permissionType)) {
+            return {
+              error: {
+                status: "CUSTOM_ERROR",
+                error: `Permission "${permissionType}" is not configured`
+              }
+            };
+          }
+          try {
+            const data = await requestPermission(permissionType);
+            return { data };
+          } catch (error) {
+            return {
+              error: {
+                status: "CUSTOM_ERROR",
+                error: error instanceof Error ? error.message : "Unknown error"
+              }
+            };
+          }
+        },
+        invalidatesTags: (_, __, permissionType) => [
+          { type: "Permission", id: permissionType }
+        ]
+      })
+    })
+  });
+  return {
+    ...api,
+    config: mergedConfig
+  };
+}
+
+// src/api.ts
+var permissionsApi = createPermissionsApi();
+var {
+  useGetPermissionQuery,
+  useLazyGetPermissionQuery,
+  useRequestPermissionMutation,
+  usePrefetch
+} = permissionsApi;
+
+// src/store.ts
+var import_toolkit = require("@reduxjs/toolkit");
+var store = (0, import_toolkit.configureStore)({
+  reducer: {
+    [permissionsApi.reducerPath]: permissionsApi.reducer
+  },
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(permissionsApi.middleware)
+});
+
+// src/foreground.ts
+var import_react_native = require("react-native");
+function setupForegroundListener(api) {
+  let previousState = import_react_native.AppState.currentState;
+  const subscription = import_react_native.AppState.addEventListener("change", (nextState) => {
+    if (previousState !== "active" && nextState === "active") {
+      api.util.invalidateTags(["Permission"]);
+    }
+    previousState = nextState;
+  });
+  return () => subscription.remove();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_PERMISSIONS,
+  DEFAULT_CONFIG,
+  createPermissionsApi,
+  permissionsApi,
+  setupForegroundListener,
+  store,
+  useGetPermissionQuery,
+  useLazyGetPermissionQuery,
+  usePrefetch,
+  useRequestPermissionMutation
+});

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { PermissionType, PermissionStatus, PermissionState, PermissionsConfig, } from "./types";
+export { ALL_PERMISSIONS, DEFAULT_CONFIG } from "./types";
+export { createPermissionsApi, type PermissionsApi } from "./createApi";
+export { permissionsApi, useGetPermissionQuery, useLazyGetPermissionQuery, useRequestPermissionMutation, usePrefetch, } from "./api";
+export { store, type RootState, type AppDispatch } from "./store";
+export { setupForegroundListener } from "./foreground";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG1D,OAAO,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAGxE,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,yBAAyB,EACzB,4BAA4B,EAC5B,WAAW,GACZ,MAAM,OAAO,CAAC;AAGf,OAAO,EAAE,KAAK,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAGlE,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,286 @@
+// src/types.ts
+var ALL_PERMISSIONS = [
+  "camera",
+  "microphone",
+  "mediaLibrary",
+  "locationForeground",
+  "locationBackground",
+  "notifications",
+  "contacts",
+  "calendar",
+  "tracking"
+];
+var DEFAULT_CONFIG = {
+  permissions: ALL_PERMISSIONS,
+  recheckOnForeground: true,
+  autoCheckOnMount: false,
+  cacheTime: Infinity
+};
+
+// src/createApi.ts
+import { createApi, fakeBaseQuery } from "@reduxjs/toolkit/query/react";
+
+// src/permissions/handlers.ts
+function normalizeResponse(response) {
+  const status = response.status;
+  return {
+    status: status === "granted" || status === "denied" || status === "limited" ? status : "undetermined",
+    canAskAgain: response.canAskAgain ?? true,
+    expires: response.expires ?? "never"
+  };
+}
+async function tryImport(moduleName) {
+  try {
+    return await import(moduleName);
+  } catch {
+    return null;
+  }
+}
+async function getPermission(type) {
+  switch (type) {
+    case "camera": {
+      const Camera = await tryImport("expo-camera");
+      if (!Camera) throw new Error("expo-camera is not installed");
+      const response = await Camera.Camera.getCameraPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "microphone": {
+      const Camera = await tryImport("expo-camera");
+      if (!Camera) throw new Error("expo-camera is not installed");
+      const response = await Camera.Camera.getMicrophonePermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "mediaLibrary": {
+      const MediaLibrary = await tryImport(
+        "expo-media-library"
+      );
+      if (!MediaLibrary) throw new Error("expo-media-library is not installed");
+      const response = await MediaLibrary.getPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "locationForeground": {
+      const Location = await tryImport("expo-location");
+      if (!Location) throw new Error("expo-location is not installed");
+      const response = await Location.getForegroundPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "locationBackground": {
+      const Location = await tryImport("expo-location");
+      if (!Location) throw new Error("expo-location is not installed");
+      const response = await Location.getBackgroundPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "notifications": {
+      const Notifications = await tryImport(
+        "expo-notifications"
+      );
+      if (!Notifications)
+        throw new Error("expo-notifications is not installed");
+      const response = await Notifications.getPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "contacts": {
+      const Contacts = await tryImport("expo-contacts");
+      if (!Contacts) throw new Error("expo-contacts is not installed");
+      const response = await Contacts.getPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "calendar": {
+      const Calendar = await tryImport("expo-calendar");
+      if (!Calendar) throw new Error("expo-calendar is not installed");
+      const response = await Calendar.getCalendarPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "tracking": {
+      const Tracking = await tryImport("expo-tracking-transparency");
+      if (!Tracking)
+        throw new Error("expo-tracking-transparency is not installed");
+      const response = await Tracking.getTrackingPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    default: {
+      const _exhaustive = type;
+      throw new Error(`Unknown permission type: ${_exhaustive}`);
+    }
+  }
+}
+async function requestPermission(type) {
+  switch (type) {
+    case "camera": {
+      const Camera = await tryImport("expo-camera");
+      if (!Camera) throw new Error("expo-camera is not installed");
+      const response = await Camera.Camera.requestCameraPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "microphone": {
+      const Camera = await tryImport("expo-camera");
+      if (!Camera) throw new Error("expo-camera is not installed");
+      const response = await Camera.Camera.requestMicrophonePermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "mediaLibrary": {
+      const MediaLibrary = await tryImport(
+        "expo-media-library"
+      );
+      if (!MediaLibrary) throw new Error("expo-media-library is not installed");
+      const response = await MediaLibrary.requestPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "locationForeground": {
+      const Location = await tryImport("expo-location");
+      if (!Location) throw new Error("expo-location is not installed");
+      const response = await Location.requestForegroundPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "locationBackground": {
+      const Location = await tryImport("expo-location");
+      if (!Location) throw new Error("expo-location is not installed");
+      const response = await Location.requestBackgroundPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "notifications": {
+      const Notifications = await tryImport(
+        "expo-notifications"
+      );
+      if (!Notifications)
+        throw new Error("expo-notifications is not installed");
+      const response = await Notifications.requestPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "contacts": {
+      const Contacts = await tryImport("expo-contacts");
+      if (!Contacts) throw new Error("expo-contacts is not installed");
+      const response = await Contacts.requestPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "calendar": {
+      const Calendar = await tryImport("expo-calendar");
+      if (!Calendar) throw new Error("expo-calendar is not installed");
+      const response = await Calendar.requestCalendarPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    case "tracking": {
+      const Tracking = await tryImport("expo-tracking-transparency");
+      if (!Tracking)
+        throw new Error("expo-tracking-transparency is not installed");
+      const response = await Tracking.requestTrackingPermissionsAsync();
+      return normalizeResponse(response);
+    }
+    default: {
+      const _exhaustive = type;
+      throw new Error(`Unknown permission type: ${_exhaustive}`);
+    }
+  }
+}
+
+// src/createApi.ts
+function createPermissionsApi(config = {}) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  const api = createApi({
+    reducerPath: "permissionsApi",
+    baseQuery: fakeBaseQuery(),
+    tagTypes: ["Permission"],
+    endpoints: (builder) => ({
+      getPermission: builder.query({
+        queryFn: async (permissionType) => {
+          if (!mergedConfig.permissions.includes(permissionType)) {
+            return {
+              error: {
+                status: "CUSTOM_ERROR",
+                error: `Permission "${permissionType}" is not configured`
+              }
+            };
+          }
+          try {
+            const data = await getPermission(permissionType);
+            return { data };
+          } catch (error) {
+            return {
+              error: {
+                status: "CUSTOM_ERROR",
+                error: error instanceof Error ? error.message : "Unknown error"
+              }
+            };
+          }
+        },
+        providesTags: (_, __, permissionType) => [
+          { type: "Permission", id: permissionType }
+        ],
+        keepUnusedDataFor: mergedConfig.cacheTime
+      }),
+      requestPermission: builder.mutation({
+        queryFn: async (permissionType) => {
+          if (!mergedConfig.permissions.includes(permissionType)) {
+            return {
+              error: {
+                status: "CUSTOM_ERROR",
+                error: `Permission "${permissionType}" is not configured`
+              }
+            };
+          }
+          try {
+            const data = await requestPermission(permissionType);
+            return { data };
+          } catch (error) {
+            return {
+              error: {
+                status: "CUSTOM_ERROR",
+                error: error instanceof Error ? error.message : "Unknown error"
+              }
+            };
+          }
+        },
+        invalidatesTags: (_, __, permissionType) => [
+          { type: "Permission", id: permissionType }
+        ]
+      })
+    })
+  });
+  return {
+    ...api,
+    config: mergedConfig
+  };
+}
+
+// src/api.ts
+var permissionsApi = createPermissionsApi();
+var {
+  useGetPermissionQuery,
+  useLazyGetPermissionQuery,
+  useRequestPermissionMutation,
+  usePrefetch
+} = permissionsApi;
+
+// src/store.ts
+import { configureStore } from "@reduxjs/toolkit";
+var store = configureStore({
+  reducer: {
+    [permissionsApi.reducerPath]: permissionsApi.reducer
+  },
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(permissionsApi.middleware)
+});
+
+// src/foreground.ts
+import { AppState } from "react-native";
+function setupForegroundListener(api) {
+  let previousState = AppState.currentState;
+  const subscription = AppState.addEventListener("change", (nextState) => {
+    if (previousState !== "active" && nextState === "active") {
+      api.util.invalidateTags(["Permission"]);
+    }
+    previousState = nextState;
+  });
+  return () => subscription.remove();
+}
+export {
+  ALL_PERMISSIONS,
+  DEFAULT_CONFIG,
+  createPermissionsApi,
+  permissionsApi,
+  setupForegroundListener,
+  store,
+  useGetPermissionQuery,
+  useLazyGetPermissionQuery,
+  usePrefetch,
+  useRequestPermissionMutation
+};

package/dist/permissions/handlers.d.ts

@@ -0,0 +1,4 @@
+import type { PermissionState, PermissionType } from "../types";
+export declare function getPermission(type: PermissionType): Promise<PermissionState>;
+export declare function requestPermission(type: PermissionType): Promise<PermissionState>;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/permissions/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/permissions/handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AA6BhE,wBAAsB,aAAa,CACjC,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,eAAe,CAAC,CAsF1B;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,eAAe,CAAC,CAsF1B"}

package/dist/store.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pre-configured store with permissions API
+ * Use this for quick setup without integrating into an existing store
+ */
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    permissionsApi: import("@reduxjs/toolkit/query").CombinedState<{
+        getPermission: import("@reduxjs/toolkit/query").QueryDefinition<import("./types").PermissionType, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Permission", import("./types").PermissionState, "permissionsApi", unknown>;
+        requestPermission: import("@reduxjs/toolkit/query").MutationDefinition<import("./types").PermissionType, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Permission", import("./types").PermissionState, "permissionsApi", unknown>;
+    }, "Permission", "permissionsApi">;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        permissionsApi: import("@reduxjs/toolkit/query").CombinedState<{
+            getPermission: import("@reduxjs/toolkit/query").QueryDefinition<import("./types").PermissionType, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Permission", import("./types").PermissionState, "permissionsApi", unknown>;
+            requestPermission: import("@reduxjs/toolkit/query").MutationDefinition<import("./types").PermissionType, import("@reduxjs/toolkit/query").BaseQueryFn<any, unknown, unknown, {}, {}>, "Permission", import("./types").PermissionState, "permissionsApi", unknown>;
+        }, "Permission", "permissionsApi">;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;oCAMhB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC;AAC1D,MAAM,MAAM,WAAW,GAAG,OAAO,KAAK,CAAC,QAAQ,CAAC"}