@pubflow/react 0.1.0

package/dist/types/hooks/useBridgeApiRaw.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Bridge API Raw Hook for React
+ *
+ * Provides raw API access for custom operations
+ */
+/**
+ * Raw API request options
+ */
+export interface RawApiRequestOptions {
+    /**
+     * HTTP method
+     */
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /**
+     * Request headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request body
+     */
+    body?: any;
+    /**
+     * Whether to include session in request
+     */
+    includeSession?: boolean;
+    /**
+     * Request timeout in milliseconds
+     */
+    timeout?: number;
+}
+/**
+ * Raw API response
+ */
+export interface RawApiResponse<T = any> {
+    /**
+     * Response data
+     */
+    data: T;
+    /**
+     * Response status
+     */
+    status: number;
+    /**
+     * Response headers
+     */
+    headers: Record<string, string>;
+    /**
+     * Whether the request was successful
+     */
+    success: boolean;
+    /**
+     * Error message if any
+     */
+    error?: string;
+}
+/**
+ * Bridge API Raw hook result
+ */
+export interface UseBridgeApiRawResult {
+    /**
+     * Make a raw API request
+     */
+    request: <T = any>(endpoint: string, options?: RawApiRequestOptions) => Promise<RawApiResponse<T>>;
+    /**
+     * GET request shorthand
+     */
+    get: <T = any>(endpoint: string, options?: Omit<RawApiRequestOptions, 'method'>) => Promise<RawApiResponse<T>>;
+    /**
+     * POST request shorthand
+     */
+    post: <T = any>(endpoint: string, body?: any, options?: Omit<RawApiRequestOptions, 'method' | 'body'>) => Promise<RawApiResponse<T>>;
+    /**
+     * PUT request shorthand
+     */
+    put: <T = any>(endpoint: string, body?: any, options?: Omit<RawApiRequestOptions, 'method' | 'body'>) => Promise<RawApiResponse<T>>;
+    /**
+     * DELETE request shorthand
+     */
+    delete: <T = any>(endpoint: string, options?: Omit<RawApiRequestOptions, 'method'>) => Promise<RawApiResponse<T>>;
+    /**
+     * PATCH request shorthand
+     */
+    patch: <T = any>(endpoint: string, body?: any, options?: Omit<RawApiRequestOptions, 'method' | 'body'>) => Promise<RawApiResponse<T>>;
+}
+/**
+ * Hook for raw Bridge API access
+ *
+ * @param instanceId Pubflow instance ID
+ * @returns Raw API hook result
+ */
+export declare function useBridgeApiRaw(instanceId?: string): UseBridgeApiRawResult;

