@codeleap/permissions 6.3.0 → 7.0.0

package/dist/Permission.d.ts

@@ -0,0 +1,80 @@
+import { PermissionOptions } from './types';
+import { PermissionConfig, PermissionStatus } from './globals';
+/**
+ * Represents a single named permission with persistent reactive state.
+ *
+ * State is backed by `globalState` and persisted under the key
+ * `"permissions-<name>"`, so the last-known status survives page reloads or
+ * app restarts without an extra async check.
+ *
+ * The status machine has one sticky transition: once a permission reaches
+ * `"blocked"` it will never regress to `"denied"` via {@link check} — because
+ * on most platforms a blocked permission can only be cleared through the OS
+ * settings screen, not by a subsequent API call.
+ */
+export declare class Permission {
+    /** The name of the permission. */
+    name: string;
+    private state;
+    private checkStatus;
+    private requestStatus;
+    /**
+     * Set to `true` to enable verbose permission logs via `@codeleap/logger`.
+     * Applies to every `Permission` instance; toggling at runtime takes effect
+     * immediately.
+     */
+    static logsEnabled: boolean;
+    /**
+     * Converts a raw status string into a structured descriptor object.
+     * Prefer this over equality checks scattered across call sites so that
+     * adding a new status variant only requires updating this method.
+     */
+    static is(status: PermissionStatus): {
+        value: null;
+        isGranted: boolean;
+        isLimited: boolean;
+        isDenied: boolean;
+        isBlocked: boolean;
+    };
+    /** Configuration object associated with the permission. */
+    config: PermissionConfig;
+    /**
+     * Snapshot of the persisted status.  Returns `null` until the first
+     * `check()` or `request()` resolves.
+     */
+    get value(): null;
+    get isGranted(): boolean;
+    get isLimited(): boolean;
+    get isDenied(): boolean;
+    get isBlocked(): boolean;
+    constructor(options: PermissionOptions<PermissionConfig>);
+    private log;
+    /**
+     * Directly overwrites the stored status without going through the native
+     * check or request flow.  Useful when the status is already known from an
+     * external source (e.g. a push-notification token registration callback).
+     */
+    set(newStatus: PermissionStatus): void;
+    /**
+     * React hook that subscribes a component to this permission's reactive
+     * state.  Re-renders whenever the status changes.
+     */
+    use(): null;
+    /**
+     * Queries the native status without showing a user-facing prompt.
+     *
+     * If the platform returns `"denied"` but the stored value is already
+     * `"blocked"`, the `"blocked"` value is preserved.  This guards against
+     * platforms that report a previously-blocked permission as merely denied on
+     * subsequent queries, which would incorrectly allow a re-request attempt.
+     */
+    check(): Promise<null>;
+    /**
+     * Triggers an interactive permission prompt (may show a system dialog) and
+     * updates stored state when the result differs from the current value.
+     * Only call this in direct response to a user action; invoking it
+     * speculatively or on mount will fail silently on most platforms.
+     */
+    request(): Promise<null>;
+}
+//# sourceMappingURL=Permission.d.ts.map

package/dist/Permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Permission.d.ts","sourceRoot":"","sources":["../src/Permission.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAI9D;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;IACrB,kCAAkC;IAC3B,IAAI,EAAE,MAAM,CAAA;IAEnB,OAAO,CAAC,KAAK,CAA+B;IAE5C,OAAO,CAAC,WAAW,CAAiC;IAEpD,OAAO,CAAC,aAAa,CAAiC;IAEtD;;;;OAIG;IACH,MAAM,CAAC,WAAW,EAAE,OAAO,CAAQ;IAEnC;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB;;;;;;;IAUlC,2DAA2D;IACpD,MAAM,EAAE,gBAAgB,CAAA;IAE/B;;;OAGG;IACH,IAAI,KAAK,SAER;IAED,IAAI,SAAS,YAEZ;IAED,IAAI,SAAS,YAEZ;IAED,IAAI,QAAQ,YAEX;IAED,IAAI,SAAS,YAEZ;gBAEW,OAAO,EAAE,iBAAiB,CAAC,gBAAgB,CAAC;IAWxD,OAAO,CAAC,GAAG;IAKX;;;;OAIG;IACH,GAAG,CAAC,SAAS,EAAE,gBAAgB;IAI/B;;;OAGG;IACH,GAAG;IAIH;;;;;;;OAOG;IACG,KAAK;IAkBX;;;;;OAKG;IACG,OAAO;CAYd"}

package/dist/PermissionsManager.d.ts

