@apvee/spfx-react-toolkit 1.0.0

package/lib/hooks/useSPFxTenantProperty.js

@@ -0,0 +1,683 @@
+// useSPFxTenantProperty.ts
+// Hook to manage tenant-wide properties using SharePoint StorageEntity API
+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 { useSPFxSPHttpClient } from './useSPFxSPHttpClient';
+import { useSPFxPageContext } from './useSPFxPageContext';
+import { SPHttpClient } from '@microsoft/sp-http';
+/**
+ * Hook to manage tenant-wide properties using SharePoint StorageEntity API
+ *
+ * Provides read/write operations for tenant-scoped properties stored in the
+ * SharePoint tenant app catalog. Properties are accessible across all sites
+ * in the tenant and support metadata (description only).
+ *
+ * Features:
+ * - Tenant-wide centralized storage (not site-specific)
+ * - Smart serialization for primitives, Date, and complex objects
+ * - Permission checking (canWrite flag)
+ * - Optional metadata (description only - SharePoint limitation)
+ * - Type-safe with TypeScript generics
+ * - Memory leak safe with mounted state tracking
+ * - Automatic app catalog URL discovery
+ * - Remove operation for cleanup
+ *
+ * Requirements:
+ * - Tenant app catalog must be provisioned
+ * - Read: Any authenticated user
+ * - Write/Remove: Site Collection Administrator role on tenant app catalog site
+ *
+ * Permission Notes:
+ * - Being a Tenant Admin is NOT sufficient for write operations
+ * - You must be explicitly added as Site Collection Administrator to the tenant app catalog
+ * - Navigate to the app catalog site → Site Settings → Site Collection Administrators
+ * - Add your user account if write operations fail with permission errors
+ *
+ * Storage Format:
+ * - Primitives (string, number, boolean, null) → stored as string
+ * - Date → stored as ISO 8601 string
+ * - Objects/arrays → stored as JSON string
+ *
+ * @param key - Unique property key (e.g., 'appVersion', 'apiEndpoint', 'featureFlags')
+ * @param autoFetch - Whether to automatically load property on mount. Default: true
+ *
+ * @returns Object with data, metadata, loading states, error states, and CRUD functions
+ *
+ * @example Basic usage - string property
+ * ```tsx
+ * function VersionDisplay() {
+ *   const { data, isLoading, error, write, canWrite } =
+ *     useSPFxTenantProperty<string>('appVersion');
+ *
+ *   if (isLoading) return <Spinner label="Loading version..." />;
+ *   if (error) return <MessageBar messageBarType={MessageBarType.error}>
+ *     Failed to load: {error.message}
+ *   </MessageBar>;
+ *
+ *   const handleUpdate = async () => {
+ *     if (!canWrite) {
+ *       alert('Insufficient permissions');
+ *       return;
+ *     }
+ *
+ *     try {
+ *       await write('2.0.1', 'Current application version');
+ *       console.log('Version updated!');
+ *     } catch (err) {
+ *       console.error('Update failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <Text>Current Version: {data ?? 'Not Set'}</Text>
+ *       {canWrite && <PrimaryButton onClick={handleUpdate}>Update Version</PrimaryButton>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example Number property
+ * ```tsx
+ * const { data, write } = useSPFxTenantProperty<number>('maxUploadSize');
+ *
+ * // Stored as "10485760" (10MB in bytes)
+ * await write(10485760, 'Maximum file upload size in bytes');
+ *
+ * // Read returns: 10485760 (number)
+ * console.log(typeof data); // "number"
+ * ```
+ *
+ * @example Boolean flag
+ * ```tsx
+ * const { data: maintenanceMode, write } = useSPFxTenantProperty<boolean>('maintenanceMode');
+ *
+ * // Stored as "true" or "false"
+ * await write(true, 'Maintenance mode enabled');
+ *
+ * if (maintenanceMode) {
+ *   return <MessageBar>System is under maintenance</MessageBar>;
+ * }
+ * ```
+ *
+ * @example Date property
+ * ```tsx
+ * const { data, write } = useSPFxTenantProperty<string>('lastDeployment');
+ *
+ * // Write date as ISO string
+ * await write(new Date().toISOString(), 'Last deployment timestamp');
+ *
+ * // Read and convert back to Date
+ * const lastDeploy = data ? new Date(data) : undefined;
+ * ```
+ *
+ * @example Complex object with JSON
+ * ```tsx
+ * interface FeatureFlags {
+ *   enableChat: boolean;
+ *   enableAnalytics: boolean;
+ *   maxUsers: number;
+ * }
+ *
+ * const { data, write, isLoading } = useSPFxTenantProperty<FeatureFlags>('featureFlags');
+ *
+ * // Stored as JSON string
+ * await write({
+ *   enableChat: true,
+ *   enableAnalytics: false,
+ *   maxUsers: 1000
+ * }, 'Global feature flags configuration');
+ *
+ * // Read returns parsed object
+ * if (data?.enableChat) {
+ *   return <ChatPanel />;
+ * }
+ * ```
+ *
+ * @example Permission-aware UI
+ * ```tsx
+ * function TenantConfigPanel() {
+ *   const { data, canWrite, write, isWriting, error, writeError } =
+ *     useSPFxTenantProperty<string>('apiEndpoint');
+ *
+ *   const [editValue, setEditValue] = React.useState(data ?? '');
+ *
+ *   React.useEffect(() => {
+ *     setEditValue(data ?? '');
+ *   }, [data]);
+ *
+ *   if (!canWrite) {
+ *     return (
+ *       <MessageBar messageBarType={MessageBarType.info}>
+ *         You don't have permission to edit tenant properties.
+ *         Contact your SharePoint administrator.
+ *       </MessageBar>
+ *     );
+ *   }
+ *
+ *   const handleSave = async () => {
+ *     try {
+ *       await write(editValue, 'Production API endpoint URL');
+ *     } catch (err) {
+ *       console.error('Save failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <Stack tokens={{ childrenGap: 10 }}>
+ *       <TextField
+ *         label="API Endpoint"
+ *         value={editValue}
+ *         onChange={(_, val) => setEditValue(val ?? '')}
+ *         disabled={isWriting}
+ *       />
+ *       <PrimaryButton
+ *         onClick={handleSave}
+ *         disabled={isWriting || editValue === data}
+ *       >
+ *         {isWriting ? 'Saving...' : 'Save'}
+ *       </PrimaryButton>
+ *       {writeError && (
+ *         <MessageBar messageBarType={MessageBarType.error}>
+ *           {writeError.message}
+ *         </MessageBar>
+ *       )}
+ *     </Stack>
+ *   );
+ * }
+ * ```
+ *
+ * @example With metadata viewing
+ * ```tsx
+ * function PropertyViewer() {
+ *   const { data, description, isLoading } =
+ *     useSPFxTenantProperty<string>('appConfig');
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <Stack tokens={{ childrenGap: 5 }}>
+ *       <Text variant="large">Value: {data}</Text>
+ *       {description && <Text variant="small">Description: {description}</Text>}
+ *     </Stack>
+ *   );
+ * }
+ * ```
+ *
+ * @example Lazy loading with manual trigger
+ * ```tsx
+ * const { data, load, isLoading, write } = useSPFxTenantProperty<Config>(
+ *   'appConfig',
+ *   false  // Don't auto-fetch
+ * );
+ *
+ * return (
+ *   <div>
+ *     <button onClick={load} disabled={isLoading}>
+ *       {isLoading ? 'Loading...' : 'Load Config'}
+ *     </button>
+ *     {data && <ConfigDisplay config={data} />}
+ *   </div>
+ * );
+ * ```
+ *
+ * @example Property removal
+ * ```tsx
+ * function PropertyManager() {
+ *   const { data, remove, canWrite } = useSPFxTenantProperty<string>('deprecatedSetting');
+ *
+ *   const handleDelete = async () => {
+ *     if (!confirm('Delete this property? This cannot be undone.')) return;
+ *
+ *     try {
+ *       await remove();
+ *       console.log('Property deleted');
+ *     } catch (err) {
+ *       console.error('Delete failed:', err);
+ *     }
+ *   };
+ *
+ *   if (!data) return <Text>Property not found</Text>;
+ *
+ *   return (
+ *     <Stack tokens={{ childrenGap: 10 }}>
+ *       <Text>Value: {data}</Text>
+ *       {canWrite && (
+ *         <DefaultButton onClick={handleDelete} text="Delete Property" />
+ *       )}
+ *     </Stack>
+ *   );
+ * }
+ * ```
+ *
+ * @example Multi-property dashboard
+ * ```tsx
+ * function TenantDashboard() {
+ *   const version = useSPFxTenantProperty<string>('appVersion');
+ *   const maintenance = useSPFxTenantProperty<boolean>('maintenanceMode');
+ *   const lastUpdate = useSPFxTenantProperty<string>('lastUpdate');
+ *   const config = useSPFxTenantProperty<AppConfig>('appConfig');
+ *
+ *   const isLoading = version.isLoading || maintenance.isLoading ||
+ *                     lastUpdate.isLoading || config.isLoading;
+ *
+ *   if (isLoading) return <Spinner label="Loading dashboard..." />;
+ *
+ *   return (
+ *     <Stack tokens={{ childrenGap: 20 }}>
+ *       <Text variant="xxLarge">Tenant Configuration</Text>
+ *
+ *       <Stack tokens={{ childrenGap: 10 }}>
+ *         <Label>App Version: {version.data ?? 'Not Set'}</Label>
+ *         <Label>Maintenance Mode: {maintenance.data ? 'ON' : 'OFF'}</Label>
+ *         <Label>Last Update: {lastUpdate.data ? new Date(lastUpdate.data).toLocaleString() : 'Never'}</Label>
+ *       </Stack>
+ *
+ *       {config.data && (
+ *         <Stack tokens={{ childrenGap: 5 }}>
+ *           <Text variant="large">Configuration</Text>
+ *           <pre>{JSON.stringify(config.data, null, 2)}</pre>
+ *         </Stack>
+ *       )}
+ *     </Stack>
+ *   );
+ * }
+ * ```
+ */
+export function useSPFxTenantProperty(key, autoFetch) {
+    var _this = this;
+    if (autoFetch === void 0) { autoFetch = true; }
+    var spHttpClient = useSPFxSPHttpClient().client;
+    var pageContext = useSPFxPageContext();
+    // State management
+    var _a = useState(undefined), data = _a[0], setData = _a[1];
+    var _b = useState(undefined), description = _b[0], setDescription = _b[1];
+    var _c = useState(false), isLoading = _c[0], setIsLoading = _c[1];
+    var _d = useState(undefined), error = _d[0], setError = _d[1];
+    var _e = useState(false), isWriting = _e[0], setIsWriting = _e[1];
+    var _f = useState(undefined), writeError = _f[0], setWriteError = _f[1];
+    var _g = useState(false), canWrite = _g[0], setCanWrite = _g[1];
+    var _h = useState(undefined), appCatalogUrl = _h[0], setAppCatalogUrl = _h[1];
+    // Track component mounted state to prevent memory leaks
+    var isMounted = useRef(true);
+    useEffect(function () {
+        isMounted.current = true;
+        return function () {
+            isMounted.current = false;
+        };
+    }, []);
+    /**
+     * Check if value is a primitive type (including null, Date)
+     */
+    var isPrimitive = useCallback(function (val) {
+        if (val === null)
+            return true;
+        var type = typeof val;
+        // ES5-compatible array check
+        var primitiveTypes = ['string', 'number', 'boolean', 'bigint'];
+        if (primitiveTypes.indexOf(type) !== -1)
+            return true;
+        // Date is special: treat as primitive and convert to ISO string
+        if (val instanceof Date)
+            return true;
+        return false;
+    }, []);
+    /**
+     * Serialize content for storage
+     * - Primitives → String(content)
+     * - Date → ISO string
+     * - Objects/arrays → JSON.stringify()
+     */
+    var serializeValue = useCallback(function (content) {
+        if (isPrimitive(content)) {
+            return content instanceof Date ? content.toISOString() : String(content);
+        }
+        return JSON.stringify(content);
+    }, [isPrimitive]);
+    /**
+     * Deserialize value from storage
+     * - Try JSON.parse first
+     * - If fails, return raw string (will be cast to T by TypeScript)
+     */
+    var deserializeValue = useCallback(function (rawValue) {
+        try {
+            return JSON.parse(rawValue);
+        }
+        catch (_a) {
+            // Not valid JSON, assume it's a primitive value
+            return rawValue;
+        }
+    }, []);
+    /**
+     * Discover tenant app catalog URL
+     */
+    var discoverAppCatalogUrl = useCallback(function () { return __awaiter(_this, void 0, void 0, function () {
+        var response, data_1, err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!spHttpClient || !pageContext) {
+                        throw new Error('SPHttpClient or PageContext not available');
+                    }
+                    // Check cache first
+                    if (appCatalogUrl) {
+                        return [2 /*return*/, appCatalogUrl];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, spHttpClient.get("".concat(pageContext.web.absoluteUrl, "/_api/SP_TenantSettings_Current"), SPHttpClient.configurations.v1)];
+                case 2:
+                    response = _a.sent();
+                    if (!response.ok) {
+                        throw new Error("Failed to discover app catalog: ".concat(response.statusText));
+                    }
+                    return [4 /*yield*/, response.json()];
+                case 3:
+                    data_1 = _a.sent();
+                    if (!data_1.CorporateCatalogUrl) {
+                        throw new Error('Tenant app catalog is not provisioned. Please provision the app catalog first.');
+                    }
+                    if (isMounted.current) {
+                        setAppCatalogUrl(data_1.CorporateCatalogUrl);
+                    }
+                    return [2 /*return*/, data_1.CorporateCatalogUrl];
+                case 4:
+                    err_1 = _a.sent();
+                    throw new Error("App catalog discovery failed: ".concat(err_1 instanceof Error ? err_1.message : String(err_1)));
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, [spHttpClient, pageContext, appCatalogUrl]);
+    /**
+     * Check write permissions on tenant app catalog
+     * User must be Site Collection Administrator of the tenant app catalog
+     */
+    var checkWritePermission = useCallback(function (catalogUrl) { return __awaiter(_this, void 0, void 0, function () {
+        var response, user, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!spHttpClient)
+                        return [2 /*return*/, false];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, spHttpClient.get("".concat(catalogUrl, "/_api/web/currentuser?$select=IsSiteAdmin"), SPHttpClient.configurations.v1)];
+                case 2:
+                    response = _b.sent();
+                    if (!response.ok)
+                        return [2 /*return*/, false];
+                    return [4 /*yield*/, response.json()];
+                case 3:
+                    user = _b.sent();
+                    return [2 /*return*/, user.IsSiteAdmin === true];
+                case 4:
+                    _a = _b.sent();
+                    return [2 /*return*/, false];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); }, [spHttpClient]);
+    /**
+     * Load property from tenant app catalog
+     */
+    var load = useCallback(function () { return __awaiter(_this, void 0, void 0, function () {
+        var catalogUrl, response, entity, err_2, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!spHttpClient || !pageContext) {
+                        console.warn('SPHttpClient or PageContext not available yet. Skipping load.');
+                        return [2 /*return*/];
+                    }
+                    if (!key) {
+                        console.warn('key is required. Skipping load.');
+                        return [2 /*return*/];
+                    }
+                    setIsLoading(true);
+                    setError(undefined);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 5, 6, 7]);
+                    return [4 /*yield*/, discoverAppCatalogUrl()];
+                case 2:
+                    catalogUrl = _a.sent();
+                    // Check write permissions (async, non-blocking)
+                    checkWritePermission(catalogUrl).then(function (hasPermission) {
+                        if (isMounted.current) {
+                            setCanWrite(hasPermission);
+                        }
+                    }).catch(function () {
+                        if (isMounted.current) {
+                            setCanWrite(false);
+                        }
+                    });
+                    return [4 /*yield*/, spHttpClient.get("".concat(catalogUrl, "/_api/web/GetStorageEntity('").concat(encodeURIComponent(key), "')"), SPHttpClient.configurations.v1)];
+                case 3:
+                    response = _a.sent();
+                    if (!response.ok) {
+                        throw new Error("Failed to read property: ".concat(response.statusText));
+                    }
+                    return [4 /*yield*/, response.json()];
+                case 4:
+                    entity = _a.sent();
+                    if (isMounted.current) {
+                        if (entity.Value) {
+                            setData(deserializeValue(entity.Value));
+                            setDescription(entity.Description);
+                        }
+                        else {
+                            // Property doesn't exist or has no value
+                            setData(undefined);
+                            setDescription(undefined);
+                        }
+                    }
+                    return [3 /*break*/, 7];
+                case 5:
+                    err_2 = _a.sent();
+                    if (isMounted.current) {
+                        error_1 = err_2 instanceof Error ? err_2 : new Error(String(err_2));
+                        setError(error_1);
+                        console.error('Failed to load tenant property:', error_1);
+                    }
+                    return [3 /*break*/, 7];
+                case 6:
+                    if (isMounted.current) {
+                        setIsLoading(false);
+                    }
+                    return [7 /*endfinally*/];
+                case 7: return [2 /*return*/];
+            }
+        });
+    }); }, [spHttpClient, pageContext, key, discoverAppCatalogUrl, checkWritePermission, deserializeValue]);
+    /**
+     * Write property to tenant app catalog
+     */
+    var write = useCallback(function (content, desc) { return __awaiter(_this, void 0, void 0, function () {
+        var catalogUrl, serializedValue, body, response, errorText, err_3, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!spHttpClient || !pageContext) {
+                        throw new Error('SPHttpClient or PageContext not available. Cannot write property.');
+                    }
+                    if (!key) {
+                        throw new Error('key is required. Cannot write property.');
+                    }
+                    setIsWriting(true);
+                    setWriteError(undefined);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 6, 7, 8]);
+                    return [4 /*yield*/, discoverAppCatalogUrl()];
+                case 2:
+                    catalogUrl = _a.sent();
+                    serializedValue = serializeValue(content);
+                    body = {
+                        key: key,
+                        value: serializedValue,
+                        description: desc !== null && desc !== void 0 ? desc : ''
+                        // comment is NOT supported by SharePoint SetStorageEntity API
+                    };
+                    return [4 /*yield*/, spHttpClient.post("".concat(catalogUrl, "/_api/web/SetStorageEntity"), SPHttpClient.configurations.v1, {
+                            headers: {
+                                'Content-Type': 'application/json;odata=verbose',
+                                'Accept': 'application/json;odata=verbose'
+                            },
+                            body: JSON.stringify(body)
+                        })];
+                case 3:
+                    response = _a.sent();
+                    if (!!response.ok) return [3 /*break*/, 5];
+                    return [4 /*yield*/, response.text()];
+                case 4:
+                    errorText = _a.sent();
+                    throw new Error("Failed to write property: ".concat(response.statusText, ". ").concat(errorText));
+                case 5:
+                    if (isMounted.current) {
+                        // Update local state to reflect successful write
+                        setData(content);
+                        setDescription(desc);
+                        // Clear read error if write succeeds
+                        setError(undefined);
+                    }
+                    return [3 /*break*/, 8];
+                case 6:
+                    err_3 = _a.sent();
+                    if (isMounted.current) {
+                        error_2 = err_3 instanceof Error ? err_3 : new Error(String(err_3));
+                        setWriteError(error_2);
+                        console.error('Failed to write tenant property:', error_2);
+                    }
+                    // Re-throw to allow caller to handle
+                    throw err_3;
+                case 7:
+                    if (isMounted.current) {
+                        setIsWriting(false);
+                    }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); }, [spHttpClient, pageContext, key, discoverAppCatalogUrl, serializeValue]);
+    /**
+     * Remove property from tenant app catalog
+     */
+    var remove = useCallback(function () { return __awaiter(_this, void 0, void 0, function () {
+        var catalogUrl, response, errorText, err_4, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!spHttpClient || !pageContext) {
+                        throw new Error('SPHttpClient or PageContext not available. Cannot remove property.');
+                    }
+                    if (!key) {
+                        throw new Error('key is required. Cannot remove property.');
+                    }
+                    setIsWriting(true);
+                    setWriteError(undefined);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 6, 7, 8]);
+                    return [4 /*yield*/, discoverAppCatalogUrl()];
+                case 2:
+                    catalogUrl = _a.sent();
+                    return [4 /*yield*/, spHttpClient.post("".concat(catalogUrl, "/_api/web/RemoveStorageEntity('").concat(encodeURIComponent(key), "')"), SPHttpClient.configurations.v1, {
+                            headers: {
+                                'Accept': 'application/json;odata=verbose'
+                            }
+                        })];
+                case 3:
+                    response = _a.sent();
+                    if (!!response.ok) return [3 /*break*/, 5];
+                    return [4 /*yield*/, response.text()];
+                case 4:
+                    errorText = _a.sent();
+                    throw new Error("Failed to remove property: ".concat(response.statusText, ". ").concat(errorText));
+                case 5:
+                    if (isMounted.current) {
+                        // Clear local state
+                        setData(undefined);
+                        setDescription(undefined);
+                        setError(undefined);
+                    }
+                    return [3 /*break*/, 8];
+                case 6:
+                    err_4 = _a.sent();
+                    if (isMounted.current) {
+                        error_3 = err_4 instanceof Error ? err_4 : new Error(String(err_4));
+                        setWriteError(error_3);
+                        console.error('Failed to remove tenant property:', error_3);
+                    }
+                    // Re-throw to allow caller to handle
+                    throw err_4;
+                case 7:
+                    if (isMounted.current) {
+                        setIsWriting(false);
+                    }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); }, [spHttpClient, pageContext, key, discoverAppCatalogUrl]);
+    // Auto-fetch on mount if enabled
+    useEffect(function () {
+        if (autoFetch && spHttpClient && pageContext && key) {
+            load().catch(function () {
+                // Error already handled in load() function
+            });
+        }
+    }, [autoFetch, spHttpClient, pageContext, key, load]);
+    // Computed state: ready when data loaded successfully
+    var isReady = !isLoading && !error && data !== undefined;
+    return {
+        data: data,
+        description: description,
+        isLoading: isLoading,
+        error: error,
+        isWriting: isWriting,
+        writeError: writeError,
+        canWrite: canWrite,
+        load: load,
+        write: write,
+        remove: remove,
+        isReady: isReady,
+    };
+}
+//# sourceMappingURL=useSPFxTenantProperty.js.map