@dspranger/react-permissions 0.1.0

package/README.md

@@ -0,0 +1,204 @@
+# @dspranger/react-permissions
+
+Action-based permission checking for React.
+
+## Overview
+
+`@dspranger/react-permissions` lets you check user permissions in React components and hooks. You supply a list of permission strings (from your auth system, API, or wherever) via a provider, then check against them anywhere in your component tree.
+
+Permissions are plain strings. The library doesn't dictate format. A common convention is `resource:action` (e.g. `post:edit`, `comment:delete`) but any string works.
+
+## Installation
+
+```bash
+npm install @dspranger/react-permissions -S
+```
+
+Requires React 19 or later as a peer dependency.
+
+## Quick Start
+
+```tsx
+import { PermissionsProvider, Can, usePermission } from '@dspranger/react-permissions';
+
+const userPermissions = ['post:edit', 'comment:delete'];
+
+function App() {
+  return (
+    <PermissionsProvider permissions={userPermissions}>
+      <Dashboard />
+    </PermissionsProvider>
+  );
+}
+```
+
+---
+
+## API
+
+### `<PermissionsProvider>`
+
+Wraps your app (or any subtree) and makes the permissions list available to all descendants.
+
+```tsx
+<PermissionsProvider permissions={userPermissions}>
+  {children}
+</PermissionsProvider>
+```
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `permissions` | `string[]` | The full list of permissions the current user has |
+| `children` | `ReactNode` | Your component tree |
+
+---
+
+### `usePermission`
+
+Hook that returns `true` if the current user has the given permission.
+
+**Type-level check:** Does this user have this permission at all?
+
+```tsx
+const canEdit = usePermission('post:edit');
+```
+
+**Type-level check with condition:** Permission plus an extra check that isn't specific to any resource (e.g. a global flag, feature toggle, or user-level state)   :
+
+```tsx
+// App-wide read-only mode
+const canEdit = usePermission('post:edit', () => !isReadOnlyMode);
+
+// User must have a verified email to publish
+const canPublish = usePermission('post:publish', () => currentUser.emailVerified);
+```
+
+**Instance-level check:** Permission plus a check against a specific resource. TypeScript infers the resource type from whatever you pass.
+
+```tsx
+const canEdit = usePermission('post:edit', post, (p) => p.authorId === currentUser.id);
+```
+
+| Signature | Parameters |
+|-----------|-----------|
+| `usePermission(action)` | `action: string` |
+| `usePermission(action, condition)` | `action: string`, `condition: () => boolean` |
+| `usePermission(action, resource, condition)` | `action: string`, `resource: R`, `condition: (resource: R) => boolean` |
+
+Returns `boolean`. Throws if called outside a `<PermissionsProvider>`.
+
+---
+
+### `<Can>`
+
+Component wrapper around `usePermission`. Renders `children` when the check passes, nothing otherwise.
+
+**Type-level check:**
+
+```tsx
+<Can action="post:edit">
+  <EditButton />
+</Can>
+```
+
+**Type-level check with condition:** Permission plus a global or user-level check, not tied to any specific resource:
+
+```tsx
+<Can action="post:edit" condition={() => !isReadOnlyMode}>
+  <EditButton />
+</Can>
+```
+
+**Instance-level check:**
+
+```tsx
+<Can action="post:edit" resource={post} condition={(p) => p.authorId === currentUser.id}>
+  <EditButton />
+</Can>
+```
+
+| Prop | Type | Required | Description |
+|------|------|----------|-------------|
+| `action` | `string` | Yes | The permission string to check |
+| `children` | `ReactNode` | Yes | Rendered when the check passes |
+| `resource` | `R` | No | A specific resource instance to check against |
+| `condition` | `() => boolean` or `(resource: R) => boolean` | No | Extra check run after the action check passes. Required when `resource` is provided. |
+
+> When `resource` is provided, `condition` is required and TypeScript enforces that it accepts the same type as `resource`.
+
+---
+
+## Full Example
+
+```tsx
+import { PermissionsProvider, Can, usePermission } from '@dspranger/react-permissions';
+
+type Post = {
+  id: string;
+  authorId: string;
+  title: string;
+};
+
+function PostActions({ post, currentUserId }: { post: Post; currentUserId: string }) {
+  // Hook for imperative checks
+  const canDelete = usePermission(
+    'post:delete',
+    post,
+    (p) => p.authorId === currentUserId,
+  );
+
+  return (
+    <div>
+      {/* Type-level: can this user edit any post? */}
+      <Can action="post:edit">
+        <button>Edit</button>
+      </Can>
+
+      {/* Instance-level via hook */}
+      {canDelete && <button>Delete</button>}
+
+      {/* Instance-level via component: own posts only */}
+      <Can
+        action="post:edit"
+        resource={post}
+        condition={(p) => p.authorId === currentUserId}
+      >
+        <button>Edit (owner only)</button>
+      </Can>
+    </div>
+  );
+}
+
+function App({ currentUser }: { currentUser: { id: string; permissions: string[] } }) {
+  return (
+    <PermissionsProvider permissions={currentUser.permissions}>
+      <PostActions post={post} currentUserId={currentUser.id} />
+    </PermissionsProvider>
+  );
+}
+```
+
+---
+
+## How Permission Strings Work
+
+The library treats permission strings as opaque. It checks whether the string exists in the list, nothing more. The format is entirely up to you:
+
+```ts
+// resource:action (most common)
+['post:read', 'post:edit', 'comment:delete']
+
+// verb-first
+['read:posts', 'edit:posts']
+
+// flat
+['edit_posts', 'delete_comments']
+```
+
+The `condition` function is where instance-level logic lives. Ownership checks, status checks, or anything else specific to a particular resource. The library passes the resource through to your condition and stays out of the way.
+
+---
+
+## License
+
+ISC

