@finspringinnovations/fdsdk 0.0.1

package/lib/state/paymentSession.d.ts

@@ -0,0 +1,8 @@
+export declare function setPaymentSession(params: {
+    paymentUrl?: string;
+    transactionId?: string;
+}): void;
+export declare function getPaymentSession(): {
+    paymentUrl: string | undefined;
+    transactionId: string | undefined;
+};

package/lib/state/paymentSession.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPaymentSession = setPaymentSession;
+exports.getPaymentSession = getPaymentSession;
+let lastPaymentUrl;
+let lastTransactionId;
+function setPaymentSession(params) {
+    lastPaymentUrl = params.paymentUrl;
+    lastTransactionId = params.transactionId;
+}
+function getPaymentSession() {
+    return { paymentUrl: lastPaymentUrl, transactionId: lastTransactionId };
+}

package/lib/store/fdListSelectedSlice.d.ts

@@ -0,0 +1,21 @@
+export interface FDListSelectedData {
+    id: string;
+    providerId: string;
+    name: string;
+    accountNumber: string;
+    roi: string;
+    tenure: string;
+    amount: number;
+    maturityDate: string;
+    status: 'active' | 'matured' | 'pending';
+    creditRating: string;
+    companyName: string;
+    fdRate: string;
+    interestPayout: string;
+}
+export declare const setFDListSelected: import("@reduxjs/toolkit").ActionCreatorWithPayload<FDListSelectedData, "fdListSelected/setFDListSelected">, clearFDListSelected: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"fdListSelected/clearFDListSelected">, updateFDListSelectedField: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    field: keyof FDListSelectedData;
+    value: any;
+}, "fdListSelected/updateFDListSelectedField">;
+declare const _default: import("redux").Reducer<any>;
+export default _default;

package/lib/store/fdListSelectedSlice.js

@@ -0,0 +1,26 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateFDListSelectedField = exports.clearFDListSelected = exports.setFDListSelected = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const initialState = null;
+const fdListSelectedSlice = (0, toolkit_1.createSlice)({
+    name: 'fdListSelected',
+    initialState: initialState,
+    reducers: {
+        setFDListSelected: (state, action) => {
+            // Replace the entire state with the new payload
+            return action.payload;
+        },
+        clearFDListSelected: (state) => {
+            return null;
+        },
+        updateFDListSelectedField: (state, action) => {
+            if (state) {
+                state[action.payload.field] = action.payload.value;
+            }
+        },
+    },
+});
+_a = fdListSelectedSlice.actions, exports.setFDListSelected = _a.setFDListSelected, exports.clearFDListSelected = _a.clearFDListSelected, exports.updateFDListSelectedField = _a.updateFDListSelectedField;
+exports.default = fdListSelectedSlice.reducer;

package/lib/store/hooks.d.ts

@@ -0,0 +1,8 @@
+import { TypedUseSelectorHook } from 'react-redux';
+import type { RootState } from './store';
+export declare const useAppDispatch: () => import("redux-thunk").ThunkDispatch<{
+    shriramApi: import("@reduxjs/toolkit/query").CombinedState<{}, "InterestRate", "shriramApi">;
+    onboarding: import("./onboardingSlice").OnboardingIds;
+    fdListSelected: any;
+}, undefined, import("redux").UnknownAction> & import("redux").Dispatch<import("redux").UnknownAction>;
+export declare const useAppSelector: TypedUseSelectorHook<RootState>;

package/lib/store/hooks.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppSelector = exports.useAppDispatch = void 0;
+const react_redux_1 = require("react-redux");
+// Use throughout your app instead of plain `useDispatch` and `useSelector`
+// ✅ These hooks automatically use the nearest Redux Provider's store
+// Since SDK screens are wrapped in ApiProvider, they will use SDK's store
+const useAppDispatch = () => {
+    try {
+        return (0, react_redux_1.useDispatch)();
+    }
+    catch (error) {
+        if (__DEV__) {
+            console.error('❌ [useAppDispatch] Error: Component must be wrapped in ApiProvider', error);
+        }
+        throw error;
+    }
+};
+exports.useAppDispatch = useAppDispatch;
+const useAppSelector = (selector) => {
+    try {
+        return (0, react_redux_1.useSelector)(selector);
+    }
+    catch (error) {
+        if (__DEV__) {
+            console.error('❌ [useAppSelector] Error: Component must be wrapped in ApiProvider', error);
+        }
+        throw error;
+    }
+};
+exports.useAppSelector = useAppSelector;

