@apvee/spfx-react-toolkit 1.0.0

package/lib/hooks/useSPFxPageContext.d.ts

@@ -0,0 +1,37 @@
+import type { PageContext } from '@microsoft/sp-page-context';
+/**
+ * Hook to access SharePoint page context
+ *
+ * Provides access to SharePoint page context containing information about:
+ * - Site collection and web
+ * - Current user
+ * - Current list and list item (if applicable)
+ * - Teams context (if running in Teams)
+ * - Culture and locale settings
+ * - Permissions and capabilities
+ *
+ * @returns SharePoint page context object
+ *
+ * @remarks
+ * This hook extracts and returns the `pageContext` property from the SPFx context.
+ * If you need access to the full SPFx context object, use `useSPFxContext` instead.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const pageContext = useSPFxPageContext();
+ *
+ *   return (
+ *     <div>
+ *       <p>Site: {pageContext.web.title}</p>
+ *       <p>User: {pageContext.user.displayName}</p>
+ *       <p>Locale: {pageContext.cultureInfo.currentUICultureName}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @see {@link useSPFxContext} for accessing the full SPFx context
+ */
+export declare function useSPFxPageContext(): PageContext;
+//# sourceMappingURL=useSPFxPageContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSPFxPageContext.d.ts","sourceRoot":"","sources":["../../src/hooks/useSPFxPageContext.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,kBAAkB,IAAI,WAAW,CAehD"}

package/lib/hooks/useSPFxPageContext.js

@@ -0,0 +1,49 @@
+// useSPFxPageContext.ts
+// Hook to access SharePoint page context
+import { useSPFxContext } from './useSPFxContext';
+/**
+ * Hook to access SharePoint page context
+ *
+ * Provides access to SharePoint page context containing information about:
+ * - Site collection and web
+ * - Current user
+ * - Current list and list item (if applicable)
+ * - Teams context (if running in Teams)
+ * - Culture and locale settings
+ * - Permissions and capabilities
+ *
+ * @returns SharePoint page context object
+ *
+ * @remarks
+ * This hook extracts and returns the `pageContext` property from the SPFx context.
+ * If you need access to the full SPFx context object, use `useSPFxContext` instead.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const pageContext = useSPFxPageContext();
+ *
+ *   return (
+ *     <div>
+ *       <p>Site: {pageContext.web.title}</p>
+ *       <p>User: {pageContext.user.displayName}</p>
+ *       <p>Locale: {pageContext.cultureInfo.currentUICultureName}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @see {@link useSPFxContext} for accessing the full SPFx context
+ */
+export function useSPFxPageContext() {
+    var spfxContext = useSPFxContext().spfxContext;
+    // Extract pageContext from SPFx context
+    // All SPFx contexts have pageContext property
+    var ctx = spfxContext;
+    if (!ctx.pageContext) {
+        throw new Error('SPFx context does not contain pageContext. ' +
+            'This should never happen with valid SPFx contexts.');
+    }
+    return ctx.pageContext;
+}
+//# sourceMappingURL=useSPFxPageContext.js.map

package/lib/hooks/useSPFxPageContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSPFxPageContext.js","sourceRoot":"","sources":["../../src/hooks/useSPFxPageContext.ts"],"names":[],"mappings":"AAAA,wBAAwB;AACxB,yCAAyC;AAGzC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,kBAAkB;IACxB,IAAA,WAAW,GAAK,cAAc,EAAE,YAArB,CAAsB;IAEzC,wCAAwC;IACxC,8CAA8C;IAC9C,IAAM,GAAG,GAAG,WAA4C,CAAC;IAEzD,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CACb,6CAA6C;YAC7C,oDAAoD,CACrD,CAAC;IACJ,CAAC;IAED,OAAO,GAAG,CAAC,WAAW,CAAC;AACzB,CAAC"}

package/lib/hooks/useSPFxPageType.d.ts

