@bdking71/spsignature 1.0.5

package/README.md

@@ -0,0 +1,148 @@
+# @bdking71/spsignature
+# NOT READY FOR PRODUCTION USE! Please do not use at this time. #
+@bdking71/spsignature provides a secure, lightweight, and framework-agnostic digital signature module engineered specifically for Microsoft 365 environments. Built to run inside custom SPFx Web Parts and Extension Application Customizers, it delivers tamper-evident signature collection, automated base64 image encoding, and structured payload generation directly integrated with SharePoint Online list infrastructure.
+
+Key Capabilities & Business Value
+
+- Zero Infrastructure Overhead: Operates entirely within client-side M365 contexts—no external APIs, azure functions, or third-party storage backends required.
+
+- Cross-Platform M365 Integration: Designed for seamless deployment across SharePoint Online, Microsoft Teams, and Viva Connections desktop/mobile experiences.
+
+- Integrity & Non-Repudiation: Generates cryptographic SHA-256 hashes bound to user identities, timestamps, and target record IDs to prevent signature tampering.
+
+- Standardized JSON Payload: Encapsulates complete signing metadata inside standard SharePoint Multiline Text columns (Plain Text / JSON formatted) for effortless integration with Power Automate and Power BI.
+
+## Two-Factor Authentication (2FA / TFA) Architecture
+
+To enforce non-repudiation and meet compliance standards, @bdking71/spsignature includes a flexible Two-Factor Authentication engine. Rather than relying on rigid third-party SMS gateways, it delegates code delivery to Power Automate, allowing organizations to route standard 6-digit verification codes via Microsoft Teams, Outlook Email, or both.
+
+![Diagram illustrating the 2FA workflow between SPFx, SharePoint, and Power Automate](./img/tfa.jpg)
+
+## How The 2FA Workflow Operates-
+- Code Generation: When a user initiates a signing transaction, the component generates a cryptographically secure, time-sensitive verification code (e.g., 849204) and registers a pending transaction state.
+
+- Power Automate Trigger: The component triggers a light HTTP webhook or writes a record to a dedicated SharePoint verification list.
+
+- Multi-Channel Delivery: The Power Automate flow instantly dispatches the code to the signer via:
+
+- Microsoft Teams: Direct Adaptive Card or Activity Feed notification.
+
+- Outlook Email: High-priority internal notification.
+
+- Validation & Signing: The signer enters the 6-digit code into the @bdking71/spsignature UI component. Upon successful validation, the final signed JSON payload is generated and stored in the target record.
+
+## Signature Data Schema
+
+The module returns a single, structured JSON object designed to be stored directly inside a SharePoint Multiple lines of text field (Plain Text format):
+
+```JSON
+{
+  "signatureHash": "e3b0c4429 ...",
+  "signatureData": "data:image/png;base64,iVB....",
+  "signatureTimestamp": "2026-08-31T19:55:06.121Z",
+  "verificationItemId": 1
+}
+```
+
+
+## Toolchain & Compatibility Matrix
+
+This project requires a precise local environment build. Strict adherence to the versioning matrix is mandatory to prevent toolchain compilation errors.
+
+* **SPFx Version:** `v1.22.1`
+* **Node.js:** `v18.17.1` (Recommended use of `nvm` or `nvs`)
+* **Gulp CLI:** `v4.x`
+* **Primary UI Framework:** React `v17.0.1` / Fluent UI `v8.x`
+
+## Quick Start & Local Development
+
+Execute these commands in sequence to establish your local development runtime:
+
+## Integration & Usage Guide
+
+### Provision Infrastructure
+Call `ensurePendingVerificationsList` during the WebPart lifecycle (e.g., inside `onInit()`) to automatically ensure the required `PendingVerifications` SharePoint list and columns exist on the site collection[cite: 2].
+
+```typescript
+import { ensurePendingVerificationsList } from "@bdking71/spsignature";
+
+public async onInit(): Promise<void> {
+  await super.onInit();
+
+  // Ensures 'PendingVerifications' list with 'Passcode' and 'Channel' fields exists
+  await ensurePendingVerificationsList({ context: this.context });
+}
+```
+
+### Launch Signature Modal & Capture Audit
+
+Execute promptAndGenerateSecureAudit within your component or event handler. This renders an enterprise modal overlay that handles draw, upload, or cached signature selection, triggers 2FA code delivery, validates the 5-digit passcode, and outputs a cryptographic audit payload.
+
+```TypeScript
+import {
+  promptAndGenerateSecureAudit,
+  SharePointAuditRecord
+} from "@bdking71/spsignature";
+
+private handleSignAction = async (): Promise<void> => {
+  const auditRecord: SharePointAuditRecord | undefined = await promptAndGenerateSecureAudit(
+    {
+      itemID: 1042, // Record/Item ID being signed
+      signer: this.context.pageContext.user.email,
+      spContext: this.context,
+      channel: "teams", // Code delivery route: "teams" | "email" | "both"
+      requireTFA: true,
+      payload: {
+        DocumentTitle: "Purchase Requisition #4402",
+        TotalCost: "$12,450.00",
+        ApprovedBy: this.context.pageContext.user.displayName
+      }
+    },
+    "Approve Purchase Requisition",
+    "Please review your entry and apply your signature to finalize this record."
+  );
+
+  if (auditRecord) {
+    // Save auditRecord JSON payload directly to your SharePoint multiline text column
+    console.log("Signature Hash:", auditRecord.signatureHash);
+    console.log("Compressed Image Data:", auditRecord.signatureData);
+    console.log("Timestamp:", auditRecord.signatureTimestamp);
+    console.log("Verification Log ID:", auditRecord.verificationItemId);
+  }
+};
+```
+
+### Verification & Image Reconstruction
+
+To verify non-repudiation or render the stored LZW-compressed signature image back into a view or report, use the built-in helper utilities.
+
+```typescript
+import {
+  verifySecureAuditRecord,
+  getReportableSignature
+} from "@bdking71/spsignature";
+
+// 1. Re-calculate SHA-256 hash to verify record integrity
+const isValid: boolean = await verifySecureAuditRecord(
+  payload,
+  signerEmail,
+  timestamp,
+  compressedSignatureData,
+  storedHash
+);
+
+// 2. Decompress LZW signature string into a standard PNG base64 Data-URI
+const renderableImageSrc: string = getReportableSignature(compressedSignatureData);
+```
+
+# License
+
+MIT License
+
+Copyright (C) 2012 Veselin Todorov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/lib/ProvisioningService.d.ts

