@caseparts-org/casecore 0.0.3 → 0.0.5

package/dist/src/lib/authentication/AuthContext.test.js

@@ -0,0 +1,214 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, waitFor, act } from '@testing-library/react';
+import { useAuthContext, default as AuthProvider } from './AuthContext';
+import { buildClaimsFromPayload } from '../utils/ClaimsUtils';
+// Dummy data for API responses
+const dummyEmployee = {
+    UserId: 'emp1',
+    UserName: 'employee@example.com',
+    NickName: 'Emp',
+    Branch: 'HQ',
+    Rights: 'VIEW,EDIT',
+};
+const dummyCustomer = {
+    UserName: 'customer@example.com',
+    UserId: 'cust1',
+    CustKey: 123,
+    CustId: 'C123',
+    CustName: 'Test Customer',
+    CustClass: 'Dealer',
+    FirstName: 'John',
+    LastName: 'Doe',
+    Address: '123 Main St',
+    City: 'Metropolis',
+    State: 'NY',
+    ZipCode: '10001',
+    Phone: '555-1234',
+    Hq: 'HQ',
+    HqCustKey: '456',
+    PaymentTerms: 'Net30',
+    LastLoginDate: '2024-01-01',
+    Rights: 'BUY,SELL',
+    PendingInvites: ['invite1'],
+    PrimaryAdmin: 'admin1',
+};
+const dummyJwtPayload = {
+    Time: 'now',
+    IpAddress: '127.0.0.1',
+    Origin: 'test',
+    UserType: 'Employee',
+    Customer: JSON.stringify(dummyCustomer),
+    Employee: JSON.stringify(dummyEmployee),
+    exp: 9999999999,
+    iss: 'issuer',
+};
+const dummyJwt = 'dummy.jwt.token';
+const guestDefaultClaims = {
+    Time: 'now',
+    IpAddress: '127.0.0.1',
+    Origin: 'test',
+    UserType: "Guest",
+    Customer: null,
+    Employee: null,
+    exp: 9999999999,
+    iss: 'issuer',
+};
+const guestJwtPayload = guestDefaultClaims;
+const guestJwt = 'guest.jwt.token';
+// Mock jwtDecode to just return our dummy payload
+vi.mock('jwt-decode', () => ({
+    jwtDecode: (jwt) => {
+        if (jwt === dummyJwt) {
+            return dummyJwtPayload;
+        }
+        else {
+            return guestJwtPayload;
+        }
+    }
+}));
+global.fetch = vi.fn();
+const urls = {
+    Login: '/api/login',
+    Logout: '/api/logout',
+    Impersonate: (email) => `/api/impersonate/${email}`,
+};
+const apiKey = 'test-api-key';
+const sessionClientId = 'test-session-id';
+function TestConsumer() {
+    const ctx = useAuthContext();
+    if (!ctx)
+        return _jsx("div", { children: "no context" });
+    return (_jsxs("div", { children: [_jsx("div", { "data-testid": "initialized", children: ctx.initialized }), _jsx("div", { "data-testid": "email", children: ctx.email }), _jsx("div", { "data-testid": "userType", children: ctx.userType }), _jsx("div", { "data-testid": "claims", children: JSON.stringify(ctx.claims) }), _jsx("button", { onClick: () => ctx.login('test@example.com', 'pw'), children: "Login" }), _jsx("button", { onClick: () => ctx.logout(), children: "Logout" }), _jsx("button", { onClick: () => ctx.impersonate('imp@example.com'), children: "Impersonate" })] }));
+}
+describe('AuthProvider', () => {
+    // Setup mock API endpoints
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Default fetch mock: login returns a dummy JWT string
+        global.fetch.mockImplementation((url, opts) => {
+            if (url.includes('/api/login')) {
+                // If no body or body does not include UserName/Password, return guest JWT
+                if (!opts?.body) {
+                    return Promise.resolve({
+                        status: 200,
+                        text: () => Promise.resolve('"' + guestJwt + '"'),
+                    });
+                }
+                try {
+                    const body = JSON.parse(opts.body);
+                    if (!body.UserName || !body.Password) {
+                        return Promise.resolve({
+                            status: 200,
+                            text: () => Promise.resolve('"' + guestJwt + '"'),
+                        });
+                    }
+                }
+                catch {
+                    // fallback to guest
+                    return Promise.resolve({
+                        status: 200,
+                        text: () => Promise.resolve('"' + guestJwt + '"'),
+                    });
+                }
+                // Otherwise, return employee/customer JWT
+                return Promise.resolve({
+                    status: 200,
+                    text: () => Promise.resolve('"' + dummyJwt + '"'),
+                });
+            }
+            if (url.includes('/api/impersonate')) {
+                return Promise.resolve({
+                    status: 200,
+                    text: () => Promise.resolve('"' + dummyJwt + '"'),
+                });
+            }
+            if (url.includes('/api/logout')) {
+                return Promise.resolve({
+                    status: 200,
+                    text: () => Promise.resolve(''),
+                });
+            }
+            return Promise.resolve({ status: 404, text: () => Promise.resolve('Not found') });
+        });
+        // Clear localStorage
+        window.localStorage.clear();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+        window.localStorage.clear();
+    });
+    // Tests
+    it('calls login on mount (useEffect) and sets state', async () => {
+        await act(async () => {
+            render(_jsx(AuthProvider, { urls: urls, apiKey: apiKey, sessionClientId: sessionClientId, children: _jsx(TestConsumer, {}) }));
+        });
+        await waitFor(() => {
+            expect(screen.getByTestId('initialized').textContent).toBe('OK');
+            expect(screen.getByTestId('email').textContent).toBe('');
+            expect(screen.getByTestId('userType').textContent).toBe('Guest');
+            expect(screen.getByTestId('claims').textContent).toContain('');
+        });
+    });
+    it('loads token from localStorage and sets state on mount', async () => {
+        // The key used by useLocalStorage (with CPC. prefix)
+        window.localStorage.setItem('CPC.token', JSON.stringify(dummyJwt));
+        await act(async () => {
+            render(_jsx(AuthProvider, { urls: urls, apiKey: apiKey, sessionClientId: sessionClientId, children: _jsx(TestConsumer, {}) }));
+        });
+        await waitFor(() => {
+            expect(screen.getByTestId('initialized').textContent).toBe('OK');
+            expect(screen.getByTestId('email').textContent).toBe('customer@example.com');
+            expect(screen.getByTestId('userType').textContent).toBe('Employee');
+            expect(screen.getByTestId('claims').textContent).toContain('customer@example.com');
+        });
+    });
+    it('login() sets state with new credentials', async () => {
+        render(_jsx(AuthProvider, { urls: urls, apiKey: apiKey, sessionClientId: sessionClientId, children: _jsx(TestConsumer, {}) }));
+        await act(async () => {
+            screen.getByText('Login').click();
+        });
+        await waitFor(() => {
+            expect(screen.getByTestId('initialized').textContent).toBe('OK');
+            expect(screen.getByTestId('email').textContent).toBe('customer@example.com');
+        });
+    });
+    it('impersonate() sets state with impersonated user', async () => {
+        render(_jsx(AuthProvider, { urls: urls, apiKey: apiKey, sessionClientId: sessionClientId, children: _jsx(TestConsumer, {}) }));
+        await act(async () => {
+            screen.getByText('Impersonate').click();
+        });
+        await waitFor(() => {
+            expect(screen.getByTestId('initialized').textContent).toBe('OK');
+            expect(screen.getByTestId('email').textContent).toBe('customer@example.com');
+        });
+    });
+    it('logout() resets state to guest', async () => {
+        render(_jsx(AuthProvider, { urls: urls, apiKey: apiKey, sessionClientId: sessionClientId, children: _jsx(TestConsumer, {}) }));
+        // First, login
+        await act(async () => {
+            screen.getByText('Login').click();
+        });
+        await waitFor(() => {
+            expect(screen.getByTestId('userType').textContent).toBe('Employee');
+        });
+        // Now, logout
+        await act(async () => {
+            screen.getByText('Logout').click();
+        });
+        await waitFor(async () => {
+            const userTypeDiv = await screen.findByTestId('userType');
+            expect(userTypeDiv.textContent).toBe('Guest');
+        });
+    });
+});
+describe('buildClaimsFromPayload', () => {
+    it('parses payload and normalizes claims', () => {
+        const claims = buildClaimsFromPayload(dummyJwtPayload);
+        expect(claims.Customer?.UserName).toBe('customer@example.com');
+        expect(claims.Employee?.UserName).toBe('employee@example.com');
+        expect(claims.UserType).toBe('Employee');
+        expect(Array.isArray(claims.Customer?.Rights)).toBe(true);
+        expect(Array.isArray(claims.Employee?.Rights)).toBe(true);
+    });
+});