package/lib/store/index.d.ts

@@ -0,0 +1,3 @@
+export { store } from './store';
+export { useAppDispatch, useAppSelector } from './hooks';
+export type { RootState, AppDispatch } from './store';

package/lib/store/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppSelector = exports.useAppDispatch = exports.store = void 0;
+var store_1 = require("./store");
+Object.defineProperty(exports, "store", { enumerable: true, get: function () { return store_1.store; } });
+var hooks_1 = require("./hooks");
+Object.defineProperty(exports, "useAppDispatch", { enumerable: true, get: function () { return hooks_1.useAppDispatch; } });
+Object.defineProperty(exports, "useAppSelector", { enumerable: true, get: function () { return hooks_1.useAppSelector; } });

package/lib/store/onboardingSlice.d.ts

@@ -0,0 +1,12 @@
+export interface OnboardingIds {
+    workflowInstanceId?: string;
+    applicationId?: string;
+    entityid?: string;
+    customerId?: string;
+    fdId?: string;
+    providerId?: string;
+    wfStatus?: string;
+}
+export declare const setOnboardingIds: import("@reduxjs/toolkit").ActionCreatorWithPayload<OnboardingIds, "onboarding/setOnboardingIds">, clearOnboardingIds: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"onboarding/clearOnboardingIds">;
+declare const _default: import("redux").Reducer<OnboardingIds>;
+export default _default;

package/lib/store/onboardingSlice.js

@@ -0,0 +1,32 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearOnboardingIds = exports.setOnboardingIds = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const initialState = {};
+const onboardingSlice = (0, toolkit_1.createSlice)({
+    name: 'onboarding',
+    initialState,
+    reducers: {
+        setOnboardingIds: (state, action) => {
+            const { workflowInstanceId, applicationId, entityid, customerId, fdId, providerId, wfStatus } = action.payload;
+            if (workflowInstanceId)
+                state.workflowInstanceId = workflowInstanceId;
+            if (applicationId)
+                state.applicationId = applicationId;
+            if (entityid)
+                state.entityid = entityid;
+            if (customerId)
+                state.customerId = customerId;
+            if (fdId)
+                state.fdId = fdId;
+            if (providerId)
+                state.providerId = providerId;
+            if (wfStatus)
+                state.wfStatus = wfStatus;
+        },
+        clearOnboardingIds: () => initialState,
+    },
+});
+_a = onboardingSlice.actions, exports.setOnboardingIds = _a.setOnboardingIds, exports.clearOnboardingIds = _a.clearOnboardingIds;
+exports.default = onboardingSlice.reducer;

package/lib/store/store.d.ts

@@ -0,0 +1,13 @@
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    shriramApi: import("@reduxjs/toolkit/query").CombinedState<{}, "InterestRate", "shriramApi">;
+    onboarding: import("./onboardingSlice").OnboardingIds;
+    fdListSelected: any;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        shriramApi: import("@reduxjs/toolkit/query").CombinedState<{}, "InterestRate", "shriramApi">;
+        onboarding: import("./onboardingSlice").OnboardingIds;
+        fdListSelected: any;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;

package/lib/store/store.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.store = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const baseApi_1 = require("../api/baseApi");
+const onboardingSlice_1 = __importDefault(require("./onboardingSlice"));
+const fdListSelectedSlice_1 = __importDefault(require("./fdListSelectedSlice"));
+// Configure the Redux store
+exports.store = (0, toolkit_1.configureStore)({
+    reducer: {
+        // Add the generated reducer as a specific top-level slice
+        [baseApi_1.baseApi.reducerPath]: baseApi_1.baseApi.reducer,
+        onboarding: onboardingSlice_1.default,
+        fdListSelected: fdListSelectedSlice_1.default,
+    },
+    // Adding the api middleware enables caching, invalidation, polling,
+    // and other useful features of `rtk-query`.
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+        serializableCheck: {
+            // Ignore these action types for serializable check
+            ignoredActions: ['persist/PERSIST', 'persist/REHYDRATE'],
+        },
+    }).concat(baseApi_1.baseApi.middleware),
+});
+// ✅ FIX: Set SDK store reference in baseApi to ensure interceptor always uses SDK's store
+// This prevents conflicts when parent app also uses baseApi.middleware
+(0, baseApi_1.setSDKStoreRef)(exports.store);
+if (__DEV__) {
+    console.log('✅ [SDK Store] Store created and reference set in baseApi');
+}