@@ -0,0 +1,82 @@
+/**
+ * SharePoint page types
+ */
+export type SPFxPageType = 'sitePage' | 'webPartPage' | 'listPage' | 'listFormPage' | 'profilePage' | 'searchPage' | 'unknown';
+/**
+ * Return type for useSPFxPageType hook
+ */
+export interface SPFxPageTypeInfo {
+    /** Current page type */
+    readonly pageType: SPFxPageType;
+    /** Whether the page is a modern site page */
+    readonly isModernPage: boolean;
+    /** Whether the page is a site page (modern) */
+    readonly isSitePage: boolean;
+    /** Whether the page is a list page (list view) */
+    readonly isListPage: boolean;
+    /** Whether the page is a list form page */
+    readonly isListFormPage: boolean;
+    /** Whether the page is a classic web part page */
+    readonly isWebPartPage: boolean;
+}
+/**
+ * Hook for SharePoint page type detection
+ *
+ * Detects the current SharePoint page type:
+ * - sitePage: Modern site page (Site Pages library)
+ * - webPartPage: Classic web part page
+ * - listPage: List view page
+ * - listFormPage: List form (new/edit/display item)
+ * - profilePage: User profile page
+ * - searchPage: Search results page
+ * - unknown: Unable to determine
+ *
+ * Helper flags provided:
+ * - isModernPage: True for modern site pages
+ * - isSitePage: True for site pages
+ * - isListPage: True for list views
+ * - isListFormPage: True for list forms
+ * - isWebPartPage: True for classic web part pages
+ *
+ * Use this hook for:
+ * - Conditional rendering based on page type
+ * - Feature availability checks (e.g., modern-only features)
+ * - Page-specific behavior
+ * - Analytics/telemetry
+ *
+ * @returns Page type information
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { pageType, isModernPage, isSitePage } = useSPFxPageType();
+ *
+ *   if (!isModernPage) {
+ *     return <div>This feature requires a modern page</div>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <h3>Page Type: {pageType}</h3>
+ *       {isSitePage && <ModernPageFeature />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example Conditional features
+ * ```tsx
+ * function ConditionalUI() {
+ *   const { isListPage, isListFormPage } = useSPFxPageType();
+ *
+ *   return (
+ *     <div>
+ *       {isListPage && <ListViewCustomizer />}
+ *       {isListFormPage && <FormFieldCustomizer />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useSPFxPageType(): SPFxPageTypeInfo;
+//# sourceMappingURL=useSPFxPageType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSPFxPageType.d.ts","sourceRoot":"","sources":["../../src/hooks/useSPFxPageType.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,UAAU,GACV,aAAa,GACb,UAAU,GACV,cAAc,GACd,aAAa,GACb,YAAY,GACZ,SAAS,CAAC;AAEd;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,wBAAwB;IACxB,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAEhC,6CAA6C;IAC7C,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAE/B,+CAA+C;IAC/C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B,kDAAkD;IAClD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B,2CAA2C;IAC3C,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IAEjC,kDAAkD;IAClD,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,eAAe,IAAI,gBAAgB,CAoFlD"}

package/lib/hooks/useSPFxPageType.js

@@ -0,0 +1,137 @@
+// useSPFxPageType.ts
+// Hook for SharePoint page type detection
+import { useSPFxPageContext } from './useSPFxPageContext';
+/**
+ * Hook for SharePoint page type detection
+ *
+ * Detects the current SharePoint page type:
+ * - sitePage: Modern site page (Site Pages library)
+ * - webPartPage: Classic web part page
+ * - listPage: List view page
+ * - listFormPage: List form (new/edit/display item)
+ * - profilePage: User profile page
+ * - searchPage: Search results page
+ * - unknown: Unable to determine
+ *
+ * Helper flags provided:
+ * - isModernPage: True for modern site pages
+ * - isSitePage: True for site pages
+ * - isListPage: True for list views
+ * - isListFormPage: True for list forms
+ * - isWebPartPage: True for classic web part pages
+ *
+ * Use this hook for:
+ * - Conditional rendering based on page type
+ * - Feature availability checks (e.g., modern-only features)
+ * - Page-specific behavior
+ * - Analytics/telemetry
+ *
+ * @returns Page type information
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { pageType, isModernPage, isSitePage } = useSPFxPageType();
+ *
+ *   if (!isModernPage) {
+ *     return <div>This feature requires a modern page</div>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <h3>Page Type: {pageType}</h3>
+ *       {isSitePage && <ModernPageFeature />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example Conditional features
+ * ```tsx
+ * function ConditionalUI() {
+ *   const { isListPage, isListFormPage } = useSPFxPageType();
+ *
+ *   return (
+ *     <div>
+ *       {isListPage && <ListViewCustomizer />}
+ *       {isListFormPage && <FormFieldCustomizer />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useSPFxPageType() {
+    var _a, _b;
+    var pageContext = useSPFxPageContext();
+    // Try to get page type from modern pageContext
+    var modernPage = pageContext.page;
+    // Try to get page type from legacy context
+    var legacy = pageContext.legacyPageContext;
+    // Determine page type
+    var pageType = 'unknown';
+    // Check modern page type first
+    var modernPageType = (_a = modernPage === null || modernPage === void 0 ? void 0 : modernPage.type) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (modernPageType) {
+        if (modernPageType.indexOf('sitepage') !== -1) {
+            pageType = 'sitePage';
+        }
+        else if (modernPageType.indexOf('webpartpage') !== -1) {
+            pageType = 'webPartPage';
+        }
+    }
+    // Check legacy page type
+    if (pageType === 'unknown') {
+        var legacyPageType = (_b = legacy === null || legacy === void 0 ? void 0 : legacy.pageType) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+        if (legacyPageType) {
+            if (legacyPageType.indexOf('sitepage') !== -1) {
+                pageType = 'sitePage';
+            }
+            else if (legacyPageType.indexOf('webpartpage') !== -1) {
+                pageType = 'webPartPage';
+            }
+            else if (legacyPageType.indexOf('list') !== -1) {
+                // Check if it's a form or list view
+                if ((legacy === null || legacy === void 0 ? void 0 : legacy.formType) !== undefined && legacy.formType !== null) {
+                    pageType = 'listFormPage';
+                }
+                else {
+                    pageType = 'listPage';
+                }
+            }
+            else if (legacyPageType.indexOf('profile') !== -1) {
+                pageType = 'profilePage';
+            }
+            else if (legacyPageType.indexOf('search') !== -1) {
+                pageType = 'searchPage';
+            }
+        }
+    }
+    // If still unknown, try to infer from context
+    if (pageType === 'unknown') {
+        // If we have a list ID, likely a list page
+        if (legacy === null || legacy === void 0 ? void 0 : legacy.listId) {
+            if (legacy.formType !== undefined && legacy.formType !== null) {
+                pageType = 'listFormPage';
+            }
+            else {
+                pageType = 'listPage';
+            }
+        }
+    }
+    // Calculate helper flags
+    var isSitePage = pageType === 'sitePage';
+    var isWebPartPage = pageType === 'webPartPage';
+    var isListPage = pageType === 'listPage';
+    var isListFormPage = pageType === 'listFormPage';
+    // Modern page = site page (not classic web part page)
+    var isModernPage = isSitePage;
+    return {
+        pageType: pageType,
+        isModernPage: isModernPage,
+        isSitePage: isSitePage,
+        isListPage: isListPage,
+        isListFormPage: isListFormPage,
+        isWebPartPage: isWebPartPage,
+    };
+}
+//# sourceMappingURL=useSPFxPageType.js.map

package/lib/hooks/useSPFxPageType.js.map

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

package/lib/hooks/useSPFxPerformance.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Performance result type
+ */
+export interface SPFxPerfResult<T = unknown> {
+    /** Measurement name */
+    readonly name: string;
+    /** Duration in milliseconds */
+    readonly durationMs: number;
+    /** Optional result from timed operation */
+    readonly result?: T;
+    /** SPFx instance ID */
+    readonly instanceId: string;
+    /** Host kind */
+    readonly host: string;
+    /** Correlation ID for tracking */
+    readonly correlationId: string | undefined;
+}
+/**
+ * Return type for useSPFxPerformance hook
+ */
+export interface SPFxPerformanceInfo {
+    /** Create a performance mark */
+    readonly mark: (name: string) => void;
+    /** Measure duration between two marks */
+    readonly measure: (name: string, startMark: string, endMark?: string) => SPFxPerfResult;
+    /** Time an async operation */
+    readonly time: <T>(name: string, fn: () => Promise<T> | T) => Promise<SPFxPerfResult<T>>;
+}
+/**
+ * Hook for performance measurement and monitoring
+ *
+ * Provides access to the Performance API for measuring code execution time.
+ *
+ * Methods:
+ * - mark(): Create named performance marks
+ * - measure(): Calculate duration between marks
+ * - time(): Wrap async operations with automatic timing
+ *
+ * All measurements include SPFx context (instanceId, correlationId) for
+ * integration with logging and monitoring systems.
+ *
+ * Useful for:
+ * - Performance profiling
+ * - Identifying bottlenecks
+ * - Monitoring real-world performance
+ * - Integration with Application Insights
+ * - Custom performance dashboards
+ *
+ * @returns Performance measurement methods
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { mark, measure, time } = useSPFxPerformance();
+ *   const [data, setData] = useState(null);
+ *
+ *   const fetchData = async () => {
+ *     const result = await time('fetch-data', async () => {
+ *       const response = await fetch('/api/data');
+ *       return response.json();
+ *     });
+ *
+ *     console.log(`Fetch took ${result.durationMs}ms`);
+ *     setData(result.result);
+ *   };
+ *
+ *   return <button onClick={fetchData}>Load Data</button>;
+ * }
+ * ```
+ */
+export declare function useSPFxPerformance(): SPFxPerformanceInfo;
+//# sourceMappingURL=useSPFxPerformance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSPFxPerformance.d.ts","sourceRoot":"","sources":["../../src/hooks/useSPFxPerformance.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO;IACzC,uBAAuB;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,+BAA+B;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAEpB,uBAAuB;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,gBAAgB;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,kCAAkC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEtC,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,cAAc,CAAC;IAExF,8BAA8B;IAC9B,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;CAC1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,kBAAkB,IAAI,mBAAmB,CA+ExD"}