package/dist/src/lib/authentication/AuthTypes.d.ts

@@ -0,0 +1,82 @@
+export type EmployeeResponse = {
+    UserId: string;
+    UserName: string;
+    NickName: string;
+    Branch: string;
+    Rights: string;
+};
+export type CustomerResponse = {
+    UserName: string;
+    UserId: string;
+    CustKey: number;
+    CustId: string;
+    CustName: string;
+    CustClass: string;
+    FirstName: string;
+    LastName: string;
+    Address: string;
+    City: string;
+    State: string;
+    ZipCode: string;
+    Phone: string;
+    HQ: string;
+    HQCustKey: string;
+    PaymentTerms: string;
+    LastLoginDate: string | null;
+    Rights: string;
+    PendingInvites: Invite[];
+    PrimaryAdmin: string;
+};
+export type InviteType = "NewAcctPrimary" | "Standard" | "Primary" | "LinkedStandard" | "LinkedPrimary";
+export type Invite = {
+    Id: string;
+    SenderEmail: string;
+    CustKey: number;
+    CustId: string;
+    CustName: string;
+    TargetEmail: string;
+    TargetUserId: string;
+    InviteType: InviteType | string;
+    Rights: string;
+    Status: string;
+    CreatedDate: string;
+};
+export type EmployeeClaims = {
+    UserId: string;
+    UserName: string;
+    NickName: string;
+    Branch: string | null;
+    Rights: string[];
+};
+export type CustomerClaims = {
+    UserName: string;
+    UserId: string;
+    CustKey: number;
+    CustId: string;
+    CustName: string;
+    CustClass: string;
+    FirstName: string;
+    LastName: string;
+    Address: string;
+    City: string;
+    State: string;
+    ZipCode: string;
+    Phone: string;
+    HQ: string | null;
+    HQCustKey: number;
+    PaymentTerms: string;
+    LastLoginDate: string;
+    Rights: string[];
+    PendingInvites: unknown[];
+    PrimaryAdmin: unknown | null;
+};
+export type Claims = {
+    Time: string;
+    IpAddress: string;
+    Origin: string;
+    UserType: "Guest" | "Employee" | "LinkedCustomer" | string;
+    Customer: CustomerClaims | null;
+    Employee: EmployeeClaims | null;
+    exp: number;
+    iss: string;
+};