package/lib/theme/ThemeContext.d.ts

@@ -0,0 +1,210 @@
+import React, { ReactNode } from 'react';
+import { type Theme, type ThemeName } from './index';
+interface ThemeContextType {
+    theme: Theme;
+    themeName: ThemeName;
+    setTheme: (themeName: ThemeName) => void;
+}
+interface ThemeProviderProps {
+    children: ReactNode;
+    initialTheme?: ThemeName;
+    theme?: Theme;
+}
+export declare const ThemeProvider: React.FC<ThemeProviderProps>;
+export declare const useTheme: () => ThemeContextType;
+export declare const useColors: () => import("./colors").ColorScheme;
+export declare const useTypography: () => {
+    readonly fontFamily: {
+        readonly primary: "poppins.regular";
+        readonly medium: "poppins.medium";
+        readonly semiBold: "poppins.semibold";
+        readonly bold: "poppins.bold";
+    };
+    readonly fontSize: {
+        readonly xxs: 8;
+        readonly xs: 10;
+        readonly sm: 12;
+        readonly md: 14;
+        readonly lg: 16;
+        readonly xl: 18;
+        readonly xxl: 20;
+        readonly xxxl: 24;
+    };
+    readonly fontWeight: {
+        readonly regular: "400";
+        readonly medium: "500";
+        readonly semiBold: "600";
+        readonly bold: "700";
+    };
+    readonly lineHeight: {
+        readonly tight: 1.2;
+        readonly normal: 1.4;
+        readonly relaxed: 1.6;
+    };
+    readonly styles: {
+        readonly h1: {
+            readonly fontFamily: "poppins.bold";
+            readonly fontSize: 24;
+            readonly fontWeight: "700";
+            readonly lineHeight: 32;
+        };
+        readonly h2: {
+            readonly fontFamily: "poppins.semibold";
+            readonly fontSize: 20;
+            readonly fontWeight: "600";
+            readonly lineHeight: 28;
+        };
+        readonly h3: {
+            readonly fontFamily: "poppins.medium";
+            readonly fontSize: 16;
+            readonly fontWeight: "500";
+            readonly lineHeight: 24;
+        };
+        readonly bodyLarge: {
+            readonly fontFamily: "poppins.regular";
+            readonly fontSize: 16;
+            readonly fontWeight: "400";
+            readonly lineHeight: 24;
+        };
+        readonly bodyMedium: {
+            readonly fontFamily: "poppins.regular";
+            readonly fontSize: 14;
+            readonly fontWeight: "400";
+            readonly lineHeight: 20;
+        };
+        readonly bodySmall: {
+            readonly fontFamily: "poppins.regular";
+            readonly fontSize: 12;
+            readonly fontWeight: "400";
+            readonly lineHeight: 16;
+        };
+        readonly text14Medium: {
+            readonly fontFamily: "poppins.medium";
+            readonly fontSize: 14;
+            readonly fontWeight: "600";
+            readonly lineHeight: 12;
+        };
+        readonly text12Regular: {
+            readonly fontFamily: "poppins.regular";
+            readonly fontSize: 12;
+            readonly fontWeight: "400";
+            readonly lineHeight: 16;
+        };
+        readonly text12Medium: {
+            readonly fontFamily: "poppins.medium";
+            readonly fontSize: 12;
+            readonly fontWeight: "500";
+            readonly lineHeight: 12;
+        };
+        readonly text11Regular: {
+            readonly fontFamily: "poppins.regular";
+            readonly fontSize: 11;
+            readonly fontWeight: "400";
+            readonly lineHeight: 11;
+        };
+        readonly text10Regular: {
+            readonly fontFamily: "poppins.regular";
+            readonly fontSize: 10;
+            readonly fontWeight: "400";
+            readonly lineHeight: 12;
+        };
+        readonly text10Medium: {
+            readonly fontFamily: "poppins.medium";
+            readonly fontSize: 10;
+            readonly fontWeight: "500";
+            readonly lineHeight: 14;
+        };
+        readonly text8Regular: {
+            readonly fontFamily: "poppins.regular";
+            readonly fontSize: 8;
+            readonly fontWeight: "400";
+            readonly lineHeight: 10;
+        };
+        readonly label: {
+            readonly fontFamily: "poppins.medium";
+            readonly fontSize: 12;
+            readonly fontWeight: "500";
+            readonly lineHeight: 16;
+        };
+        readonly caption: {
+            readonly fontFamily: "poppins.regular";
+            readonly fontSize: 10;
+            readonly fontWeight: "400";
+            readonly lineHeight: 14;
+        };
+        readonly button: {
+            readonly fontFamily: "poppins.medium";
+            readonly fontSize: 16;
+            readonly fontWeight: "500";
+            readonly lineHeight: 20;
+        };
+        readonly buttonSmall: {
+            readonly fontFamily: "poppins.medium";
+            readonly fontSize: 14;
+            readonly fontWeight: "500";
+            readonly lineHeight: 18;
+        };
+    };
+};
+export declare const useShadows: () => {
+    readonly default: {
+        readonly shadowColor: "#000000";
+        readonly shadowOffset: {
+            readonly width: 0;
+            readonly height: 2;
+        };
+        readonly shadowOpacity: 0.1;
+        readonly shadowRadius: 4;
+        readonly elevation: 3;
+    };
+    readonly light: {
+        readonly shadowColor: "#000000";
+        readonly shadowOffset: {
+            readonly width: 0;
+            readonly height: 1;
+        };
+        readonly shadowOpacity: 0.05;
+        readonly shadowRadius: 2;
+        readonly elevation: 1;
+    };
+    readonly medium: {
+        readonly shadowColor: "#000000";
+        readonly shadowOffset: {
+            readonly width: 0;
+            readonly height: 4;
+        };
+        readonly shadowOpacity: 0.15;
+        readonly shadowRadius: 6;
+        readonly elevation: 5;
+    };
+    readonly heavy: {
+        readonly shadowColor: "#000000";
+        readonly shadowOffset: {
+            readonly width: 0;
+            readonly height: 6;
+        };
+        readonly shadowOpacity: 0.2;
+        readonly shadowRadius: 8;
+        readonly elevation: 8;
+    };
+    readonly card: {
+        readonly shadowColor: "#000000";
+        readonly shadowOffset: {
+            readonly width: 0;
+            readonly height: 2;
+        };
+        readonly shadowOpacity: 0.1;
+        readonly shadowRadius: 4;
+        readonly elevation: 3;
+    };
+};
+export declare const useSpacing: () => {
+    readonly xs: 4;
+    readonly sm: 8;
+    readonly md: 12;
+    readonly lg: 16;
+    readonly xl: 20;
+    readonly xxl: 24;
+    readonly xxxl: 32;
+};
+export {};