package/lib/hooks/useSPFxPerformance.js

@@ -0,0 +1,167 @@
+// useSPFxPerformance.ts
+// Hook for performance measurement and monitoring
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { useCallback } from 'react';
+import { useSPFxInstanceInfo } from './useSPFxInstanceInfo';
+import { useSPFxCorrelationInfo } from './useSPFxCorrelationInfo';
+/**
+ * Hook for performance measurement and monitoring
+ *
+ * Provides access to the Performance API for measuring code execution time.
+ *
+ * Methods:
+ * - mark(): Create named performance marks
+ * - measure(): Calculate duration between marks
+ * - time(): Wrap async operations with automatic timing
+ *
+ * All measurements include SPFx context (instanceId, correlationId) for
+ * integration with logging and monitoring systems.
+ *
+ * Useful for:
+ * - Performance profiling
+ * - Identifying bottlenecks
+ * - Monitoring real-world performance
+ * - Integration with Application Insights
+ * - Custom performance dashboards
+ *
+ * @returns Performance measurement methods
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { mark, measure, time } = useSPFxPerformance();
+ *   const [data, setData] = useState(null);
+ *
+ *   const fetchData = async () => {
+ *     const result = await time('fetch-data', async () => {
+ *       const response = await fetch('/api/data');
+ *       return response.json();
+ *     });
+ *
+ *     console.log(`Fetch took ${result.durationMs}ms`);
+ *     setData(result.result);
+ *   };
+ *
+ *   return <button onClick={fetchData}>Load Data</button>;
+ * }
+ * ```
+ */
+export function useSPFxPerformance() {
+    var _this = this;
+    var _a = useSPFxInstanceInfo(), instanceId = _a.id, host = _a.kind;
+    var correlationId = useSPFxCorrelationInfo().correlationId;
+    // Create a performance mark
+    var mark = useCallback(function (name) {
+        if (typeof (performance === null || performance === void 0 ? void 0 : performance.mark) === 'function') {
+            try {
+                performance.mark(name);
+            }
+            catch (_a) {
+                // Swallow errors (e.g., invalid mark name)
+            }
+        }
+    }, []);
+    // Measure duration between marks
+    var measure = useCallback(function (name, startMark, endMark) {
+        var _a;
+        try {
+            // Create end mark if provided
+            if (endMark && typeof (performance === null || performance === void 0 ? void 0 : performance.mark) === 'function') {
+                performance.mark(endMark);
+            }
+            // Create measure
+            if (typeof (performance === null || performance === void 0 ? void 0 : performance.measure) === 'function') {
+                performance.measure(name, startMark, endMark);
+                // Get the measurement
+                var entries = performance.getEntriesByName(name, 'measure');
+                var lastEntry = entries[entries.length - 1];
+                return {
+                    name: name,
+                    durationMs: (_a = lastEntry === null || lastEntry === void 0 ? void 0 : lastEntry.duration) !== null && _a !== void 0 ? _a : 0,
+                    instanceId: instanceId,
+                    host: host,
+                    correlationId: correlationId,
+                };
+            }
+        }
+        catch (_b) {
+            // Swallow errors
+        }
+        // Fallback result
+        return {
+            name: name,
+            durationMs: 0,
+            instanceId: instanceId,
+            host: host,
+            correlationId: correlationId,
+        };
+    }, [instanceId, host, correlationId]);
+    // Time an async operation
+    var time = useCallback(function (name, fn) { return __awaiter(_this, void 0, void 0, function () {
+        var startMark, result, measurement;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    startMark = name + '-start';
+                    mark(startMark);
+                    return [4 /*yield*/, Promise.resolve().then(fn)];
+                case 1:
+                    result = _a.sent();
+                    measurement = measure(name, startMark);
+                    return [2 /*return*/, __assign(__assign({}, measurement), { result: result })];
+            }
+        });
+    }); }, [mark, measure]);
+    return {
+        mark: mark,
+        measure: measure,
+        time: time,
+    };
+}
+//# sourceMappingURL=useSPFxPerformance.js.map

