@sailfish-ai/recorder 1.8.13 → 1.8.17

package/dist/inAppReportIssueModal/integrations.js

@@ -0,0 +1,240 @@
+import { fetchEngineeringTicketPlatformIntegrations } from "../graphql";
+const SUPPORT_TICKET_INTEGRATIONS = ["jira", "linear", "zendesk"];
+let integrationData = null;
+export function getIntegrationData() {
+    return integrationData;
+}
+export function hasValidIntegration() {
+    return integrationData !== null && integrationData.installed === true;
+}
+export async function fetchIntegrationData(apiKey, backendApi) {
+    if (integrationData) {
+        return;
+    }
+    try {
+        const response = await fetchEngineeringTicketPlatformIntegrations(apiKey, backendApi);
+        // Check for GraphQL errors
+        if (response?.errors && response.errors.length > 0) {
+            console.error("GraphQL errors fetching integrations:", response.errors);
+            integrationData = null;
+            return;
+        }
+        const integrations = response?.data?.getEngineeringTicketPlatformIntegrationsFromApiKey;
+        // Filter for installed support ticket integrations only
+        const validIntegrations = (integrations || []).filter((item) => SUPPORT_TICKET_INTEGRATIONS.includes(item.provider?.toLowerCase() || "") && item.installed === true);
+        if (validIntegrations.length === 0) {
+            console.warn("No valid installed integrations found");
+            integrationData = null;
+            return;
+        }
+        // Prefer Jira integration, fallback to first available
+        integrationData =
+            validIntegrations.find((i) => i.provider?.toLowerCase() === "jira") ||
+                validIntegrations[0];
+    }
+    catch (error) {
+        console.error("Error fetching integration data:", error);
+        integrationData = null;
+    }
+}
+export function populateSelectOptions(selectElement, options, defaultValue) {
+    const placeholderOption = document.createElement("option");
+    placeholderOption.value = "";
+    placeholderOption.disabled = true;
+    placeholderOption.selected = !defaultValue;
+    placeholderOption.textContent = "Select...";
+    placeholderOption.style.color = "#9ca3af";
+    selectElement.innerHTML = "";
+    selectElement.appendChild(placeholderOption);
+    options.forEach((option) => {
+        const optionElement = document.createElement("option");
+        optionElement.value = option.id || option.value || option;
+        optionElement.textContent = option.name || option.label || option;
+        selectElement.appendChild(optionElement);
+    });
+    if (defaultValue) {
+        selectElement.value = defaultValue;
+        selectElement.style.color = "";
+    }
+    else {
+        selectElement.style.color = "#9ca3af";
+    }
+}
+export function populatePriorityOptions(selectElement, provider, defaultPriority) {
+    const isJira = provider?.toLowerCase() === "jira";
+    selectElement.innerHTML = "";
+    if (isJira) {
+        // Jira priorities: 1-5 (Highest to Lowest)
+        const jiraPriorities = [
+            { id: "1", name: "Highest" },
+            { id: "2", name: "High" },
+            { id: "3", name: "Medium" },
+            { id: "4", name: "Low" },
+            { id: "5", name: "Lowest" },
+        ];
+        jiraPriorities.forEach((priority) => {
+            const optionElement = document.createElement("option");
+            optionElement.value = priority.id;
+            optionElement.textContent = priority.name;
+            selectElement.appendChild(optionElement);
+        });
+    }
+    else {
+        // Linear priorities: 0-4 (No Priority, Urgent to Low)
+        const linearPriorities = [
+            { id: "0", name: "No Priority" },
+            { id: "1", name: "Urgent" },
+            { id: "2", name: "High" },
+            { id: "3", name: "Medium" },
+            { id: "4", name: "Low" },
+        ];
+        linearPriorities.forEach((priority) => {
+            const optionElement = document.createElement("option");
+            optionElement.value = priority.id;
+            optionElement.textContent = priority.name;
+            selectElement.appendChild(optionElement);
+        });
+    }
+    if (defaultPriority !== undefined && defaultPriority !== null) {
+        selectElement.value = String(defaultPriority);
+    }
+    else if (!isJira) {
+        // Default to 0 (No Priority) for Linear if not specified
+        selectElement.value = "0";
+    }
+}
+export function updateIssueTypeOptions(selectElement, projectId) {
+    if (!integrationData?.projects || !projectId) {
+        selectElement.innerHTML = "";
+        const placeholderOption = document.createElement("option");
+        placeholderOption.value = "";
+        placeholderOption.disabled = true;
+        placeholderOption.selected = true;
+        placeholderOption.textContent = "Select project first...";
+        placeholderOption.style.color = "#9ca3af";
+        selectElement.appendChild(placeholderOption);
+        selectElement.style.color = "#9ca3af";
+        return;
+    }
+    // Find the project in the projects array to get issue_types
+    const selectedProject = integrationData.projects.find((p) => p.id === projectId);
+    if (!selectedProject || !selectedProject.issue_types) {
+        selectElement.innerHTML = "";
+        const placeholderOption = document.createElement("option");
+        placeholderOption.value = "";
+        placeholderOption.disabled = true;
+        placeholderOption.selected = true;
+        placeholderOption.textContent = "No issue types available";
+        placeholderOption.style.color = "#9ca3af";
+        selectElement.appendChild(placeholderOption);
+        selectElement.style.color = "#9ca3af";
+        return;
+    }
+    const issueTypes = selectedProject.issue_types || [];
+    selectElement.innerHTML = "";
+    const placeholderOption = document.createElement("option");
+    placeholderOption.value = "";
+    placeholderOption.disabled = true;
+    placeholderOption.textContent = "Select...";
+    placeholderOption.style.color = "#9ca3af";
+    selectElement.appendChild(placeholderOption);
+    issueTypes.forEach((issueType) => {
+        const optionElement = document.createElement("option");
+        optionElement.value = issueType.id || issueType.value || issueType;
+        optionElement.textContent = issueType.name || issueType.label || issueType;
+        selectElement.appendChild(optionElement);
+    });
+    // Set default issue type (prefer "bug", then "task", then first available)
+    if (issueTypes.length > 0) {
+        const bugIssueType = issueTypes.find((it) => it.name?.toLowerCase() === "bug");
+        const taskIssueType = issueTypes.find((it) => it.name?.toLowerCase() === "task");
+        const defaultIssueType = bugIssueType?.id || taskIssueType?.id || issueTypes[0]?.id;
+        if (defaultIssueType) {
+            selectElement.value = defaultIssueType;
+            selectElement.style.color = "#000"; // Explicitly set to black
+        }
+        else {
+            placeholderOption.selected = true;
+            selectElement.style.color = "#9ca3af";
+        }
+    }
+}
+export function getFieldsForProject(projectId, issueTypeId) {
+    if (!integrationData?.fieldConfigurations || !projectId) {
+        return [];
+    }
+    // fieldConfigurations is organized by project+issue_type combination
+    // Match on both project_key and issue_type_id
+    const projectConfig = Array.isArray(integrationData.fieldConfigurations)
+        ? integrationData.fieldConfigurations.find((config) => config.project_key === projectId &&
+            (!issueTypeId || config.issue_type_id === issueTypeId))
+        : integrationData.fieldConfigurations[projectId];
+    if (!projectConfig || !projectConfig.fields) {
+        return [];
+    }
+    return projectConfig.fields;
+}
+export function getUsers() {
+    if (!integrationData?.users) {
+        return [];
+    }
+    return integrationData.users;
+}
+// Get projects based on team selection (for Linear) or directly from integration (for Jira)
+export function getProjectsForTeam(teamId) {
+    if (!integrationData)
+        return [];
+    const hasTeams = integrationData.teams &&
+        Array.isArray(integrationData.teams) &&
+        integrationData.teams.length > 0;
+    // For Linear (with teams): get projects from selected team
+    if (hasTeams && teamId) {
+        const selectedTeam = integrationData.teams.find((t) => t.id === teamId);
+        return selectedTeam?.projects || [];
+    }
+    // For Jira (no teams): get projects directly from integration
+    if (!hasTeams && integrationData.projects) {
+        return integrationData.projects;
+    }
+    return [];
+}
+export function updateFormWithIntegrationData(currentState) {
+    if (!integrationData)
+        return currentState;
+    const hasTeams = integrationData.teams &&
+        Array.isArray(integrationData.teams) &&
+        integrationData.teams.length > 0;
+    // Update team dropdown (only for Linear)
+    const teamSelect = document.getElementById("sf-eng-ticket-team");
+    if (teamSelect && hasTeams) {
+        populateSelectOptions(teamSelect, integrationData.teams, integrationData.defaultTeam);
+        currentState.engTicketTeam = teamSelect.value;
+    }
+    // Update project dropdown
+    const projectSelect = document.getElementById("sf-eng-ticket-project");
+    if (projectSelect) {
+        // Get projects based on whether teams exist
+        const projects = hasTeams
+            ? getProjectsForTeam(currentState.engTicketTeam)
+            : integrationData.projects || [];
+        populateSelectOptions(projectSelect, projects, integrationData.defaultProject);
+        currentState.engTicketProject = projectSelect.value;
+    }
+    // Update priority dropdown with proper values
+    const prioritySelect = document.getElementById("sf-eng-ticket-priority");
+    if (prioritySelect) {
+        populatePriorityOptions(prioritySelect, integrationData.provider || "", integrationData.defaultPriority);
+        currentState.engTicketPriority = Number(prioritySelect.value);
+    }
+    // Update issue type dropdown based on selected project (for Jira)
+    const issueTypeSelect = document.getElementById("sf-eng-ticket-type");
+    const isJira = integrationData.provider?.toLowerCase() === "jira";
+    if (issueTypeSelect && isJira && currentState.engTicketProject) {
+        updateIssueTypeOptions(issueTypeSelect, currentState.engTicketProject);
+        // Always update currentState with the selected issue type value
+        if (issueTypeSelect.value) {
+            currentState.engTicketIssueType = issueTypeSelect.value;
+        }
+    }
+    return currentState;
+}