package/lib/theme/ThemeContext.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSpacing = exports.useShadows = exports.useTypography = exports.useColors = exports.useTheme = exports.ThemeProvider = void 0;
+const react_1 = __importStar(require("react"));
+const index_1 = require("./index");
+const ThemeContext = (0, react_1.createContext)(undefined);
+const ThemeProvider = ({ children, initialTheme = 'primary', theme: customTheme, }) => {
+    const [currentThemeName, setCurrentThemeName] = react_1.default.useState(initialTheme);
+    const theme = customTheme || (0, index_1.createTheme)(currentThemeName);
+    const setTheme = react_1.default.useCallback((themeName) => {
+        setCurrentThemeName(themeName);
+    }, []);
+    const value = react_1.default.useMemo(() => ({
+        theme,
+        themeName: currentThemeName,
+        setTheme,
+    }), [theme, currentThemeName, setTheme]);
+    return (react_1.default.createElement(ThemeContext.Provider, { value: value }, children));
+};
+exports.ThemeProvider = ThemeProvider;
+const useTheme = () => {
+    const context = (0, react_1.useContext)(ThemeContext);
+    if (context === undefined) {
+        // Return default theme if no provider
+        return {
+            theme: index_1.defaultTheme,
+            themeName: 'primary',
+            setTheme: () => { },
+        };
+    }
+    return context;
+};
+exports.useTheme = useTheme;
+// Hook for just getting theme colors
+const useColors = () => {
+    const { theme } = (0, exports.useTheme)();
+    return theme.colors;
+};
+exports.useColors = useColors;
+// Hook for getting typography
+const useTypography = () => {
+    const { theme } = (0, exports.useTheme)();
+    return theme.typography;
+};
+exports.useTypography = useTypography;
+// Hook for getting shadows
+const useShadows = () => {
+    const { theme } = (0, exports.useTheme)();
+    return theme.shadows;
+};
+exports.useShadows = useShadows;
+// Hook for getting spacing
+const useSpacing = () => {
+    const { theme } = (0, exports.useTheme)();
+    return theme.spacing;
+};
+exports.useSpacing = useSpacing;

