authera 1.0.0

package/dist/helper/context.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export type userBaseData<T extends string> = {
+    id: string;
+    username: string;
+    permits: T[];
+};
+export interface AuthContextValueType<T extends string> {
+    fallback_401_url: string;
+    userData: userBaseData<T>;
+    setUserData: (value: userBaseData<T>) => void;
+}
+export declare const AuthContext: React.Context<AuthContextValueType<any> | undefined>;

package/dist/helper/context.js

@@ -0,0 +1,2 @@
+import React from "react";
+export const AuthContext = React.createContext(undefined);

package/dist/helper/storage.d.ts

@@ -0,0 +1,6 @@
+export type storagesNames = "cookie" | "local";
+export type customeFunc = {
+    get: (key: string) => any | undefined;
+    set: (key: string, value: any) => void;
+};
+export declare function name2storage(name: storagesNames): customeFunc;

package/dist/helper/storage.js

@@ -0,0 +1,17 @@
+"use client";
+import Cookie from "js-cookie";
+export function name2storage(name) {
+    const cookie = {
+        get: (key) => JSON.parse(Cookie.get(key) || "{}"),
+        set: (key, value) => Cookie.set(key, JSON.stringify(value)),
+    };
+    const local = {
+        get: (key) => JSON.parse(localStorage.getItem(key) || "{}"),
+        set: (key, value) => localStorage.setItem(key, JSON.stringify(value)),
+    };
+    const mapStorage = {
+        cookie,
+        local,
+    };
+    return mapStorage[name];
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,20 @@
+import { customeFunc, storagesNames } from "../helper/storage";
+export interface AuthHookSettings<T extends string[]> {
+    backendUrl: string;
+    storage: storagesNames | customeFunc;
+    tokenType: "jwt";
+    refreshStrategy: "silent";
+}
+export declare function AuthHook<T extends string[]>(props: AuthHookSettings<T>): {
+    AuthProvider: ({ children }: {
+        children: React.ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    useAuth: () => {
+        permits: T[];
+        isPermitted: (perm: T) => boolean;
+        on: (perm: T, callback: () => void, fallback: () => void) => void;
+        setPermits: (permits: T[]) => void;
+        addPermits: (permits: T[]) => void;
+        removePermits: (permits: T[]) => void;
+    };
+};

package/dist/hooks/index.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { name2storage } from "../helper/storage";
+import AuthProvider from "../web";
+import { useAuth } from "./useAuth";
+export function AuthHook(props) {
+    // set storage functions
+    let storage = props.storage;
+    if (typeof storage === "string")
+        storage = name2storage(storage);
+    return {
+        AuthProvider: ({ children }) => (_jsx(AuthProvider, { storage: storage, children: children })),
+        useAuth: () => useAuth(),
+    };
+}

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,12 @@
+import { userBaseData } from "../helper/context";
+export declare function useAuth<T extends string>(): {
+    permits: T[];
+    isPermitted: (perm: T) => boolean;
+    on: (perm: T, callback: () => void, fallback?: () => void) => void;
+    setPermits: (permits: T[]) => void;
+    addPermits: (permits: T[]) => void;
+    removePermits: (permits: T[]) => void;
+    setUserData: (userData: userBaseData<T>) => void;
+    fallback_401_url: string;
+    isPermittedAll: (perms: T[]) => boolean;
+};

package/dist/hooks/useAuth.js

@@ -0,0 +1,56 @@
+import { AuthContext, } from "../helper/context";
+import React from "react";
+export function useAuth() {
+    // -------------------------------------------------- context
+    const ctx = React.useContext(AuthContext);
+    if (!ctx)
+        throw new Error("useAuth must be used within an AuthContext");
+    // -------------------------------------------------- data
+    const { permits: permitsData } = ctx.userData;
+    const prm = (permitsData || []);
+    const fallback_401_url = ctx.fallback_401_url;
+    // -------------------------------------------------- funtions
+    const isPermitted = (perm) => {
+        return prm.includes(perm);
+    };
+    const isPermittedAll = (perms) => {
+        return perms.every((p) => prm.includes(p));
+    };
+    const on = (perm, callback, fallback) => {
+        if (isPermitted(perm))
+            callback();
+        else if (fallback)
+            fallback();
+    };
+    const setPermits = (permits) => {
+        ctx.setUserData({ ...ctx.userData, permits });
+    };
+    const addPermits = (permits) => {
+        if (typeof permits !== "object")
+            return;
+        ctx.setUserData({
+            ...ctx.userData,
+            permits: [...prm.filter((p) => !permits.includes(p)), ...permits],
+        });
+    };
+    const removePermits = (permits) => {
+        ctx.setUserData({
+            ...ctx.userData,
+            permits: prm.filter((p) => !permits.includes(p)),
+        });
+    };
+    const setUserData = (userData) => {
+        ctx.setUserData(userData);
+    };
+    return {
+        permits: prm,
+        isPermitted,
+        on,
+        setPermits,
+        addPermits,
+        removePermits,
+        setUserData,
+        fallback_401_url,
+        isPermittedAll,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { customeFunc, storagesNames } from "./helper/storage";
+export interface AuthHookSettings<T extends string> {
+    backendUrl: string;
+    storage: storagesNames | customeFunc;
+    tokenType: "jwt";
+    refreshStrategy: "silent";
+    fallback_401_url: string;
+}
+export default function AuthHook<T extends string>(props: AuthHookSettings<T>): {
+    createAuthProvider: (children: React.ReactNode) => React.ReactNode;
+    useAuth: () => {
+        permits: T[];
+        isPermitted: (perm: T) => boolean;
+        on: (perm: T, callback: () => void, fallback?: (() => void) | undefined) => void;
+        setPermits: (permits: T[]) => void;
+        addPermits: (permits: T[]) => void;
+        removePermits: (permits: T[]) => void;
+        setUserData: (userData: import("./helper/context").userBaseData<T>) => void;
+        fallback_401_url: string;
+        isPermittedAll: (perms: T[]) => boolean;
+    };
+};
+export { default as AuthGuard } from "./web/guard";

package/dist/index.js

@@ -0,0 +1,16 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { name2storage } from "./helper/storage";
+import AuthProvider from "./web";
+import { useAuth } from "./hooks/useAuth";
+export default function AuthHook(props) {
+    // set storage functions
+    let storage = props.storage;
+    if (typeof storage === "string")
+        storage = name2storage(storage);
+    return {
+        createAuthProvider: (children) => (_jsx(AuthProvider, { storage: storage, fallback_401_url: props.fallback_401_url, children: children })),
+        useAuth: () => useAuth(),
+    };
+}
+export { default as AuthGuard } from "./web/guard";

package/dist/web/guard.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+export interface AuthGuardProps {
+    children: ReactNode;
+    permits: string[];
+    action: "show" | "hide" | "redirect";
+}
+export default function AuthGuard({ children, permits, action, }: AuthGuardProps): import("react/jsx-runtime").JSX.Element | null | undefined;

package/dist/web/guard.js

@@ -0,0 +1,23 @@
+"use client";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useAuth } from "../hooks/useAuth";
+export default function AuthGuard({ children, permits, action, }) {
+    const { isPermittedAll: isPermittedHook, fallback_401_url } = useAuth();
+    const isPermitted = isPermittedHook(permits);
+    if (action === "redirect" && !isPermitted) {
+        window.location.href = fallback_401_url;
+        return null;
+    }
+    if (action === "show") {
+        if (isPermitted)
+            return _jsx(_Fragment, { children: children });
+        else
+            return null;
+    }
+    if (action === "hide") {
+        if (isPermitted)
+            return null;
+        else
+            return _jsx(_Fragment, { children: children });
+    }
+}

package/dist/web/index.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { customeFunc as storageFunc } from "../helper/storage";
+interface AuthProviderProps<T extends string> {
+    children: React.ReactNode;
+    storage: storageFunc;
+    fallback_401_url: string;
+}
+export default function AuthProvider<T extends string>({ children, storage, fallback_401_url, }: AuthProviderProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/index.js

@@ -0,0 +1,14 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AuthContext } from "../helper/context";
+export default function AuthProvider({ children, storage, fallback_401_url, }) {
+    /**
+     * Context Provider
+     */
+    const Provider = AuthContext.Provider;
+    const userData = storage.get("userData");
+    const setUserData = (value) => {
+        storage.set("userData", value);
+    };
+    return (_jsx(Provider, { value: { userData, setUserData, fallback_401_url }, children: children }));
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "authera",
+  "version": "1.0.0",
+  "description": "this project is a simple auth hook for react",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:watch": "tsc -p tsconfig.json -w",
+    "prepublishOnly": "npm run build",
+    "pu": "npm run build && npm publish --access public",
+    "link": "npm run build && npm link",
+    "test": "vitest"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@testing-library/react": "^16.3.0",
+    "@types/js-cookie": "^3.0.6",
+    "@types/react": "^19.2.2",
+    "@vitest/coverage-c8": "^0.33.0",
+    "jsdom": "^27.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^4.0.5"
+  },
+  "peerDependencies": {
+    "react": "^18 || ^19"
+  },
+  "dependencies": {
+    "js-cookie": "^3.0.5"
+  }
+}