@arkitektbedriftene/fe-lib 6.0.0 → 6.1.0

package/dist/oidc/AuthManager.d.ts

@@ -0,0 +1,53 @@
+import { SigninPopupArgs, SigninRedirectArgs, SigninSilentArgs, SignoutRedirectArgs, User, UserManagerSettings } from 'oidc-client-ts';
+export type UserInfo = {
+    email: string;
+    firmaccess: string;
+    firstname: string;
+    lastname: string;
+    username: string;
+    fc: string;
+    externalid: string;
+    role: string;
+};
+export type ImpersonationData = {
+    impersonatedUser: UserInfo;
+    impersonationToken: string;
+};
+/**
+ * A simpler wrapper around UserManager that combines normal authentication
+ * with impersonation functionality without React context dependency.
+ */
+export declare class AuthManager {
+    private userManager;
+    private storageKey;
+    constructor(settings: UserManagerSettings);
+    /**
+     * Get impersonation user from localStorage
+     */
+    getImpersonationData(): ImpersonationData | null;
+    /**
+     * Get the current user, preferring impersonated user if available
+     */
+    getUser(): Promise<({
+        access_token: string;
+        profile: UserInfo;
+        impersonating: boolean;
+    }) | null>;
+    signinRedirect(args?: SigninRedirectArgs): Promise<void>;
+    signinPopup(args?: SigninPopupArgs): Promise<User>;
+    signinSilent(args?: SigninSilentArgs): Promise<User | null>;
+    signinCallback(): Promise<User | null>;
+    signoutRedirect(args?: SignoutRedirectArgs): Promise<void>;
+    /**
+     * Set impersonation with access token
+     */
+    setImpersonation(accessToken: string): void;
+    /**
+     * Clear impersonation and return to normal user
+     */
+    clearImpersonation(): void;
+    /**
+     * Handle impersonation callback from URL parameters
+     */
+    handleImpersonationCallback(urlStr: string): void;
+}

package/dist/oidc/oidc.d.ts

@@ -3,6 +3,7 @@ import { Context, ReactNode } from 'react';
 export * from 'oidc-client-ts';
 export * from './impersonate';
 export * from './firmAccess';