package/lib/hooks/useSPFxPerformance.js.map

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

package/lib/hooks/useSPFxPermissions.d.ts

@@ -0,0 +1,61 @@
+import { SPPermission } from '@microsoft/sp-page-context';
+/**
+ * Return type for useSPFxPermissions hook
+ */
+export interface SPFxPermissionsInfo {
+    /** Site collection permissions */
+    readonly sitePermissions: SPPermission | undefined;
+    /** Web permissions */
+    readonly webPermissions: SPPermission | undefined;
+    /** List permissions (if in list context) */
+    readonly listPermissions: SPPermission | undefined;
+    /** Check if user has specific web permission */
+    readonly hasWebPermission: (permission: SPPermission) => boolean;
+    /** Check if user has specific site permission */
+    readonly hasSitePermission: (permission: SPPermission) => boolean;
+    /** Check if user has specific list permission */
+    readonly hasListPermission: (permission: SPPermission) => boolean;
+}
+/**
+ * Hook for SharePoint permissions checking
+ *
+ * Provides access to current user's permissions at different scopes:
+ * - Site collection level
+ * - Web (subsite) level
+ * - List level (if applicable)
+ *
+ * Includes helper methods for permission checks using SPPermission enum.
+ *
+ * Common permissions to check:
+ * - SPPermission.manageWeb
+ * - SPPermission.addListItems
+ * - SPPermission.editListItems
+ * - SPPermission.deleteListItems
+ * - SPPermission.viewListItems
+ * - SPPermission.managePermissions
+ *
+ * Useful for:
+ * - Conditional UI rendering
+ * - Feature availability
+ * - Security trimming
+ * - Authorization checks
+ *
+ * @returns Permissions and helper methods
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { web, hasWebPermission } = useSPFxPermissions();
+ *   const canManage = hasWebPermission(SPPermission.manageWeb);
+ *
+ *   return (
+ *     <div>
+ *       {canManage && <button>Manage Settings</button>}
+ *       <p>Can manage: {canManage ? 'Yes' : 'No'}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useSPFxPermissions(): SPFxPermissionsInfo;
+//# sourceMappingURL=useSPFxPermissions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSPFxPermissions.d.ts","sourceRoot":"","sources":["../../src/hooks/useSPFxPermissions.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAG1D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,kCAAkC;IAClC,QAAQ,CAAC,eAAe,EAAE,YAAY,GAAG,SAAS,CAAC;IAEnD,sBAAsB;IACtB,QAAQ,CAAC,cAAc,EAAE,YAAY,GAAG,SAAS,CAAC;IAElD,4CAA4C;IAC5C,QAAQ,CAAC,eAAe,EAAE,YAAY,GAAG,SAAS,CAAC;IAEnD,gDAAgD;IAChD,QAAQ,CAAC,gBAAgB,EAAE,CAAC,UAAU,EAAE,YAAY,KAAK,OAAO,CAAC;IAEjE,iDAAiD;IACjD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,UAAU,EAAE,YAAY,KAAK,OAAO,CAAC;IAElE,iDAAiD;IACjD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,UAAU,EAAE,YAAY,KAAK,OAAO,CAAC;CACnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,kBAAkB,IAAI,mBAAmB,CA2CxD"}