package/dist/types/hooks/useBridgeCrud.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Bridge CRUD Hook for React
+ *
+ * Provides a hook for CRUD operations using Bridge API
+ */
+import { EntityConfig, EntityData, FilterOperator } from '@pubflow/core';
+import { MutationOptions } from './useBridgeMutation';
+/**
+ * Search configuration
+ */
+export interface SearchConfig {
+    /**
+     * Initial search term
+     */
+    initialSearchTerm?: string;
+    /**
+     * Initial filters
+     */
+    initialFilters?: Array<{
+        field: string;
+        operator: FilterOperator | string;
+        value: any;
+    }>;
+    /**
+     * Initial sort
+     */
+    initialSort?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    /**
+     * Initial page
+     */
+    initialPage?: number;
+    /**
+     * Initial limit
+     */
+    initialLimit?: number;
+    /**
+     * Fields to search
+     */
+    searchFields?: string[];
+    /**
+     * Debounce time in milliseconds
+     */
+    debounceMs?: number;
+    /**
+     * Whether to search automatically
+     */
+    autoSearch?: boolean;
+}
+/**
+ * Entity schemas
+ */
+export interface EntitySchemas<T, U, V> {
+    /**
+     * Schema for the complete entity
+     */
+    entity?: any;
+    /**
+     * Schema for creating an entity
+     */
+    create?: any;
+    /**
+     * Schema for updating an entity
+     */
+    update?: any;
+}
+/**
+ * Success messages
+ */
+export interface SuccessMessages {
+    /**
+     * Success message for create operation
+     */
+    create?: string;
+    /**
+     * Success message for update operation
+     */
+    update?: string;
+    /**
+     * Success message for delete operation
+     */
+    delete?: string;
+}
+/**
+ * Error messages
+ */
+export interface ErrorMessages {
+    /**
+     * Error message for create operation
+     */
+    create?: string;
+    /**
+     * Error message for update operation
+     */
+    update?: string;
+    /**
+     * Error message for delete operation
+     */
+    delete?: string;
+    /**
+     * Error message for fetch operation
+     */
+    fetch?: string;
+}
+/**
+ * Bridge CRUD hook options
+ */
+export interface UseBridgeCrudOptions<T extends EntityData, U = Partial<T>, V = Partial<T>> {
+    /**
+     * Entity configuration
+     */
+    entityConfig: EntityConfig;
+    /**
+     * Pubflow instance ID
+     */
+    instanceId?: string;
+    /**
+     * Entity schemas
+     */
+    schemas?: EntitySchemas<T, U, V>;
+    /**
+     * Search configuration
+     */
+    searchConfig?: SearchConfig;
+    /**
+     * Success messages
+     */
+    successMessages?: SuccessMessages;
+    /**
+     * Error messages
+     */
+    errorMessages?: ErrorMessages;
+    /**
+     * Notification configuration
+     */
+    notificationConfig?: {
+        /**
+         * Whether to show notifications automatically
+         */
+        autoNotify?: boolean;
+        /**
+         * Function to show notifications
+         */
+        showNotification?: (message: string, type: 'success' | 'error') => void;
+    };
+}
+/**
+ * Bridge CRUD hook result
+ */
+export interface UseBridgeCrudResult<T extends EntityData> {
+    items: T[];
+    selectedItem: T | null;
+    totalItems: number;
+    loading: boolean;
+    creating: boolean;
+    updating: boolean;
+    deleting: boolean;
+    error: Error | null;
+    validationErrors: Record<string, string[]> | null;
+    page: number;
+    limit: number;
+    hasMore: boolean;
+    setPage: (page: number) => void;
+    setLimit: (limit: number) => void;
+    orderBy: string | undefined;
+    orderDir: 'asc' | 'desc' | undefined;
+    setSort: (field: string, direction?: 'asc' | 'desc') => void;
+    searchTerm: string;
+    setSearchTerm: (term: string) => void;
+    filters: Array<{
+        field: string;
+        operator: FilterOperator | string;
+        value: any;
+    }>;
+    addFilter: (field: string, operator: FilterOperator | string, value: any) => void;
+    removeFilter: (field: string) => void;
+    resetFilters: () => void;
+    getItem: (id: string) => Promise<T>;
+    createItem: (data: Partial<T>, options?: MutationOptions) => Promise<T>;
+    updateItem: (id: string, data: Partial<T>, options?: MutationOptions) => Promise<T>;
+    deleteItem: (id: string, options?: MutationOptions) => Promise<void>;
+    refresh: () => Promise<void>;
+    selectItem: (item: T | null) => void;
+}
+/**
+ * Hook for CRUD operations using Bridge API
+ *
+ * @param options Hook options
+ * @returns CRUD hook result
+ */
+export declare function useBridgeCrud<T extends EntityData, U = Partial<T>, V = Partial<T>>(options: UseBridgeCrudOptions<T, U, V>): UseBridgeCrudResult<T>;