@@ -0,0 +1,82 @@
+import { Permission } from './Permission';
+import { PermissionOptions } from './types';
+import { PermissionStatus, PermissionConfig } from './globals';
+/**
+ * Registry and coordinator for a fixed set of named permissions.
+ *
+ * Instantiating this class immediately calls `checkAll()` in the background so
+ * that every permission's cached status is refreshed before the first render.
+ * The `requester` callback is the single authoritative place to implement any
+ * pre-prompt logic (e.g. showing an educational interstitial before the OS
+ * dialog appears).
+ */
+export declare class PermissionsManager<P extends string> {
+    private requester;
+    permissions: Record<P, Permission>;
+    private get keys();
+    /**
+     * Snapshot of all registered permissions' current statuses.  Values reflect
+     * whatever is in persistent state at the moment of access — call
+     * `checkAll()` first if you need fresh data from the platform.
+     */
+    get values(): Record<P, null>;
+    private forEach;
+    constructor(requester: (permission: Permission) => Promise<PermissionStatus>, permissions: Record<P, Omit<PermissionOptions<PermissionConfig>, 'name'>>);
+    private log;
+    /**
+     * React hook that subscribes a component to the reactive state of a single
+     * named permission.  Re-renders whenever that permission's status changes.
+     */
+    use(permissionName: P): null;
+    /**
+     * Requests a single permission through the manager's `requester` callback.
+     * The result passes through {@link Permission.is} so callers get a
+     * structured descriptor rather than a raw string.
+     *
+     * Note: this bypasses `Permission.request()` on the individual instance —
+     * the `requester` callback owns the full flow, including any pre-prompt UI.
+     */
+    request(permissionName: P): Promise<{
+        value: null;
+        isGranted: boolean;
+        isLimited: boolean;
+        isDenied: boolean;
+        isBlocked: boolean;
+    }>;
+    /**
+     * Silently queries a single permission's current status (no system dialog).
+     * Returns a structured descriptor via {@link Permission.is}.
+     */
+    check(permissionName: P): Promise<{
+        value: null;
+        isGranted: boolean;
+        isLimited: boolean;
+        isDenied: boolean;
+        isBlocked: boolean;
+    }>;
+    /**
+     * Requests multiple permissions sequentially.  Requests are serial, not
+     * parallel, to avoid triggering concurrent system dialogs which may be
+     * rejected or silently dropped on some platforms.
+     */
+    requestMany<K extends P>(permissionsNames: K[]): Promise<Record<K, ReturnType<typeof Permission.is>>>;
+    /**
+     * Silently queries multiple permissions sequentially.  Serial execution
+     * ensures consistent ordering and avoids race conditions in the underlying
+     * state store.
+     */
+    checkMany<K extends P>(permissionsNames: K[]): Promise<Record<K, ReturnType<typeof Permission.is>>>;
+    /**
+     * Silently refreshes every registered permission.  Called automatically
+     * during construction so that cached statuses are up to date before the
+     * first render without requiring the caller to await initialization.
+     */
+    checkAll(): Promise<Record<P, {
+        value: null;
+        isGranted: boolean;
+        isLimited: boolean;
+        isDenied: boolean;
+        isBlocked: boolean;
+    }>>;
+}
+//# sourceMappingURL=PermissionsManager.d.ts.map

package/dist/PermissionsManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermissionsManager.d.ts","sourceRoot":"","sources":["../src/PermissionsManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAG9D;;;;;;;;GAQG;AACH,qBAAa,kBAAkB,CAAC,CAAC,SAAS,MAAM;IAC9C,OAAO,CAAC,SAAS,CAAuD;IAExE,WAAW,EAAE,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAA8B;IAEhE,OAAO,KAAK,IAAI,GAEf;IAED;;;;OAIG;IACH,IAAI,MAAM,oBAQT;YAEa,OAAO;gBAQnB,SAAS,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,OAAO,CAAC,gBAAgB,CAAC,EAChE,WAAW,EAAE,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC,CAAC;IAkB3E,OAAO,CAAC,GAAG;IAKX;;;OAGG;IACH,GAAG,CAAC,cAAc,EAAE,CAAC;IAIrB;;;;;;;OAOG;IACG,OAAO,CAAC,cAAc,EAAE,CAAC;;;;;;;IAM/B;;;OAGG;IACG,KAAK,CAAC,cAAc,EAAE,CAAC;;;;;;;IAM7B;;;;OAIG;IACG,WAAW,CAAC,CAAC,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;IAU3G;;;;OAIG;IACG,SAAS,CAAC,CAAC,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;IAUzG;;;;OAIG;IACG,QAAQ;;;;;;;CAIf"}