package/dist/src/lib/authentication/AuthTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/src/lib/hooks/useLocalStorage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * React hook for managing a value in localStorage with a CPC-prefixed key.
+ *
+ * The key is automatically prefixed with "CPC." if not already present (case-insensitive).
+ *
+ * @template T The type of the value to store.
+ * @param {string} key - The key to use in localStorage. Will be prefixed with "CPC." if not already.
+ * @param {T} initialValue - The initial value to use if no value is found in localStorage.
+ * @returns {[T, (value?: T) => void]} A tuple containing the current value and a setter function.
+ *
+ * The setter function updates both state and localStorage. Passing `undefined` removes the item from localStorage.
+ * Passing `null` resets the value to the initial value.
+ */
+export default function useLocalStorage<T>(key: string, initialValue: T): [T, (_value?: T) => void];

package/dist/src/lib/hooks/useLocalStorage.js

@@ -0,0 +1,41 @@
+import { useState } from "react";
+function getPrefixedKey(key) {
+    return key.toLowerCase().startsWith("cpc.") ? key : "CPC." + key;
+}
+/**
+ * React hook for managing a value in localStorage with a CPC-prefixed key.
+ *
+ * The key is automatically prefixed with "CPC." if not already present (case-insensitive).
+ *
+ * @template T The type of the value to store.
+ * @param {string} key - The key to use in localStorage. Will be prefixed with "CPC." if not already.
+ * @param {T} initialValue - The initial value to use if no value is found in localStorage.
+ * @returns {[T, (value?: T) => void]} A tuple containing the current value and a setter function.
+ *
+ * The setter function updates both state and localStorage. Passing `undefined` removes the item from localStorage.
+ * Passing `null` resets the value to the initial value.
+ */
+export default function useLocalStorage(key, initialValue) {
+    const fullKey = getPrefixedKey(key);
+    const getStoredValue = () => {
+        try {
+            const item = window.localStorage.getItem(fullKey);
+            return item ? JSON.parse(item) : initialValue;
+        }
+        catch {
+            return initialValue;
+        }
+    };
+    const [storedValue, setStoredValue] = useState(getStoredValue);
+    const setValue = (value) => {
+        const denullified = value === null ? initialValue : value;
+        setStoredValue(denullified);
+        if (value === undefined) {
+            window.localStorage.removeItem(fullKey);
+        }
+        else {
+            window.localStorage.setItem(fullKey, JSON.stringify(denullified));
+        }
+    };
+    return [storedValue, setValue];
+}

