@hamak/auth 0.5.1

package/dist/impl/storage/SessionTokenStorage.js

@@ -0,0 +1,147 @@
+/**
+ * Session Storage Token Storage Implementation
+ * Persists tokens using browser sessionStorage (cleared when tab closes)
+ */
+/**
+ * Storage keys
+ */
+const STORAGE_KEYS = {
+    ACCESS_TOKEN: 'accessToken',
+    REFRESH_TOKEN: 'refreshToken',
+    EXPIRES_AT: 'expiresAt',
+    TOKEN_TYPE: 'tokenType',
+    SCOPE: 'scope',
+    USER: 'user'
+};
+/**
+ * Token storage implementation using sessionStorage
+ * Tokens are cleared when the browser tab is closed
+ */
+export class SessionTokenStorage {
+    constructor(config = {}) {
+        this.keyPrefix = config.keyPrefix || '@hamak/auth';
+    }
+    getKey(key) {
+        return `${this.keyPrefix}:${key}`;
+    }
+    getItem(key) {
+        try {
+            return sessionStorage.getItem(this.getKey(key));
+        }
+        catch {
+            return null;
+        }
+    }
+    setItem(key, value) {
+        try {
+            sessionStorage.setItem(this.getKey(key), value);
+        }
+        catch {
+            console.warn('Failed to store item in sessionStorage:', key);
+        }
+    }
+    removeItem(key) {
+        try {
+            sessionStorage.removeItem(this.getKey(key));
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    getAccessToken() {
+        return this.getItem(STORAGE_KEYS.ACCESS_TOKEN);
+    }
+    setAccessToken(token, expiresAt) {
+        this.setItem(STORAGE_KEYS.ACCESS_TOKEN, token);
+        if (expiresAt !== undefined) {
+            this.setItem(STORAGE_KEYS.EXPIRES_AT, String(expiresAt));
+        }
+    }
+    getRefreshToken() {
+        return this.getItem(STORAGE_KEYS.REFRESH_TOKEN);
+    }
+    setRefreshToken(token) {
+        this.setItem(STORAGE_KEYS.REFRESH_TOKEN, token);
+    }
+    getTokens() {
+        const accessToken = this.getAccessToken();
+        if (!accessToken) {
+            return null;
+        }
+        const expiresAtStr = this.getItem(STORAGE_KEYS.EXPIRES_AT);
+        const scopeStr = this.getItem(STORAGE_KEYS.SCOPE);
+        return {
+            accessToken,
+            refreshToken: this.getRefreshToken() || undefined,
+            tokenType: this.getItem(STORAGE_KEYS.TOKEN_TYPE) || 'Bearer',
+            expiresAt: expiresAtStr ? parseInt(expiresAtStr, 10) : undefined,
+            scope: scopeStr ? JSON.parse(scopeStr) : undefined
+        };
+    }
+    setTokens(tokens) {
+        this.setAccessToken(tokens.accessToken, tokens.expiresAt);
+        if (tokens.refreshToken) {
+            this.setRefreshToken(tokens.refreshToken);
+        }
+        if (tokens.tokenType) {
+            this.setItem(STORAGE_KEYS.TOKEN_TYPE, tokens.tokenType);
+        }
+        if (tokens.scope) {
+            this.setItem(STORAGE_KEYS.SCOPE, JSON.stringify(tokens.scope));
+        }
+    }
+    clearTokens() {
+        this.removeItem(STORAGE_KEYS.ACCESS_TOKEN);
+        this.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
+        this.removeItem(STORAGE_KEYS.EXPIRES_AT);
+        this.removeItem(STORAGE_KEYS.TOKEN_TYPE);
+        this.removeItem(STORAGE_KEYS.SCOPE);
+    }
+    isTokenExpired() {
+        const accessToken = this.getAccessToken();
+        if (!accessToken) {
+            return true;
+        }
+        const expiresAt = this.getTokenExpiry();
+        if (!expiresAt) {
+            return false;
+        }
+        return Date.now() >= expiresAt;
+    }
+    isTokenExpiringSoon(thresholdMs) {
+        const expiresAt = this.getTokenExpiry();
+        if (!expiresAt) {
+            return false;
+        }
+        return Date.now() + thresholdMs >= expiresAt;
+    }
+    getTokenExpiry() {
+        const expiresAtStr = this.getItem(STORAGE_KEYS.EXPIRES_AT);
+        if (!expiresAtStr) {
+            return null;
+        }
+        return parseInt(expiresAtStr, 10);
+    }
+    getUser() {
+        const userStr = this.getItem(STORAGE_KEYS.USER);
+        if (!userStr) {
+            return null;
+        }
+        try {
+            return JSON.parse(userStr);
+        }
+        catch {
+            return null;
+        }
+    }
+    setUser(user) {
+        this.setItem(STORAGE_KEYS.USER, JSON.stringify(user));
+    }
+    clearUser() {
+        this.removeItem(STORAGE_KEYS.USER);
+    }
+    clearAll() {
+        this.clearTokens();
+        this.clearUser();
+    }
+}

package/dist/impl/storage/index.d.ts

@@ -0,0 +1,10 @@
+export * from './LocalTokenStorage';
+export * from './SessionTokenStorage';
+export * from './MemoryTokenStorage';
+import type { TokenStorageType } from '../../api';
+import type { ITokenStorage, TokenStorageConfig } from '../../spi';
+/**
+ * Factory function to create a token storage based on type
+ */
+export declare function createTokenStorage(type: TokenStorageType, config?: TokenStorageConfig): ITokenStorage;
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AAErC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAKnE;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,gBAAgB,EACtB,MAAM,CAAC,EAAE,kBAAkB,GAC1B,aAAa,CAgBf"}

package/dist/impl/storage/index.js

@@ -0,0 +1,26 @@
+export * from './LocalTokenStorage';
+export * from './SessionTokenStorage';
+export * from './MemoryTokenStorage';
+import { LocalTokenStorage } from './LocalTokenStorage';
+import { SessionTokenStorage } from './SessionTokenStorage';
+import { MemoryTokenStorage } from './MemoryTokenStorage';
+/**
+ * Factory function to create a token storage based on type
+ */
+export function createTokenStorage(type, config) {
+    switch (type) {
+        case 'localStorage':
+            return new LocalTokenStorage(config);
+        case 'sessionStorage':
+            return new SessionTokenStorage(config);
+        case 'memory':
+            return new MemoryTokenStorage();
+        case 'cookie':
+            // Cookie storage would require additional implementation
+            // Fall back to localStorage for now
+            console.warn('Cookie storage not implemented, falling back to localStorage');
+            return new LocalTokenStorage(config);
+        default:
+            return new LocalTokenStorage(config);
+    }
+}

package/dist/impl/store/auth-reducer.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Auth Redux Reducer
+ * State management for authentication
+ */
+import type { AuthError, User } from '../../api';
+/**
+ * Auth state shape
+ */
+export interface AuthState {
+    /** Whether the user is authenticated */
+    isAuthenticated: boolean;
+    /** The current user */
+    user: User | null;
+    /** Whether an auth operation is in progress */
+    loading: boolean;
+    /** The last auth error */
+    error: AuthError | null;
+    /** Whether the auth service has been initialized */
+    initialized: boolean;
+}
+/**
+ * Auth action types
+ */
+export declare const AUTH_ACTION_TYPES: {
+    readonly INIT: "@hamak/auth/INIT";
+    readonly INIT_SUCCESS: "@hamak/auth/INIT_SUCCESS";
+    readonly INIT_FAILURE: "@hamak/auth/INIT_FAILURE";
+    readonly LOGIN_REQUEST: "@hamak/auth/LOGIN_REQUEST";
+    readonly LOGIN_SUCCESS: "@hamak/auth/LOGIN_SUCCESS";
+    readonly LOGIN_FAILURE: "@hamak/auth/LOGIN_FAILURE";
+    readonly LOGOUT: "@hamak/auth/LOGOUT";
+    readonly TOKEN_REFRESH: "@hamak/auth/TOKEN_REFRESH";
+    readonly TOKEN_REFRESH_SUCCESS: "@hamak/auth/TOKEN_REFRESH_SUCCESS";
+    readonly TOKEN_REFRESH_FAILURE: "@hamak/auth/TOKEN_REFRESH_FAILURE";
+    readonly SESSION_EXPIRED: "@hamak/auth/SESSION_EXPIRED";
+    readonly UPDATE_USER: "@hamak/auth/UPDATE_USER";
+    readonly CLEAR_ERROR: "@hamak/auth/CLEAR_ERROR";
+};
+/**
+ * Auth action types
+ */
+export type AuthActionType = (typeof AUTH_ACTION_TYPES)[keyof typeof AUTH_ACTION_TYPES];
+/**
+ * Auth actions
+ */
+export type AuthAction = {
+    type: typeof AUTH_ACTION_TYPES.INIT;
+} | {
+    type: typeof AUTH_ACTION_TYPES.INIT_SUCCESS;
+    payload: {
+        user: User | null;
+        isAuthenticated: boolean;
+    };
+} | {
+    type: typeof AUTH_ACTION_TYPES.INIT_FAILURE;
+    payload: AuthError;
+} | {
+    type: typeof AUTH_ACTION_TYPES.LOGIN_REQUEST;
+} | {
+    type: typeof AUTH_ACTION_TYPES.LOGIN_SUCCESS;
+    payload: {
+        user: User;
+    };
+} | {
+    type: typeof AUTH_ACTION_TYPES.LOGIN_FAILURE;
+    payload: AuthError;
+} | {
+    type: typeof AUTH_ACTION_TYPES.LOGOUT;
+} | {
+    type: typeof AUTH_ACTION_TYPES.TOKEN_REFRESH;
+} | {
+    type: typeof AUTH_ACTION_TYPES.TOKEN_REFRESH_SUCCESS;
+    payload: {
+        user?: User;
+    };
+} | {
+    type: typeof AUTH_ACTION_TYPES.TOKEN_REFRESH_FAILURE;
+    payload: AuthError;
+} | {
+    type: typeof AUTH_ACTION_TYPES.SESSION_EXPIRED;
+} | {
+    type: typeof AUTH_ACTION_TYPES.UPDATE_USER;
+    payload: User;
+} | {
+    type: typeof AUTH_ACTION_TYPES.CLEAR_ERROR;
+};
+/**
+ * Auth reducer
+ */
+export declare function authReducer(state: AuthState | undefined, action: AuthAction): AuthState;
+/**
+ * Action creators
+ */
+export declare const authActions: {
+    init: () => AuthAction;
+    initSuccess: (user: User | null, isAuthenticated: boolean) => AuthAction;
+    initFailure: (error: AuthError) => AuthAction;
+    loginRequest: () => AuthAction;
+    loginSuccess: (user: User) => AuthAction;
+    loginFailure: (error: AuthError) => AuthAction;
+    logout: () => AuthAction;
+    tokenRefresh: () => AuthAction;
+    tokenRefreshSuccess: (user?: User) => AuthAction;
+    tokenRefreshFailure: (error: AuthError) => AuthAction;
+    sessionExpired: () => AuthAction;
+    updateUser: (user: User) => AuthAction;
+    clearError: () => AuthAction;
+};
+/**
+ * Selectors
+ */
+export declare const authSelectors: {
+    selectIsAuthenticated: (state: {
+        auth: AuthState;
+    }) => boolean;
+    selectUser: (state: {
+        auth: AuthState;
+    }) => User | null;
+    selectIsLoading: (state: {
+        auth: AuthState;
+    }) => boolean;
+    selectError: (state: {
+        auth: AuthState;
+    }) => AuthError | null;
+    selectIsInitialized: (state: {
+        auth: AuthState;
+    }) => boolean;
+    selectRoles: (state: {
+        auth: AuthState;
+    }) => string[];
+    selectPermissions: (state: {
+        auth: AuthState;
+    }) => string[];
+};
+//# sourceMappingURL=auth-reducer.d.ts.map

package/dist/impl/store/auth-reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-reducer.d.ts","sourceRoot":"","sources":["../../../src/impl/store/auth-reducer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,wCAAwC;IACxC,eAAe,EAAE,OAAO,CAAC;IACzB,uBAAuB;IACvB,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClB,+CAA+C;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,0BAA0B;IAC1B,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACxB,oDAAoD;IACpD,WAAW,EAAE,OAAO,CAAC;CACtB;AAaD;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;CAcpB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC;AAExF;;GAEG;AACH,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,IAAI,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,YAAY,CAAC;IAAC,OAAO,EAAE;QAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;QAAC,eAAe,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,GACzG;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,YAAY,CAAC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAE,GACnE;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,aAAa,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,aAAa,CAAC;IAAC,OAAO,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,CAAA;CAAE,GACzE;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,aAAa,CAAC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAE,GACpE;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,aAAa,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,qBAAqB,CAAC;IAAC,OAAO,EAAE;QAAE,IAAI,CAAC,EAAE,IAAI,CAAA;KAAE,CAAA;CAAE,GAClF;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,qBAAqB,CAAC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAE,GAC5E;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,eAAe,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,WAAW,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,OAAO,iBAAiB,CAAC,WAAW,CAAA;CAAE,CAAC;AAEnD;;GAEG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,YAAe,EAC/B,MAAM,EAAE,UAAU,GACjB,SAAS,CAyGX;AAED;;GAEG;AACH,eAAO,MAAM,WAAW;gBACZ,UAAU;wBAEA,IAAI,GAAG,IAAI,mBAAmB,OAAO,KAAG,UAAU;yBAKjD,SAAS,KAAG,UAAU;wBAKzB,UAAU;yBAEP,IAAI,KAAG,UAAU;0BAKhB,SAAS,KAAG,UAAU;kBAKhC,UAAU;wBAEJ,UAAU;iCAEC,IAAI,KAAG,UAAU;iCAKjB,SAAS,KAAG,UAAU;0BAK/B,UAAU;uBAEX,IAAI,KAAG,UAAU;sBAKpB,UAAU;CAC3B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa;mCACO;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,KAAG,OAAO;wBAGxC;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,KAAG,IAAI,GAAG,IAAI;6BAG5B;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,KAAG,OAAO;yBAGjC;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,KAAG,SAAS,GAAG,IAAI;iCAG9B;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,KAAG,OAAO;yBAGrC;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,KAAG,MAAM,EAAE;+BAGxB;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,KAAG,MAAM,EAAE;CAE1D,CAAC"}

package/dist/impl/store/auth-reducer.js

@@ -0,0 +1,179 @@
+/**
+ * Auth Redux Reducer
+ * State management for authentication
+ */
+/**
+ * Initial auth state
+ */
+const initialState = {
+    isAuthenticated: false,
+    user: null,
+    loading: false,
+    error: null,
+    initialized: false
+};
+/**
+ * Auth action types
+ */
+export const AUTH_ACTION_TYPES = {
+    INIT: '@hamak/auth/INIT',
+    INIT_SUCCESS: '@hamak/auth/INIT_SUCCESS',
+    INIT_FAILURE: '@hamak/auth/INIT_FAILURE',
+    LOGIN_REQUEST: '@hamak/auth/LOGIN_REQUEST',
+    LOGIN_SUCCESS: '@hamak/auth/LOGIN_SUCCESS',
+    LOGIN_FAILURE: '@hamak/auth/LOGIN_FAILURE',
+    LOGOUT: '@hamak/auth/LOGOUT',
+    TOKEN_REFRESH: '@hamak/auth/TOKEN_REFRESH',
+    TOKEN_REFRESH_SUCCESS: '@hamak/auth/TOKEN_REFRESH_SUCCESS',
+    TOKEN_REFRESH_FAILURE: '@hamak/auth/TOKEN_REFRESH_FAILURE',
+    SESSION_EXPIRED: '@hamak/auth/SESSION_EXPIRED',
+    UPDATE_USER: '@hamak/auth/UPDATE_USER',
+    CLEAR_ERROR: '@hamak/auth/CLEAR_ERROR'
+};
+/**
+ * Auth reducer
+ */
+export function authReducer(state = initialState, action) {
+    switch (action.type) {
+        case AUTH_ACTION_TYPES.INIT:
+            return {
+                ...state,
+                loading: true,
+                error: null
+            };
+        case AUTH_ACTION_TYPES.INIT_SUCCESS:
+            return {
+                ...state,
+                loading: false,
+                initialized: true,
+                isAuthenticated: action.payload.isAuthenticated,
+                user: action.payload.user,
+                error: null
+            };
+        case AUTH_ACTION_TYPES.INIT_FAILURE:
+            return {
+                ...state,
+                loading: false,
+                initialized: true,
+                isAuthenticated: false,
+                user: null,
+                error: action.payload
+            };
+        case AUTH_ACTION_TYPES.LOGIN_REQUEST:
+            return {
+                ...state,
+                loading: true,
+                error: null
+            };
+        case AUTH_ACTION_TYPES.LOGIN_SUCCESS:
+            return {
+                ...state,
+                loading: false,
+                isAuthenticated: true,
+                user: action.payload.user,
+                error: null
+            };
+        case AUTH_ACTION_TYPES.LOGIN_FAILURE:
+            return {
+                ...state,
+                loading: false,
+                isAuthenticated: false,
+                user: null,
+                error: action.payload
+            };
+        case AUTH_ACTION_TYPES.LOGOUT:
+            return {
+                ...initialState,
+                initialized: true
+            };
+        case AUTH_ACTION_TYPES.TOKEN_REFRESH:
+            return {
+                ...state,
+                // Don't set loading for background refresh
+                error: null
+            };
+        case AUTH_ACTION_TYPES.TOKEN_REFRESH_SUCCESS:
+            return {
+                ...state,
+                user: action.payload.user || state.user,
+                error: null
+            };
+        case AUTH_ACTION_TYPES.TOKEN_REFRESH_FAILURE:
+            return {
+                ...state,
+                error: action.payload
+            };
+        case AUTH_ACTION_TYPES.SESSION_EXPIRED:
+            return {
+                ...initialState,
+                initialized: true,
+                error: {
+                    code: 'token_expired',
+                    message: 'Your session has expired. Please login again.'
+                }
+            };
+        case AUTH_ACTION_TYPES.UPDATE_USER:
+            return {
+                ...state,
+                user: action.payload
+            };
+        case AUTH_ACTION_TYPES.CLEAR_ERROR:
+            return {
+                ...state,
+                error: null
+            };
+        default:
+            return state;
+    }
+}
+/**
+ * Action creators
+ */
+export const authActions = {
+    init: () => ({ type: AUTH_ACTION_TYPES.INIT }),
+    initSuccess: (user, isAuthenticated) => ({
+        type: AUTH_ACTION_TYPES.INIT_SUCCESS,
+        payload: { user, isAuthenticated }
+    }),
+    initFailure: (error) => ({
+        type: AUTH_ACTION_TYPES.INIT_FAILURE,
+        payload: error
+    }),
+    loginRequest: () => ({ type: AUTH_ACTION_TYPES.LOGIN_REQUEST }),
+    loginSuccess: (user) => ({
+        type: AUTH_ACTION_TYPES.LOGIN_SUCCESS,
+        payload: { user }
+    }),
+    loginFailure: (error) => ({
+        type: AUTH_ACTION_TYPES.LOGIN_FAILURE,
+        payload: error
+    }),
+    logout: () => ({ type: AUTH_ACTION_TYPES.LOGOUT }),
+    tokenRefresh: () => ({ type: AUTH_ACTION_TYPES.TOKEN_REFRESH }),
+    tokenRefreshSuccess: (user) => ({
+        type: AUTH_ACTION_TYPES.TOKEN_REFRESH_SUCCESS,
+        payload: { user }
+    }),
+    tokenRefreshFailure: (error) => ({
+        type: AUTH_ACTION_TYPES.TOKEN_REFRESH_FAILURE,
+        payload: error
+    }),
+    sessionExpired: () => ({ type: AUTH_ACTION_TYPES.SESSION_EXPIRED }),
+    updateUser: (user) => ({
+        type: AUTH_ACTION_TYPES.UPDATE_USER,
+        payload: user
+    }),
+    clearError: () => ({ type: AUTH_ACTION_TYPES.CLEAR_ERROR })
+};
+/**
+ * Selectors
+ */
+export const authSelectors = {
+    selectIsAuthenticated: (state) => state.auth.isAuthenticated,
+    selectUser: (state) => state.auth.user,
+    selectIsLoading: (state) => state.auth.loading,
+    selectError: (state) => state.auth.error,
+    selectIsInitialized: (state) => state.auth.initialized,
+    selectRoles: (state) => state.auth.user?.roles || [],
+    selectPermissions: (state) => state.auth.user?.permissions || []
+};

package/dist/impl/store/index.d.ts

@@ -0,0 +1,2 @@
+export * from './auth-reducer';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/store/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/impl/store/index.js

@@ -0,0 +1 @@
+export * from './auth-reducer';

package/dist/impl/strategies/KeycloakStrategy.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Keycloak Authentication Strategy
+ * Implements authentication with Keycloak identity provider
+ */
+import type { AuthResult, KeycloakStrategyConfig, LoginCredentials, OAuthCallbackParams, User } from '../../api';
+import type { IDirectAuthStrategy, IOAuthStrategy, IHttpClient } from '../../spi';
+/**
+ * Keycloak authentication strategy
+ *
+ * Extends OAuth2 strategy with Keycloak-specific features:
+ * - Direct grant (password) authentication
+ * - Role extraction from JWT tokens
+ * - Keycloak realm and resource roles
+ * - Proper logout with session invalidation
+ */
+export declare class KeycloakStrategy implements IOAuthStrategy, IDirectAuthStrategy {
+    private readonly config;
+    private readonly httpClient;
+    readonly type: "keycloak";
+    readonly name: string;
+    private readonly oauth2;
+    private readonly baseUrl;
+    private readonly tokenUrl;
+    private readonly logoutUrl;
+    constructor(config: KeycloakStrategyConfig, httpClient: IHttpClient, name?: string);
+    getAuthorizationUrl(): Promise<string>;
+    handleCallback(params: OAuthCallbackParams): Promise<AuthResult>;
+    authenticate(credentials: LoginCredentials): Promise<AuthResult>;
+    authenticateDirect(username: string, password: string): Promise<AuthResult>;
+    refreshToken(refreshToken: string): Promise<AuthResult>;
+    logout(accessToken: string): Promise<void>;
+    /**
+     * Logout with refresh token for complete session invalidation
+     */
+    logoutWithRefreshToken(refreshToken: string): Promise<void>;
+    getStoredState(): string | null;
+    clearOAuthState(): void;
+    extractUserFromToken(token: string): User | null;
+    private extractUserWithRoles;
+    private handleKeycloakError;
+}
+//# sourceMappingURL=KeycloakStrategy.d.ts.map

package/dist/impl/strategies/KeycloakStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeycloakStrategy.d.ts","sourceRoot":"","sources":["../../../src/impl/strategies/KeycloakStrategy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,IAAI,EACL,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAkBlF;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,YAAW,cAAc,EAAE,mBAAmB;IAUxE,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAV7B,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAU;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAGhB,MAAM,EAAE,sBAAsB,EAC9B,UAAU,EAAE,WAAW,EACxC,IAAI,SAAa;IAyBb,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAItC,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAWhE,YAAY,CAAC,WAAW,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IAuBhE,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IA+C3E,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAmCvD,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBhD;;OAEG;IACG,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBjE,cAAc,IAAI,MAAM,GAAG,IAAI;IAI/B,eAAe,IAAI,IAAI;IAIvB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAIhD,OAAO,CAAC,oBAAoB;IAK5B,OAAO,CAAC,mBAAmB;CA8D5B"}