@apvee/spfx-react-toolkit 1.0.0

package/lib/hooks/useSPFxOneDriveAppData.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Return type for useSPFxOneDriveAppData hook
+ */
+export interface SPFxOneDriveAppDataResult<T> {
+    /**
+     * The loaded data from OneDrive.
+     * Undefined if not loaded yet or on error.
+     */
+    readonly data: T | undefined;
+    /**
+     * Loading state for read operations.
+     * True during initial load or manual load() calls.
+     */
+    readonly isLoading: boolean;
+    /**
+     * Last error from read operations.
+     * Cleared on successful load or write.
+     */
+    readonly error: Error | undefined;
+    /**
+     * Loading state for write operations.
+     * True during write() calls.
+     */
+    readonly isWriting: boolean;
+    /**
+     * Last error from write operations.
+     * Cleared on successful write or load.
+     */
+    readonly writeError: Error | undefined;
+    /**
+     * Manually load/reload the file from OneDrive.
+     * Updates data, isLoading, and error states.
+     *
+     * @returns Promise that resolves when load completes
+     *
+     * @example
+     * ```tsx
+     * const { data, load } = useSPFxOneDriveAppData<Config>('config.json', undefined, false);
+     *
+     * // Load on button click
+     * <button onClick={load}>Refresh</button>
+     * ```
+     */
+    readonly load: () => Promise<void>;
+    /**
+     * Write data to OneDrive file.
+     * Creates file if it doesn't exist, updates if it does.
+     * Updates isWriting and writeError states.
+     *
+     * @param content - Data to write (will be JSON.stringify'd)
+     * @returns Promise that resolves when write completes
+     *
+     * @example
+     * ```tsx
+     * const { write, isWriting } = useSPFxOneDriveAppData<Config>('config.json');
+     *
+     * const handleSave = async () => {
+     *   await write({ theme: 'dark', language: 'en' });
+     * };
+     * ```
+     */
+    readonly write: (content: T) => Promise<void>;
+    /**
+     * Computed state: true if data is loaded successfully.
+     * Equivalent to: !isLoading && !error && data !== undefined
+     *
+     * Useful for conditional rendering:
+     * ```tsx
+     * if (!isReady) return <Spinner />;
+     * return <div>{data.title}</div>;
+     * ```
+     */
+    readonly isReady: boolean;
+}
+/**
+ * Hook to manage JSON files in user's OneDrive appRoot folder
+ *
+ * Provides unified read/write operations for JSON data stored in OneDrive's special
+ * appRoot folder (accessible per-app, user-scoped storage).
+ *
+ * Features:
+ * - Automatic JSON serialization/deserialization
+ * - Separate loading states for read/write operations
+ * - Optional auto-fetch on mount
+ * - Folder/namespace support for file organization
+ * - Type-safe with TypeScript generics
+ * - Memory leak safe with mounted state tracking
+ * - Error handling for both read and write operations
+ *
+ * Requirements:
+ * - Microsoft Graph permissions: Files.ReadWrite or Files.ReadWrite.AppFolder
+ * - User must be authenticated
+ *
+ * @param fileName - Name of the JSON file (e.g., 'config.json', 'settings.json')
+ * @param folder - Optional folder/namespace identifier for file organization.
+ *                 Will be sanitized to prevent path traversal.
+ *                 Examples: 'my-app', instanceId (GUID), 'config-v2'
+ * @param autoFetch - Whether to automatically load file on mount. Default: true
+ *
+ * @returns Object with data, loading states, error states, and read/write functions
+ *
+ * @example Basic usage - auto-fetch from root
+ * ```tsx
+ * import type { MyConfig } from './types';
+ *
+ * function ConfigPanel() {
+ *   const { data, isLoading, error, write, isWriting } =
+ *     useSPFxOneDriveAppData<MyConfig>('config.json');
+ *
+ *   if (isLoading) return <Spinner label="Loading configuration..." />;
+ *   if (error) return <MessageBar messageBarType={MessageBarType.error}>
+ *     Failed to load: {error.message}
+ *   </MessageBar>;
+ *
+ *   const handleSave = async (newConfig: MyConfig) => {
+ *     try {
+ *       await write(newConfig);
+ *       console.log('Saved successfully!');
+ *     } catch (err) {
+ *       console.error('Save failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <TextField
+ *         value={data?.title}
+ *         onChange={(_, val) => handleSave({ ...data, title: val })}
+ *         disabled={isWriting}
+ *       />
+ *       {isWriting && <Spinner label="Saving..." />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example With folder namespace
+ * ```tsx
+ * // Store files in a dedicated folder
+ * const { data, write } = useSPFxOneDriveAppData<State>(
+ *   'state.json',
+ *   'my-app-v2'  // Files stored in appRoot:/my-app-v2/state.json
+ * );
+ * ```
+ *
+ * @example Per-instance storage (multi-instance support)
+ * ```tsx
+ * // Each WebPart instance has its own data
+ * const { id } = useSPFxInstanceInfo();
+ * const { data, write } = useSPFxOneDriveAppData<Settings>(
+ *   'settings.json',
+ *   id  // Files stored in appRoot:/abc-123-guid/settings.json
+ * );
+ * ```
+ *
+ * @example Lazy loading (manual load)
+ * ```tsx
+ * const { data, load, isLoading, write } = useSPFxOneDriveAppData<Cache>(
+ *   'cache.json',
+ *   'my-app',
+ *   false  // Don't auto-fetch
+ * );
+ *
+ * return (
+ *   <div>
+ *     <button onClick={load} disabled={isLoading}>
+ *       {isLoading ? 'Loading...' : 'Load Cache'}
+ *     </button>
+ *     {data && <pre>{JSON.stringify(data, null, 2)}</pre>}
+ *   </div>
+ * );
+ * ```
+ *
+ * @example Multiple files in same namespace
+ * ```tsx
+ * function MyApp() {
+ *   const config = useSPFxOneDriveAppData<Config>('config.json', 'myapp');
+ *   const state = useSPFxOneDriveAppData<State>('state.json', 'myapp');
+ *   const cache = useSPFxOneDriveAppData<Cache>('cache.json', 'myapp');
+ *
+ *   // All files stored in appRoot:/myapp/
+ *   // Easy to manage and clean up as a group
+ * }
+ * ```
+ *
+ * @example Error handling and retry
+ * ```tsx
+ * function DataManager() {
+ *   const { data, error, load, writeError, write, isReady } =
+ *     useSPFxOneDriveAppData<MyData>('data.json');
+ *
+ *   if (error) {
+ *     return (
+ *       <MessageBar
+ *         messageBarType={MessageBarType.error}
+ *         actions={<button onClick={load}>Retry</button>}
+ *       >
+ *         Load failed: {error.message}
+ *       </MessageBar>
+ *     );
+ *   }
+ *
+ *   if (writeError) {
+ *     return (
+ *       <MessageBar messageBarType={MessageBarType.warning}>
+ *         Save failed: {writeError.message}
+ *       </MessageBar>
+ *     );
+ *   }
+ *
+ *   if (!isReady) return <Spinner />;
+ *
+ *   return <DataDisplay data={data} onSave={write} />;
+ * }
+ * ```
+ *
+ * @example CRUD-like operations
+ * ```tsx
+ * interface TodoList {
+ *   items: Array<{ id: string; text: string; done: boolean }>;
+ * }
+ *
+ * function TodoApp() {
+ *   const { data, write, isLoading, isWriting } =
+ *     useSPFxOneDriveAppData<TodoList>('todos.json', 'todo-app');
+ *
+ *   const addTodo = async (text: string) => {
+ *     const newItem = { id: crypto.randomUUID(), text, done: false };
+ *     await write({
+ *       items: [...(data?.items ?? []), newItem]
+ *     });
+ *   };
+ *
+ *   const toggleTodo = async (id: string) => {
+ *     await write({
+ *       items: data?.items.map(item =>
+ *         item.id === id ? { ...item, done: !item.done } : item
+ *       ) ?? []
+ *     });
+ *   };
+ *
+ *   const deleteTodo = async (id: string) => {
+ *     await write({
+ *       items: data?.items.filter(item => item.id !== id) ?? []
+ *     });
+ *   };
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <div>
+ *       <TodoList
+ *         items={data?.items ?? []}
+ *         onToggle={toggleTodo}
+ *         onDelete={deleteTodo}
+ *       />
+ *       <AddTodoForm onAdd={addTodo} disabled={isWriting} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useSPFxOneDriveAppData<T = unknown>(fileName: string, folder?: string, autoFetch?: boolean): SPFxOneDriveAppDataResult<T>;
+//# sourceMappingURL=useSPFxOneDriveAppData.d.ts.map

package/lib/hooks/useSPFxOneDriveAppData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSPFxOneDriveAppData.d.ts","sourceRoot":"","sources":["../../src/hooks/useSPFxOneDriveAppData.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,yBAAyB,CAAC,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IAElC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,KAAK,GAAG,SAAS,CAAC;IAEvC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9C;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2LG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,GAAG,OAAO,EAChD,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,EACf,SAAS,GAAE,OAAc,GACxB,yBAAyB,CAAC,CAAC,CAAC,CA4J9B"}

package/lib/hooks/useSPFxOneDriveAppData.js

@@ -0,0 +1,395 @@
+// useSPFxOneDriveAppData.ts
+// Hook to manage JSON files in OneDrive appRoot folder with state management
+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, useEffect, useRef } from 'react';
+import { useSPFxMSGraphClient } from './useSPFxMSGraphClient';
+/**
+ * Hook to manage JSON files in user's OneDrive appRoot folder
+ *
+ * Provides unified read/write operations for JSON data stored in OneDrive's special
+ * appRoot folder (accessible per-app, user-scoped storage).
+ *
+ * Features:
+ * - Automatic JSON serialization/deserialization
+ * - Separate loading states for read/write operations
+ * - Optional auto-fetch on mount
+ * - Folder/namespace support for file organization
+ * - Type-safe with TypeScript generics
+ * - Memory leak safe with mounted state tracking
+ * - Error handling for both read and write operations
+ *
+ * Requirements:
+ * - Microsoft Graph permissions: Files.ReadWrite or Files.ReadWrite.AppFolder
+ * - User must be authenticated
+ *
+ * @param fileName - Name of the JSON file (e.g., 'config.json', 'settings.json')
+ * @param folder - Optional folder/namespace identifier for file organization.
+ *                 Will be sanitized to prevent path traversal.
+ *                 Examples: 'my-app', instanceId (GUID), 'config-v2'
+ * @param autoFetch - Whether to automatically load file on mount. Default: true
+ *
+ * @returns Object with data, loading states, error states, and read/write functions
+ *
+ * @example Basic usage - auto-fetch from root
+ * ```tsx
+ * import type { MyConfig } from './types';
+ *
+ * function ConfigPanel() {
+ *   const { data, isLoading, error, write, isWriting } =
+ *     useSPFxOneDriveAppData<MyConfig>('config.json');
+ *
+ *   if (isLoading) return <Spinner label="Loading configuration..." />;
+ *   if (error) return <MessageBar messageBarType={MessageBarType.error}>
+ *     Failed to load: {error.message}
+ *   </MessageBar>;
+ *
+ *   const handleSave = async (newConfig: MyConfig) => {
+ *     try {
+ *       await write(newConfig);
+ *       console.log('Saved successfully!');
+ *     } catch (err) {
+ *       console.error('Save failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <TextField
+ *         value={data?.title}
+ *         onChange={(_, val) => handleSave({ ...data, title: val })}
+ *         disabled={isWriting}
+ *       />
+ *       {isWriting && <Spinner label="Saving..." />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example With folder namespace
+ * ```tsx
+ * // Store files in a dedicated folder
+ * const { data, write } = useSPFxOneDriveAppData<State>(
+ *   'state.json',
+ *   'my-app-v2'  // Files stored in appRoot:/my-app-v2/state.json
+ * );
+ * ```
+ *
+ * @example Per-instance storage (multi-instance support)
+ * ```tsx
+ * // Each WebPart instance has its own data
+ * const { id } = useSPFxInstanceInfo();
+ * const { data, write } = useSPFxOneDriveAppData<Settings>(
+ *   'settings.json',
+ *   id  // Files stored in appRoot:/abc-123-guid/settings.json
+ * );
+ * ```
+ *
+ * @example Lazy loading (manual load)
+ * ```tsx
+ * const { data, load, isLoading, write } = useSPFxOneDriveAppData<Cache>(
+ *   'cache.json',
+ *   'my-app',
+ *   false  // Don't auto-fetch
+ * );
+ *
+ * return (
+ *   <div>
+ *     <button onClick={load} disabled={isLoading}>
+ *       {isLoading ? 'Loading...' : 'Load Cache'}
+ *     </button>
+ *     {data && <pre>{JSON.stringify(data, null, 2)}</pre>}
+ *   </div>
+ * );
+ * ```
+ *
+ * @example Multiple files in same namespace
+ * ```tsx
+ * function MyApp() {
+ *   const config = useSPFxOneDriveAppData<Config>('config.json', 'myapp');
+ *   const state = useSPFxOneDriveAppData<State>('state.json', 'myapp');
+ *   const cache = useSPFxOneDriveAppData<Cache>('cache.json', 'myapp');
+ *
+ *   // All files stored in appRoot:/myapp/
+ *   // Easy to manage and clean up as a group
+ * }
+ * ```
+ *
+ * @example Error handling and retry
+ * ```tsx
+ * function DataManager() {
+ *   const { data, error, load, writeError, write, isReady } =
+ *     useSPFxOneDriveAppData<MyData>('data.json');
+ *
+ *   if (error) {
+ *     return (
+ *       <MessageBar
+ *         messageBarType={MessageBarType.error}
+ *         actions={<button onClick={load}>Retry</button>}
+ *       >
+ *         Load failed: {error.message}
+ *       </MessageBar>
+ *     );
+ *   }
+ *
+ *   if (writeError) {
+ *     return (
+ *       <MessageBar messageBarType={MessageBarType.warning}>
+ *         Save failed: {writeError.message}
+ *       </MessageBar>
+ *     );
+ *   }
+ *
+ *   if (!isReady) return <Spinner />;
+ *
+ *   return <DataDisplay data={data} onSave={write} />;
+ * }
+ * ```
+ *
+ * @example CRUD-like operations
+ * ```tsx
+ * interface TodoList {
+ *   items: Array<{ id: string; text: string; done: boolean }>;
+ * }
+ *
+ * function TodoApp() {
+ *   const { data, write, isLoading, isWriting } =
+ *     useSPFxOneDriveAppData<TodoList>('todos.json', 'todo-app');
+ *
+ *   const addTodo = async (text: string) => {
+ *     const newItem = { id: crypto.randomUUID(), text, done: false };
+ *     await write({
+ *       items: [...(data?.items ?? []), newItem]
+ *     });
+ *   };
+ *
+ *   const toggleTodo = async (id: string) => {
+ *     await write({
+ *       items: data?.items.map(item =>
+ *         item.id === id ? { ...item, done: !item.done } : item
+ *       ) ?? []
+ *     });
+ *   };
+ *
+ *   const deleteTodo = async (id: string) => {
+ *     await write({
+ *       items: data?.items.filter(item => item.id !== id) ?? []
+ *     });
+ *   };
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <div>
+ *       <TodoList
+ *         items={data?.items ?? []}
+ *         onToggle={toggleTodo}
+ *         onDelete={deleteTodo}
+ *       />
+ *       <AddTodoForm onAdd={addTodo} disabled={isWriting} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useSPFxOneDriveAppData(fileName, folder, autoFetch) {
+    var _this = this;
+    if (autoFetch === void 0) { autoFetch = true; }
+    var client = useSPFxMSGraphClient().client;
+    // State management
+    var _a = useState(undefined), data = _a[0], setData = _a[1];
+    var _b = useState(false), isLoading = _b[0], setIsLoading = _b[1];
+    var _c = useState(undefined), error = _c[0], setError = _c[1];
+    var _d = useState(false), isWriting = _d[0], setIsWriting = _d[1];
+    var _e = useState(undefined), writeError = _e[0], setWriteError = _e[1];
+    // Track component mounted state to prevent memory leaks
+    var isMounted = useRef(true);
+    useEffect(function () {
+        isMounted.current = true;
+        return function () {
+            isMounted.current = false;
+        };
+    }, []);
+    /**
+     * Build Graph API path with optional folder namespace
+     * Sanitizes folder name to prevent path traversal attacks
+     */
+    var buildApiPath = useCallback(function (file, folderName) {
+        var basePath = '/me/drive/special/appRoot:';
+        if (folderName) {
+            // Sanitize folder name: only allow alphanumeric, hyphens, underscores
+            // This prevents path traversal (../) and other injection attacks
+            var safeFolderName = folderName.replace(/[^a-zA-Z0-9-_]/g, '-');
+            return "".concat(basePath, "/").concat(safeFolderName, "/").concat(file, ":/content");
+        }
+        return "".concat(basePath, "/").concat(file, ":/content");
+    }, []);
+    /**
+     * Load file from OneDrive
+     * Updates data, isLoading, and error states
+     */
+    var load = useCallback(function () { return __awaiter(_this, void 0, void 0, function () {
+        var apiPath, fileContent, err_1, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!client) {
+                        console.warn('Graph client not available yet. Skipping load.');
+                        return [2 /*return*/];
+                    }
+                    if (!fileName) {
+                        console.warn('fileName is required. Skipping load.');
+                        return [2 /*return*/];
+                    }
+                    setIsLoading(true);
+                    setError(undefined);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, 4, 5]);
+                    apiPath = buildApiPath(fileName, folder);
+                    return [4 /*yield*/, client.api(apiPath).get()];
+                case 2:
+                    fileContent = _a.sent();
+                    if (isMounted.current) {
+                        // Parse JSON if response is string, otherwise use as-is
+                        if (typeof fileContent === 'string') {
+                            try {
+                                setData(JSON.parse(fileContent));
+                            }
+                            catch (parseError) {
+                                throw new Error("Failed to parse JSON: ".concat(parseError instanceof Error ? parseError.message : 'Unknown error'));
+                            }
+                        }
+                        else {
+                            setData(fileContent);
+                        }
+                    }
+                    return [3 /*break*/, 5];
+                case 3:
+                    err_1 = _a.sent();
+                    if (isMounted.current) {
+                        error_1 = err_1 instanceof Error ? err_1 : new Error(String(err_1));
+                        setError(error_1);
+                        // Don't throw - allow component to handle error via state
+                        console.error('Failed to load file from OneDrive:', error_1);
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    if (isMounted.current) {
+                        setIsLoading(false);
+                    }
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, [client, fileName, folder, buildApiPath]);
+    /**
+     * Write data to OneDrive file
+     * Creates file if it doesn't exist, updates if it does (upsert)
+     * Updates isWriting and writeError states
+     */
+    var write = useCallback(function (content) { return __awaiter(_this, void 0, void 0, function () {
+        var apiPath, jsonContent, err_2, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!client) {
+                        throw new Error('Graph client not available. Cannot write file.');
+                    }
+                    if (!fileName) {
+                        throw new Error('fileName is required. Cannot write file.');
+                    }
+                    setIsWriting(true);
+                    setWriteError(undefined);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, 4, 5]);
+                    apiPath = buildApiPath(fileName, folder);
+                    jsonContent = JSON.stringify(content);
+                    return [4 /*yield*/, client
+                            .api(apiPath)
+                            .header('Content-Type', 'application/json')
+                            .put(jsonContent)];
+                case 2:
+                    _a.sent();
+                    if (isMounted.current) {
+                        // Update local data to reflect successful write
+                        setData(content);
+                        // Clear read error if write succeeds (fresh state)
+                        setError(undefined);
+                    }
+                    return [3 /*break*/, 5];
+                case 3:
+                    err_2 = _a.sent();
+                    if (isMounted.current) {
+                        error_2 = err_2 instanceof Error ? err_2 : new Error(String(err_2));
+                        setWriteError(error_2);
+                        console.error('Failed to write file to OneDrive:', error_2);
+                    }
+                    // Re-throw to allow caller to handle
+                    throw err_2;
+                case 4:
+                    if (isMounted.current) {
+                        setIsWriting(false);
+                    }
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, [client, fileName, folder, buildApiPath]);
+    // Auto-fetch on mount if enabled
+    useEffect(function () {
+        if (autoFetch && client && fileName) {
+            load().catch(function () {
+                // Error already handled in load() function
+            });
+        }
+    }, [autoFetch, client, fileName, load]);
+    // Computed state: ready when data loaded successfully
+    var isReady = !isLoading && !error && data !== undefined;
+    return {
+        data: data,
+        isLoading: isLoading,
+        error: error,
+        isWriting: isWriting,
+        writeError: writeError,
+        load: load,
+        write: write,
+        isReady: isReady,
+    };
+}
+//# sourceMappingURL=useSPFxOneDriveAppData.js.map

package/lib/hooks/useSPFxOneDriveAppData.js.map

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