package/lib/theme/colors.d.ts

@@ -0,0 +1,80 @@
+export declare const colors: {
+    readonly primary: {
+        readonly primary: "#3073e0";
+        readonly tabSelected: "#3073e0";
+        readonly headerBg: "#415fe6";
+        readonly headerText: "#ffffff";
+        readonly success: "#32c997";
+        readonly textSecondary: "#8f8f8f";
+        readonly border: "#606677";
+        readonly shadow: "#000000";
+        readonly background: "#ffffff";
+        readonly surface: "#f8f9fa";
+        readonly text: "#1a1a1a";
+        readonly textLight: "#6c757d";
+        readonly error: "#dc3545";
+        readonly warning: "#ffc107";
+        readonly info: "#17a2b8";
+        readonly muted: "#f0f0f0";
+        readonly black: "#000000";
+        readonly inputBackground: "#ffffff";
+        readonly inputBorder: "#606677";
+        readonly placeholderColor: "rgba(0,0,0,0.2)";
+        readonly labelColor: "#1a1a1a";
+        readonly buttonBackground: "#415fe6";
+        readonly buttonTextColor: "#ffffff";
+        readonly cancelButtonBg: "#f8f9fa";
+    };
+    readonly dark: {
+        readonly primary: "#4285f4";
+        readonly tabSelected: "#ffc631";
+        readonly headerBg: "#051620";
+        readonly headerText: "#ffffff";
+        readonly success: "#48bb78";
+        readonly textSecondary: "#a0aec0";
+        readonly border: "#154c6e";
+        readonly shadow: "#154c6e";
+        readonly background: "#000000";
+        readonly surface: "#082739";
+        readonly text: "#ffffff";
+        readonly textLight: "#a0aec0";
+        readonly error: "#f56565";
+        readonly warning: "#ed8936";
+        readonly info: "#4299e1";
+        readonly muted: "#2a2a2a";
+        readonly inputBackground: "#082739";
+        readonly inputBorder: "#195C86";
+        readonly placeholderColor: "#a0aec0";
+        readonly labelColor: "#ffffff";
+        readonly buttonBackground: "#ffc631";
+        readonly buttonTextColor: "#000000";
+        readonly cancelButtonBg: "#0d3248";
+    };
+    readonly corporate: {
+        readonly primary: "#1e40af";
+        readonly tabSelected: "#1e40af";
+        readonly headerBg: "#3730a3";
+        readonly headerText: "#ffffff";
+        readonly success: "#059669";
+        readonly textSecondary: "#6b7280";
+        readonly border: "#9ca3af";
+        readonly shadow: "#000000";
+        readonly background: "#f9fafb";
+        readonly surface: "#ffffff";
+        readonly text: "#111827";
+        readonly textLight: "#6b7280";
+        readonly error: "#dc2626";
+        readonly warning: "#d97706";
+        readonly info: "#2563eb";
+        readonly muted: "#e5e7eb";
+        readonly inputBackground: "#ffffff";
+        readonly inputBorder: "#9ca3af";
+        readonly placeholderColor: "rgba(0,0,0,0.2)";
+        readonly labelColor: "#111827";
+        readonly buttonBackground: "#3730a3";
+        readonly buttonTextColor: "#ffffff";
+        readonly cancelButtonBg: "#ffffff";
+    };
+};
+export type ThemeName = keyof typeof colors;
+export type ColorScheme = typeof colors[ThemeName];