@@ -0,0 +1,9 @@
+import "@pnp/sp/webs";
+import "@pnp/sp/lists";
+import "@pnp/sp/fields";
+import "@pnp/sp/views";
+import { WebPartContext } from "@microsoft/sp-webpart-base";
+export interface IEnsurePendingVerificationsListProps {
+    context: WebPartContext;
+}
+export declare const ensurePendingVerificationsList: (props: IEnsurePendingVerificationsListProps) => Promise<void>;

package/lib/ProvisioningService.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePendingVerificationsList = void 0;
+const sp_1 = require("@pnp/sp");
+require("@pnp/sp/webs");
+require("@pnp/sp/lists");
+require("@pnp/sp/fields");
+require("@pnp/sp/views");
+const ensurePendingVerificationsList = async (props) => {
+    if (!props.context) {
+        throw new Error("Execution restricted: Valid WebPartContext is required.");
+    }
+    const sp = (0, sp_1.spfi)().using((0, sp_1.SPFx)(props.context));
+    const LIST_NAME = "PendingVerifications";
+    const LIST_DESCRIPTION = "Stores temporary PIN verification codes for document signatures.";
+    const list = sp.web.lists.getByTitle(LIST_NAME);
+    let listCreated = false;
+    try {
+        await list();
+    }
+    catch (_a) {
+        await sp.web.lists.add(LIST_NAME, LIST_DESCRIPTION, 100, true);
+        listCreated = true;
+    }
+    if (!listCreated) {
+        return;
+    }
+    const ensureField = async (fieldName, createFieldFn) => {
+        try {
+            await createFieldFn();
+        }
+        catch (creationErr) {
+            throw creationErr;
+        }
+    };
+    await ensureField("Passcode", async () => {
+        await list.fields.addText("Passcode", {
+            Required: true,
+            Description: "Temporary 6-digit signature verification code."
+        });
+    });
+    await ensureField("Channel", async () => {
+        await list.fields.addChoice("Channel", {
+            Choices: ["email", "teams", "both"],
+            Required: true,
+            FillInChoice: false,
+            Description: "Target notification delivery route."
+        });
+        const channelField = list.fields.getByInternalNameOrTitle("Channel");
+        await channelField.update({ DefaultValue: "teams" });
+    });
+    try {
+        await list.update({
+            ReadSecurity: 2,
+            WriteSecurity: 2
+        });
+    }
+    catch (secErr) {
+        throw secErr;
+    }
+};
+exports.ensurePendingVerificationsList = ensurePendingVerificationsList;

package/lib/TransactionSigner.d.ts

@@ -0,0 +1,24 @@
+import { WebPartContext } from "@microsoft/sp-webpart-base";
+import { DeliveryChannel } from "./VerificationService";
+export interface SignerContext {
+    itemID: number;
+    signer: string;
+    payload: Record<string, unknown>;
+    spContext: WebPartContext;
+    channel?: DeliveryChannel;
+    requireTFA?: boolean;
+}
+export interface SharePointAuditRecord {
+    signatureHash: string;
+    signatureData: string;
+    signatureTimestamp: string;
+    verificationItemId: number;
+}
+export interface AuditEnvelopeRecord {
+    payload: Record<string, unknown>;
+    signer: string;
+    timestamp: string;
+}
+export declare function promptAndGenerateSecureAudit(context: SignerContext, modalTitle?: string, warningMessage?: string): Promise<SharePointAuditRecord | undefined>;
+export declare function getReportableSignature(compressedSignatureData: string): string;
+export declare function verifySecureAuditRecord(payloadToVerify: Record<string, unknown>, signer: string, timestamp: string, compressedSignatureData: string, storedHash: string): Promise<boolean>;

package/lib/TransactionSigner.js

