@salesforce/webapp-experimental 1.80.1 → 1.82.0

package/dist/api/utils/records.test.js

@@ -1,190 +0,0 @@
-/**
- * Copyright (c) 2026, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { getRecord, createRecord, updateRecord, deleteRecord } from "./records.js";
-// Mock the uiApiClient
-vi.mock("../clients.js", () => {
-    const mockGet = vi.fn();
-    const mockPost = vi.fn();
-    const mockPatch = vi.fn();
-    const mockDelete = vi.fn();
-    return {
-        uiApiClient: {
-            get: mockGet,
-            post: mockPost,
-            patch: mockPatch,
-            delete: mockDelete,
-        },
-    };
-});
-// Get references to the mocked functions for assertions
-const { uiApiClient } = await import("../clients.js");
-const mockGet = vi.mocked(uiApiClient.get);
-const mockPost = vi.mocked(uiApiClient.post);
-const mockPatch = vi.mocked(uiApiClient.patch);
-const mockDelete = vi.mocked(uiApiClient.delete);
-describe("Records API Utils", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("getRecord", () => {
-        const data = {
-            fields: {
-                Name: { value: "Test Account" },
-                Industry: { value: "Technology" },
-                Phone: { value: "555-0123" },
-            },
-        };
-        const mockRecordResponse = { json: vi.fn().mockResolvedValue(data) };
-        it("fetches a record by ID with default params", async () => {
-            mockGet.mockResolvedValue(mockRecordResponse);
-            const result = await getRecord("001000000000001");
-            expect(mockGet).toHaveBeenCalledWith("/records/001000000000001");
-            expect(result).toEqual(data);
-        });
-        it("fetches a record by ID with custom params", async () => {
-            mockGet.mockResolvedValue(mockRecordResponse);
-            const params = { fields: "Name,Industry,Phone" };
-            const result = await getRecord("001000000000001", params);
-            expect(mockGet).toHaveBeenCalledWith("/records/001000000000001?fields=Name%2CIndustry%2CPhone");
-            expect(result).toEqual(data);
-        });
-        it("handles API errors correctly", async () => {
-            const apiError = new Error("Record not found");
-            mockGet.mockRejectedValue(apiError);
-            await expect(getRecord("001000000000001")).rejects.toThrow("Record not found");
-            expect(mockGet).toHaveBeenCalledWith("/records/001000000000001");
-        });
-    });
-    describe("createRecord", () => {
-        const data = {
-            id: "001000000000002",
-            success: true,
-        };
-        const mockCreateResponse = { json: vi.fn().mockResolvedValue(data) };
-        it("creates a record with correct API name and fields", async () => {
-            mockPost.mockResolvedValue(mockCreateResponse);
-            const apiName = "Account";
-            const fields = {
-                Name: "New Test Account",
-                Industry: "Healthcare",
-                Phone: "555-0456",
-            };
-            const result = await createRecord(apiName, fields);
-            expect(mockPost).toHaveBeenCalledWith("/records", { apiName, fields });
-            expect(result).toEqual(data);
-        });
-        it("handles empty fields object", async () => {
-            mockPost.mockResolvedValue(mockCreateResponse);
-            const result = await createRecord("Account", {});
-            expect(mockPost).toHaveBeenCalledWith("/records", {
-                apiName: "Account",
-                fields: {},
-            });
-            expect(result).toEqual(data);
-        });
-        it("handles API errors during creation", async () => {
-            const apiError = new Error("Invalid field value");
-            mockPost.mockRejectedValue(apiError);
-            const fields = { Name: "" }; // Invalid empty name
-            await expect(createRecord("Account", fields)).rejects.toThrow("Invalid field value");
-            expect(mockPost).toHaveBeenCalledWith("/records", {
-                apiName: "Account",
-                fields,
-            });
-        });
-    });
-    describe("updateRecord", () => {
-        const data = { success: true };
-        const mockUpdateResponse = { json: vi.fn().mockResolvedValue(data) };
-        it("updates a record with correct ID and fields", async () => {
-            mockPatch.mockResolvedValue(mockUpdateResponse);
-            const recordId = "001000000000001";
-            const fields = {
-                Name: "Updated Account Name",
-                Industry: "Finance",
-            };
-            const result = await updateRecord(recordId, fields);
-            expect(mockPatch).toHaveBeenCalledWith(`/records/${recordId}`, {
-                fields,
-            });
-            expect(result).toEqual(data);
-        });
-        it("handles partial field updates", async () => {
-            mockPatch.mockResolvedValue(mockUpdateResponse);
-            const recordId = "001000000000001";
-            const fields = { Industry: "Manufacturing" };
-            const result = await updateRecord(recordId, fields);
-            expect(mockPatch).toHaveBeenCalledWith(`/records/${recordId}`, {
-                fields,
-            });
-            expect(result).toEqual(data);
-        });
-        it("handles API errors during update", async () => {
-            const apiError = new Error("Record is locked");
-            mockPatch.mockRejectedValue(apiError);
-            const recordId = "001000000000001";
-            const fields = { Name: "New Name" };
-            await expect(updateRecord(recordId, fields)).rejects.toThrow("Record is locked");
-            expect(mockPatch).toHaveBeenCalledWith(`/records/${recordId}`, {
-                fields,
-            });
-        });
-        it("handles empty fields object for update", async () => {
-            mockPatch.mockResolvedValue(mockUpdateResponse);
-            const result = await updateRecord("001000000000001", {});
-            expect(mockPatch).toHaveBeenCalledWith("/records/001000000000001", {
-                fields: {},
-            });
-            expect(result).toEqual(data);
-        });
-    });
-    describe("deleteRecord", () => {
-        it("deletes a record by ID and returns true", async () => {
-            mockDelete.mockResolvedValue({});
-            const result = await deleteRecord("001000000000001");
-            expect(mockDelete).toHaveBeenCalledWith("/records/001000000000001");
-            expect(result).toBe(true);
-        });
-        it("handles API errors during deletion", async () => {
-            const apiError = new Error("Cannot delete record");
-            mockDelete.mockRejectedValue(apiError);
-            await expect(deleteRecord("001000000000001")).rejects.toThrow("Cannot delete record");
-            expect(mockDelete).toHaveBeenCalledWith("/records/001000000000001");
-        });
-        it("always returns true on successful deletion", async () => {
-            mockDelete.mockResolvedValue({ status: 204 });
-            const result = await deleteRecord("001000000000001");
-            expect(result).toBe(true);
-        });
-    });
-    describe("Error Handling", () => {
-        it("propagates network errors from getRecord", async () => {
-            const networkError = new Error("Network timeout");
-            networkError.name = "NetworkError";
-            mockGet.mockRejectedValue(networkError);
-            await expect(getRecord("001000000000001")).rejects.toThrow("Network timeout");
-        });
-        it("propagates validation errors from createRecord", async () => {
-            const validationError = new Error("Required field missing");
-            validationError.name = "ValidationError";
-            mockPost.mockRejectedValue(validationError);
-            await expect(createRecord("Account", {})).rejects.toThrow("Required field missing");
-        });
-        it("propagates permission errors from updateRecord", async () => {
-            const permissionError = new Error("Insufficient permissions");
-            permissionError.name = "PermissionError";
-            mockPatch.mockRejectedValue(permissionError);
-            await expect(updateRecord("001000000000001", { Name: "Test" })).rejects.toThrow("Insufficient permissions");
-        });
-        it("propagates not found errors from deleteRecord", async () => {
-            const notFoundError = new Error("Record not found");
-            notFoundError.name = "NotFoundError";
-            mockDelete.mockRejectedValue(notFoundError);
-            await expect(deleteRecord("001000000000001")).rejects.toThrow("Record not found");
-        });
-    });
-});

package/dist/api/utils/user.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Copyright (c) 2026, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-export {};
-//# sourceMappingURL=user.test.d.ts.map

package/dist/api/utils/user.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"user.test.d.ts","sourceRoot":"","sources":["../../../src/api/utils/user.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/api/utils/user.test.js

@@ -1,108 +0,0 @@
-/**
- * Copyright (c) 2026, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { getCurrentUser } from "./user.js";
-const mockFetch = vi.fn();
-vi.mock("@salesforce/sdk-data", () => ({
-    getDataSDK: vi.fn(() => Promise.resolve({
-        fetch: mockFetch,
-    })),
-}));
-// Mock console.error to avoid noise in test output
-const mockConsoleError = vi.spyOn(console, "error").mockImplementation(() => {
-    /* noop */
-});
-describe("User API Utils", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        mockConsoleError.mockClear();
-    });
-    describe("getCurrentUser", () => {
-        const mockChatterUser = {
-            id: "005000000000001",
-            name: "John Doe",
-            email: "john@example.com",
-            username: "john@example.com",
-        };
-        it("successfully fetches current user", async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve(mockChatterUser),
-            });
-            const result = await getCurrentUser();
-            expect(mockFetch).toHaveBeenCalledWith("/services/data/v99.0/chatter/users/me");
-            expect(result).toEqual({
-                id: "005000000000001",
-                name: "John Doe",
-            });
-        });
-        it('falls back to "User" when name is empty', async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    id: "005000000000003",
-                    name: "",
-                }),
-            });
-            const result = await getCurrentUser();
-            expect(result).toEqual({
-                id: "005000000000003",
-                name: "User",
-            });
-        });
-        it('falls back to "User" when name is null', async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    id: "005000000000004",
-                    name: null,
-                }),
-            });
-            const result = await getCurrentUser();
-            expect(result).toEqual({
-                id: "005000000000004",
-                name: "User",
-            });
-        });
-        it('falls back to "User" when name is undefined', async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    id: "005000000000005",
-                }),
-            });
-            const result = await getCurrentUser();
-            expect(result).toEqual({
-                id: "005000000000005",
-                name: "User",
-            });
-        });
-        it("throws error when request fails", async () => {
-            mockFetch.mockResolvedValue({
-                ok: false,
-                status: 500,
-            });
-            await expect(getCurrentUser()).rejects.toThrow("HTTP 500");
-            expect(mockConsoleError).toHaveBeenCalled();
-        });
-        it("throws error when no user data is found", async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({}),
-            });
-            await expect(getCurrentUser()).rejects.toThrow("No user data found in Chatter API response");
-            expect(mockConsoleError).toHaveBeenCalled();
-        });
-        it("throws error when fetch rejects", async () => {
-            const apiError = new Error("Network error");
-            mockFetch.mockRejectedValue(apiError);
-            await expect(getCurrentUser()).rejects.toThrow("Network error");
-            expect(mockConsoleError).toHaveBeenCalledWith("Error fetching user data:", apiError);
-        });
-    });
-});