package/dist/index.cjs

@@ -0,0 +1,71 @@
+"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, {
+  Can: () => Can,
+  PermissionsProvider: () => PermissionsProvider,
+  usePermission: () => usePermission
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/PermissionsContext.ts
+var import_react = require("react");
+var PermissionsContext = (0, import_react.createContext)(null);
+var usePermissionsContext = () => (0, import_react.useContext)(PermissionsContext);
+
+// src/usePermission.ts
+function usePermission(action, resourceOrCondition, condition) {
+  const permissions = usePermissionsContext();
+  if (permissions === null)
+    throw new Error("usePermission must be used within a PermissionsProvider");
+  if (!permissions.includes(action)) return false;
+  if (resourceOrCondition === void 0) return true;
+  if (typeof resourceOrCondition === "function")
+    return resourceOrCondition();
+  return condition !== void 0 ? condition(resourceOrCondition) : true;
+}
+
+// src/Can.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function hasResource(props) {
+  return "resource" in props;
+}
+function Can(props) {
+  const condition = hasResource(props) ? () => props.condition(props.resource) : props.condition;
+  const allowed = usePermission(props.action, condition);
+  return allowed ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: props.children }) : null;
+}
+
+// src/PermissionsProvider.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function PermissionsProvider({
+  permissions,
+  children
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(PermissionsContext.Provider, { value: permissions, children });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Can,
+  PermissionsProvider,
+  usePermission
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/PermissionsContext.ts","../src/usePermission.ts","../src/Can.tsx","../src/PermissionsProvider.tsx"],"sourcesContent":["export { Can } from './Can';\nexport { PermissionsProvider } from './PermissionsProvider';\nexport { usePermission } from './usePermission';\n","import { createContext, useContext } from 'react';\n\n// string[] | null — null lets the hook detect a missing PermissionsProvider\n// and throw a clear error rather than silently returning an empty array.\nexport const PermissionsContext = createContext<string[] | null>(null);\n\n// Pre-bound hook — call this inside components instead of useContext directly\nexport const usePermissionsContext = () => useContext(PermissionsContext);\n","import { usePermissionsContext } from './PermissionsContext';\n\n// Overload 1:\n// Type-level check. No resource. Optional no-arg condition.\nexport function usePermission(\n  action: string,\n  condition?: () => boolean,\n): boolean;\n\n// Overload 2:\n// Instance-level check. the type of R is inferred from resource.\n// Optional condition receives it as an argument.\nexport function usePermission<R>(\n  action: string,\n  resource: R,\n  condition: (resource: R) => boolean,\n): boolean;\n\n// Function implementation:\n// TypeScript hides this signature from callers, only the overloads above are public\nexport function usePermission<R>(\n  action: string,\n  resourceOrCondition?: R | (() => boolean),\n  condition?: (resource: R) => boolean,\n): boolean {\n  const permissions = usePermissionsContext();\n\n  if (permissions === null)\n    throw new Error('usePermission must be used within a PermissionsProvider');\n\n  if (!permissions.includes(action)) return false;\n\n  if (resourceOrCondition === undefined) return true;\n\n  // resourceOrCondition is a function, this is overload 1's condition being passed in the second slot.\n  // Cast needed because typeof can't narrow `R | (() => boolean)` to `() => boolean on its own.\n  if (typeof resourceOrCondition === 'function')\n    return (resourceOrCondition as () => boolean)();\n\n  // resourceOrCondition is a resource. Pass it to condition, or allow if no condition was given.\n  return condition !== undefined ? condition(resourceOrCondition) : true;\n}\n","import type { ReactNode } from 'react';\nimport { usePermission } from './usePermission';\n\n// Two separate prop shapes are needed to enforce the relationship between resource and condition at the type level. If\n// you pass one, you must pass the other.\n\n// Shape 1:\n// Instance-level check. resource and a matching condition are both required.\ntype CanWithResource<R> = {\n  action: string;\n  resource: R;\n  condition: (resource: R) => boolean;\n  children: ReactNode;\n};\n\n// Shape 2:\n// Type-level check. Resource is forbidden (`never`), condition is optional. `resource?: never` means the prop cannot be\n// passed at all in this shape, which is stronger than `resource?: undefined`.\ntype CanWithoutResource = {\n  action: string;\n  resource?: never;\n  condition?: () => boolean;\n  children: ReactNode;\n};\n\n// The union of both shapes. TypeScript treats Can as accepting either one.\ntype CanProps<R> = CanWithResource<R> | CanWithoutResource;\n\n// Type Predicate:\n// The return type `props is CanWithResource<R>` is a promise to TypeScript: \"When this returns true, props is\n// definitely CanWithResource<R>.\" This is needed because `'resource' in props` alone doesn't reliably narrow a union\n// where one member has `resource?: never`.\nfunction hasResource<R>(props: CanProps<R>): props is CanWithResource<R> {\n  return 'resource' in props;\n}\n\n// R is inferred from whatever is passed as `resource`. If no `resource` is passed, `R` is unused and `condition` stays\n// as `() => boolean`.\nexport function Can<R>(props: CanProps<R>) {\n  // Normalize both shapes into a no-arg condition so `usePermission` can be called unconditionally (calling hooks inside\n  // conditionals is not allowed in React). If `resource` was provided, wrap it in a closure so it gets passed to\n  // `condition` at call time.\n  const condition = hasResource(props)\n    ? () => props.condition(props.resource)\n    : props.condition;\n\n  const allowed = usePermission(props.action, condition);\n\n  return allowed ? <>{props.children}</> : null;\n}\n","import { PermissionsContext } from './PermissionsContext';\nimport type { ReactNode } from 'react';\n\ntype PermissionsProviderProps = {\n  permissions: string[];\n  children: ReactNode;\n};\n\nexport function PermissionsProvider({\n  permissions,\n  children,\n}: PermissionsProviderProps) {\n  return (\n    <PermissionsContext.Provider value={permissions}>\n      {children}\n    </PermissionsContext.Provider>\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,mBAA0C;AAInC,IAAM,yBAAqB,4BAA+B,IAAI;AAG9D,IAAM,wBAAwB,UAAM,yBAAW,kBAAkB;;;ACajE,SAAS,cACd,QACA,qBACA,WACS;AACT,QAAM,cAAc,sBAAsB;AAE1C,MAAI,gBAAgB;AAClB,UAAM,IAAI,MAAM,yDAAyD;AAE3E,MAAI,CAAC,YAAY,SAAS,MAAM,EAAG,QAAO;AAE1C,MAAI,wBAAwB,OAAW,QAAO;AAI9C,MAAI,OAAO,wBAAwB;AACjC,WAAQ,oBAAsC;AAGhD,SAAO,cAAc,SAAY,UAAU,mBAAmB,IAAI;AACpE;;;ACOmB;AAhBnB,SAAS,YAAe,OAAiD;AACvE,SAAO,cAAc;AACvB;AAIO,SAAS,IAAO,OAAoB;AAIzC,QAAM,YAAY,YAAY,KAAK,IAC/B,MAAM,MAAM,UAAU,MAAM,QAAQ,IACpC,MAAM;AAEV,QAAM,UAAU,cAAc,MAAM,QAAQ,SAAS;AAErD,SAAO,UAAU,2EAAG,gBAAM,UAAS,IAAM;AAC3C;;;ACpCI,IAAAA,sBAAA;AALG,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AACF,GAA6B;AAC3B,SACE,6CAAC,mBAAmB,UAAnB,EAA4B,OAAO,aACjC,UACH;AAEJ;","names":["import_jsx_runtime"]}

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+type CanWithResource<R> = {
+    action: string;
+    resource: R;
+    condition: (resource: R) => boolean;
+    children: ReactNode;
+};
+type CanWithoutResource = {
+    action: string;
+    resource?: never;
+    condition?: () => boolean;
+    children: ReactNode;
+};
+type CanProps<R> = CanWithResource<R> | CanWithoutResource;
+declare function Can<R>(props: CanProps<R>): react.JSX.Element | null;
+
+type PermissionsProviderProps = {
+    permissions: string[];
+    children: ReactNode;
+};
+declare function PermissionsProvider({ permissions, children, }: PermissionsProviderProps): react.JSX.Element;
+
+declare function usePermission(action: string, condition?: () => boolean): boolean;
+declare function usePermission<R>(action: string, resource: R, condition: (resource: R) => boolean): boolean;
+
+export { Can, PermissionsProvider, usePermission };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+type CanWithResource<R> = {
+    action: string;
+    resource: R;
+    condition: (resource: R) => boolean;
+    children: ReactNode;
+};
+type CanWithoutResource = {
+    action: string;
+    resource?: never;
+    condition?: () => boolean;
+    children: ReactNode;
+};
+type CanProps<R> = CanWithResource<R> | CanWithoutResource;
+declare function Can<R>(props: CanProps<R>): react.JSX.Element | null;
+
+type PermissionsProviderProps = {
+    permissions: string[];
+    children: ReactNode;
+};
+declare function PermissionsProvider({ permissions, children, }: PermissionsProviderProps): react.JSX.Element;
+
+declare function usePermission(action: string, condition?: () => boolean): boolean;
+declare function usePermission<R>(action: string, resource: R, condition: (resource: R) => boolean): boolean;
+
+export { Can, PermissionsProvider, usePermission };

