@salesforce/webapp-experimental 0.2.0

package/dist/api/utils/accounts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @attention agents
+ * This file serves as a reference example for accessing Salesforce data via GraphQL.
+ * Use this pattern when implementing new data fetching utilities:
+ * 1. Define TypeScript interfaces for the response shape
+ * 2. Write the GraphQL query using UIAPI syntax
+ * 3. Use executeGraphQL<T>() with proper typing
+ * 4. Extract and return the relevant data from the response
+ */
+export interface Account {
+    Id: string;
+    Name: {
+        value: string;
+    };
+    AnnualRevenue: {
+        value: number | null;
+    };
+    Industry: {
+        value: string | null;
+    };
+    Website: {
+        value: string | null;
+    };
+}
+/**
+ * Fetch accounts with annual revenue greater than the specified amount
+ *
+ * @param minRevenue - Minimum annual revenue threshold (default: 100000)
+ * @returns Array of accounts matching the criteria
+ */
+export declare function getHighRevenueAccounts(minRevenue?: number): Promise<Account[]>;
+//# sourceMappingURL=accounts.d.ts.map

package/dist/api/utils/accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../../src/api/utils/accounts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,MAAM,WAAW,OAAO;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACxB,aAAa,EAAE;QAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACxC,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACnC,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;CAClC;AAsCD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,UAAU,SAAS,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAMpF"}

package/dist/api/utils/accounts.js