package/dist/globals.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Extend this interface via module augmentation in the consuming app to attach
+ * platform-specific metadata (e.g. Android rationale strings, iOS usage
+ * descriptions) to every registered permission.
+ *
+ * @example
+ * declare module '@codeleap/permissions' {
+ *   interface PermissionConfig {
+ *     rationale: string
+ *   }
+ * }
+ */
+export interface PermissionConfig {
+}
+/**
+ * Extend this interface via module augmentation to register the set of valid
+ * permission statuses for the target platform.  The keys become the union type
+ * used throughout the package.
+ *
+ * @example
+ * declare module '@codeleap/permissions' {
+ *   interface Status {
+ *     granted: never
+ *     denied: never
+ *     blocked: never
+ *     limited: never
+ *   }
+ * }
+ */
+export interface Status {
+}
+/**
+ * Union of every key registered in {@link Status} plus `null`.
+ * `null` means the status has not yet been resolved (e.g. before the first
+ * `check()` call completes).
+ */
+export type PermissionStatus = keyof Status | null;
+//# sourceMappingURL=globals.d.ts.map

package/dist/globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../src/globals.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;CAEhC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,MAAM;CAEtB;AAED;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,MAAM,GAAG,IAAI,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './PermissionsManager';
+export * from './Permission';
+export * from './types';
+export * from './globals';
+//# 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":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,cAAc,CAAA;AAC5B,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+import { AnyRecord } from '@codeleap/types';
+import { PermissionStatus } from './globals';
+/**
+ * Construction options for a single {@link Permission} instance.
+ *
+ * `check` and `request` are intentionally separate callbacks because many
+ * platforms distinguish a silent status query (no UI) from an interactive
+ * prompt (may show a system dialog).  Provide both even if the underlying API
+ * is the same — the manager calls them at different points in the flow.
+ */
+export type PermissionOptions<Config extends AnyRecord> = {
+    name: string;
+    config: Config;
+    check: () => Promise<PermissionStatus>;
+    request: () => Promise<PermissionStatus>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAE5C;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,CAAC,MAAM,SAAS,SAAS,IAAI;IACxD,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAA;IACtC,OAAO,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAA;CACzC,CAAA"}

package/package.json

@@ -1,7 +1,20 @@
 {
   "name": "@codeleap/permissions",
-  "version": "6.3.0",
+  "version": "7.0.0",
   "main": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "license": "UNLICENSED",
   "repository": {
     "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
@@ -9,18 +22,20 @@
     "directory": "packages/permissions"
   },
   "devDependencies": {
-    "@codeleap/config": "6.3.0",
-    "@codeleap/store": "6.3.0",
-    "@codeleap/types": "6.3.0",
+    "@codeleap/config": "7.0.0",
+    "@codeleap/logger": "7.0.0",
+    "@codeleap/store": "7.0.0",
+    "@codeleap/types": "7.0.0",
     "ts-node-dev": "1.1.8"
   },
   "scripts": {
-    "build": "echo 'No build needed'"
+    "build": "tsc --build tsconfig.build.json",
+    "typecheck": "bun tsc --noEmit -p ./tsconfig.json"
   },
   "peerDependencies": {
-    "@codeleap/store": "6.3.0",
-    "@codeleap/types": "6.3.0",
-    "@codeleap/logger": "6.3.0",
+    "@codeleap/store": "7.0.0",
+    "@codeleap/types": "7.0.0",
+    "@codeleap/logger": "7.0.0",
     "typescript": "5.5.2"
   }
-}
+}

package/src/Permission.ts

@@ -4,6 +4,18 @@ import { PermissionConfig, PermissionStatus } from './globals'
 import { TypeGuards } from '@codeleap/types'
 import { logger } from '@codeleap/logger'
 