package/dist/src/lib/hooks/useMicroFlex.d.ts

@@ -0,0 +1,28 @@
+type MicroFlexFieldSelectors = {
+    number: string;
+    securityCode: string;
+};
+type MicroFlexOptions = {
+    initializeForm: boolean;
+    apiURL: string;
+    fetchFn: (_url: string, _options?: RequestInit) => Promise<Response>;
+    fieldSelectors?: MicroFlexFieldSelectors;
+    styles?: Record<string, any>;
+    scriptUrl?: string;
+    setupInterval?: number;
+    onError?: (_error: unknown) => void;
+};
+type MicroFlexReturn = {
+    validate: () => Promise<string | undefined>;
+    cardToken: string | null;
+    cardError: string | null;
+    setupError: unknown;
+    autoCompleteData: unknown;
+};
+declare global {
+    interface Window {
+        Flex?: any;
+    }
+}
+export default function useMicroFlex({ initializeForm, apiURL, fetchFn, fieldSelectors, styles, scriptUrl, setupInterval, onError, }: MicroFlexOptions): MicroFlexReturn;
+export {};

package/dist/src/lib/hooks/useMicroFlex.js

@@ -0,0 +1,138 @@
+import { useState, useEffect, useRef } from "react";
+const defaultStyles = {
+    input: {
+        "font-size": "1rem",
+        "font-family": "Roboto, helvetica, tahoma, calibri, sans-serif",
+        color: "#555",
+        "line-height": "1rem",
+    },
+    ":focus": { color: "blue" },
+    ":disabled": { cursor: "not-allowed" },
+    valid: { color: "#3C763D" },
+    invalid: { color: "#A94442" },
+};
+const defaultFieldSelectors = { number: "#number", securityCode: "#securityCode" };
+const defaultScriptUrl = "https://flex.cybersource.com/cybersource/assets/microform/0.11/flex-microform.min.js";
+export default function useMicroFlex({ initializeForm, apiURL, fetchFn, fieldSelectors = defaultFieldSelectors, styles = defaultStyles, scriptUrl = defaultScriptUrl, setupInterval = 15 * 60 * 1000, onError, }) {
+    const [error, setError] = useState(null);
+    const [autoCompleteData, setAutoCompleteData] = useState(null);
+    const [setupError, setSetupError] = useState(null);
+    const [token, setToken] = useState(null);
+    const formRef = useRef(null);
+    useEffect(() => {
+        if (!initializeForm)
+            return;
+        const scriptLoaded = !!window.Flex;
+        if (!scriptLoaded) {
+            const script = document.createElement("script");
+            script.src = scriptUrl;
+            script.async = true;
+            script.onload = () => {
+                setupMicroform();
+            };
+            document.body.appendChild(script);
+        }
+        try {
+            setupMicroform();
+        }
+        catch {
+            // Script might not be loaded yet
+        }
+        const timerId = setInterval(() => setupMicroform(), setupInterval);
+        return () => {
+            clearInterval(timerId);
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [initializeForm, apiURL, scriptUrl]);
+    async function setupMicroform() {
+        if (!window.Flex)
+            return;
+        setToken(null);
+        setError(null);
+        let jwt;
+        try {
+            jwt = await fetchFn(apiURL, { method: "GET" })
+                .then((resp) => resp.text())
+                .catch((err) => {
+                setSetupError(err);
+                if (onError)
+                    onError(err);
+                return undefined;
+            });
+        }
+        catch (err) {
+            setSetupError(err);
+            if (onError)
+                onError(err);
+            return;
+        }
+        if (!jwt)
+            return;
+        try {
+            const flex = new window.Flex(jwt);
+            const microform = flex.microform({ styles });
+            formRef.current = microform;
+            const number = microform.createField("number");
+            const securityCode = microform.createField("securityCode");
+            number.on("autocomplete", function (data) {
+                setAutoCompleteData(data);
+                setToken(null);
+            });
+            securityCode.on("autocomplete", function (data) {
+                setAutoCompleteData(data);
+                setToken(null);
+            });
+            number.on("change", () => {
+                setToken(null);
+                setError(null);
+            });
+            securityCode.on("change", () => {
+                setToken(null);
+                setError(null);
+            });
+            number.load(fieldSelectors.number);
+            securityCode.load(fieldSelectors.securityCode);
+        }
+        catch (error) {
+            setSetupError(error);
+            if (onError)
+                onError(error);
+        }
+    }
+    function validate() {
+        return new Promise((resolve, reject) => {
+            if (!formRef.current) {
+                const err = new Error("Form reference is not available.");
+                if (onError)
+                    onError(err);
+                return reject(err);
+            }
+            formRef.current.createToken({}, function (error, token) {
+                let errorMessage = error?.message;
+                if (error && error.status === 429) {
+                    errorMessage = "Credit card could not be validated. Please refresh and try again.";
+                }
+                if (error && error.status === 400) {
+                    errorMessage = "Invalid credit card. Please double-check details.";
+                }
+                setError(errorMessage);
+                setToken(token);
+                if (error) {
+                    if (onError)
+                        onError(error);
+                    reject(new Error(errorMessage));
+                }
+                else {
+                    resolve(token);
+                }
+            });
+        });
+    }
+    return {
+        validate,
+        cardToken: token,
+        cardError: error,
+        setupError,
+        autoCompleteData,
+    };
+}

package/dist/src/lib/index.d.ts

@@ -0,0 +1,6 @@
+export type { AuthUrls, AuthContextType, AuthProviderProps, Credentials } from './authentication/AuthContext';
+export { default as AuthProvider, useAuthContext } from './authentication/AuthContext';
+export type { EmployeeResponse, CustomerResponse, InviteType, Invite, EmployeeClaims, CustomerClaims, Claims } from './authentication/AuthTypes';
+export { default as useLocalStorage } from './hooks/useLocalStorage';
+export { getSessionId } from './utils/SessionUtils';
+export { buildClaimsFromPayload } from './utils/ClaimsUtils';

package/dist/src/lib/index.js

@@ -0,0 +1,6 @@
+// Export AuthProvider as default and useAuthContext hook
+export { default as AuthProvider, useAuthContext } from './authentication/AuthContext';
+// Export utility hooks and functions
+export { default as useLocalStorage } from './hooks/useLocalStorage';
+export { getSessionId } from './utils/SessionUtils';
+export { buildClaimsFromPayload } from './utils/ClaimsUtils';

package/dist/src/lib/utils/ClaimsUtils.d.ts

@@ -0,0 +1,16 @@
+import { Claims } from "../authentication/AuthTypes";
+/**
+ * Converts a decoded JWT payload into a normalized Claims object for authentication.
+ *
+ * This function parses the nested Customer and Employee fields (if present) from the payload,
+ * normalizes their structure (including splitting comma-separated rights into arrays),
+ * and returns a Claims object suitable for use in authentication and authorization logic.
+ *
+ * - If the payload contains stringified JSON for Customer or Employee, they are parsed and normalized.
+ * - Rights fields are always returned as arrays of strings.
+ * - Handles missing or malformed fields gracefully, returning nulls or empty arrays as appropriate.
+ *
+ * @param payload - The decoded JWT payload as a plain object.
+ * @returns {Claims} The normalized Claims object with Customer and Employee claims, or nulls if not present.
+ */
+export declare function buildClaimsFromPayload(payload: Record<string, any>): Claims;

package/dist/src/lib/utils/ClaimsUtils.js

@@ -0,0 +1,76 @@
+/**
+ * Converts a decoded JWT payload into a normalized Claims object for authentication.
+ *
+ * This function parses the nested Customer and Employee fields (if present) from the payload,
+ * normalizes their structure (including splitting comma-separated rights into arrays),
+ * and returns a Claims object suitable for use in authentication and authorization logic.
+ *
+ * - If the payload contains stringified JSON for Customer or Employee, they are parsed and normalized.
+ * - Rights fields are always returned as arrays of strings.
+ * - Handles missing or malformed fields gracefully, returning nulls or empty arrays as appropriate.
+ *
+ * @param payload - The decoded JWT payload as a plain object.
+ * @returns {Claims} The normalized Claims object with Customer and Employee claims, or nulls if not present.
+ */
+export function buildClaimsFromPayload(payload) {
+    // Parse nested Customer and Employee using API response types
+    function parseNested(obj, name) {
+        if (obj && typeof obj === "object" && typeof obj[name] === "string" && obj[name].length > 0) {
+            return JSON.parse(obj[name]);
+        }
+        return "";
+    }
+    const customerRaw = parseNested(payload, "Customer");
+    const employeeRaw = parseNested(payload, "Employee");
+    // Convert EmployeeResponse to EmployeeClaims (normalize Rights)
+    let employeeClaims = null;
+    if (employeeRaw && typeof employeeRaw === "object") {
+        employeeClaims = {
+            UserId: employeeRaw.UserId,
+            UserName: employeeRaw.UserName,
+            NickName: employeeRaw.NickName,
+            Branch: employeeRaw.Branch ?? null,
+            Rights: typeof employeeRaw.Rights === "string"
+                ? employeeRaw.Rights.split(",").map((s) => s.trim())
+                : [],
+        };
+    }
+    // Convert CustomerResponse to CustomerClaims (normalize Rights, PendingInvites, etc.)
+    let customerClaims = null;
+    if (customerRaw && typeof customerRaw === "object") {
+        customerClaims = {
+            UserName: customerRaw.UserName,
+            UserId: customerRaw.UserId,
+            CustKey: customerRaw.CustKey,
+            CustId: customerRaw.CustId,
+            CustName: customerRaw.CustName,
+            CustClass: customerRaw.CustClass,
+            FirstName: customerRaw.FirstName,
+            LastName: customerRaw.LastName,
+            Address: customerRaw.Address,
+            City: customerRaw.City,
+            State: customerRaw.State,
+            ZipCode: customerRaw.ZipCode,
+            Phone: customerRaw.Phone,
+            HQ: customerRaw.HQ ?? null,
+            HQCustKey: typeof customerRaw.HQCustKey === "string" ? parseInt(customerRaw.HQCustKey, 10) : customerRaw.HQCustKey,
+            PaymentTerms: customerRaw.PaymentTerms,
+            LastLoginDate: customerRaw.LastLoginDate ?? "",
+            Rights: typeof customerRaw.Rights === "string"
+                ? customerRaw.Rights.split(",").map((s) => s.trim())
+                : [],
+            PendingInvites: customerRaw.PendingInvites ?? [],
+            PrimaryAdmin: customerRaw.PrimaryAdmin ?? null,
+        };
+    }
+    return {
+        Time: String(payload.Time ?? ""),
+        IpAddress: String(payload.IpAddress ?? ""),
+        Origin: String(payload.Origin ?? ""),
+        UserType: String(payload.UserType ?? "Guest"),
+        Customer: customerClaims,
+        Employee: employeeClaims,
+        exp: Number(payload.exp ?? 0),
+        iss: String(payload.iss ?? ""),
+    };
+}

package/dist/src/lib/utils/SessionUtils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Gets or creates a session ID stored in sessionStorage under a CPC-prefixed key.
+ *
+ * @param {string} clientId - The identifier to inject into the session key (e.g., 'CatBaker2').
+ * @returns {string} The session ID.
+ */
+export declare const getSessionId: (clientId: string) => string;

package/dist/src/lib/utils/SessionUtils.js

@@ -0,0 +1,18 @@
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Gets or creates a session ID stored in sessionStorage under a CPC-prefixed key.
+ *
+ * @param {string} clientId - The identifier to inject into the session key (e.g., 'CatBaker2').
+ * @returns {string} The session ID.
+ */
+export const getSessionId = (clientId) => {
+    const SESSION_ID_KEY = `CPC.${clientId}.SessionId`;
+    // Check if we already have a session ID
+    let sessionId = sessionStorage.getItem(SESSION_ID_KEY);
+    // If not, generate a new one and store it
+    if (!sessionId) {
+        sessionId = uuidv4();
+        sessionStorage.setItem(SESSION_ID_KEY, sessionId);
+    }
+    return sessionId;
+};

package/dist/src/local/impersonate/Impersonate.d.ts

@@ -0,0 +1 @@
+export default function Impersonate(): import("react/jsx-runtime").JSX.Element;