package/dist/index.js

@@ -0,0 +1,42 @@
+// src/PermissionsContext.ts
+import { createContext, useContext } from "react";
+var PermissionsContext = createContext(null);
+var usePermissionsContext = () => useContext(PermissionsContext);
+
+// src/usePermission.ts
+function usePermission(action, resourceOrCondition, condition) {
+  const permissions = usePermissionsContext();
+  if (permissions === null)
+    throw new Error("usePermission must be used within a PermissionsProvider");
+  if (!permissions.includes(action)) return false;
+  if (resourceOrCondition === void 0) return true;
+  if (typeof resourceOrCondition === "function")
+    return resourceOrCondition();
+  return condition !== void 0 ? condition(resourceOrCondition) : true;
+}
+
+// src/Can.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+function hasResource(props) {
+  return "resource" in props;
+}
+function Can(props) {
+  const condition = hasResource(props) ? () => props.condition(props.resource) : props.condition;
+  const allowed = usePermission(props.action, condition);
+  return allowed ? /* @__PURE__ */ jsx(Fragment, { children: props.children }) : null;
+}
+
+// src/PermissionsProvider.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function PermissionsProvider({
+  permissions,
+  children
+}) {
+  return /* @__PURE__ */ jsx2(PermissionsContext.Provider, { value: permissions, children });
+}
+export {
+  Can,
+  PermissionsProvider,
+  usePermission
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/PermissionsContext.ts","../src/usePermission.ts","../src/Can.tsx","../src/PermissionsProvider.tsx"],"sourcesContent":["import { createContext, useContext } from 'react';\n\n// string[] | null — null lets the hook detect a missing PermissionsProvider\n// and throw a clear error rather than silently returning an empty array.\nexport const PermissionsContext = createContext<string[] | null>(null);\n\n// Pre-bound hook — call this inside components instead of useContext directly\nexport const usePermissionsContext = () => useContext(PermissionsContext);\n","import { usePermissionsContext } from './PermissionsContext';\n\n// Overload 1:\n// Type-level check. No resource. Optional no-arg condition.\nexport function usePermission(\n  action: string,\n  condition?: () => boolean,\n): boolean;\n\n// Overload 2:\n// Instance-level check. the type of R is inferred from resource.\n// Optional condition receives it as an argument.\nexport function usePermission<R>(\n  action: string,\n  resource: R,\n  condition: (resource: R) => boolean,\n): boolean;\n\n// Function implementation:\n// TypeScript hides this signature from callers, only the overloads above are public\nexport function usePermission<R>(\n  action: string,\n  resourceOrCondition?: R | (() => boolean),\n  condition?: (resource: R) => boolean,\n): boolean {\n  const permissions = usePermissionsContext();\n\n  if (permissions === null)\n    throw new Error('usePermission must be used within a PermissionsProvider');\n\n  if (!permissions.includes(action)) return false;\n\n  if (resourceOrCondition === undefined) return true;\n\n  // resourceOrCondition is a function, this is overload 1's condition being passed in the second slot.\n  // Cast needed because typeof can't narrow `R | (() => boolean)` to `() => boolean on its own.\n  if (typeof resourceOrCondition === 'function')\n    return (resourceOrCondition as () => boolean)();\n\n  // resourceOrCondition is a resource. Pass it to condition, or allow if no condition was given.\n  return condition !== undefined ? condition(resourceOrCondition) : true;\n}\n","import type { ReactNode } from 'react';\nimport { usePermission } from './usePermission';\n\n// Two separate prop shapes are needed to enforce the relationship between resource and condition at the type level. If\n// you pass one, you must pass the other.\n\n// Shape 1:\n// Instance-level check. resource and a matching condition are both required.\ntype CanWithResource<R> = {\n  action: string;\n  resource: R;\n  condition: (resource: R) => boolean;\n  children: ReactNode;\n};\n\n// Shape 2:\n// Type-level check. Resource is forbidden (`never`), condition is optional. `resource?: never` means the prop cannot be\n// passed at all in this shape, which is stronger than `resource?: undefined`.\ntype CanWithoutResource = {\n  action: string;\n  resource?: never;\n  condition?: () => boolean;\n  children: ReactNode;\n};\n\n// The union of both shapes. TypeScript treats Can as accepting either one.\ntype CanProps<R> = CanWithResource<R> | CanWithoutResource;\n\n// Type Predicate:\n// The return type `props is CanWithResource<R>` is a promise to TypeScript: \"When this returns true, props is\n// definitely CanWithResource<R>.\" This is needed because `'resource' in props` alone doesn't reliably narrow a union\n// where one member has `resource?: never`.\nfunction hasResource<R>(props: CanProps<R>): props is CanWithResource<R> {\n  return 'resource' in props;\n}\n\n// R is inferred from whatever is passed as `resource`. If no `resource` is passed, `R` is unused and `condition` stays\n// as `() => boolean`.\nexport function Can<R>(props: CanProps<R>) {\n  // Normalize both shapes into a no-arg condition so `usePermission` can be called unconditionally (calling hooks inside\n  // conditionals is not allowed in React). If `resource` was provided, wrap it in a closure so it gets passed to\n  // `condition` at call time.\n  const condition = hasResource(props)\n    ? () => props.condition(props.resource)\n    : props.condition;\n\n  const allowed = usePermission(props.action, condition);\n\n  return allowed ? <>{props.children}</> : null;\n}\n","import { PermissionsContext } from './PermissionsContext';\nimport type { ReactNode } from 'react';\n\ntype PermissionsProviderProps = {\n  permissions: string[];\n  children: ReactNode;\n};\n\nexport function PermissionsProvider({\n  permissions,\n  children,\n}: PermissionsProviderProps) {\n  return (\n    <PermissionsContext.Provider value={permissions}>\n      {children}\n    </PermissionsContext.Provider>\n  );\n}\n"],"mappings":";AAAA,SAAS,eAAe,kBAAkB;AAInC,IAAM,qBAAqB,cAA+B,IAAI;AAG9D,IAAM,wBAAwB,MAAM,WAAW,kBAAkB;;;ACajE,SAAS,cACd,QACA,qBACA,WACS;AACT,QAAM,cAAc,sBAAsB;AAE1C,MAAI,gBAAgB;AAClB,UAAM,IAAI,MAAM,yDAAyD;AAE3E,MAAI,CAAC,YAAY,SAAS,MAAM,EAAG,QAAO;AAE1C,MAAI,wBAAwB,OAAW,QAAO;AAI9C,MAAI,OAAO,wBAAwB;AACjC,WAAQ,oBAAsC;AAGhD,SAAO,cAAc,SAAY,UAAU,mBAAmB,IAAI;AACpE;;;ACOmB;AAhBnB,SAAS,YAAe,OAAiD;AACvE,SAAO,cAAc;AACvB;AAIO,SAAS,IAAO,OAAoB;AAIzC,QAAM,YAAY,YAAY,KAAK,IAC/B,MAAM,MAAM,UAAU,MAAM,QAAQ,IACpC,MAAM;AAEV,QAAM,UAAU,cAAc,MAAM,QAAQ,SAAS;AAErD,SAAO,UAAU,gCAAG,gBAAM,UAAS,IAAM;AAC3C;;;ACpCI,gBAAAA,YAAA;AALG,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AACF,GAA6B;AAC3B,SACE,gBAAAA,KAAC,mBAAmB,UAAnB,EAA4B,OAAO,aACjC,UACH;AAEJ;","names":["jsx"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@dspranger/react-permissions",
+  "author": "dspranger",
+  "version": "0.1.0",
+  "description": "Action-based permission checking for React",
+  "keywords": [
+    "typescript",
+    "react",
+    "reactjs",
+    "hooks",
+    "permissions",
+    "permission",
+    "authorization"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^7.0.0",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.2.17",
+    "jsdom": "^29.1.1",
+    "react": "*",
+    "react-dom": "^19.2.8",
+    "tsup": "^8.5.1",
+    "vitest": "^4.1.10"
+  },
+  "peerDependencies": {
+    "react": "^19.2.8"
+  }
+}