+/**
+ * Represents a single named permission with persistent reactive state.
+ *
+ * State is backed by `globalState` and persisted under the key
+ * `"permissions-<name>"`, so the last-known status survives page reloads or
+ * app restarts without an extra async check.
+ *
+ * The status machine has one sticky transition: once a permission reaches
+ * `"blocked"` it will never regress to `"denied"` via {@link check} — because
+ * on most platforms a blocked permission can only be cleared through the OS
+ * settings screen, not by a subsequent API call.
+ */
 export class Permission {
   /** The name of the permission. */
   public name: string
@@ -14,8 +26,18 @@ export class Permission {
 
   private requestStatus: () => Promise<PermissionStatus>
 
+  /**
+   * Set to `true` to enable verbose permission logs via `@codeleap/logger`.
+   * Applies to every `Permission` instance; toggling at runtime takes effect
+   * immediately.
+   */
   static logsEnabled: boolean = false
 
+  /**
+   * Converts a raw status string into a structured descriptor object.
+   * Prefer this over equality checks scattered across call sites so that
+   * adding a new status variant only requires updating this method.
+   */
   static is(status: PermissionStatus) {
     return {
       value: status,
@@ -30,8 +52,8 @@ export class Permission {
   public config: PermissionConfig
 
   /**
-   * Gets the current permission status.
-   * @returns The current permission status.
+   * Snapshot of the persisted status.  Returns `null` until the first
+   * `check()` or `request()` resolves.
    */
   get value() {
     return this.state.get()
@@ -70,24 +92,29 @@ export class Permission {
   }
 
   /**
-   * Updates the permission status.
-   * @param newStatus - The new permission status.
+   * Directly overwrites the stored status without going through the native
+   * check or request flow.  Useful when the status is already known from an
+   * external source (e.g. a push-notification token registration callback).
    */
   set(newStatus: PermissionStatus) {
     this.state.set(newStatus)
   }
 
   /**
-   * React hook for consuming the permission state.
-   * @returns The current permission status state.
+   * React hook that subscribes a component to this permission's reactive
+   * state.  Re-renders whenever the status changes.
    */
   use() {
     return this.state.use()
   }
 
   /**
-   * Checks the current permission status and updates the state if it has changed.
-   * @returns The checked permission status.
+   * Queries the native status without showing a user-facing prompt.
+   *
+   * If the platform returns `"denied"` but the stored value is already
+   * `"blocked"`, the `"blocked"` value is preserved.  This guards against
+   * platforms that report a previously-blocked permission as merely denied on
+   * subsequent queries, which would incorrectly allow a re-request attempt.
    */
   async check() {
     let status = await this.checkStatus()
@@ -108,8 +135,10 @@ export class Permission {
   }
 
   /**
-   * Requests the permission and updates the state if it has changed.
-   * @returns The requested permission status.
+   * Triggers an interactive permission prompt (may show a system dialog) and
+   * updates stored state when the result differs from the current value.
+   * Only call this in direct response to a user action; invoking it
+   * speculatively or on mount will fail silently on most platforms.
    */
   async request() {
     const status = await this.requestStatus()

package/src/PermissionsManager.ts

@@ -3,6 +3,15 @@ import { PermissionOptions } from './types'
 import { PermissionStatus, PermissionConfig } from './globals'
 import { logger } from '@codeleap/logger'
 
+/**
+ * Registry and coordinator for a fixed set of named permissions.
+ *
+ * Instantiating this class immediately calls `checkAll()` in the background so
+ * that every permission's cached status is refreshed before the first render.
+ * The `requester` callback is the single authoritative place to implement any
+ * pre-prompt logic (e.g. showing an educational interstitial before the OS
+ * dialog appears).
+ */
 export class PermissionsManager<P extends string> {
   private requester: (permission: Permission) => Promise<PermissionStatus>
 
@@ -13,14 +22,15 @@ export class PermissionsManager<P extends string> {
   }
 
   /**
-   * Retrieves the current status values of all permissions.
-   * @returns An object mapping permission names to their statuses.
+   * Snapshot of all registered permissions' current statuses.  Values reflect
+   * whatever is in persistent state at the moment of access — call
+   * `checkAll()` first if you need fresh data from the platform.
    */
   get values() {
     const values = {} as Record<P, PermissionStatus>
 
     this.forEach(permission => {
-      values[permission.name] = permission.value
+      values[permission.name as P] = permission.value
     })
 
     return values
@@ -59,17 +69,20 @@ export class PermissionsManager<P extends string> {
   }
 
   /**
-   * React hook for consuming the permission state.
-   * @returns The current permission status state.
+   * React hook that subscribes a component to the reactive state of a single
+   * named permission.  Re-renders whenever that permission's status changes.
    */
   use(permissionName: P) {
     return this.permissions[permissionName].use()
   }
 
   /**
-   * Requests a specific permission.
-   * @param {P} permissionName - The name of the permission to request.
-   * @returns The updated permission status.
+   * Requests a single permission through the manager's `requester` callback.
+   * The result passes through {@link Permission.is} so callers get a
+   * structured descriptor rather than a raw string.
+   *
+   * Note: this bypasses `Permission.request()` on the individual instance —
+   * the `requester` callback owns the full flow, including any pre-prompt UI.
    */
   async request(permissionName: P) {
     const permission = this.permissions[permissionName]
@@ -78,9 +91,8 @@ export class PermissionsManager<P extends string> {
   }
 
   /**
-   * Checks the status of a specific permission.
-   * @param {P} permissionName - The name of the permission to check.
-   * @returns The current permission status.
+   * Silently queries a single permission's current status (no system dialog).
+   * Returns a structured descriptor via {@link Permission.is}.
    */
   async check(permissionName: P) {
     const permission = this.permissions[permissionName]
@@ -89,9 +101,9 @@ export class PermissionsManager<P extends string> {
   }
 
   /**
-   * Requests multiple permissions at once.
-   * @param {P[]} permissionsNames - An array of permission names to request.
-   * @returns A record of updated permission statuses.
+   * Requests multiple permissions sequentially.  Requests are serial, not
+   * parallel, to avoid triggering concurrent system dialogs which may be
+   * rejected or silently dropped on some platforms.
    */
   async requestMany<K extends P>(permissionsNames: K[]): Promise<Record<K, ReturnType<typeof Permission.is>>> {
     const status = {} as Record<K, ReturnType<typeof Permission.is>>
@@ -104,9 +116,9 @@ export class PermissionsManager<P extends string> {
   }
 
   /**
-   * Checks the status of multiple permissions at once.
-   * @param {P[]} permissionsNames - An array of permission names to check.
-   * @returns A record of current permission statuses.
+   * Silently queries multiple permissions sequentially.  Serial execution
+   * ensures consistent ordering and avoids race conditions in the underlying
+   * state store.
    */
   async checkMany<K extends P>(permissionsNames: K[]): Promise<Record<K, ReturnType<typeof Permission.is>>> {
     const status = {} as Record<K, ReturnType<typeof Permission.is>>
@@ -119,8 +131,9 @@ export class PermissionsManager<P extends string> {
   }
 
   /**
-   * Checks the status of all managed permissions.
-   * @returns A record of all current permission statuses.
+   * Silently refreshes every registered permission.  Called automatically
+   * during construction so that cached statuses are up to date before the
+   * first render without requiring the caller to await initialization.
    */
   async checkAll() {
     this.log('checkAll')

package/src/globals.ts

@@ -1,10 +1,42 @@
 
+/**
+ * Extend this interface via module augmentation in the consuming app to attach
+ * platform-specific metadata (e.g. Android rationale strings, iOS usage
+ * descriptions) to every registered permission.
+ *
+ * @example
+ * declare module '@codeleap/permissions' {
+ *   interface PermissionConfig {
+ *     rationale: string
+ *   }
+ * }
+ */
 export interface PermissionConfig {
 
 }
 
+/**
+ * Extend this interface via module augmentation to register the set of valid
+ * permission statuses for the target platform.  The keys become the union type
+ * used throughout the package.
+ *
+ * @example
+ * declare module '@codeleap/permissions' {
+ *   interface Status {
+ *     granted: never
+ *     denied: never
+ *     blocked: never
+ *     limited: never
+ *   }
+ * }
+ */
 export interface Status {
 
 }
 
+/**
+ * Union of every key registered in {@link Status} plus `null`.
+ * `null` means the status has not yet been resolved (e.g. before the first
+ * `check()` call completes).
+ */
 export type PermissionStatus = keyof Status | null

package/src/types.ts

@@ -1,6 +1,14 @@
 import { AnyRecord } from '@codeleap/types'
 import { PermissionStatus } from './globals'
 
+/**
+ * Construction options for a single {@link Permission} instance.
+ *
+ * `check` and `request` are intentionally separate callbacks because many
+ * platforms distinguish a silent status query (no UI) from an interactive
+ * prompt (may show a system dialog).  Provide both even if the underlying API
+ * is the same — the manager calls them at different points in the flow.
+ */
 export type PermissionOptions<Config extends AnyRecord> = {
   name: string
   config: Config

package/package.json.bak

@@ -1,26 +0,0 @@
-{
-  "name": "@codeleap/permissions",
-  "version": "6.3.0",
-  "main": "src/index.ts",
-  "license": "UNLICENSED",
-  "repository": {
-    "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
-    "type": "git",
-    "directory": "packages/permissions"
-  },
-  "devDependencies": {
-    "@codeleap/config": "workspace:*",
-    "@codeleap/store": "workspace:*",
-    "@codeleap/types": "workspace:*",
-    "ts-node-dev": "1.1.8"
-  },
-  "scripts": {
-    "build": "echo 'No build needed'"
-  },
-  "peerDependencies": {
-    "@codeleap/store": "workspace:*",
-    "@codeleap/types": "workspace:*",
-    "@codeleap/logger": "workspace:*",
-    "typescript": "5.5.2"
-  }
-}