package/dist/design/interactions/communicationManager.js

@@ -1,108 +0,0 @@
-/**
- * Copyright (c) 2026, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-/**
- * Communication Manager Module
- * Handles communication with the parent window (VS Code extension)
- */
-import { TEXT_TAGS } from "./editableManager.js";
-import { getElementStyles } from "./utils/cssUtils.js";
-import { getLabelFromSource, getSourceFromDataAttributes } from "./utils/sourceUtils.js";
-export class CommunicationManager {
-    constructor() {
-        // CommunicationManager has no required initialization
-    }
-    /**
-     * Notify the extension about a selected component
-     * @param element - The selected element
-     */
-    notifyComponentSelected(element) {
-        const label = getLabelFromSource(element);
-        // Temporarily remove design-mode-selected class to get original styles
-        const wasSelected = element.classList.contains("design-mode-selected");
-        if (wasSelected) {
-            element.classList.remove("design-mode-selected");
-        }
-        const styles = getElementStyles(element);
-        // Restore design-mode-selected class if it was present
-        if (wasSelected) {
-            element.classList.add("design-mode-selected");
-        }
-        // Source location metadata injected at compile time (babel-plugin-enhanced-locator)
-        const debugSource = getSourceFromDataAttributes(element);
-        const textType = element.dataset?.textType ?? "none";
-        const hasNonEditableText = TEXT_TAGS.includes(element.tagName) && (textType === "dynamic" || textType === "mixed");
-        // Send message to parent window
-        try {
-            if (window.parent !== window) {
-                window.parent.postMessage({
-                    type: "component-selected",
-                    component: {
-                        name: label,
-                        tagName: element.tagName,
-                        styles: {
-                            ...styles,
-                        },
-                        debugSource: debugSource,
-                        hasNonEditableText,
-                    },
-                }, "*");
-            }
-        }
-        catch (error) {
-            console.log("Could not notify extension:", error);
-        }
-        // Store in global for polling fallback
-        window.selectedComponentInfo =
-            {
-                name: label,
-                element: element,
-                tagName: element.tagName,
-            };
-    }
-    /**
-     * Notify the extension about a text change
-     * @param element - The element that changed
-     * @param originalText - The original text
-     * @param newText - The new text
-     */
-    notifyTextChange(element, originalText, newText) {
-        const label = getLabelFromSource(element);
-        const debugSource = getSourceFromDataAttributes(element);
-        try {
-            if (window.parent !== window) {
-                window.parent.postMessage({
-                    type: "text-changed",
-                    change: {
-                        componentName: label,
-                        tagName: element.tagName,
-                        originalText,
-                        newText,
-                        debugSource,
-                    },
-                }, "*");
-            }
-        }
-        catch (error) {
-            console.log("Could not notify extension about text change:", error);
-        }
-    }
-    /**
-     * Notify the parent window that interactions initialization is complete
-     */
-    notifyInitializationComplete() {
-        try {
-            if (typeof window !== "undefined" && window.parent && window.parent !== window) {
-                window.parent.postMessage({
-                    type: "interactions-initialized",
-                }, "*");
-            }
-        }
-        catch (error) {
-            const err = error;
-            console.warn("Could not send initialization message to parent:", err.message);
-        }
-    }
-}