package/dist/types/hooks/useBridgeMutation.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Bridge Mutation Hook for React
+ *
+ * Provides a hook for mutating data using Bridge API
+ */
+import { BridgeApiService, EntityData } from '@pubflow/core';
+/**
+ * Mutation types
+ */
+type MutationType = 'create' | 'update' | 'delete';
+/**
+ * Mutation parameters
+ */
+type MutationParams<T, M> = M extends 'create' ? Partial<T> : M extends 'update' ? {
+    id: string;
+    data: Partial<T>;
+} : M extends 'delete' ? string : never;
+/**
+ * Mutation result
+ */
+type MutationResult<T, M> = M extends 'create' ? T : M extends 'update' ? T : M extends 'delete' ? void : never;
+/**
+ * Mutation options
+ */
+export interface MutationOptions {
+    /**
+     * Whether to invalidate queries after mutation
+     */
+    invalidateQueries?: boolean;
+    /**
+     * Success message
+     */
+    successMessage?: string;
+    /**
+     * Error message
+     */
+    errorMessage?: string;
+    /**
+     * Success callback
+     */
+    onSuccess?: (data: any) => void;
+    /**
+     * Error callback
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Whether to show alerts for success/error
+     */
+    showAlerts?: boolean;
+}
+/**
+ * Bridge mutation hook result
+ */
+export interface UseBridgeMutationResult<T, M extends MutationType> {
+    mutate: (params: MutationParams<T, M>, options?: MutationOptions) => Promise<MutationResult<T, M>>;
+    isLoading: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+/**
+ * Hook for mutating data using Bridge API
+ *
+ * @param service Bridge API service
+ * @param type Mutation type
+ * @param defaultOptions Default mutation options
+ * @returns Mutation result
+ */
+export declare function useBridgeMutation<T extends EntityData, M extends MutationType>(service: BridgeApiService<T>, type: M, defaultOptions?: MutationOptions): UseBridgeMutationResult<T, M>;
+export {};

package/dist/types/hooks/useBridgeQuery.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Bridge Query Hook for React
+ *
+ * Provides a hook for querying data using Bridge API with SWR
+ */
+import { SWRConfiguration } from 'swr';
+import { BridgeApiService, EntityData, SearchParams, QueryParams as CoreQueryParams } from '@pubflow/core';
+/**
+ * Bridge query types
+ */
+type QueryType = 'list' | 'get' | 'search';
+/**
+ * Bridge query parameters
+ */
+type BridgeQueryParams<T> = T extends 'list' ? CoreQueryParams : T extends 'get' ? {
+    id: string;
+    params?: CoreQueryParams;
+} : T extends 'search' ? SearchParams : never;
+/**
+ * Bridge query hook result
+ */
+export interface UseBridgeQueryResult<T extends EntityData, Q extends QueryType> {
+    data: Q extends 'list' | 'search' ? T[] : T | null;
+    meta: Q extends 'list' | 'search' ? {
+        page: number;
+        limit: number;
+        total: number;
+        hasMore: boolean;
+    } : null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for querying data using Bridge API with SWR
+ *
+ * @param service Bridge API service
+ * @param type Query type
+ * @param params Query parameters
+ * @param config SWR configuration
+ * @returns Query result
+ */
+export declare function useBridgeQuery<T extends EntityData, Q extends QueryType>(service: BridgeApiService<T>, type: Q, params: BridgeQueryParams<Q>, config?: SWRConfiguration): UseBridgeQueryResult<T, Q>;
+export {};

package/dist/types/hooks/useSearchQueryBuilder.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Search Query Builder Hook for React
+ *
+ * Provides utilities for building complex search queries
+ */
+import { FilterDefinition, FilterOperator } from '@pubflow/core';
+/**
+ * Search field definition
+ */
+export interface SearchField {
+    /**
+     * Field name
+     */
+    name: string;
+    /**
+     * Display label
+     */
+    label: string;
+    /**
+     * Field type
+     */
+    type: 'text' | 'number' | 'date' | 'boolean' | 'select';
+    /**
+     * Whether the field is searchable
+     */
+    searchable?: boolean;
+    /**
+     * Whether the field is filterable
+     */
+    filterable?: boolean;
+    /**
+     * Whether the field is sortable
+     */
+    sortable?: boolean;
+    /**
+     * Options for select type
+     */
+    options?: {
+        label: string;
+        value: any;
+    }[];
+    /**
+     * Default operator for this field
+     */
+    defaultOperator?: FilterOperator;
+}
+/**
+ * Search query state
+ */
+export interface SearchQueryState {
+    /**
+     * Search term
+     */
+    searchTerm: string;
+    /**
+     * Active filters
+     */
+    filters: FilterDefinition[];
+    /**
+     * Sort field
+     */
+    sortField?: string;
+    /**
+     * Sort direction
+     */
+    sortDirection?: 'asc' | 'desc';
+    /**
+     * Current page
+     */
+    page: number;
+    /**
+     * Items per page
+     */
+    limit: number;
+}
+/**
+ * Search query builder hook result
+ */
+export interface UseSearchQueryBuilderResult {
+    /**
+     * Current query state
+     */
+    queryState: SearchQueryState;
+    /**
+     * Set search term
+     */
+    setSearchTerm: (term: string) => void;
+    /**
+     * Add a filter
+     */
+    addFilter: (filter: FilterDefinition) => void;
+    /**
+     * Remove a filter by index
+     */
+    removeFilter: (index: number) => void;
+    /**
+     * Update a filter
+     */
+    updateFilter: (index: number, filter: FilterDefinition) => void;
+    /**
+     * Clear all filters
+     */
+    clearFilters: () => void;
+    /**
+     * Set sort
+     */
+    setSort: (field: string, direction: 'asc' | 'desc') => void;
+    /**
+     * Clear sort
+     */
+    clearSort: () => void;
+    /**
+     * Set page
+     */
+    setPage: (page: number) => void;
+    /**
+     * Set limit
+     */
+    setLimit: (limit: number) => void;
+    /**
+     * Reset query to initial state
+     */
+    resetQuery: () => void;
+    /**
+     * Build query string for API
+     */
+    buildQueryString: () => string;
+    /**
+     * Build query object for API
+     */
+    buildQueryObject: () => Record<string, any>;
+    /**
+     * Get searchable fields
+     */
+    getSearchableFields: () => SearchField[];
+    /**
+     * Get filterable fields
+     */
+    getFilterableFields: () => SearchField[];
+    /**
+     * Get sortable fields
+     */
+    getSortableFields: () => SearchField[];
+}
+/**
+ * Hook for building search queries
+ *
+ * @param fields Available search fields
+ * @param initialState Initial query state
+ * @returns Search query builder result
+ */
+export declare function useSearchQueryBuilder(fields: SearchField[], initialState?: Partial<SearchQueryState>): UseSearchQueryBuilderResult;

package/dist/types/hooks/useServerAuth.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Server Authentication Hook for React
+ *
+ * Provides a hook for handling authentication with automatic redirects
+ */
+/**
+ * Server authentication hook options
+ */
+export interface UseServerAuthOptions {
+    /**
+     * Path to redirect to when not authenticated
+     */
+    loginRedirectPath?: string;
+    /**
+     * User types allowed to access the page
+     */
+    allowedTypes?: string[];
+    /**
+     * Whether to validate the session on mount
+     */
+    validateOnMount?: boolean;
+    /**
+     * Pubflow instance ID
+     */
+    instanceId?: string;
+    /**
+     * Custom redirect function
+     */
+    onRedirect?: (path: string) => void;
+}
+/**
+ * Hook for handling authentication with automatic redirects
+ *
+ * @param options Hook options
+ * @returns Authentication hook result
+ */
+export declare function useServerAuth({ loginRedirectPath, allowedTypes, validateOnMount, instanceId, onRedirect }?: UseServerAuthOptions): {
+    user: import("@pubflow/core").User | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    validateSession: () => Promise<{
+        isValid: boolean;
+        expiresAt?: string;
+    }>;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pubflow React Adapter
+ *
+ * Main entry point for the Pubflow React adapter
+ */
+export * from '@pubflow/core';
+export * from './components/BridgeView';
+export * from './components/BridgeTable';
+export * from './components/BridgeForm';
+export * from './components/BridgeList';
+export * from './components/OfflineIndicator';
+export * from './components/AdvancedFilter';
+export * from './components/auth';
+export * from './components/theme';
+export * from './context/PubflowProvider';
+export * from './hooks/useAuth';
+export * from './hooks/useBridgeApi';
+export * from './hooks/useBridgeApiRaw';
+export * from './hooks/useBridgeQuery';
+export * from './hooks/useBridgeMutation';
+export * from './hooks/useServerAuth';
+export * from './hooks/useSearchQueryBuilder';
+import { useBridgeCrud } from './hooks/useBridgeCrud';
+export { useBridgeCrud };
+export * from './storage/BrowserStorageAdapter';
+export * from './utils/auth-utils';