@apvee/spfx-react-toolkit 1.0.0

package/lib/hooks/useSPFxPnP.js

@@ -0,0 +1,533 @@
+// useSPFxPnP.ts
+// Hook to access PnPjs with state management and batching support
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { useState, useCallback } from 'react';
+import { useSPFxPnPContext } from './useSPFxPnPContext';
+/**
+ * Hook to access PnPjs with built-in state management and batching support
+ *
+ * Provides convenient wrappers around PnPjs SPFI instance with automatic
+ * loading and error state tracking. Offers three usage patterns:
+ *
+ * 1. **invoke()** - Single operations with automatic state management
+ * 2. **batch()** - Multiple operations in one request with state management
+ * 3. **sp** - Direct access for full control (advanced scenarios)
+ *
+ * This hook wraps the SPFI instance from useSPFxPnPContext and adds
+ * React state management for common patterns.
+ *
+ * **Selective Imports Required**:
+ * This hook provides access to the base PnPjs instance with minimal imports.
+ * To use specific PnP modules, import them in your code:
+ *
+ * ```typescript
+ * // For lists and items
+ * import '@pnp/sp/lists';
+ * import '@pnp/sp/items';
+ *
+ * // For files and folders
+ * import '@pnp/sp/files';
+ * import '@pnp/sp/folders';
+ *
+ * // For search
+ * import '@pnp/sp/search';
+ *
+ * // For user profiles
+ * import '@pnp/sp/profiles';
+ *
+ * // For taxonomy (managed metadata)
+ * import '@pnp/sp/taxonomy';
+ *
+ * // For site users and groups
+ * import '@pnp/sp/site-users';
+ * import '@pnp/sp/site-groups';
+ * ```
+ *
+ * This approach enables optimal tree-shaking and keeps bundle size minimal.
+ *
+ * @param pnpContext - Optional PnPContextInfo from useSPFxPnPContext.
+ *                     If not provided, creates default context for current site.
+ *
+ * @returns SPFxPnPInfo object with sp, invoke, batch, and state management
+ *
+ * @example Current site with invoke
+ * ```tsx
+ * import '@pnp/sp/lists';
+ *
+ * function ListsViewer() {
+ *   const { invoke, isLoading, error } = useSPFxPnP();
+ *   const [lists, setLists] = useState([]);
+ *
+ *   useEffect(() => {
+ *     invoke(sp => sp.web.lists()).then(setLists);
+ *   }, []);
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <MessageBar messageBarType={MessageBarType.error}>
+ *     {error.message}
+ *   </MessageBar>;
+ *
+ *   return <DetailsList items={lists} />;
+ * }
+ * ```
+ *
+ * @example Cross-site with context injection
+ * ```tsx
+ * import '@pnp/sp/lists';
+ * import '@pnp/sp/items';
+ *
+ * function HRDashboard() {
+ *   // Create context for HR site
+ *   const hrContext = useSPFxPnPContext('/sites/hr');
+ *   const { invoke, isLoading, error } = useSPFxPnP(hrContext);
+ *
+ *   const [employees, setEmployees] = useState([]);
+ *
+ *   const loadEmployees = async () => {
+ *     const items = await invoke(sp =>
+ *       sp.web.lists
+ *         .getByTitle('Employees')
+ *         .items
+ *         .select('Id', 'Title', 'Department')
+ *         .top(100)()
+ *     );
+ *     setEmployees(items);
+ *   };
+ *
+ *   if (error) return <MessageBar>{error.message}</MessageBar>;
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={loadEmployees} disabled={isLoading}>
+ *         {isLoading ? 'Loading...' : 'Load Employees'}
+ *       </button>
+ *       <DetailsList items={employees} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example With caching configuration
+ * ```tsx
+ * function CachedDataViewer() {
+ *   // Create context with caching enabled
+ *   const context = useSPFxPnPContext(undefined, {
+ *     cache: {
+ *       enabled: true,
+ *       storage: 'session',
+ *       timeout: 600000 // 10 minutes
+ *     }
+ *   });
+ *
+ *   const { invoke } = useSPFxPnP(context);
+ *
+ *   // Subsequent calls within 10 minutes use cached data
+ *   const lists = await invoke(sp => sp.web.lists());
+ * }
+ * ```
+ *
+ * @example Batch operations for dashboard
+ * ```tsx
+ * import '@pnp/sp/lists';
+ * import '@pnp/sp/items';
+ *
+ * function Dashboard() {
+ *   const { batch, isLoading, error } = useSPFxPnP();
+ *   const [data, setData] = useState(null);
+ *
+ *   const loadDashboard = async () => {
+ *     // All operations in ONE HTTP request
+ *     const [user, tasks, announcements, events] = await batch(async (batchedSP) => {
+ *       const user = batchedSP.web.currentUser();
+ *       const tasks = batchedSP.web.lists.getByTitle('Tasks').items.top(10)();
+ *       const announcements = batchedSP.web.lists.getByTitle('Announcements').items.top(5)();
+ *       const events = batchedSP.web.lists.getByTitle('Events').items.top(10)();
+ *
+ *       return Promise.all([user, tasks, announcements, events]);
+ *     });
+ *
+ *     setData({ user, tasks, announcements, events });
+ *   };
+ *
+ *   useEffect(() => { loadDashboard(); }, []);
+ *
+ *   if (isLoading) return <Spinner label="Loading dashboard..." />;
+ *   if (error) return <MessageBar messageBarType={MessageBarType.error}>
+ *     Failed to load dashboard: {error.message}
+ *   </MessageBar>;
+ *
+ *   return (
+ *     <Stack tokens={{ childrenGap: 20 }}>
+ *       <Text variant="xLarge">Welcome, {data?.user?.Title}</Text>
+ *       <TasksSection items={data?.tasks} />
+ *       <AnnouncementsSection items={data?.announcements} />
+ *       <EventsSection items={data?.events} />
+ *     </Stack>
+ *   );
+ * }
+ * ```
+ *
+ * @example Multi-site dashboard
+ * ```tsx
+ * function MultiSiteDashboard() {
+ *   const hrContext = useSPFxPnPContext('/sites/hr');
+ *   const financeContext = useSPFxPnPContext('/sites/finance');
+ *
+ *   const { invoke: hrInvoke, isLoading: hrLoading } = useSPFxPnP(hrContext);
+ *   const { invoke: financeInvoke, isLoading: financeLoading } = useSPFxPnP(financeContext);
+ *
+ *   const [hrData, setHrData] = useState([]);
+ *   const [financeData, setFinanceData] = useState([]);
+ *
+ *   useEffect(() => {
+ *     hrInvoke(sp => sp.web.lists.getByTitle('Employees').items.top(10)())
+ *       .then(setHrData);
+ *
+ *     financeInvoke(sp => sp.web.lists.getByTitle('Invoices').items.top(10)())
+ *       .then(setFinanceData);
+ *   }, []);
+ *
+ *   return (
+ *     <Stack tokens={{ childrenGap: 20 }}>
+ *       <Section title="HR" loading={hrLoading}>
+ *         <DetailsList items={hrData} />
+ *       </Section>
+ *       <Section title="Finance" loading={financeLoading}>
+ *         <DetailsList items={financeData} />
+ *       </Section>
+ *     </Stack>
+ *   );
+ * }
+ * ```
+ *
+ * @example Direct sp access for advanced control
+ * ```tsx
+ * function AdvancedBatchingComponent() {
+ *   const { sp, isLoading, error } = useSPFxPnP();
+ *   const [data, setData] = useState(null);
+ *   const [customLoading, setCustomLoading] = useState(false);
+ *
+ *   if (!sp) return <Spinner label="Initializing..." />;
+ *
+ *   const loadWithCustomBatch = async () => {
+ *     setCustomLoading(true);
+ *     try {
+ *       // Manual batch control
+ *       const [batchedSP, execute] = sp.batched();
+ *
+ *       const promise1 = batchedSP.web.lists();
+ *       const promise2 = batchedSP.web.currentUser();
+ *
+ *       // Execute when ready
+ *       await execute();
+ *
+ *       const [lists, user] = await Promise.all([promise1, promise2]);
+ *       setData({ lists, user });
+ *     } finally {
+ *       setCustomLoading(false);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={loadWithCustomBatch} disabled={customLoading}>
+ *       {customLoading ? 'Loading...' : 'Load Data'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @example Combining invoke and batch
+ * ```tsx
+ * function MixedOperationsComponent() {
+ *   const { invoke, batch, isLoading } = useSPFxPnP();
+ *   const [lists, setLists] = useState([]);
+ *   const [dashboardData, setDashboardData] = useState(null);
+ *
+ *   // Single operation with invoke
+ *   const loadLists = async () => {
+ *     const data = await invoke(sp => sp.web.lists());
+ *     setLists(data);
+ *   };
+ *
+ *   // Multiple operations with batch
+ *   const loadDashboard = async () => {
+ *     const data = await batch(async (batchedSP) => {
+ *       const tasks = batchedSP.web.lists.getByTitle('Tasks').items.top(10)();
+ *       const events = batchedSP.web.lists.getByTitle('Events').items.top(10)();
+ *       return Promise.all([tasks, events]);
+ *     });
+ *     setDashboardData(data);
+ *   };
+ *
+ *   return (
+ *     <Stack>
+ *       <button onClick={loadLists} disabled={isLoading}>Load Lists</button>
+ *       <button onClick={loadDashboard} disabled={isLoading}>Load Dashboard</button>
+ *     </Stack>
+ *   );
+ * }
+ * ```
+ *
+ * @example Error handling with retry
+ * ```tsx
+ * function RobustDataLoader() {
+ *   const { invoke, error, clearError, isLoading } = useSPFxPnP();
+ *   const [items, setItems] = useState([]);
+ *   const [retryCount, setRetryCount] = useState(0);
+ *
+ *   const loadItems = async () => {
+ *     try {
+ *       const data = await invoke(sp =>
+ *         sp.web.lists.getByTitle('Tasks').items()
+ *       );
+ *       setItems(data);
+ *       setRetryCount(0); // Reset on success
+ *     } catch (err) {
+ *       console.error('Failed to load items:', err);
+ *       // Error already in state
+ *     }
+ *   };
+ *
+ *   const handleRetry = () => {
+ *     clearError();
+ *     setRetryCount(prev => prev + 1);
+ *     loadItems();
+ *   };
+ *
+ *   useEffect(() => { loadItems(); }, []);
+ *
+ *   if (error) {
+ *     return (
+ *       <MessageBar
+ *         messageBarType={MessageBarType.error}
+ *         actions={
+ *           <MessageBarButton onClick={handleRetry}>
+ *             Retry {retryCount > 0 && `(${retryCount})`}
+ *           </MessageBarButton>
+ *         }
+ *       >
+ *         {error.message}
+ *       </MessageBar>
+ *     );
+ *   }
+ *
+ *   if (isLoading) {
+ *     return <Spinner label="Loading items..." />;
+ *   }
+ *
+ *   return <DetailsList items={items} />;
+ * }
+ * ```
+ *
+ * @example Loading states best practices
+ * ```tsx
+ * function OptimizedLoadingStates() {
+ *   const { invoke, isLoading, error, isInitialized } = useSPFxPnP();
+ *   const [items, setItems] = useState([]);
+ *   const [hasLoaded, setHasLoaded] = useState(false);
+ *
+ *   useEffect(() => {
+ *     if (isInitialized) {
+ *       invoke(sp => sp.web.lists.getByTitle('Tasks').items())
+ *         .then(data => {
+ *           setItems(data);
+ *           setHasLoaded(true);
+ *         });
+ *     }
+ *   }, [isInitialized]);
+ *
+ *   // Initial loading (no data yet)
+ *   if (!hasLoaded && isLoading) {
+ *     return <Spinner label="Loading tasks..." />;
+ *   }
+ *
+ *   // Initialization failed
+ *   if (!isInitialized && error) {
+ *     return <MessageBar messageBarType={MessageBarType.error}>
+ *       Failed to initialize: {error.message}
+ *     </MessageBar>;
+ *   }
+ *
+ *   // Data error
+ *   if (error) {
+ *     return <MessageBar messageBarType={MessageBarType.error}>
+ *       {error.message}
+ *     </MessageBar>;
+ *   }
+ *
+ *   // Refreshing (show data with shimmer)
+ *   if (hasLoaded && isLoading) {
+ *     return (
+ *       <div style={{ position: 'relative' }}>
+ *         <Shimmer />
+ *         <DetailsList items={items} />
+ *       </div>
+ *     );
+ *   }
+ *
+ *   // Success
+ *   return <DetailsList items={items} />;
+ * }
+ * ```
+ *
+ * @remarks
+ * **State Management**:
+ * - `isLoading` is shared between invoke() and batch() operations
+ * - `error` prioritizes invoke/batch errors over context initialization errors
+ * - Direct `sp` usage does not update isLoading or error states
+ *
+ * **Performance**:
+ * - invoke() and batch() are memoized with useCallback
+ * - Reuses SPFI instance from context (no re-initialization)
+ * - Batching reduces network roundtrips significantly
+ *
+ * **Cross-Site Operations**:
+ * - Pass PnPContextInfo from useSPFxPnPContext for different sites
+ * - Each context maintains separate configuration (cache, headers, etc.)
+ * - Requires appropriate permissions on target sites
+ *
+ * **Tree-Shaking**:
+ * - This hook imports no additional PnP modules
+ * - User-side selective imports enable optimal bundle size
+ * - Only import what you actually use
+ *
+ * @see {@link useSPFxPnPContext} for creating configured SPFI instances
+ * @see {@link useSPFxPnPList} for specialized list operations
+ */
+export function useSPFxPnP(pnpContext) {
+    var _this = this;
+    // If no context provided, create default for current site
+    var defaultContext = useSPFxPnPContext();
+    var contextToUse = pnpContext || defaultContext;
+    var sp = contextToUse.sp, isInitialized = contextToUse.isInitialized, contextError = contextToUse.error, siteUrl = contextToUse.siteUrl;
+    // Local state for invoke/batch operations
+    var _a = useState(false), isLoading = _a[0], setIsLoading = _a[1];
+    var _b = useState(), invokeError = _b[0], setInvokeError = _b[1];
+    // Prioritized error: invoke/batch errors take precedence over context errors
+    var error = invokeError || contextError;
+    /**
+     * Execute single PnPjs operation with state management
+     */
+    var invoke = useCallback(function (fn) { return __awaiter(_this, void 0, void 0, function () {
+        var result, err_1, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!sp) {
+                        throw new Error('SPFI instance not initialized. ' +
+                            'Check isInitialized property or context error.');
+                    }
+                    setIsLoading(true);
+                    setInvokeError(undefined);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, 4, 5]);
+                    return [4 /*yield*/, fn(sp)];
+                case 2:
+                    result = _a.sent();
+                    return [2 /*return*/, result];
+                case 3:
+                    err_1 = _a.sent();
+                    error_1 = err_1 instanceof Error ? err_1 : new Error(String(err_1));
+                    setInvokeError(error_1);
+                    throw error_1;
+                case 4:
+                    setIsLoading(false);
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, [sp]);
+    /**
+     * Execute multiple PnPjs operations in a single batch
+     */
+    var batch = useCallback(function (fn) { return __awaiter(_this, void 0, void 0, function () {
+        var _a, batchedSP, execute, resultPromise, result, err_2, error_2;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!sp) {
+                        throw new Error('SPFI instance not initialized. ' +
+                            'Check isInitialized property or context error.');
+                    }
+                    setIsLoading(true);
+                    setInvokeError(undefined);
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 4, 5, 6]);
+                    _a = sp.batched(), batchedSP = _a[0], execute = _a[1];
+                    resultPromise = fn(batchedSP);
+                    // Execute batch automatically
+                    return [4 /*yield*/, execute()];
+                case 2:
+                    // Execute batch automatically
+                    _b.sent();
+                    return [4 /*yield*/, resultPromise];
+                case 3:
+                    result = _b.sent();
+                    return [2 /*return*/, result];
+                case 4:
+                    err_2 = _b.sent();
+                    error_2 = err_2 instanceof Error ? err_2 : new Error(String(err_2));
+                    setInvokeError(error_2);
+                    throw error_2;
+                case 5:
+                    setIsLoading(false);
+                    return [7 /*endfinally*/];
+                case 6: return [2 /*return*/];
+            }
+        });
+    }); }, [sp]);
+    /**
+     * Clear current error state
+     */
+    var clearError = useCallback(function () {
+        setInvokeError(undefined);
+    }, []);
+    return {
+        sp: sp,
+        invoke: invoke,
+        batch: batch,
+        isLoading: isLoading,
+        error: error,
+        clearError: clearError,
+        isInitialized: isInitialized,
+        siteUrl: siteUrl,
+    };
+}
+//# sourceMappingURL=useSPFxPnP.js.map

package/lib/hooks/useSPFxPnP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSPFxPnP.js","sourceRoot":"","sources":["../../src/hooks/useSPFxPnP.ts"],"names":[],"mappings":"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"}