package/dist/design/interactions/componentMatcher.js

@@ -1,80 +0,0 @@
-/**
- * Copyright (c) 2026, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-export class ComponentMatcher {
-    allowlist;
-    constructor(options = {}) {
-        this.allowlist = options.allowlist ?? [];
-    }
-    /**
-     * Check whether an element contains compile-time source metadata attributes.
-     * @param element - The element to check
-     * @returns True if the data-source-file attribute is present
-     */
-    hasSourceMetadata(element) {
-        if (!element) {
-            return false;
-        }
-        return element.hasAttribute("data-source-file");
-    }
-    matchesList(element, selectors) {
-        return selectors.some((selector) => element.matches(selector));
-    }
-    /**
-     * Checks if a label represents a component name (not a fallback like tag name, ID, or text content)
-     * @param label - The label to check
-     * @param tagName - The element's tag name (lowercase)
-     * @returns True if the label is a component name
-     */
-    isComponentNameLabel(label, tagName) {
-        return (label !== tagName && !label.includes("#") && !label.includes("(") && !label.includes('"'));
-    }
-    /**
-     * Check if an element is highlightable.
-     * @param element - The element to check
-     * @returns True if the element should be highlighted
-     */
-    isHighlightableElement(element) {
-        if (!element || element === document.body || element === document.documentElement) {
-            return false;
-        }
-        if (!this.hasSourceMetadata(element)) {
-            return false;
-        }
-        if (this.allowlist.length > 0) {
-            return this.matchesList(element, this.allowlist);
-        }
-        return true;
-    }
-    /**
-     * Find the nearest highlightable element by walking up the DOM tree
-     * @param target - The target element
-     * @returns The highlightable element or null
-     */
-    findHighlightableElement(target) {
-        if (!target || target === document.body || target === document.documentElement) {
-            return null;
-        }
-        // Fast path: use closest() if supported.
-        const closest = typeof target.closest === "function"
-            ? target.closest("[data-source-file]")
-            : null;
-        if (closest &&
-            closest !== document.body &&
-            closest !== document.documentElement &&
-            this.isHighlightableElement(closest)) {
-            return closest;
-        }
-        // Fallback: manual walk.
-        let current = target;
-        while (current && current !== document.body && current !== document.documentElement) {
-            if (this.isHighlightableElement(current)) {
-                return current;
-            }
-            current = current.parentElement;
-        }
-        return null;
-    }
-}