package/dist/inAppReportIssueModal/state.js

@@ -0,0 +1,69 @@
+import { STORAGE_KEYS } from "./types";
+// Helper function to load user preferences from localStorage
+function loadUserPreferences() {
+    return {
+        createIssue: localStorage.getItem(STORAGE_KEYS.CREATE_ISSUE) === "true",
+        createEngTicket: localStorage.getItem(STORAGE_KEYS.CREATE_ENG_TICKET) === "true",
+    };
+}
+// Helper function to get initial state
+export function getInitialState() {
+    const prefs = loadUserPreferences();
+    return {
+        mode: "lookback",
+        description: "",
+        occurredInThisTab: true,
+        createIssue: prefs.createIssue,
+        issueName: "",
+        issueDescription: "",
+        createEngTicket: prefs.createEngTicket,
+        engTicketTeam: "",
+        engTicketProject: "",
+        engTicketPriority: 0,
+        engTicketLabels: [],
+        engTicketIssueType: "",
+        engTicketCustomFields: {},
+    };
+}
+// State variables
+export let currentState = getInitialState();
+export let recordingStartTime = null;
+export let recordingEndTime = null;
+export let timerInterval = null;
+export let isRecording = false;
+// State setters
+export function setCurrentState(state) {
+    currentState = state;
+}
+export function resetState() {
+    currentState = getInitialState();
+    recordingStartTime = null;
+    recordingEndTime = null;
+}
+export function setRecordingStartTime(time) {
+    recordingStartTime = time;
+}
+export function setRecordingEndTime(time) {
+    recordingEndTime = time;
+}
+export function setTimerInterval(interval) {
+    timerInterval = interval;
+}
+export function setIsRecording(recording) {
+    isRecording = recording;
+}
+export function getCurrentState() {
+    return currentState;
+}
+export function getRecordingStartTime() {
+    return recordingStartTime;
+}
+export function getRecordingEndTime() {
+    return recordingEndTime;
+}
+export function getTimerInterval() {
+    return timerInterval;
+}
+export function getIsRecording() {
+    return isRecording;
+}

package/dist/inAppReportIssueModal/types.js

@@ -0,0 +1,16 @@
+export const STORAGE_KEYS = {
+    CREATE_ISSUE: "sf-create-issue-preference",
+    CREATE_ENG_TICKET: "sf-create-eng-ticket-preference",
+};
+export const DEFAULT_SHORTCUTS = {
+    openReportIssue: { key: "r", requireCmdCtrl: true },
+    openStartNowMode: { key: "n", requireCmdCtrl: true },
+};
+export const ReportIssueContext = {
+    shortcuts: { ...DEFAULT_SHORTCUTS },
+    resolveSessionId: null,
+    apiKey: null,
+    backendApi: null,
+    triageBaseUrl: "https://app.sailfishqa.com",
+    deactivateIsolation: () => { },
+};