ad-feature-components 0.0.3 → 0.0.5

package/dist/index.d.ts

@@ -0,0 +1,582 @@
+import * as React$1 from 'react';
+import React__default, { Component, ReactNode } from 'react';
+import * as _azure_msal_browser from '@azure/msal-browser';
+import { Configuration, PopupRequest, RedirectRequest, InteractionType } from '@azure/msal-browser';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { NavigateFunction } from 'react-router-dom';
+import * as _tanstack_react_query from '@tanstack/react-query';
+
+interface AppInsightProps {
+    instrumentationKey: string;
+}
+declare const AppInsight: React__default.FC<AppInsightProps>;
+
+type AuthProviderProps = {
+    config: Configuration;
+    children: React__default.ReactNode;
+};
+declare const AuthProvider: React__default.FC<AuthProviderProps>;
+
+type Options = {
+    loginType?: "popup" | "redirect";
+    defaultScopes?: string[];
+};
+declare function useAuth(options?: Options): {
+    isAuthenticated: boolean;
+    account: _azure_msal_browser.AccountInfo | null;
+    login: (request?: PopupRequest | RedirectRequest) => Promise<void>;
+    logout: () => Promise<void>;
+    acquireToken: (scopes: string[]) => Promise<string>;
+    InteractionType: typeof InteractionType;
+};
+
+declare const Protected: React__default.FC<{
+    children: React__default.ReactNode;
+}>;
+
+interface RouteConfig {
+    path: string;
+    component: React__default.ComponentType;
+    errorFallback?: React__default.ReactNode;
+}
+interface RouterProviderProps {
+    routes: RouteConfig[];
+    fallbackUI?: React__default.ReactNode;
+}
+
+declare const RouterProvider: React__default.FC<RouterProviderProps>;
+
+interface ErrorBoundaryProps {
+    fallback?: ReactNode;
+    children: ReactNode;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+}
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(_: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, info: React__default.ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+}
+
+declare const getNavigate: () => NavigateFunction;
+
+interface ClientConfig {
+    endpoint: string;
+    headers?: Record<string, string>;
+}
+declare const configureClient: ({ endpoint, headers }: ClientConfig) => void;
+declare const get: <T>(url: string) => Promise<T>;
+declare const post: <T>(url: string, data: any) => Promise<T>;
+declare const put: <T>(url: string, data: any) => Promise<T>;
+declare const del: <T>(url: string) => Promise<T>;
+
+declare const useGetQuery: <T>(key: string, url: string) => _tanstack_react_query.UseQueryResult<_tanstack_react_query.NoInfer<T>, Error>;
+declare const usePostMutation: <T>() => _tanstack_react_query.UseMutationResult<T, Error, {
+    url: string;
+    data: any;
+    invalidateKeys?: string[];
+}, unknown>;
+declare const usePutMutation: <T>() => _tanstack_react_query.UseMutationResult<T, Error, {
+    url: string;
+    data: any;
+    invalidateKeys?: string[];
+}, unknown>;
+declare const useDeleteMutation: <T>() => _tanstack_react_query.UseMutationResult<T, Error, {
+    url: string;
+    invalidateKeys?: string[];
+}, unknown>;
+
+interface QueryProviderProps {
+    children: ReactNode;
+}
+declare const QueryProvider: React__default.FC<QueryProviderProps>;
+
+type Values = Record<string, string>;
+type SyncOrAsync<T> = T | Promise<T>;
+type Validator = ((value: string, values: Values) => SyncOrAsync<boolean | string>) | undefined;
+
+interface FormProps {
+    initialValues?: Values;
+    /** Async submit handler from target application */
+    onSubmit: (values: Values) => Promise<void>;
+    /** Optional error callback when onSubmit throws */
+    onSubmitError?: (error: unknown) => void;
+    /** Optional reset side-effect */
+    onReset?: () => void;
+    /** Children should include InputField and buttons */
+    children: React__default.ReactNode;
+}
+declare const Form: React__default.FC<FormProps>;
+
+interface InputFieldProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "name" | "onChange" | "value"> {
+    /** Unique field name */
+    name: string;
+    /** Visible label (optional) */
+    label?: string;
+    /** Show a clear icon inside input (default true) */
+    clearable?: boolean;
+    /** Validator function; can be sync or async and return boolean or string */
+    validator?: Validator;
+    /**
+     * Fallback error message to show if validator returns false.
+     * This satisfies: "take error message as a prop from target application"
+     */
+    errorMessage?: string;
+    /** Additional CSS class name */
+    className?: string;
+}
+declare const InputField: React__default.FC<InputFieldProps>;
+
+interface DropdownOption {
+    value: string;
+    label: string;
+}
+interface InputDropdownProps {
+    /** Unique field name */
+    name: string;
+    /** Visible label (optional) */
+    label?: string;
+    /** Array of dropdown options */
+    options: DropdownOption[];
+    /** Placeholder text for empty selection */
+    placeholder?: string;
+    /** Show a clear icon (default true) */
+    clearable?: boolean;
+    /** Validator function; can be sync or async and return boolean or string */
+    validator?: Validator;
+    /**
+     * Fallback error message to show if validator returns false.
+     * This satisfies: "take error message as a prop from target application"
+     */
+    errorMessage?: string;
+    /** Whether the dropdown is disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: React__default.CSSProperties;
+    /** Accessibility attributes */
+    'aria-label'?: string;
+    'aria-describedby'?: string;
+}
+declare const InputDropdown: React__default.FC<InputDropdownProps>;
+
+interface RadioOption {
+    value: string;
+    label: string;
+}
+interface InputRadioProps {
+    /** Unique field name */
+    name: string;
+    /** Visible label (optional) */
+    label?: string;
+    /** Array of radio options */
+    options: RadioOption[];
+    /** Validator function; can be sync or async and return boolean or string */
+    validator?: Validator;
+    /**
+     * Fallback error message to show if validator returns false.
+     * This satisfies: "take error message as a prop from target application"
+     */
+    errorMessage?: string;
+    /** Whether the radio group is disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Accessibility attributes */
+    'aria-label'?: string;
+    'aria-describedby'?: string;
+}
+declare const InputRadio: React__default.FC<InputRadioProps>;
+
+interface CheckboxOption {
+    value: string;
+    label: string;
+}
+interface InputCheckboxProps {
+    /** Unique field name */
+    name: string;
+    /** Visible label (optional) */
+    label?: string;
+    /** Array of checkbox options */
+    options: CheckboxOption[];
+    /** Validator function; can be sync or async and return boolean or string */
+    validator?: Validator;
+    /**
+     * Fallback error message to show if validator returns false.
+     * This satisfies: "take error message as a prop from target application"
+     */
+    errorMessage?: string;
+    /** Whether the checkbox group is disabled */
+    disabled?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** Accessibility attributes */
+    'aria-label'?: string;
+    'aria-describedby'?: string;
+}
+declare const InputCheckbox: React__default.FC<InputCheckboxProps>;
+
+interface InputTextareaProps {
+    /** Unique field name */
+    name: string;
+    /** Visible label (optional) */
+    label?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Show a clear icon (default true) */
+    clearable?: boolean;
+    /** Validator function; can be sync or async and return boolean or string */
+    validator?: Validator;
+    /**
+     * Fallback error message to show if validator returns false.
+     * This satisfies: "take error message as a prop from target application"
+     */
+    errorMessage?: string;
+    /** Whether the textarea is disabled */
+    disabled?: boolean;
+    /** Number of rows */
+    rows?: number;
+    /** Maximum length */
+    maxLength?: number;
+    /** Additional CSS class name */
+    className?: string;
+    /** Additional inline styles */
+    style?: React__default.CSSProperties;
+    /** Accessibility attributes */
+    'aria-label'?: string;
+    'aria-describedby'?: string;
+}
+declare const InputTextarea: React__default.FC<InputTextareaProps>;
+
+interface ResetButtonProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, "type" | "onClick"> {
+    /** Optional custom text (default: "Reset") */
+    children?: React__default.ReactNode;
+}
+declare const ResetButton: React__default.FC<ResetButtonProps>;
+
+interface InputFileProps {
+    name?: string;
+    label?: string;
+    accept?: string;
+    maxLength?: number;
+    maxFileSize?: number;
+    uploadUrl?: string;
+    onFileChange?: (file: File | null) => void;
+    disabled?: boolean;
+    validator?: (value: string) => boolean | string;
+    errorMessage?: string;
+    /** Additional CSS class name */
+    className?: string;
+}
+declare const InputFile: React__default.FC<InputFileProps>;
+
+interface ToastProviderProps {
+    children: ReactNode;
+    /** Default duration in milliseconds (default: 3000) */
+    defaultDuration?: number;
+    /** Maximum number of toasts to show at once (default: 5) */
+    maxToasts?: number;
+}
+declare const ToastProvider: React__default.FC<ToastProviderProps>;
+
+type ToastType = 'success' | 'error' | 'info' | 'warning';
+interface Toast {
+    id: string;
+    message: string;
+    type: ToastType;
+    duration: number;
+}
+interface ToastContextValue {
+    toasts: Toast[];
+    showToast: (message: string, type: ToastType, duration?: number) => void;
+    showSuccess: (message: string, duration?: number) => void;
+    showError: (message: string, duration?: number) => void;
+    showInfo: (message: string, duration?: number) => void;
+    showWarning: (message: string, duration?: number) => void;
+    removeToast: (id: string) => void;
+}
+
+declare const useToast: () => ToastContextValue;
+
+interface ToastContainerProps {
+    /** Position of toast container (default: 'top-right') */
+    position?: 'top-left' | 'top-right' | 'top-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
+    /** Additional CSS class name */
+    className?: string;
+}
+declare const ToastContainer: React__default.FC<ToastContainerProps>;
+
+interface InlineAlertProps {
+    /** Type of alert */
+    type: 'success' | 'error' | 'warning' | 'info';
+    /** Alert message */
+    message: string;
+    /** Optional title */
+    title?: string;
+    /** Whether to show close button */
+    dismissible?: boolean;
+    /** Callback when alert is dismissed */
+    onDismiss?: () => void;
+    /** Additional CSS class name */
+    className?: string;
+}
+declare const InlineAlert: React__default.FC<InlineAlertProps>;
+
+type StorageType = 'local' | 'session' | 'memory';
+interface StorageOptions {
+    /**
+     * Type of storage to use
+     * @default 'local'
+     */
+    storageType?: StorageType;
+    /**
+     * Namespace prefix for all keys to avoid collisions
+     * @default ''
+     */
+    namespace?: string;
+    /**
+     * Enable JSON serialization/deserialization
+     * @default true
+     */
+    serialize?: boolean;
+    /**
+     * Enable encryption for sensitive data (basic obfuscation)
+     * @default false
+     */
+    encrypt?: boolean;
+}
+interface StorageContextValue {
+    /**
+     * Get an item from storage
+     */
+    getItem: <T = string>(key: string, defaultValue?: T) => T | null;
+    /**
+     * Set an item in storage
+     */
+    setItem: <T = unknown>(key: string, value: T) => void;
+    /**
+     * Remove an item from storage
+     */
+    removeItem: (key: string) => void;
+    /**
+     * Clear all items from storage (respects namespace)
+     */
+    clear: () => void;
+    /**
+     * Check if a key exists in storage
+     */
+    hasItem: (key: string) => boolean;
+    /**
+     * Get all keys in storage (respects namespace)
+     */
+    getAllKeys: () => string[];
+    /**
+     * Get the current storage type
+     */
+    storageType: StorageType;
+}
+
+interface StorageProviderProps extends StorageOptions {
+    children: ReactNode;
+}
+declare const StorageProvider: React__default.FC<StorageProviderProps>;
+
+declare const StorageContext: React$1.Context<StorageContextValue | undefined>;
+/**
+ * Hook to access storage functionality
+ * Must be used within a StorageProvider
+ *
+ * @example
+ * ```tsx
+ * const storage = useStorage();
+ *
+ * // Store data
+ * storage.setItem('user', { name: 'John', age: 30 });
+ *
+ * // Retrieve data
+ * const user = storage.getItem('user', { name: '', age: 0 });
+ *
+ * // Remove data
+ * storage.removeItem('user');
+ *
+ * // Check if key exists
+ * if (storage.hasItem('user')) {
+ *   console.log('User exists');
+ * }
+ *
+ * // Clear all storage
+ * storage.clear();
+ * ```
+ */
+declare function useStorage(): StorageContextValue;
+
+interface ContextConfig<T> {
+    /**
+     * Display name for the context (used in error messages and DevTools)
+     */
+    name: string;
+    /**
+     * Error message to show when hook is used outside provider
+     */
+    errorMessage?: string;
+    /**
+     * Default value for the context (optional)
+     */
+    defaultValue?: T;
+}
+interface ProviderProps<T> {
+    children: ReactNode;
+    value: T;
+}
+interface CreateContextResult<T> {
+    /**
+     * The React Context object
+     */
+    Context: React.Context<T | undefined>;
+    /**
+     * Provider component to wrap your app/component tree
+     */
+    Provider: React.FC<ProviderProps<T>>;
+    /**
+     * Hook to access the context value
+     * @throws Error if used outside the Provider
+     */
+    useContext: () => T;
+}
+
+/**
+ * Factory function to create a type-safe context with provider and hook
+ *
+ * @example
+ * ```tsx
+ * // Define your context value type
+ * interface ThemeContextValue {
+ *   theme: 'light' | 'dark';
+ *   toggleTheme: () => void;
+ * }
+ *
+ * // Create the context
+ * const { Provider: ThemeProvider, useContext: useTheme } = createContext<ThemeContextValue>({
+ *   name: 'Theme',
+ * });
+ *
+ * // Use in your app
+ * function App() {
+ *   const [theme, setTheme] = useState<'light' | 'dark'>('light');
+ *
+ *   const toggleTheme = () => {
+ *     setTheme(prev => prev === 'light' ? 'dark' : 'light');
+ *   };
+ *
+ *   return (
+ *     <ThemeProvider value={{ theme, toggleTheme }}>
+ *       <YourComponents />
+ *     </ThemeProvider>
+ *   );
+ * }
+ *
+ * // Access in child components
+ * function ChildComponent() {
+ *   const { theme, toggleTheme } = useTheme();
+ *   return <button onClick={toggleTheme}>Current: {theme}</button>;
+ * }
+ * ```
+ */
+declare function createContext<T>(config: ContextConfig<T>): CreateContextResult<T>;
+
+interface ContextWithHookConfig<T, P> {
+    /**
+     * Display name for the context (used in error messages and DevTools)
+     */
+    name: string;
+    /**
+     * Hook that provides the context value based on props
+     */
+    useValue: (props: P) => T;
+    /**
+     * Error message to show when hook is used outside provider
+     */
+    errorMessage?: string;
+}
+interface ProviderWithHookProps {
+    children: ReactNode;
+}
+interface CreateContextWithHookResult<T, P> {
+    /**
+     * The React Context object
+     */
+    Context: React__default.Context<T | undefined>;
+    /**
+     * Provider component that uses the hook internally
+     */
+    Provider: React__default.FC<ProviderWithHookProps & P>;
+    /**
+     * Hook to access the context value
+     * @throws Error if used outside the Provider
+     */
+    useContext: () => T;
+}
+/**
+ * Factory function to create a context with a custom hook that manages state
+ * This pattern is useful when you want to encapsulate state logic in the provider
+ *
+ * @example
+ * ```tsx
+ * // Define your context value and props types
+ * interface CounterContextValue {
+ *   count: number;
+ *   increment: () => void;
+ *   decrement: () => void;
+ *   reset: () => void;
+ * }
+ *
+ * interface CounterProviderProps {
+ *   initialCount?: number;
+ * }
+ *
+ * // Create the context with a custom hook
+ * const { Provider: CounterProvider, useContext: useCounter } = createContextWithHook<
+ *   CounterContextValue,
+ *   CounterProviderProps
+ * >({
+ *   name: 'Counter',
+ *   useValue: ({ initialCount = 0 }) => {
+ *     const [count, setCount] = useState(initialCount);
+ *
+ *     return {
+ *       count,
+ *       increment: () => setCount(prev => prev + 1),
+ *       decrement: () => setCount(prev => prev - 1),
+ *       reset: () => setCount(initialCount),
+ *     };
+ *   },
+ * });
+ *
+ * // Use in your app
+ * function App() {
+ *   return (
+ *     <CounterProvider initialCount={10}>
+ *       <YourComponents />
+ *     </CounterProvider>
+ *   );
+ * }
+ *
+ * // Access in child components
+ * function ChildComponent() {
+ *   const { count, increment, decrement } = useCounter();
+ *   return (
+ *     <div>
+ *       <p>Count: {count}</p>
+ *       <button onClick={increment}>+</button>
+ *       <button onClick={decrement}>-</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function createContextWithHook<T, P = Record<string, never>>(config: ContextWithHookConfig<T, P>): CreateContextWithHookResult<T, P>;
+
+export { AppInsight, AuthProvider, type AuthProviderProps, type CheckboxOption, type ClientConfig, type ContextConfig, type ContextWithHookConfig, type CreateContextResult, type CreateContextWithHookResult, type DropdownOption, ErrorBoundary, Form, type FormProps, InlineAlert, type InlineAlertProps, InputCheckbox, type InputCheckboxProps, InputDropdown, type InputDropdownProps, InputField, type InputFieldProps, InputFile, InputRadio, type InputRadioProps, InputTextarea, type InputTextareaProps, Protected, type ProviderProps, type ProviderWithHookProps, QueryProvider, type RadioOption, ResetButton, type RouteConfig, RouterProvider, type RouterProviderProps, StorageContext, type StorageContextValue, type StorageOptions, StorageProvider, type StorageProviderProps, type StorageType, type Toast, ToastContainer, type ToastContextValue, ToastProvider, type ToastType, type Validator, type Values, configureClient, createContext, createContextWithHook, del, get, getNavigate, post, put, useAuth, useDeleteMutation, useGetQuery, usePostMutation, usePutMutation, useStorage, useToast };