package/dist/design/interactions/editableManager.js

@@ -1,95 +0,0 @@
-/**
- * Copyright (c) 2026, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-/**
- * Editable Manager Module
- * Handles making elements editable and notifying the extension of text changes.
- * History/undo for style changes is owned by the design property panel (host); this module does not use history.
- */
-import { findElementsBySourceLocation, getSourceFromDataAttributes } from "./utils/sourceUtils.js";
-export const TEXT_TAGS = ["H1", "H2", "H3", "H4", "H5", "H6", "P", "SPAN", "A", "BUTTON", "LABEL"];
-export class EditableManager {
-    communicationManager;
-    boundHandleBlur;
-    boundHandleKeydown;
-    boundHandleInput;
-    editableGroup;
-    constructor(communicationManager) {
-        this.communicationManager = communicationManager;
-        this.boundHandleBlur = this._handleBlur.bind(this);
-        this.boundHandleKeydown = this._handleKeydown.bind(this);
-        this.boundHandleInput = this._handleInput.bind(this);
-        this.editableGroup = [];
-    }
-    makeEditableIfText(element) {
-        if (!this._isTextElement(element)) {
-            return;
-        }
-        const source = getSourceFromDataAttributes(element);
-        const siblings = source ? findElementsBySourceLocation(source) : [];
-        const others = siblings.filter((el) => el !== element);
-        this.editableGroup = [element, ...others];
-        for (const el of this.editableGroup) {
-            el.dataset.originalText = el.textContent ?? "";
-        }
-        element.contentEditable = "true";
-        element.addEventListener("blur", this.boundHandleBlur);
-        element.addEventListener("keydown", this.boundHandleKeydown);
-        element.addEventListener("input", this.boundHandleInput);
-    }
-    removeEditable(element) {
-        if (element.contentEditable === "true") {
-            element.contentEditable = "false";
-        }
-        element.removeEventListener("blur", this.boundHandleBlur);
-        element.removeEventListener("keydown", this.boundHandleKeydown);
-        element.removeEventListener("input", this.boundHandleInput);
-        for (const el of this.editableGroup) {
-            delete el.dataset.originalText;
-        }
-        this.editableGroup = [];
-    }
-    _isTextElement(element) {
-        return (TEXT_TAGS.includes(element.tagName) &&
-            (element.textContent ?? "").trim().length > 0 &&
-            element.dataset.textType === "static");
-    }
-    _handleInput(e) {
-        const primary = e.target;
-        const text = primary.textContent ?? "";
-        for (let i = 1; i < this.editableGroup.length; i++) {
-            this.editableGroup[i].textContent = text;
-        }
-    }
-    _handleBlur(e) {
-        const element = e.target;
-        const newText = element.textContent ?? "";
-        const originalText = element.dataset.originalText ?? "";
-        if (newText !== originalText) {
-            for (const el of this.editableGroup) {
-                el.dataset.originalText = newText;
-            }
-            if (this.communicationManager) {
-                this.communicationManager.notifyTextChange(element, originalText, newText);
-            }
-        }
-        this.removeEditable(element);
-    }
-    _handleKeydown(e) {
-        const element = e.target;
-        if (e.key === "Enter" && !e.shiftKey) {
-            e.preventDefault();
-            element.blur();
-        }
-        if (e.key === "Escape") {
-            for (const el of this.editableGroup) {
-                if (el.dataset.originalText) {
-                    el.textContent = el.dataset.originalText;
-                }
-            }
-            element.blur();
-        }
-    }
-}