@@ -0,0 +1,871 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySecureAuditRecord = exports.getReportableSignature = exports.promptAndGenerateSecureAudit = void 0;
+const VerificationService_1 = require("./VerificationService");
+const STORAGE_KEY = "secure_audit_cached_signature_v1";
+function generateFiveDigitPasscode() {
+    const array = new Uint32Array(1);
+    window.crypto.getRandomValues(array);
+    const code = (array[0] % 90000) + 10000;
+    return code.toString();
+}
+async function promptAndGenerateSecureAudit(context, modalTitle = "Approve Purchase Requisition", warningMessage = "Please review your entry and apply your signature to finalize this record.") {
+    if (!context.spContext) {
+        throw new Error("Execution restricted: Valid WebPartContext must be supplied.");
+    }
+    return new Promise((resolve) => {
+        const requireTFA = context.requireTFA !== false;
+        const generatedPasscode = generateFiveDigitPasscode();
+        let storedVerificationItemId = context.itemID;
+        const overlay = document.createElement("div");
+        overlay.style.position = "fixed";
+        overlay.style.top = "0";
+        overlay.style.left = "0";
+        overlay.style.width = "100vw";
+        overlay.style.height = "100vh";
+        overlay.style.backgroundColor = "rgba(0, 0, 0, 0.7)";
+        overlay.style.zIndex = "999999";
+        overlay.style.display = "flex";
+        overlay.style.alignItems = "center";
+        overlay.style.justifyContent = "center";
+        overlay.style.fontFamily = "'Segoe UI', Tahoma, Geneva, Verdana, sans-serif";
+        overlay.style.backdropFilter = "blur(3px)";
+        const modalBox = document.createElement("div");
+        modalBox.style.backgroundColor = "#ffffff";
+        modalBox.style.padding = "0";
+        modalBox.style.borderRadius = "8px";
+        modalBox.style.maxWidth = "640px";
+        modalBox.style.width = "90%";
+        modalBox.style.boxShadow = "0 8px 32px rgba(0,0,0,0.3)";
+        modalBox.style.overflow = "hidden";
+        modalBox.style.maxHeight = "90vh";
+        modalBox.style.display = "flex";
+        modalBox.style.flexDirection = "column";
+        const headerSection = document.createElement("div");
+        headerSection.style.backgroundColor = "#0078d4";
+        headerSection.style.padding = "20px 24px";
+        headerSection.style.borderBottom = "3px solid #005a9e";
+        const title = document.createElement("h2");
+        title.innerText = modalTitle;
+        title.style.margin = "0";
+        title.style.color = "#ffffff";
+        title.style.fontSize = "20px";
+        title.style.fontWeight = "600";
+        title.style.letterSpacing = "0.3px";
+        headerSection.appendChild(title);
+        const contentSection = document.createElement("div");
+        contentSection.style.padding = "24px";
+        contentSection.style.backgroundColor = "#fafafa";
+        contentSection.style.overflowY = "auto";
+        contentSection.style.flex = "1";
+        const body = document.createElement("p");
+        body.innerHTML = warningMessage;
+        body.style.fontSize = "14px";
+        body.style.color = "#323130";
+        body.style.lineHeight = "1.6";
+        body.style.margin = "0 0 20px 0";
+        const signButton = document.createElement("button");
+        signButton.innerText = "I Agree and Sign";
+        signButton.style.padding = "10px 24px";
+        signButton.style.backgroundColor = "#0078d4";
+        signButton.style.color = "#ffffff";
+        signButton.style.border = "none";
+        signButton.style.cursor = "pointer";
+        signButton.style.fontSize = "14px";
+        signButton.style.fontWeight = "600";
+        signButton.style.borderRadius = "4px";
+        signButton.style.transition = "all 0.2s ease";
+        const verificationContainer = document.createElement("div");
+        if (requireTFA) {
+            verificationContainer.style.marginBottom = "20px";
+            verificationContainer.style.padding = "16px";
+            verificationContainer.style.backgroundColor = "#fff8e1";
+            verificationContainer.style.border = "1px solid #ffd54f";
+            verificationContainer.style.borderRadius = "6px";
+            verificationContainer.style.boxShadow = "0 2px 4px rgba(0,0,0,0.05)";
+            const verificationHeader = document.createElement("div");
+            verificationHeader.style.display = "flex";
+            verificationHeader.style.alignItems = "center";
+            verificationHeader.style.marginBottom = "12px";
+            verificationHeader.style.gap = "8px";
+            const lockIcon = document.createElement("span");
+            lockIcon.innerHTML = "🔐";
+            lockIcon.style.fontSize = "18px";
+            const verificationLabel = document.createElement("label");
+            verificationLabel.innerText = "Two-Factor Authentication";
+            verificationLabel.style.display = "block";
+            verificationLabel.style.fontSize = "13px";
+            verificationLabel.style.fontWeight = "700";
+            verificationLabel.style.color = "#323130";
+            verificationLabel.style.margin = "0";
+            verificationHeader.appendChild(lockIcon);
+            verificationHeader.appendChild(verificationLabel);
+            const verificationDescription = document.createElement("p");
+            verificationDescription.innerText = `A 5-digit verification code has been sent to ${context.channel === "teams" ? "Microsoft Teams" : "your email"}.`;
+            verificationDescription.style.fontSize = "12px";
+            verificationDescription.style.color = "#605e5c";
+            verificationDescription.style.margin = "0 0 12px 0";
+            verificationDescription.style.lineHeight = "1.5";
+            const verificationRow = document.createElement("div");
+            verificationRow.style.display = "flex";
+            verificationRow.style.gap = "10px";
+            const verificationInput = document.createElement("input");
+            verificationInput.type = "text";
+            verificationInput.maxLength = 5;
+            verificationInput.placeholder = "Enter 5-digit code";
+            verificationInput.style.flex = "1";
+            verificationInput.style.padding = "10px 12px";
+            verificationInput.style.fontSize = "14px";
+            verificationInput.style.boxSizing = "border-box";
+            verificationInput.style.border = "2px solid #d1d1d1";
+            verificationInput.style.borderRadius = "4px";
+            verificationInput.style.outline = "none";
+            verificationInput.style.transition = "border-color 0.2s ease";
+            verificationInput.style.textAlign = "center";
+            verificationInput.style.letterSpacing = "2px";
+            verificationInput.style.fontWeight = "600";
+            verificationInput.onfocus = () => {
+                verificationInput.style.borderColor = "#0078d4";
+            };
+            verificationInput.onblur = () => {
+                verificationInput.style.borderColor = "#d1d1d1";
+            };
+            const sendCodeButton = document.createElement("button");
+            sendCodeButton.innerText = "Resend Code";
+            sendCodeButton.type = "button";
+            sendCodeButton.style.padding = "10px 16px";
+            sendCodeButton.style.fontSize = "12px";
+            sendCodeButton.style.backgroundColor = "#ffffff";
+            sendCodeButton.style.color = "#0078d4";
+            sendCodeButton.style.border = "2px solid #0078d4";
+            sendCodeButton.style.cursor = "pointer";
+            sendCodeButton.style.whiteSpace = "nowrap";
+            sendCodeButton.style.borderRadius = "4px";
+            sendCodeButton.style.fontWeight = "600";
+            sendCodeButton.style.transition = "all 0.2s ease";
+            sendCodeButton.onmouseover = () => {
+                sendCodeButton.style.backgroundColor = "#0078d4";
+                sendCodeButton.style.color = "#ffffff";
+            };
+            sendCodeButton.onmouseout = () => {
+                if (!sendCodeButton.disabled) {
+                    sendCodeButton.style.backgroundColor = "#ffffff";
+                    sendCodeButton.style.color = "#0078d4";
+                }
+            };
+            verificationRow.appendChild(verificationInput);
+            verificationRow.appendChild(sendCodeButton);
+            verificationContainer.appendChild(verificationHeader);
+            verificationContainer.appendChild(verificationDescription);
+            verificationContainer.appendChild(verificationRow);
+        }
+        const cachedCompressedSig = localStorage.getItem(STORAGE_KEY);
+        const hasCachedSignature = cachedCompressedSig !== null && cachedCompressedSig.trim() !== "";
+        const decompressedCachedDataUri = (hasCachedSignature && cachedCompressedSig)
+            ? lzwDecompress(cachedCompressedSig)
+            : "";
+        const signatureSection = document.createElement("div");
+        signatureSection.style.marginBottom = "20px";
+        signatureSection.style.padding = "16px";
+        signatureSection.style.backgroundColor = "#ffffff";
+        signatureSection.style.border = "1px solid #d1d1d1";
+        signatureSection.style.borderRadius = "6px";
+        signatureSection.style.boxShadow = "0 2px 4px rgba(0,0,0,0.05)";
+        const signatureHeader = document.createElement("div");
+        signatureHeader.style.marginBottom = "12px";
+        const signatureLabel = document.createElement("h3");
+        signatureLabel.innerText = "Digital Signature";
+        signatureLabel.style.fontSize = "14px";
+        signatureLabel.style.fontWeight = "700";
+        signatureLabel.style.color = "#323130";
+        signatureLabel.style.margin = "0 0 4px 0";
+        const signatureSubtext = document.createElement("p");
+        signatureSubtext.innerText = "Choose how you'd like to provide your signature";
+        signatureSubtext.style.fontSize = "12px";
+        signatureSubtext.style.color = "#605e5c";
+        signatureSubtext.style.margin = "0";
+        signatureHeader.appendChild(signatureLabel);
+        signatureHeader.appendChild(signatureSubtext);
+        const cacheControlBox = document.createElement("div");
+        cacheControlBox.style.marginTop = "16px";
+        cacheControlBox.style.padding = "12px";
+        cacheControlBox.style.backgroundColor = "#f3f2f1";
+        cacheControlBox.style.border = "1px solid #d1d1d1";
+        cacheControlBox.style.borderRadius = "4px";
+        cacheControlBox.style.fontSize = "12px";
+        const cacheCheckboxLabel = document.createElement("label");
+        cacheCheckboxLabel.style.display = "flex";
+        cacheCheckboxLabel.style.alignItems = "center";
+        cacheCheckboxLabel.style.gap = "8px";
+        cacheCheckboxLabel.style.cursor = "pointer";
+        const cacheCheckbox = document.createElement("input");
+        cacheCheckbox.type = "checkbox";
+        cacheCheckbox.checked = true;
+        cacheCheckbox.style.cursor = "pointer";
+        cacheCheckbox.style.width = "16px";
+        cacheCheckbox.style.height = "16px";
+        const cacheCheckboxText = document.createElement("span");
+        cacheCheckboxText.innerText = "Remember my signature on this device for future transactions";
+        cacheCheckboxText.style.color = "#323130";
+        cacheCheckboxText.style.fontSize = "12px";
+        cacheCheckboxLabel.appendChild(cacheCheckbox);
+        cacheCheckboxLabel.appendChild(cacheCheckboxText);
+        cacheControlBox.appendChild(cacheCheckboxLabel);
+        const cachedNoticeContainer = document.createElement("div");
+        cachedNoticeContainer.style.marginBottom = "16px";
+        cachedNoticeContainer.style.padding = "16px";
+        cachedNoticeContainer.style.backgroundColor = "#e6f4ff";
+        cachedNoticeContainer.style.border = "1px solid #0078d4";
+        cachedNoticeContainer.style.borderRadius = "6px";
+        cachedNoticeContainer.style.display = hasCachedSignature ? "block" : "none";
+        const cachedNoticeText = document.createElement("div");
+        cachedNoticeText.innerText = "✓ Saved signature on file";
+        cachedNoticeText.style.fontSize = "13px";
+        cachedNoticeText.style.marginBottom = "12px";
+        cachedNoticeText.style.fontWeight = "600";
+        cachedNoticeText.style.color = "#0078d4";
+        const cachedPreviewImage = document.createElement("img");
+        cachedPreviewImage.src = decompressedCachedDataUri;
+        cachedPreviewImage.style.maxWidth = "100%";
+        cachedPreviewImage.style.height = "auto";
+        cachedPreviewImage.style.minHeight = "80px";
+        cachedPreviewImage.style.maxHeight = "120px";
+        cachedPreviewImage.style.display = "block";
+        cachedPreviewImage.style.marginBottom = "12px";
+        cachedPreviewImage.style.border = "2px solid #0078d4";
+        cachedPreviewImage.style.backgroundColor = "#ffffff";
+        cachedPreviewImage.style.borderRadius = "4px";
+        cachedPreviewImage.style.padding = "8px";
+        cachedPreviewImage.style.objectFit = "contain";
+        const removeCachedBtn = document.createElement("button");
+        removeCachedBtn.innerText = "Remove Saved Signature";
+        removeCachedBtn.style.padding = "6px 12px";
+        removeCachedBtn.style.fontSize = "11px";
+        removeCachedBtn.style.backgroundColor = "#ffffff";
+        removeCachedBtn.style.border = "1px solid #a4262c";
+        removeCachedBtn.style.color = "#a4262c";
+        removeCachedBtn.style.cursor = "pointer";
+        removeCachedBtn.style.borderRadius = "4px";
+        removeCachedBtn.style.fontWeight = "600";
+        removeCachedBtn.style.transition = "all 0.2s ease";
+        removeCachedBtn.onmouseover = () => {
+            removeCachedBtn.style.backgroundColor = "#a4262c";
+            removeCachedBtn.style.color = "#ffffff";
+        };
+        removeCachedBtn.onmouseout = () => {
+            removeCachedBtn.style.backgroundColor = "#ffffff";
+            removeCachedBtn.style.color = "#a4262c";
+        };
+        cachedNoticeContainer.appendChild(cachedNoticeText);
+        cachedNoticeContainer.appendChild(cachedPreviewImage);
+        cachedNoticeContainer.appendChild(removeCachedBtn);
+        const modeContainer = document.createElement("div");
+        modeContainer.style.display = "flex";
+        modeContainer.style.gap = "8px";
+        modeContainer.style.marginBottom = "16px";
+        modeContainer.style.borderBottom = "2px solid #edebe9";
+        const createTab = (text, isActive) => {
+            const tab = document.createElement("button");
+            tab.innerText = text;
+            tab.style.padding = "10px 16px";
+            tab.style.fontSize = "13px";
+            tab.style.cursor = "pointer";
+            tab.style.fontWeight = "600";
+            tab.style.backgroundColor = "transparent";
+            tab.style.color = isActive ? "#0078d4" : "#605e5c";
+            tab.style.border = "none";
+            tab.style.borderBottom = isActive ? "3px solid #0078d4" : "3px solid transparent";
+            tab.style.transition = "all 0.2s ease";
+            tab.style.outline = "none";
+            tab.onmouseover = () => {
+                if (!isActive) {
+                    tab.style.color = "#0078d4";
+                }
+            };
+            tab.onmouseout = () => {
+                if (!isActive) {
+                    tab.style.color = "#605e5c";
+                }
+            };
+            return tab;
+        };
+        const cachedTabBtn = createTab("Saved", hasCachedSignature);
+        cachedTabBtn.style.display = hasCachedSignature ? "inline-block" : "none";
+        const drawTabBtn = createTab("Draw New", !hasCachedSignature);
+        const uploadTabBtn = createTab("Upload Image", false);
+        if (hasCachedSignature) {
+            modeContainer.appendChild(cachedTabBtn);
+        }
+        modeContainer.appendChild(drawTabBtn);
+        modeContainer.appendChild(uploadTabBtn);
+        const cachedPanel = document.createElement("div");
+        cachedPanel.style.display = hasCachedSignature ? "block" : "none";
+        cachedPanel.appendChild(cachedNoticeContainer);
+        const drawPanel = document.createElement("div");
+        drawPanel.style.display = hasCachedSignature ? "none" : "block";
+        const canvasContainer = document.createElement("div");
+        canvasContainer.style.backgroundColor = "#ffffff";
+        canvasContainer.style.padding = "16px";
+        canvasContainer.style.borderRadius = "6px";
+        canvasContainer.style.border = "2px dashed #d1d1d1";
+        const canvasInstructions = document.createElement("p");
+        canvasInstructions.innerText = "Draw your signature below:";
+        canvasInstructions.style.fontSize = "12px";
+        canvasInstructions.style.color = "#605e5c";
+        canvasInstructions.style.margin = "0 0 8px 0";
+        canvasInstructions.style.fontWeight = "600";
+        const canvas = document.createElement("canvas");
+        canvas.width = 560;
+        canvas.height = 160;
+        canvas.style.border = "1px solid #d1d1d1";
+        canvas.style.backgroundColor = "#ffffff";
+        canvas.style.cursor = "crosshair";
+        canvas.style.display = "block";
+        canvas.style.width = "100%";
+        canvas.style.borderRadius = "4px";
+        canvas.style.boxShadow = "inset 0 1px 3px rgba(0,0,0,0.1)";
+        const clearButton = document.createElement("button");
+        clearButton.innerText = "Clear Canvas";
+        clearButton.style.marginTop = "10px";
+        clearButton.style.padding = "8px 16px";
+        clearButton.style.fontSize = "12px";
+        clearButton.style.backgroundColor = "#f3f2f1";
+        clearButton.style.border = "1px solid #d1d1d1";
+        clearButton.style.cursor = "pointer";
+        clearButton.style.borderRadius = "4px";
+        clearButton.style.fontWeight = "600";
+        clearButton.style.color = "#323130";
+        clearButton.style.transition = "all 0.2s ease";
+        clearButton.onmouseover = () => {
+            clearButton.style.backgroundColor = "#e1dfdd";
+        };
+        clearButton.onmouseout = () => {
+            clearButton.style.backgroundColor = "#f3f2f1";
+        };
+        canvasContainer.appendChild(canvasInstructions);
+        canvasContainer.appendChild(canvas);
+        canvasContainer.appendChild(clearButton);
+        drawPanel.appendChild(canvasContainer);
+        const uploadPanel = document.createElement("div");
+        uploadPanel.style.display = "none";
+        uploadPanel.style.padding = "32px 24px";
+        uploadPanel.style.border = "2px dashed #d1d1d1";
+        uploadPanel.style.textAlign = "center";
+        uploadPanel.style.backgroundColor = "#ffffff";
+        uploadPanel.style.borderRadius = "6px";
+        uploadPanel.style.transition = "all 0.2s ease";
+        uploadPanel.style.minHeight = "200px";
+        uploadPanel.style.display = "none";
+        uploadPanel.style.flexDirection = "column";
+        uploadPanel.style.alignItems = "center";
+        uploadPanel.style.justifyContent = "center";
+        const uploadIcon = document.createElement("div");
+        uploadIcon.innerHTML = "📁";
+        uploadIcon.style.fontSize = "48px";
+        uploadIcon.style.marginBottom = "16px";
+        const uploadText = document.createElement("p");
+        uploadText.innerText = "Click to upload or drag and drop";
+        uploadText.style.fontSize = "14px";
+        uploadText.style.color = "#605e5c";
+        uploadText.style.margin = "0 0 8px 0";
+        uploadText.style.fontWeight = "600";
+        const uploadSubtext = document.createElement("p");
+        uploadSubtext.innerText = "PNG, JPG (max 5MB)";
+        uploadSubtext.style.fontSize = "12px";
+        uploadSubtext.style.color = "#8a8886";
+        uploadSubtext.style.margin = "0 0 16px 0";
+        const fileInput = document.createElement("input");
+        fileInput.type = "file";
+        fileInput.accept = "image/png, image/jpeg, image/jpg";
+        fileInput.style.fontSize = "12px";
+        fileInput.style.marginBottom = "16px";
+        const uploadPreview = document.createElement("img");
+        uploadPreview.style.maxWidth = "100%";
+        uploadPreview.style.height = "auto";
+        uploadPreview.style.minHeight = "80px";
+        uploadPreview.style.maxHeight = "120px";
+        uploadPreview.style.marginTop = "16px";
+        uploadPreview.style.display = "none";
+        uploadPreview.style.border = "2px solid #0078d4";
+        uploadPreview.style.borderRadius = "4px";
+        uploadPreview.style.padding = "8px";
+        uploadPreview.style.backgroundColor = "#ffffff";
+        uploadPreview.style.objectFit = "contain";
+        uploadPanel.appendChild(uploadIcon);
+        uploadPanel.appendChild(uploadText);
+        uploadPanel.appendChild(uploadSubtext);
+        uploadPanel.appendChild(fileInput);
+        uploadPanel.appendChild(uploadPreview);
+        let activeMode = hasCachedSignature ? "cached" : "draw";
+        let compressedUploadBase64 = "";
+        const ctx = canvas.getContext("2d");
+        let isDrawing = false;
+        let hasDrawnContent = false;
+        if (ctx) {
+            ctx.fillStyle = "#ffffff";
+            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            ctx.strokeStyle = "#000000";
+            ctx.lineWidth = 2.5;
+            ctx.lineCap = "round";
+            ctx.lineJoin = "round";
+        }
+        const updateButtonState = () => {
+            let isCodeValid = true;
+            if (requireTFA) {
+                const verificationInput = verificationContainer.querySelector("input");
+                const codeValue = verificationInput.value.trim();
+                isCodeValid = codeValue.length === 5 && codeValue === generatedPasscode;
+            }
+            let isSignatureValid = false;
+            if (activeMode === "cached") {
+                isSignatureValid = hasCachedSignature;
+            }
+            else if (activeMode === "draw") {
+                isSignatureValid = hasDrawnContent && ctx !== null && !isCanvasEmpty(ctx, canvas.width, canvas.height);
+            }
+            else {
+                isSignatureValid = compressedUploadBase64.trim() !== "";
+            }
+            if (isCodeValid && isSignatureValid) {
+                signButton.disabled = false;
+                signButton.style.backgroundColor = "#0078d4";
+                signButton.style.cursor = "pointer";
+                signButton.style.opacity = "1";
+            }
+            else {
+                signButton.disabled = true;
+                signButton.style.backgroundColor = "#c8c6c4";
+                signButton.style.cursor = "not-allowed";
+                signButton.style.opacity = "0.6";
+            }
+        };
+        const setActiveTab = (mode) => {
+            activeMode = mode;
+            cachedPanel.style.display = mode === "cached" ? "block" : "none";
+            drawPanel.style.display = mode === "draw" ? "block" : "none";
+            uploadPanel.style.display = mode === "upload" ? "flex" : "none";
+            [cachedTabBtn, drawTabBtn, uploadTabBtn].forEach((btn) => {
+                btn.style.color = "#605e5c";
+                btn.style.borderBottom = "3px solid transparent";
+            });
+            const activeBtn = mode === "cached" ? cachedTabBtn : mode === "draw" ? drawTabBtn : uploadTabBtn;
+            activeBtn.style.color = "#0078d4";
+            activeBtn.style.borderBottom = "3px solid #0078d4";
+            updateButtonState();
+        };
+        if (hasCachedSignature) {
+            cachedTabBtn.onclick = () => setActiveTab("cached");
+        }
+        drawTabBtn.onclick = () => setActiveTab("draw");
+        uploadTabBtn.onclick = () => setActiveTab("upload");
+        removeCachedBtn.onclick = () => {
+            localStorage.removeItem(STORAGE_KEY);
+            cachedTabBtn.style.display = "none";
+            setActiveTab("draw");
+        };
+        if (requireTFA && context.channel) {
+            const sendCodeButton = verificationContainer.querySelector("button");
+            const verificationInput = verificationContainer.querySelector("input");
+            let cooldownTimer = null;
+            const startCooldownTimer = () => {
+                let secondsLeft = 60;
+                sendCodeButton.disabled = true;
+                sendCodeButton.style.backgroundColor = "#f3f2f1";
+                sendCodeButton.style.color = "#a19f9d";
+                sendCodeButton.style.borderColor = "#d1d1d1";
+                sendCodeButton.style.cursor = "not-allowed";
+                sendCodeButton.innerText = `Resend (${secondsLeft}s)`;
+                if (cooldownTimer) {
+                    clearInterval(cooldownTimer);
+                }
+                cooldownTimer = window.setInterval(() => {
+                    secondsLeft -= 1;
+                    if (secondsLeft > 0) {
+                        sendCodeButton.innerText = `Resend (${secondsLeft}s)`;
+                    }
+                    else {
+                        if (cooldownTimer) {
+                            clearInterval(cooldownTimer);
+                        }
+                        sendCodeButton.disabled = false;
+                        sendCodeButton.style.backgroundColor = "#ffffff";
+                        sendCodeButton.style.color = "#0078d4";
+                        sendCodeButton.style.borderColor = "#0078d4";
+                        sendCodeButton.style.cursor = "pointer";
+                        sendCodeButton.innerText = "Resend Code";
+                    }
+                }, 1000);
+            };
+            const triggerSendCode = async () => {
+                sendCodeButton.innerText = "Sending...";
+                sendCodeButton.disabled = true;
+                try {
+                    if (context.spContext && context.channel) {
+                        const vResult = await (0, VerificationService_1.createPendingVerification)(context.spContext, {
+                            title: context.signer,
+                            passcode: generatedPasscode,
+                            channel: context.channel,
+                        });
+                        if (vResult.success && vResult.itemId) {
+                            storedVerificationItemId = vResult.itemId;
+                        }
+                        else {
+                            alert("Failed to dispatch verification code. Please try again.");
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error("Failed to send code:", err);
+                    alert("Failed to send verification code. Please try again.");
+                }
+                finally {
+                    startCooldownTimer();
+                }
+            };
+            sendCodeButton.onclick = async () => {
+                await triggerSendCode();
+            };
+            verificationInput.oninput = () => {
+                updateButtonState();
+            };
+            void triggerSendCode();
+        }
+        const getPos = (e) => {
+            const rect = canvas.getBoundingClientRect();
+            const clientX = "touches" in e ? e.touches[0].clientX : e.clientX;
+            const clientY = "touches" in e ? e.touches[0].clientY : e.clientY;
+            return {
+                x: (clientX - rect.left) * (canvas.width / rect.width),
+                y: (clientY - rect.top) * (canvas.height / rect.height)
+            };
+        };
+        const startDraw = (e) => {
+            isDrawing = true;
+            hasDrawnContent = true;
+            const pos = getPos(e);
+            ctx === null || ctx === void 0 ? void 0 : ctx.beginPath();
+            ctx === null || ctx === void 0 ? void 0 : ctx.moveTo(pos.x, pos.y);
+            e.preventDefault();
+        };
+        const drawLine = (e) => {
+            if (!isDrawing || !ctx)
+                return;
+            const pos = getPos(e);
+            ctx.lineTo(pos.x, pos.y);
+            ctx.stroke();
+            updateButtonState();
+            e.preventDefault();
+        };
+        const stopDraw = () => {
+            isDrawing = false;
+            updateButtonState();
+        };
+        canvas.addEventListener("mousedown", startDraw);
+        canvas.addEventListener("mousemove", drawLine);
+        window.addEventListener("mouseup", stopDraw);
+        canvas.addEventListener("touchstart", startDraw);
+        canvas.addEventListener("touchmove", drawLine);
+        window.addEventListener("touchend", stopDraw);
+        clearButton.onclick = () => {
+            if (ctx) {
+                ctx.fillStyle = "#ffffff";
+                ctx.fillRect(0, 0, canvas.width, canvas.height);
+                hasDrawnContent = false;
+                updateButtonState();
+            }
+        };
+        fileInput.onchange = (e) => {
+            const target = e.target;
+            if (target.files && target.files[0]) {
+                const file = target.files[0];
+                const reader = new FileReader();
+                reader.onload = (uploadEvent) => {
+                    var _a;
+                    if ((_a = uploadEvent.target) === null || _a === void 0 ? void 0 : _a.result) {
+                        const img = new Image();
+                        img.onload = () => {
+                            const tempCanvas = document.createElement("canvas");
+                            const maxW = 560;
+                            const maxH = 160;
+                            let w = img.width;
+                            let h = img.height;
+                            if (w > maxW) {
+                                h = Math.round((h * maxW) / w);
+                                w = maxW;
+                            }
+                            if (h > maxH) {
+                                w = Math.round((w * maxH) / h);
+                                h = maxH;
+                            }
+                            tempCanvas.width = w;
+                            tempCanvas.height = h;
+                            const tCtx = tempCanvas.getContext("2d");
+                            if (tCtx) {
+                                tCtx.fillStyle = "#ffffff";
+                                tCtx.fillRect(0, 0, w, h);
+                                tCtx.drawImage(img, 0, 0, w, h);
+                                compressedUploadBase64 = tempCanvas.toDataURL("image/png");
+                                uploadPreview.src = compressedUploadBase64;
+                                uploadPreview.style.display = "block";
+                                updateButtonState();
+                            }
+                        };
+                        img.src = uploadEvent.target.result;
+                    }
+                };
+                reader.readAsDataURL(file);
+            }
+        };
+        const footerSection = document.createElement("div");
+        footerSection.style.padding = "20px 24px";
+        footerSection.style.backgroundColor = "#ffffff";
+        footerSection.style.borderTop = "1px solid #edebe9";
+        footerSection.style.display = "flex";
+        footerSection.style.justifyContent = "flex-end";
+        footerSection.style.gap = "12px";
+        const cancelButton = document.createElement("button");
+        cancelButton.innerText = "Cancel";
+        cancelButton.style.padding = "10px 24px";
+        cancelButton.style.backgroundColor = "#ffffff";
+        cancelButton.style.border = "1px solid #8a8886";
+        cancelButton.style.cursor = "pointer";
+        cancelButton.style.fontSize = "14px";
+        cancelButton.style.fontWeight = "600";
+        cancelButton.style.color = "#323130";
+        cancelButton.style.borderRadius = "4px";
+        cancelButton.style.transition = "all 0.2s ease";
+        cancelButton.onmouseover = () => {
+            cancelButton.style.backgroundColor = "#f3f2f1";
+        };
+        cancelButton.onmouseout = () => {
+            cancelButton.style.backgroundColor = "#ffffff";
+        };
+        signButton.onmouseover = () => {
+            if (!signButton.disabled) {
+                signButton.style.backgroundColor = "#005a9e";
+            }
+        };
+        signButton.onmouseout = () => {
+            if (!signButton.disabled) {
+                signButton.style.backgroundColor = "#0078d4";
+            }
+        };
+        const cleanup = () => {
+            document.body.removeChild(overlay);
+        };
+        cancelButton.onclick = () => {
+            cleanup();
+            resolve(undefined);
+        };
+        signButton.onclick = async () => {
+            if (requireTFA) {
+                const verificationInput = verificationContainer.querySelector("input");
+                const enteredCode = verificationInput.value.trim();
+                if (enteredCode !== generatedPasscode) {
+                    alert("Invalid verification code. Please enter the correct 5-digit code.");
+                    return;
+                }
+            }
+            let finalDataUrl = "";
+            if (activeMode === "cached") {
+                if (!cachedCompressedSig) {
+                    alert("No cached signature found. Please select another option.");
+                    return;
+                }
+                finalDataUrl = lzwDecompress(cachedCompressedSig);
+            }
+            else if (activeMode === "draw") {
+                if (!ctx || isCanvasEmpty(ctx, canvas.width, canvas.height)) {
+                    alert("Please draw your signature before proceeding.");
+                    return;
+                }
+                finalDataUrl = downscaleCanvas(canvas, 560, 160);
+            }
+            else {
+                if (!compressedUploadBase64 || compressedUploadBase64.trim() === "") {
+                    alert("Please upload a signature image before proceeding.");
+                    return;
+                }
+                finalDataUrl = compressedUploadBase64;
+            }
+            const compressedString = lzwCompress(finalDataUrl);
+            if (cacheCheckbox.checked) {
+                localStorage.setItem(STORAGE_KEY, compressedString);
+            }
+            else {
+                localStorage.removeItem(STORAGE_KEY);
+            }
+            cleanup();
+            try {
+                const fullContext = Object.assign(Object.assign({}, context), { signatureData: compressedString });
+                const result = await generateSecureAuditRecordInternal(fullContext);
+                if (storedVerificationItemId) {
+                    result.verificationItemId = storedVerificationItemId;
+                }
+                resolve(result);
+            }
+            catch (error) {
+                console.error("Signing failed:", error);
+                resolve(undefined);
+            }
+        };
+        updateButtonState();
+        footerSection.appendChild(cancelButton);
+        footerSection.appendChild(signButton);
+        contentSection.appendChild(body);
+        if (requireTFA) {
+            contentSection.appendChild(verificationContainer);
+        }
+        contentSection.appendChild(signatureSection);
+        signatureSection.appendChild(signatureHeader);
+        signatureSection.appendChild(modeContainer);
+        signatureSection.appendChild(cachedPanel);
+        signatureSection.appendChild(drawPanel);
+        signatureSection.appendChild(uploadPanel);
+        signatureSection.appendChild(cacheControlBox);
+        modalBox.appendChild(headerSection);
+        modalBox.appendChild(contentSection);
+        modalBox.appendChild(footerSection);
+        overlay.appendChild(modalBox);
+        document.body.appendChild(overlay);
+    });
+}
+exports.promptAndGenerateSecureAudit = promptAndGenerateSecureAudit;
+function getReportableSignature(compressedSignatureData) {
+    const decompressed = lzwDecompress(compressedSignatureData);
+    if (!decompressed || !decompressed.startsWith("data:image")) {
+        return "";
+    }
+    return decompressed;
+}
+exports.getReportableSignature = getReportableSignature;
+function lzwCompress(input) {
+    const dictionary = {};
+    let c = "";
+    let wc = "";
+    let w = "";
+    const result = [];
+    let dictionarySize = 256;
+    for (let i = 0; i < 256; i += 1) {
+        dictionary[String.fromCharCode(i)] = i;
+    }
+    for (let i = 0; i < input.length; i += 1) {
+        c = input.charAt(i);
+        wc = w + c;
+        if (Object.prototype.hasOwnProperty.call(dictionary, wc)) {
+            w = wc;
+        }
+        else {
+            result.push(dictionary[w]);
+            dictionary[wc] = dictionarySize++;
+            w = String(c);
+        }
+    }
+    if (w !== "") {
+        result.push(dictionary[w]);
+    }
+    return result.map((n) => String.fromCharCode(n)).join("");
+}
+function lzwDecompress(compressed) {
+    const dictionary = {};
+    const result = [];
+    let dictionarySize = 256;
+    for (let i = 0; i < 256; i += 1) {
+        dictionary[i] = String.fromCharCode(i);
+    }
+    if (compressed.length === 0)
+        return "";
+    let w = String.fromCharCode(compressed.charCodeAt(0));
+    result.push(w);
+    let entry = "";
+    for (let i = 1; i < compressed.length; i += 1) {
+        const k = compressed.charCodeAt(i);
+        if (dictionary[k]) {
+            entry = dictionary[k];
+        }
+        else if (k === dictionarySize) {
+            entry = w + w.charAt(0);
+        }
+        else {
+            return "";
+        }
+        result.push(entry);
+        dictionary[dictionarySize++] = w + entry.charAt(0);
+        w = entry;
+    }
+    return result.join("");
+}
+function downscaleCanvas(sourceCanvas, targetWidth, targetHeight) {
+    const tempCanvas = document.createElement("canvas");
+    tempCanvas.width = targetWidth;
+    tempCanvas.height = targetHeight;
+    const ctx = tempCanvas.getContext("2d");
+    if (ctx) {
+        ctx.fillStyle = "#ffffff";
+        ctx.fillRect(0, 0, targetWidth, targetHeight);
+        ctx.drawImage(sourceCanvas, 0, 0, targetWidth, targetHeight);
+    }
+    return tempCanvas.toDataURL("image/png");
+}
+function isCanvasEmpty(ctx, width, height) {
+    const pixelBuffer = ctx.getImageData(0, 0, width, height).data;
+    for (let i = 0; i < pixelBuffer.length; i += 4) {
+        if (pixelBuffer[i] !== 255 ||
+            pixelBuffer[i + 1] !== 255 ||
+            pixelBuffer[i + 2] !== 255) {
+            return false;
+        }
+    }
+    return true;
+}
+async function verifySecureAuditRecord(payloadToVerify, signer, timestamp, compressedSignatureData, storedHash) {
+    try {
+        if (!payloadToVerify || !storedHash)
+            return false;
+        const sortedPayloadString = JSON.stringify(payloadToVerify, Object.keys(payloadToVerify).sort());
+        const auditEnvelope = {
+            payload: JSON.parse(sortedPayloadString),
+            signer: signer.toLowerCase().trim(),
+            timestamp: timestamp.trim(),
+        };
+        const auditEnvelopeJson = JSON.stringify(auditEnvelope);
+        const encoder = new TextEncoder();
+        const encodedBytes = encoder.encode(auditEnvelopeJson);
+        const hashBuffer = await window.crypto.subtle.digest("SHA-256", encodedBytes);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const recomputedHash = hashArray
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join("");
+        return recomputedHash === storedHash.trim();
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.verifySecureAuditRecord = verifySecureAuditRecord;
+async function generateSecureAuditRecordInternal(context) {
+    const { payload, signer, signatureData } = context;
+    if (!payload || Object.keys(payload).length === 0)
+        throw new Error("Payload cannot be empty.");
+    if (!signer || signer.trim() === "")
+        throw new Error("Signer identifier is required for sealing.");
+    const signatureTimestamp = new Date().toISOString();
+    const sortedPayloadString = JSON.stringify(payload, Object.keys(payload).sort());
+    const auditEnvelope = {
+        payload: JSON.parse(sortedPayloadString),
+        signer: signer.toLowerCase().trim(),
+        timestamp: signatureTimestamp.trim()
+    };
+    const auditEnvelopeJson = JSON.stringify(auditEnvelope);
+    const encoder = new TextEncoder();
+    const encodedBytes = encoder.encode(auditEnvelopeJson);
+    const hashBuffer = await window.crypto.subtle.digest("SHA-256", encodedBytes);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const signatureHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    return {
+        signatureHash,
+        signatureData,
+        signatureTimestamp,
+        verificationItemId: context.itemID
+    };
+}

package/lib/VerificationService.d.ts

@@ -0,0 +1,16 @@
+import "@pnp/sp/webs";
+import "@pnp/sp/lists";
+import "@pnp/sp/items";
+import { WebPartContext } from "@microsoft/sp-webpart-base";
+export type DeliveryChannel = "email" | "teams" | "both";
+export interface IVerificationRequest {
+    title: string;
+    passcode: string;
+    channel: DeliveryChannel;
+}
+export interface IVerificationResult {
+    success: boolean;
+    itemId?: number;
+    error?: string;
+}
+export declare function createPendingVerification(context: WebPartContext, request: IVerificationRequest): Promise<IVerificationResult>;

package/lib/VerificationService.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPendingVerification = void 0;
+const sp_1 = require("@pnp/sp");
+require("@pnp/sp/webs");
+require("@pnp/sp/lists");
+require("@pnp/sp/items");
+async function createPendingVerification(context, request) {
+    var _a, _b, _c, _d, _e;
+    try {
+        if (!context) {
+            throw new Error("Execution restricted: Valid WebPartContext is required.");
+        }
+        const sp = (0, sp_1.spfi)().using((0, sp_1.SPFx)(context));
+        const LIST_NAME = "PendingVerifications";
+        const addedItem = await sp.web.lists.getByTitle(LIST_NAME).items.add({
+            Title: request.title,
+            Passcode: request.passcode,
+            Channel: request.channel,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const itemId = (_e = (_d = (_b = (_a = addedItem === null || addedItem === void 0 ? void 0 : addedItem.data) === null || _a === void 0 ? void 0 : _a.Id) !== null && _b !== void 0 ? _b : (_c = addedItem === null || addedItem === void 0 ? void 0 : addedItem.data) === null || _c === void 0 ? void 0 : _c.ID) !== null && _d !== void 0 ? _d : addedItem === null || addedItem === void 0 ? void 0 : addedItem.Id) !== null && _e !== void 0 ? _e : 0;
+        return {
+            success: true,
+            itemId,
+        };
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: errorMsg,
+        };
+    }
+}
+exports.createPendingVerification = createPendingVerification;

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ProvisioningService";
+export * from "./VerificationService";
+export * from "./TransactionSigner";

package/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ProvisioningService"), exports);
+__exportStar(require("./VerificationService"), exports);
+__exportStar(require("./TransactionSigner"), exports);

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@bdking71/spsignature",
+  "version": "1.0.5",
+  "description": "SharePoint Framework WebPart isolated digital signing and provisioning engine.",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "clean": "rimraf lib",
+    "build": "tsc --build",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "spfx",
+    "sharepoint",
+    "pnp",
+    "digital-signature",
+    "audit"
+  ],
+  "author": "Your Organization Name",
+  "license": "MIT",
+  "peerDependencies": {
+    "@microsoft/sp-webpart-base": ">=1.18.0",
+    "@pnp/sp": ">=3.0.0"
+  },
+  "devDependencies": {
+    "@microsoft/sp-webpart-base": "^1.18.0",
+    "@pnp/sp": "^3.0.0",
+    "rimraf": "^5.0.0",
+    "typescript": "~5.3.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bdking71/spsignature"
+  },
+  "bugs": {
+    "url": "https://github.com/bdking71/spsignature/issues"
+  },
+  "homepage": "https://github.com/bdking71/spsignature#readme"
+}