@@ -0,0 +1,45 @@
+/**
+ * @attention agents
+ * This file serves as a reference example for accessing Salesforce data via GraphQL.
+ * Use this pattern when implementing new data fetching utilities:
+ * 1. Define TypeScript interfaces for the response shape
+ * 2. Write the GraphQL query using UIAPI syntax
+ * 3. Use executeGraphQL<T>() with proper typing
+ * 4. Extract and return the relevant data from the response
+ */
+import { executeGraphQL } from "../graphql.js";
+const HIGH_REVENUE_ACCOUNTS_QUERY = `
+  query GetHighRevenueAccounts($minRevenue: Currency) {
+    uiapi {
+      query {
+        Account(
+          where: { AnnualRevenue: { gt: $minRevenue } }
+          orderBy: { AnnualRevenue: { order: DESC } }
+          first: 50
+        ) {
+          edges {
+            node {
+              Id
+              Name { value }
+              AnnualRevenue { value }
+              Industry { value }
+              Website { value }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+/**
+ * Fetch accounts with annual revenue greater than the specified amount
+ *
+ * @param minRevenue - Minimum annual revenue threshold (default: 100000)
+ * @returns Array of accounts matching the criteria
+ */
+export async function getHighRevenueAccounts(minRevenue = 100000) {
+    const response = await executeGraphQL(HIGH_REVENUE_ACCOUNTS_QUERY, {
+        minRevenue,
+    });
+    return response.uiapi.query.Account.edges.map((edge) => edge.node);
+}

package/dist/api/utils/records.d.ts

@@ -0,0 +1,11 @@
+interface RecordResponse {
+    fields: Record<string, {
+        value: string;
+    }>;
+}
+export declare function getRecord(recordId: string, params?: Record<string, string>): Promise<RecordResponse>;
+export declare function createRecord(apiName: string, fields: Record<string, unknown>): Promise<RecordResponse>;
+export declare function updateRecord(recordId: string, fields: Record<string, unknown>): Promise<RecordResponse>;
+export declare function deleteRecord(recordId: string): Promise<boolean>;
+export {};
+//# sourceMappingURL=records.d.ts.map

package/dist/api/utils/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../../src/api/utils/records.ts"],"names":[],"mappings":"AAEA,UAAU,cAAc;IACvB,MAAM,EAAE,MAAM,CACb,MAAM,EACN;QACC,KAAK,EAAE,MAAM,CAAC;KACd,CACD,CAAC;CACF;AAED,wBAAsB,SAAS,CAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACjC,OAAO,CAAC,cAAc,CAAC,CAOzB;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,cAAc,CAAC,CAGzB;AAED,wBAAsB,YAAY,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,cAAc,CAAC,CAGzB;AAED,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGrE"}

package/dist/api/utils/records.js

@@ -0,0 +1,20 @@
+import { uiApiClient } from "../clients.js";
+export async function getRecord(recordId, params = {}) {
+    const searchParams = new URLSearchParams(params);
+    const queryString = searchParams.toString();
+    const url = `/records/${recordId}${queryString ? `?${queryString}` : ""}`;
+    const response = await uiApiClient.get(url);
+    return response.json();
+}
+export async function createRecord(apiName, fields) {
+    const response = await uiApiClient.post(`/records`, { apiName, fields });
+    return response.json();
+}
+export async function updateRecord(recordId, fields) {
+    const response = await uiApiClient.patch(`/records/${recordId}`, { fields });
+    return response.json();
+}
+export async function deleteRecord(recordId) {
+    await uiApiClient.delete(`/records/${recordId}`);
+    return true;
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=records.test.d.ts.map

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

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

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

@@ -0,0 +1,185 @@
+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.d.ts

@@ -0,0 +1,12 @@
+interface User {
+    id: string;
+    name: string;
+}
+/**
+ * Fetch current user information from Salesforce
+ * Uses Chatter API to get current user details
+ * @returns User info or null if no session
+ */
+export declare function getCurrentUser(): Promise<User | null>;
+export {};
+//# sourceMappingURL=user.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../src/api/utils/user.ts"],"names":[],"mappings":"AAEA,UAAU,IAAI;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACb;AASD;;;;GAIG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAkB3D"}

package/dist/api/utils/user.js

@@ -0,0 +1,23 @@
+import { baseDataClient } from "../clients.js";
+/**
+ * Fetch current user information from Salesforce
+ * Uses Chatter API to get current user details
+ * @returns User info or null if no session
+ */
+export async function getCurrentUser() {
+    try {
+        const response = await baseDataClient.get("/chatter/users/me");
+        const userData = await response.json();
+        if (!userData || !userData.id) {
+            throw new Error("No user data found in Chatter API response");
+        }
+        return {
+            id: userData.id,
+            name: userData.name || "User",
+        };
+    }
+    catch (error) {
+        console.error("Error fetching user data:", error);
+        throw error;
+    }
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=user.test.d.ts.map

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

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

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

@@ -0,0 +1,156 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { getCurrentUser } from "./user.js";
+// Mock the baseDataClient
+vi.mock("../clients.js", () => {
+    const mockGet = vi.fn();
+    return {
+        baseDataClient: {
+            get: mockGet,
+        },
+    };
+});
+// Get reference to the mocked function for assertions
+const { baseDataClient } = await import("../clients.js");
+const mockGet = vi.mocked(baseDataClient.get);
+// Mock console.error to avoid noise in test output
+const mockConsoleError = vi
+    .spyOn(console, "error")
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    .mockImplementation(() => { });
+describe("User API Utils", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        mockConsoleError.mockClear();
+    });
+    describe("getCurrentUser", () => {
+        const mockChatterUserResponse = {
+            json: vi.fn().mockResolvedValue({
+                id: "005000000000001",
+                name: "John Doe",
+                email: "john.doe@company.com",
+                username: "john.doe@company.com",
+            }),
+        };
+        it("successfully fetches current user with complete data", async () => {
+            mockGet.mockResolvedValue(mockChatterUserResponse);
+            const result = await getCurrentUser();
+            expect(mockGet).toHaveBeenCalledWith("/chatter/users/me");
+            expect(result).toEqual({
+                id: "005000000000001",
+                name: "John Doe",
+            });
+        });
+        it("handles user with minimal data", async () => {
+            mockGet.mockResolvedValue({
+                json: vi.fn().mockResolvedValue({
+                    id: "005000000000002",
+                    name: "Jane Smith",
+                }),
+            });
+            const result = await getCurrentUser();
+            expect(result).toEqual({
+                id: "005000000000002",
+                name: "Jane Smith",
+            });
+        });
+        it('falls back to "User" when name is empty', async () => {
+            mockGet.mockResolvedValue({
+                json: vi.fn().mockResolvedValue({
+                    id: "005000000000003",
+                    name: "",
+                }),
+            });
+            const result = await getCurrentUser();
+            expect(result).toEqual({
+                id: "005000000000003",
+                name: "User",
+            });
+        });
+        it('falls back to "User" when name is null', async () => {
+            mockGet.mockResolvedValue({
+                json: vi.fn().mockResolvedValue({
+                    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 () => {
+            mockGet.mockResolvedValue({
+                json: vi.fn().mockResolvedValue({
+                    id: "005000000000005",
+                }),
+            });
+            const result = await getCurrentUser();
+            expect(result).toEqual({
+                id: "005000000000005",
+                name: "User",
+            });
+        });
+        it("throws error when Chatter API request fails", async () => {
+            const apiError = new Error("Chatter API error");
+            mockGet.mockRejectedValue(apiError);
+            await expect(getCurrentUser()).rejects.toThrow("Chatter API error");
+            expect(mockConsoleError).toHaveBeenCalledWith("Error fetching user data:", apiError);
+        });
+        it("throws error when no user data is found", async () => {
+            mockGet.mockResolvedValue({
+                json: vi.fn().mockResolvedValue(null),
+            });
+            await expect(getCurrentUser()).rejects.toThrow("No user data found in Chatter API response");
+            expect(mockConsoleError).toHaveBeenCalled();
+        });
+        it("throws error when user data is undefined", async () => {
+            mockGet.mockResolvedValue({
+                json: vi.fn().mockResolvedValue(undefined),
+            });
+            await expect(getCurrentUser()).rejects.toThrow("No user data found in Chatter API response");
+            expect(mockConsoleError).toHaveBeenCalled();
+        });
+        it("throws error when no user ID is found", async () => {
+            mockGet.mockResolvedValue({
+                json: vi.fn().mockResolvedValue({
+                    name: "John Doe",
+                }),
+            });
+            await expect(getCurrentUser()).rejects.toThrow("No user data found in Chatter API response");
+            expect(mockConsoleError).toHaveBeenCalled();
+        });
+        it("throws error when user ID is empty string", async () => {
+            mockGet.mockResolvedValue({
+                json: vi.fn().mockResolvedValue({
+                    id: "",
+                    name: "John Doe",
+                }),
+            });
+            await expect(getCurrentUser()).rejects.toThrow("No user data found in Chatter API response");
+            expect(mockConsoleError).toHaveBeenCalled();
+        });
+        it("handles network errors gracefully", async () => {
+            const networkError = new Error("Network timeout");
+            networkError.name = "NetworkError";
+            mockGet.mockRejectedValue(networkError);
+            await expect(getCurrentUser()).rejects.toThrow("Network timeout");
+            expect(mockConsoleError).toHaveBeenCalledWith("Error fetching user data:", networkError);
+        });
+        it("handles 401 unauthorized errors", async () => {
+            const unauthorizedError = new Error("Unauthorized");
+            unauthorizedError.name = "UnauthorizedError";
+            mockGet.mockRejectedValue(unauthorizedError);
+            await expect(getCurrentUser()).rejects.toThrow("Unauthorized");
+            expect(mockConsoleError).toHaveBeenCalledWith("Error fetching user data:", unauthorizedError);
+        });
+        it("handles response with invalid data structure", async () => {
+            mockGet.mockResolvedValue({
+                json: vi.fn().mockResolvedValue("invalid data"),
+            });
+            await expect(getCurrentUser()).rejects.toThrow("No user data found in Chatter API response");
+        });
+    });
+});

package/dist/app/index.d.ts

@@ -0,0 +1,5 @@
+export type { OrgInfo } from "./org.js";
+export { getOrgInfo, refreshOrgAuth } from "./org.js";
+export type { WebAppManifest, RoutingConfig, RewriteRule, RedirectRule } from "./manifest.js";
+export { loadManifest } from "./manifest.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/app/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/app/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACtD,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/dist/app/index.js

@@ -0,0 +1,2 @@
+export { getOrgInfo, refreshOrgAuth } from "./org.js";
+export { loadManifest } from "./manifest.js";

package/dist/app/manifest.d.ts

@@ -0,0 +1,32 @@
+export interface WebAppManifest {
+    name: string;
+    label: string;
+    description?: string;
+    version: string;
+    outputDir: string;
+    routing?: RoutingConfig;
+}
+export interface RoutingConfig {
+    rewrites?: RewriteRule[];
+    redirects?: RedirectRule[];
+    trailingSlash?: "always" | "never" | "auto";
+    fallback?: string;
+}
+export interface RewriteRule {
+    route: string;
+    target: string;
+}
+export interface RedirectRule {
+    route: string;
+    target: string;
+    statusCode: 301 | 302 | 307 | 308;
+}
+/**
+ * Load and parse webapp.json manifest
+ *
+ * @param manifestPath - Path to the webapp.json file
+ * @returns Promise resolving to the parsed manifest
+ * @throws Error if manifest file not found or validation fails
+ */
+export declare function loadManifest(manifestPath: string): Promise<WebAppManifest>;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/app/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/app/manifest.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,cAAc;IAE9B,IAAI,EAAE,MAAM,CAAC;IAEb,KAAK,EAAE,MAAM,CAAC;IAEd,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAEhB,SAAS,EAAE,MAAM,CAAC;IAElB,OAAO,CAAC,EAAE,aAAa,CAAC;CACxB;AAGD,MAAM,WAAW,aAAa;IAE7B,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IAEzB,SAAS,CAAC,EAAE,YAAY,EAAE,CAAC;IAE3B,aAAa,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;IAE5C,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAGD,MAAM,WAAW,WAAW;IAE3B,KAAK,EAAE,MAAM,CAAC;IAEd,MAAM,EAAE,MAAM,CAAC;CACf;AAGD,MAAM,WAAW,YAAY;IAE5B,KAAK,EAAE,MAAM,CAAC;IAEd,MAAM,EAAE,MAAM,CAAC;IAEf,UAAU,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;CAClC;AAkCD;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAchF"}

package/dist/app/manifest.js

@@ -0,0 +1,46 @@
+import { readFile } from "node:fs/promises";
+/**
+ * Validate required fields in webapp manifest
+ *
+ * @param manifest - The manifest object to validate
+ * @throws Error if any required field is missing
+ */
+function validateManifest(manifest) {
+    const errors = [];
+    if (!manifest.name) {
+        errors.push("name");
+    }
+    if (!manifest.label) {
+        errors.push("label");
+    }
+    if (!manifest.version) {
+        errors.push("version");
+    }
+    if (!manifest.outputDir) {
+        errors.push("outputDir");
+    }
+    if (errors.length > 0) {
+        throw new Error(`Manifest missing required field${errors.length > 1 ? "s" : ""}: ${errors.join(", ")}`);
+    }
+}
+/**
+ * Load and parse webapp.json manifest
+ *
+ * @param manifestPath - Path to the webapp.json file
+ * @returns Promise resolving to the parsed manifest
+ * @throws Error if manifest file not found or validation fails
+ */
+export async function loadManifest(manifestPath) {
+    try {
+        const content = await readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        validateManifest(manifest);
+        return manifest;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            throw new Error(`Manifest not found at: ${manifestPath}`);
+        }
+        throw error;
+    }
+}

package/dist/app/org.d.ts

@@ -0,0 +1,22 @@
+export interface OrgInfo {
+    orgId: string;
+    apiVersion: string;
+    instanceUrl: string;
+    username: string;
+    accessToken: string;
+    orgAlias?: string;
+}
+/**
+ * Get Salesforce org info and authentication details
+ *
+ * @param orgAlias - Optional org alias or username, uses default org if not provided
+ * @returns Promise resolving to org info or null if authentication fails
+ */
+export declare function getOrgInfo(orgAlias?: string): Promise<OrgInfo | undefined>;
+/**
+ * Refresh Salesforce org authentication
+ *
+ * @param orgAlias
+ */
+export declare function refreshOrgAuth(orgAlias: string): Promise<OrgInfo | undefined>;
+//# sourceMappingURL=org.d.ts.map

package/dist/app/org.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"org.d.ts","sourceRoot":"","sources":["../../src/app/org.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,OAAO;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAkBhF;AAcD;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,gCAKpD"}