+export * from './AuthManager';
 export type AuthState = {
     user: User | null;
     isLoading: boolean;

package/dist/oidc.es.js

@@ -1,235 +1,328 @@
-import { jsx as C } from "react/jsx-runtime";
-import { createContext as x, useContext as E, useMemo as v, useEffect as h, useState as k, useRef as U, useCallback as d } from "react";
+var v = Object.defineProperty;
+var R = (t, e, r) => e in t ? v(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var g = (t, e, r) => R(t, typeof e != "symbol" ? e + "" : e, r);
+import { jsx as A } from "react/jsx-runtime";
+import { createContext as I, useContext as k, useMemo as U, useEffect as f, useState as L, useRef as x, useCallback as d } from "react";
+import { UserManager as P } from "oidc-client-ts";
 export * from "oidc-client-ts";
-import L from "use-local-storage-state";
-import { jwtDecode as P } from "jwt-decode";
-const I = x(
+import T from "use-local-storage-state";
+import { jwtDecode as y } from "jwt-decode";
+const E = I(
   null
-), g = () => {
-  const t = E(I);
+), b = () => {
+  const t = k(E);
   if (!t)
     throw new Error(
       "useImpersonationContext must be used within a ImpersonationContextProvider"
     );
   return t;
-}, z = ({
+}, V = ({
   children: t
 }) => {
-  const [e, c] = L("impersonationState", {
+  const [e, r] = T("impersonationState", {
     defaultValue: {}
-  }), s = v(() => ({
+  }), s = U(() => ({
     accessToken: e == null ? void 0 : e.accessToken,
     userInfo: e == null ? void 0 : e.userInfo,
-    setImpersonation: (n, o) => {
-      c({ accessToken: n, userInfo: o });
+    setImpersonation: (o, i) => {
+      r({ accessToken: o, userInfo: i });
     }
   }), []);
-  return /* @__PURE__ */ C(I.Provider, { value: s, children: t });
-}, N = (t) => {
-  const { setImpersonation: e } = g();
-  h(() => {
-    const { search: c } = window.location, s = new URLSearchParams(c).get(
+  return /* @__PURE__ */ A(E.Provider, { value: s, children: t });
+}, q = (t) => {
+  const { setImpersonation: e } = b();
+  f(() => {
+    const { search: r } = window.location, s = new URLSearchParams(r).get(
       "impersonateAccessToken"
     );
     if (s && e) {
-      const n = P(s);
-      e(s, n), t();
+      const o = y(s);
+      e(s, o), t();
     }
   }, []);
 };
-function V(t) {
+function B(t) {
   return JSON.parse(t).map((s) => {
     const [
-      n,
       o,
-      u,
       i,
+      u,
+      a,
       l
-    ] = s.split("|"), m = i.split(",");
+    ] = s.split("|"), m = a.split(",");
     return {
-      CustomerExternalId: n,
-      CustomerFirmId: o,
+      CustomerExternalId: o,
+      CustomerFirmId: i,
       CustomerFirmName: u,
       CustomerUserRoles: m,
       CustomerUserIsAdmin: l === "True" || l === "1"
     };
   });
 }
-const J = [
+const G = [
   "97",
   "131",
   "132",
   "141"
-], K = [
+], H = [
   "3"
-], _ = [
+], Q = [
   "0"
-], y = ({
+];
+class W {
+  constructor(e) {
+    g(this, "userManager");
+    g(this, "storageKey", "impersonationState");
+    this.userManager = new P(e);
+  }
+  /**
+   * Get impersonation user from localStorage
+   */
+  getImpersonationData() {
+    try {
+      const e = localStorage.getItem(this.storageKey);
+      if (e) {
+        const r = JSON.parse(e);
+        if (r.impersonationToken && r.impersonatedUser)
+          return r;
+      }
+    } catch (e) {
+      console.error("Failed to load impersonation from storage:", e);
+    }
+    return null;
+  }
+  /**
+   * Get the current user, preferring impersonated user if available
+   */
+  async getUser() {
+    const e = this.getImpersonationData();
+    if (e)
+      return {
+        access_token: e.impersonationToken,
+        profile: e.impersonatedUser,
+        impersonating: !0
+      };
+    const r = await this.userManager.getUser();
+    return !r || r.expired ? null : {
+      access_token: r.access_token,
+      profile: r.profile,
+      impersonating: !1
+    };
+  }
+  async signinRedirect(e) {
+    await this.userManager.signinRedirect(e);
+  }
+  async signinPopup(e) {
+    return await this.userManager.signinPopup(e);
+  }
+  async signinSilent(e) {
+    return await this.userManager.signinSilent(e);
+  }
+  async signinCallback() {
+    const e = await this.userManager.signinCallback();
+    return e || null;
+  }
+  async signoutRedirect(e) {
+    this.clearImpersonation(), await this.userManager.signoutRedirect(e);
+  }
+  // Impersonation methods
+  /**
+   * Set impersonation with access token
+   */
+  setImpersonation(e) {
+    try {
+      const s = {
+        impersonatedUser: y(e),
+        impersonationToken: e
+      };
+      localStorage.setItem(this.storageKey, JSON.stringify(s));
+    } catch (r) {
+      console.error("Failed to decode impersonation token:", r);
+    }
+  }
+  /**
+   * Clear impersonation and return to normal user
+   */
+  clearImpersonation() {
+    localStorage.removeItem(this.storageKey);
+  }
+  /**
+   * Handle impersonation callback from URL parameters
+   */
+  handleImpersonationCallback(e) {
+    const s = new URL(e).searchParams.get("impersonateAccessToken");
+    if (!s)
+      throw new Error("Missing url param 'impersonateAccessToken'");
+    this.setImpersonation(s);
+  }
+}
+const O = ({
   userManager: t,
   context: e,
-  children: c
+  children: r
 }) => {
-  const [s, n] = k({
+  const [s, o] = L({
     user: null,
     isLoading: !0,
     isAuthenticated: !1,
     isError: !1,
     error: null
-  }), o = U(!1);
-  h(() => {
-    o.current || (o.current = !0, (async () => {
+  }), i = x(!1);
+  f(() => {
+    i.current || (i.current = !0, (async () => {
       try {
-        const r = await t.getUser();
-        n({
-          user: r,
+        const n = await t.getUser();
+        o({
+          user: n,
           isLoading: !1,
-          isAuthenticated: r ? !r.expired : !1,
+          isAuthenticated: n ? !n.expired : !1,
           isError: !1,
           error: null
         });
-      } catch (r) {
-        n({
+      } catch (n) {
+        o({
           user: null,
           isLoading: !1,
           isAuthenticated: !1,
           isError: !0,
-          error: r instanceof Error ? r : new Error("Unknown error during auth")
+          error: n instanceof Error ? n : new Error("Unknown error during auth")
         });
       }
     })());
-  }, [t]), h(() => {
-    const r = (f) => {
-      n({
-        user: f,
+  }, [t]), f(() => {
+    const n = (p) => {
+      o({
+        user: p,
         isLoading: !1,
-        isAuthenticated: !f.expired,
+        isAuthenticated: !p.expired,
         isError: !1,
         error: null
       });
     };
-    t.events.addUserLoaded(r);
-    const a = () => {
-      n({
+    t.events.addUserLoaded(n);
+    const c = () => {
+      o({
         ...s,
         user: null,
         isAuthenticated: !1
       });
     };
-    t.events.addUserUnloaded(a);
-    const w = (f) => {
-      n({
+    t.events.addUserUnloaded(c);
+    const w = (p) => {
+      o({
         ...s,
         isLoading: !1,
         isError: !0,
-        error: f
+        error: p
       });
     };
     return t.events.addSilentRenewError(w), () => {
-      t.events.removeUserLoaded(r), t.events.removeUserUnloaded(a), t.events.removeSilentRenewError(w);
+      t.events.removeUserLoaded(n), t.events.removeUserUnloaded(c), t.events.removeSilentRenewError(w);
     };
   }, [t]);
   const u = d(async () => {
-    const r = await t.signinCallback();
-    return n({
-      user: r ?? null,
+    const n = await t.signinCallback();
+    return o({
+      user: n ?? null,
       isLoading: !1,
-      isAuthenticated: r ? !r.expired : !1,
+      isAuthenticated: n ? !n.expired : !1,
       isError: !1,
       error: null
-    }), r ?? void 0;
-  }, [t]), i = d(
-    async (r) => {
+    }), n ?? void 0;
+  }, [t]), a = d(
+    async (n) => {
       try {
-        await t.signinRedirect(r);
-      } catch (a) {
-        console.error(a);
+        await t.signinRedirect(n);
+      } catch (c) {
+        console.error(c);
       }
     },
     [t]
   ), l = d(
-    async (r) => await t.signinPopup(r),
+    async (n) => await t.signinPopup(n),
     [t]
   ), m = d(
-    async (r) => {
+    async (n) => {
       try {
-        return await t.signinSilent(r);
-      } catch (a) {
-        return n({
+        return await t.signinSilent(n);
+      } catch (c) {
+        return o({
           user: null,
           isLoading: !1,
           isAuthenticated: !1,
           isError: !0,
-          error: a instanceof Error ? a : new Error("Unknown error during silent signin")
+          error: c instanceof Error ? c : new Error("Unknown error during silent signin")
         }), null;
       }
     },
     [t]
-  ), A = d(
-    async (r) => {
+  ), h = d(
+    async (n) => {
       try {
-        await t.signoutRedirect(r);
-      } catch (a) {
-        console.error(a);
+        await t.signoutRedirect(n);
+      } catch (c) {
+        console.error(c);
       }
     },
     [t]
-  ), S = v(
+  ), S = U(
     () => ({
       state: s,
       handleSigninCallback: u,
-      redirectToSignin: i,
+      redirectToSignin: a,
       signinSilent: m,
       signinPopup: l,
-      logout: A
+      logout: h
     }),
     [
       s,
       u,
-      i,
+      a,
       m,
       l,
-      A
+      h
     ]
   );
-  return /* @__PURE__ */ C(e.Provider, { value: S, children: c });
-}, p = (t) => {
-  const e = E(t);
+  return /* @__PURE__ */ A(e.Provider, { value: S, children: r });
+}, C = (t) => {
+  const e = k(t);
   if (!e)
     throw new Error("useAuthContext must be used within an AuthProvider");
   return e;
-}, R = (t) => {
-  const { state: e } = p(t);
+}, F = (t) => {
+  const { state: e } = C(t);
   return e;
-}, b = (t, e) => {
-  const { state: c, handleSigninCallback: s } = p(t), n = U(!1);
-  return h(() => {
-    n.current || (n.current = !0, s().then(
-      (o) => new Promise(
-        (u) => setTimeout(() => u(o), 0)
+}, K = (t, e) => {
+  const { state: r, handleSigninCallback: s } = C(t), o = x(!1);
+  return f(() => {
+    o.current || (o.current = !0, s().then(
+      (i) => new Promise(
+        (u) => setTimeout(() => u(i), 0)
       )
-    ).then((o) => e == null ? void 0 : e(o)));
-  }, [s]), c;
-}, q = (t) => {
-  const e = x(null);
+    ).then((i) => e == null ? void 0 : e(i)));
+  }, [s]), r;
+}, X = (t) => {
+  const e = I(null);
   return {
     AuthContext: e,
-    AuthProvider: ({ children: i }) => /* @__PURE__ */ C(y, { userManager: t, context: e, children: i }),
-    useAuthContext: () => p(e),
-    useAuthState: () => R(e),
-    useSigninCallback: (i) => b(e, i),
+    AuthProvider: ({ children: a }) => /* @__PURE__ */ A(O, { userManager: t, context: e, children: a }),
+    useAuthContext: () => C(e),
+    useAuthState: () => F(e),
+    useSigninCallback: (a) => K(e, a),
     getAccessToken: async () => {
-      const i = await t.getUser();
-      return i ? i.access_token : null;
+      const a = await t.getUser();
+      return a ? a.access_token : null;
     }
   };
 };
 export {
-  z as ImpersonationContextProvider,
-  J as ROLESAdminInCompany,
-  _ as ROLESAnsatt,
-  K as ROLESMAKSAdministrator,
-  q as createAuthContext,
-  V as parseUserProfileFCString,
-  N as useImpersonationCallback,
-  g as useImpersonationContext
+  W as AuthManager,
+  V as ImpersonationContextProvider,
+  G as ROLESAdminInCompany,
+  Q as ROLESAnsatt,
+  H as ROLESMAKSAdministrator,
+  X as createAuthContext,
+  B as parseUserProfileFCString,
+  q as useImpersonationCallback,
+  b as useImpersonationContext
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkitektbedriftene/fe-lib",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "type": "module",
   "exports": {
     "./oidc": {