LCOV - code coverage report
Current view: top level - src/platform/workflow/persistence/composables - useWorkflowPersistenceV2.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 86.7 % 188 163
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : /**
       2              :  * V2 Workflow Persistence Composable
       3              :  *
       4              :  * Key changes from V1:
       5              :  * - Uses V2 draft store with per-draft keys
       6              :  * - Uses tab state composable for session pointers
       7              :  * - Adds 512ms debounce on graph change persistence
       8              :  */
       9              : 
      10              : import { debounce } from 'es-toolkit'
      11              : import { useToast } from '@/components/ui/toast/toastStore'
      12              : import { tryOnScopeDispose, until, whenever } from '@vueuse/core'
      13              : import { computed, nextTick, ref, watch } from 'vue'
      14              : import { useI18n } from 'vue-i18n'
      15              : import { useRoute, useRouter } from 'vue-router'
      16              : 
      17              : import { useCurrentUser } from '@/composables/auth/useCurrentUser'
      18              : import { useFeatureFlags } from '@/composables/useFeatureFlags'
      19              : import {
      20              :   hydratePreservedQuery,
      21              :   mergePreservedQueryIntoQuery
      22              : } from '@/platform/navigation/preservedQueryManager'
      23              : import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces'
      24              : import { isCloud } from '@/platform/distribution/types'
      25              : import { LOCAL_HANDOFF_PARAM } from '@/platform/openOnCloud/localHandoffProtocol'
      26              : import { useSettingStore } from '@/platform/settings/settingStore'
      27              : import { useLinkedWorkflowUrlLoader } from '@/platform/workflow/management/composables/useLinkedWorkflowUrlLoader'
      28              : import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore'
      29              : import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
      30              : import {
      31              :   ComfyWorkflow,
      32              :   useWorkflowStore
      33              : } from '@/platform/workflow/management/stores/workflowStore'
      34              : import { PERSIST_DEBOUNCE_MS } from '@/platform/workflow/persistence/base/draftTypes'
      35              : import type { StartupOutcome } from '@/platform/workflow/persistence/base/draftTypes'
      36              : import {
      37              :   clearAllWorkspaceStorage,
      38              :   clearWorkflowRestoreState,
      39              :   completeWorkflowLogoutTransition,
      40              :   prepareWorkflowLogoutTransition,
      41              :   registerWorkflowPersistenceFlush
      42              : } from '@/platform/workflow/persistence/base/storageIO'
      43              : import { useWorkflowDraftStoreV2 } from '@/platform/workflow/persistence/stores/workflowDraftStoreV2'
      44              : import { useWorkflowTabState } from './useWorkflowTabState'
      45              : import { useSharedWorkflowUrlLoader } from '@/platform/workflow/sharing/composables/useSharedWorkflowUrlLoader'
      46              : import { useTemplateUrlLoader } from '@/platform/workflow/templates/composables/useTemplateUrlLoader'
      47              : import { api } from '@/scripts/api'
      48              : import { app as comfyApp } from '@/scripts/app'
      49              : import type { ComfyWorkflowJSON } from '@comfyorg/graph-model/workflowSchema'
      50              : import { isValidUuid } from '@/utils/formatUtil'
      51              : 
      52         2355 : export function useWorkflowPersistenceV2() {
      53         2355 :   const { t } = useI18n()
      54         2355 :   const workflowStore = useWorkflowStore()
      55         2355 :   const settingStore = useSettingStore()
      56         2355 :   const route = useRoute()
      57         2355 :   const router = useRouter()
      58         2355 :   const sharedWorkflowUrlLoader = useSharedWorkflowUrlLoader()
      59         2355 :   const templateUrlLoader = useTemplateUrlLoader()
      60         2355 :   const linkedWorkflowUrlLoader = useLinkedWorkflowUrlLoader()
      61         2355 :   let openedLinkedWorkflow = false
      62         2355 :   const TEMPLATE_NAMESPACE = PRESERVED_QUERY_NAMESPACES.TEMPLATE
      63         2355 :   const SHARE_NAMESPACE = PRESERVED_QUERY_NAMESPACES.SHARE
      64         2355 :   const LOCAL_HANDOFF_NAMESPACE = PRESERVED_QUERY_NAMESPACES.LOCAL_HANDOFF
      65         2355 :   const { flags } = useFeatureFlags()
      66         2355 :   const draftStore = useWorkflowDraftStoreV2()
      67         2355 :   draftStore.setAuthSubject(isCloud ? null : undefined)
      68         2355 :   const tabState = useWorkflowTabState()
      69         2355 :   const toast = useToast()
      70         2355 :   const { isAuthInitialized, onUserLogout, onUserResolved } = useCurrentUser()
      71         2355 :   const teamWorkspaceStore = useTeamWorkspaceStore()
      72         2355 :   let stopWorkspaceReadinessWatcher: (() => void) | undefined
      73              :   let resolvedAuthSubject: string | null = null
      74              :   let authTransitionVersion = 0
      75         2355 :   let authTransition = Promise.resolve()
      76              : 
      77            0 :   function stopPendingWorkspaceReadinessWatcher(): void {
      78            0 :     stopWorkspaceReadinessWatcher?.()
      79            0 :     stopWorkspaceReadinessWatcher = undefined
      80              :   }
      81              : 
      82         2355 :   const ensureTemplateQueryFromIntent = async () => {
      83         2355 :     hydratePreservedQuery(TEMPLATE_NAMESPACE)
      84         2355 :     const mergedQuery = mergePreservedQueryIntoQuery(
      85              :       TEMPLATE_NAMESPACE,
      86              :       route.query
      87              :     )
      88              : 
      89         2355 :     if (mergedQuery) {
      90            0 :       await router.replace({ query: mergedQuery })
      91              :     }
      92              : 
      93         2355 :     return mergedQuery ?? route.query
      94              :   }
      95              : 
      96         2355 :   const workflowPersistenceEnabled = computed(() =>
      97              :     settingStore.get('Comfy.Workflow.Persist')
      98              :   )
      99              : 
     100         2355 :   const lastSavedJsonByPath = ref<Record<string, string>>({})
     101              : 
     102         2355 :   watch(workflowPersistenceEnabled, (enabled) => {
     103         2340 :     if (!enabled) {
     104            0 :       draftStore.reset()
     105            0 :       lastSavedJsonByPath.value = {}
     106              :     }
     107              :   })
     108              : 
     109         2355 :   const persistCurrentWorkflow = () => {
     110         4191 :     if (!workflowPersistenceEnabled.value) return
     111         4190 :     const activeWorkflow = workflowStore.activeWorkflow
     112         4190 :     if (!activeWorkflow) return
     113              : 
     114         4190 :     const graphData = comfyApp.rootGraph.serialize()
     115         4190 :     const workflowJson = JSON.stringify(graphData)
     116         4190 :     const workflowPath = activeWorkflow.path
     117              : 
     118              :     // Skip if unchanged
     119         4190 :     if (workflowJson === lastSavedJsonByPath.value[workflowPath]) return
     120              : 
     121              :     // Save to V2 draft store
     122              :     const saved = draftStore.saveDraft(workflowPath, workflowJson, {
     123              :       name: activeWorkflow.key,
     124              :       isTemporary: activeWorkflow.isTemporary
     125              :     })
     126              : 
     127         4190 :     if (!saved) {
     128            0 :       toast.error(t('g.error'), {
     129              :         description: t('toastMessages.failedToSaveDraft')
     130              :       })
     131            0 :       return
     132              :     }
     133              : 
     134              :     // Update session pointer
     135         3976 :     tabState.setActivePath(workflowPath)
     136              : 
     137         3976 :     lastSavedJsonByPath.value[workflowPath] = workflowJson
     138              : 
     139              :     // Clean up draft if workflow is saved and unmodified
     140         4191 :     if (!activeWorkflow.isTemporary && !activeWorkflow.isModified) {
     141           49 :       draftStore.removeDraft(workflowPath)
     142              :     }
     143              :   }
     144              : 
     145              :   // Debounced version for graphChanged events
     146         2355 :   const debouncedPersist = debounce(persistCurrentWorkflow, PERSIST_DEBOUNCE_MS)
     147              : 
     148           98 :   function flushPendingPersistence() {
     149           98 :     debouncedPersist.flush()
     150              :   }
     151              : 
     152         2355 :   const unregisterPersistenceFlush = registerWorkflowPersistenceFlush(
     153              :     flushPendingPersistence
     154              :   )
     155         2355 :   window.addEventListener('pagehide', flushPendingPersistence)
     156              : 
     157              :   const isWorkspaceInitConcluded = () =>
     158              :     (teamWorkspaceStore.initState === 'ready' &&
     159              :       teamWorkspaceStore.activeWorkspaceId !== null) ||
     160              :     teamWorkspaceStore.initState === 'error'
     161              : 
     162              :   function resumePersistenceWhenWorkspaceIsReady(): void {
     163              :     if (isWorkspaceInitConcluded()) {
     164              :       completeWorkflowLogoutTransition()
     165              :       return
     166              :     }
     167              : 
     168              :     stopWorkspaceReadinessWatcher = whenever(
     169              :       isWorkspaceInitConcluded,
     170              :       () => {
     171              :         stopWorkspaceReadinessWatcher = undefined
     172              :         completeWorkflowLogoutTransition()
     173              :       },
     174              :       { once: true }
     175              :     )
     176              :   }
     177              : 
     178         4708 :   async function waitForRestoreIdentity(): Promise<() => boolean> {
     179              :     if (isCloud && !isAuthInitialized.value)
     180              :       await until(isAuthInitialized).toBe(true)
     181              :     const restoreVersion = authTransitionVersion
     182              :     if (isCloud) await authTransition
     183         4708 :     return () => restoreVersion === authTransitionVersion
     184              :   }
     185              : 
     186              :   async function waitForWorkspaceInitialization(): Promise<void> {
     187              :     if (isWorkspaceInitConcluded()) return
     188              :     await until(isWorkspaceInitConcluded).toBe(true)
     189              :   }
     190              : 
     191         2355 :   onUserLogout(() => {
     192              :     if (!isCloud) return
     193              :     authTransitionVersion++
     194              :     resolvedAuthSubject = null
     195              :     draftStore.setAuthSubject(null)
     196              :     stopPendingWorkspaceReadinessWatcher()
     197              :     debouncedPersist.cancel()
     198              :     prepareWorkflowLogoutTransition()
     199              :     clearAllWorkspaceStorage()
     200              :   })
     201         2355 :   onUserResolved((user) => {
     202              :     if (!isCloud) return
     203              :     stopPendingWorkspaceReadinessWatcher()
     204              :     const previousSubject = resolvedAuthSubject
     205              :     resolvedAuthSubject = user.id
     206              : 
     207              :     if (!previousSubject || previousSubject === user.id) {
     208              :       draftStore.setAuthSubject(user.id)
     209              :       resumePersistenceWhenWorkspaceIsReady()
     210              :       return
     211              :     }
     212              : 
     213              :     const transitionVersion = ++authTransitionVersion
     214              : 
     215              :     debouncedPersist.cancel()
     216              :     prepareWorkflowLogoutTransition()
     217              :     clearWorkflowRestoreState()
     218              :     authTransition = authTransition
     219              :       .then(async () => {
     220              :         if (transitionVersion !== authTransitionVersion) return
     221              :         workflowStore.activeWorkflow = null
     222              :         try {
     223              :           await useWorkflowService().loadBlankWorkflow()
     224              :           if (transitionVersion !== authTransitionVersion) return
     225              :           draftStore.setAuthSubject(user.id)
     226              :           await waitForWorkspaceInitialization()
     227              :           if (transitionVersion !== authTransitionVersion) return
     228              :           await draftStore.loadPersistedWorkflow({
     229              :             fallbackToLatestDraft: true
     230              :           })
     231              :         } finally {
     232              :           if (transitionVersion === authTransitionVersion) {
     233              :             draftStore.setAuthSubject(user.id)
     234              :             completeWorkflowLogoutTransition()
     235              :           }
     236              :         }
     237              :       })
     238              :       .catch((error: unknown) => {
     239              :         console.error('Error switching workflow persistence identity', error)
     240              :       })
     241              :   })
     242              : 
     243         2355 :   const loadPreviousWorkflowFromStorage = async (isCurrent: () => boolean) => {
     244         2299 :     const sessionPath = tabState.getActivePath()
     245              : 
     246         2299 :     if (
     247              :       sessionPath &&
     248              :       (await draftStore.loadPersistedWorkflow({
     249              :         preferredPath: sessionPath,
     250              :         isCurrent
     251              :       }))
     252              :     )
     253            4 :       return true
     254              : 
     255         2295 :     if (!isCurrent()) return false
     256         2295 :     if (sessionPath) {
     257            0 :       const saved = workflowStore.getWorkflowByPath(sessionPath)
     258            0 :       if (
     259              :         saved &&
     260              :         (await useWorkflowService().openWorkflow(saved, { isCurrent }))
     261              :       )
     262            0 :         return true
     263              :     }
     264              : 
     265         2295 :     return await draftStore.loadPersistedWorkflow({
     266              :       fallbackToLatestDraft: true,
     267              :       isCurrent
     268              :     })
     269              :   }
     270              : 
     271              :   /**
     272              :    * The blank canvas startup opens for itself is not the user's work, but the
     273              :    * active-workflow watcher has already saved it. Drop the draft and the
     274              :    * pointer to it, or the next boot restores it and reports `restored`.
     275              :    */
     276         2355 :   const discardStartupBlankDraft = () => {
     277            3 :     const blank = workflowStore.activeWorkflow
     278            3 :     if (!blank?.isTemporary || blank.isModified) return
     279              : 
     280            3 :     debouncedPersist.cancel()
     281            3 :     draftStore.removeDraft(blank.path)
     282            3 :     delete lastSavedJsonByPath.value[blank.path]
     283            3 :     tabState.clearActivePathPointer()
     284              :   }
     285              : 
     286         2355 :   const hasPreservedIntent = (namespace: string, key: string) => {
     287            5 :     if (typeof route.query[key] === 'string') return true
     288            3 :     hydratePreservedQuery(namespace)
     289              :     const merged = mergePreservedQueryIntoQuery(namespace, route.query)
     290            5 :     return typeof merged?.[key] === 'string'
     291              :   }
     292              : 
     293         2355 :   const hasSharedWorkflowIntent = () =>
     294              :     hasPreservedIntent(SHARE_NAMESPACE, 'share')
     295              : 
     296         2355 :   const hasTemplateUrlIntent = () =>
     297              :     hasPreservedIntent(TEMPLATE_NAMESPACE, 'template')
     298              : 
     299         2355 :   const hasLocalHandoffIntent = () =>
     300              :     flags.openOnCloudEnabled &&
     301              :     hasPreservedIntent(LOCAL_HANDOFF_NAMESPACE, LOCAL_HANDOFF_PARAM)
     302              : 
     303         2355 :   const resolveStartupOutcome = async (
     304              :     workflowLinkPending = false
     305              :   ): Promise<StartupOutcome> => {
     306         2256 :     if (settingStore.get('Comfy.TutorialCompleted')) {
     307         2253 :       await comfyApp.loadGraphData()
     308         2253 :       return 'restored'
     309              :     }
     310              : 
     311            3 :     await useWorkflowService().loadBlankWorkflow()
     312            3 :     await nextTick()
     313            3 :     discardStartupBlankDraft()
     314         2256 :     return workflowLinkPending ||
     315              :       hasSharedWorkflowIntent() ||
     316              :       hasTemplateUrlIntent() ||
     317              :       hasLocalHandoffIntent()
     318              :       ? 'url-intent'
     319              :       : 'fresh'
     320              :   }
     321              : 
     322         2355 :   const getRestorableTabState = () => {
     323         4708 :     const storedTabState = tabState.getOpenPaths()
     324         4708 :     const paths = storedTabState?.paths ?? []
     325         4708 :     const activeIndex = storedTabState?.activeIndex ?? -1
     326              : 
     327         4708 :     if (paths.length === 0 || activeIndex < 0 || activeIndex >= paths.length) {
     328         4598 :       return null
     329              :     }
     330              : 
     331          110 :     return { paths, activeIndex }
     332              :   }
     333              : 
     334         2355 :   const initializeWorkflow = async (): Promise<StartupOutcome> => {
     335         2355 :     const linkedWorkflow =
     336              :       await linkedWorkflowUrlLoader.openLinkedWorkflowFromUrl()
     337         2355 :     const workflowLinkPending = linkedWorkflow === 'pending'
     338         2355 :     openedLinkedWorkflow = linkedWorkflow === 'opened'
     339         2355 :     if (openedLinkedWorkflow) return 'restored'
     340              : 
     341         2355 :     if (!workflowPersistenceEnabled.value) {
     342            1 :       return await resolveStartupOutcome(workflowLinkPending)
     343              :     }
     344              : 
     345         2354 :     const isRestoreCurrent = await waitForRestoreIdentity()
     346              : 
     347         2355 :     try {
     348         2354 :       if (getRestorableTabState()) {
     349           55 :         return 'restored'
     350              :       }
     351              : 
     352         2299 :       await workflowStore.loadWorkflows()
     353         2299 :       if (!isRestoreCurrent()) return 'restored'
     354         2299 :       const restored = await loadPreviousWorkflowFromStorage(isRestoreCurrent)
     355         2299 :       if (!isRestoreCurrent()) return 'restored'
     356         2355 :       return restored
     357              :         ? 'restored'
     358              :         : await resolveStartupOutcome(workflowLinkPending)
     359              :     } catch (err) {
     360            0 :       console.error('Error loading previous workflow', err)
     361            0 :       return await resolveStartupOutcome(workflowLinkPending)
     362              :     }
     363              :   }
     364              : 
     365         2355 :   const loadTemplateFromUrlIfPresent = async () => {
     366         2355 :     const query = await ensureTemplateQueryFromIntent()
     367              :     const hasTemplateUrl = query.template && typeof query.template === 'string'
     368              : 
     369         2355 :     return hasTemplateUrl
     370              :       ? await templateUrlLoader.loadTemplateFromUrl()
     371              :       : undefined
     372              :   }
     373              : 
     374         2355 :   const loadSharedWorkflowFromUrlIfPresent = async () => {
     375         2355 :     return await sharedWorkflowUrlLoader.loadSharedWorkflowFromUrl()
     376              :   }
     377              : 
     378              :   // Setup watchers
     379         2355 :   watch(
     380              :     () => workflowStore.activeWorkflow?.key,
     381              :     (activeWorkflowKey) => {
     382         3894 :       if (!activeWorkflowKey) return
     383              :       // Flush any pending persistence from the previous workflow
     384         3894 :       debouncedPersist.flush()
     385              :       // Persist the new workflow immediately
     386         3894 :       persistCurrentWorkflow()
     387              :     }
     388              :   )
     389              : 
     390              :   // Debounced persistence on graph changes
     391         2355 :   api.addEventListener('graphChanged', debouncedPersist)
     392              : 
     393              :   // Clean up event listener when component unmounts
     394         2355 :   tryOnScopeDispose(() => {
     395            0 :     api.removeEventListener('graphChanged', debouncedPersist)
     396            0 :     window.removeEventListener('pagehide', flushPendingPersistence)
     397            0 :     unregisterPersistenceFlush()
     398            0 :     debouncedPersist.cancel()
     399            0 :     stopPendingWorkspaceReadinessWatcher()
     400              :   })
     401              : 
     402              :   // Restore workflow tabs states
     403         2355 :   const openWorkflows = computed(() => workflowStore.openWorkflows)
     404         2355 :   const activeWorkflow = computed(() => workflowStore.activeWorkflow)
     405         2355 :   const restoreState = computed<{ paths: string[]; activeIndex: number }>(
     406              :     () => {
     407         7933 :       const active = getActiveWorkflow()
     408         7933 :       if (!active) return { paths: [], activeIndex: -1 }
     409         5578 :       const paths = openWorkflows.value
     410              :         .map((workflow) => workflow.path)
     411              :         .filter(
     412              :           (path): path is string =>
     413              :             typeof path === 'string' && path.startsWith(ComfyWorkflow.basePath)
     414              :         )
     415              :       const activeIndex = paths.indexOf(active.path)
     416              : 
     417         5578 :       return { paths, activeIndex }
     418              :     }
     419              :   )
     420              : 
     421         7933 :   function getActiveWorkflow(): ComfyWorkflow | null {
     422         7933 :     return activeWorkflow.value
     423              :   }
     424              : 
     425              :   // Track whether tab state has been properly restored to avoid
     426              :   // overwriting with stale data during initialization
     427         2355 :   let tabStateRestored = false
     428              : 
     429         2355 :   watch(restoreState, ({ paths, activeIndex }) => {
     430              :     // Only persist after tab state has been restored to avoid
     431              :     // writing leaked data from wrong workspace during init
     432         5578 :     if (workflowPersistenceEnabled.value && tabStateRestored) {
     433         3278 :       tabState.setOpenPaths(paths, activeIndex)
     434              :     }
     435              :   })
     436              : 
     437              :   /**
     438              :    * Restores saved workflow tabs after initializeWorkflow skips the single-workflow fallback.
     439              :    * GraphCanvas must call this during startup when workflow persistence is enabled.
     440              :    */
     441         2355 :   const restoreWorkflowTabsState = async () => {
     442         2355 :     try {
     443         2355 :       await restoreSavedTabs()
     444              :     } finally {
     445         2355 :       workflowStore.markTabsRestored()
     446              :     }
     447              :   }
     448              : 
     449         2355 :   const stampWithDraftTime = (
     450              :     restored: ComfyWorkflow,
     451              :     draftPath: string,
     452              :     draftData: ComfyWorkflowJSON,
     453              :     draftUpdatedAt: number
     454              :   ) => {
     455              :     const builtFromThisDraft =
     456              :       restored.path === draftPath && isValidUuid(draftData.id)
     457           78 :     if (builtFromThisDraft) restored.lastModified = draftUpdatedAt
     458              :   }
     459              : 
     460         2355 :   const restoreSavedTabs = async () => {
     461         2355 :     if (!workflowPersistenceEnabled.value) {
     462            1 :       tabStateRestored = true
     463            1 :       return
     464              :     }
     465              : 
     466         2354 :     const isRestoreCurrent = await waitForRestoreIdentity()
     467              : 
     468         2354 :     try {
     469         2354 :       await workflowStore.loadWorkflows()
     470              :     } catch (err) {
     471            0 :       console.error('Error loading workflows for tab restore', err)
     472            0 :       await resolveStartupOutcome()
     473            0 :       tabStateRestored = true
     474            0 :       return
     475              :     }
     476              : 
     477         2355 :     const restorableTabState = isRestoreCurrent()
     478              :       ? getRestorableTabState()
     479              :       : null
     480         2355 :     if (!restorableTabState) {
     481         2299 :       tabStateRestored = true
     482         2299 :       return
     483              :     }
     484           55 :     const { paths: storedWorkflows, activeIndex: storedActiveIndex } =
     485              :       restorableTabState
     486              : 
     487           55 :     storedWorkflows.forEach((path: string) => {
     488          113 :       if (workflowStore.getWorkflowByPath(path)) return
     489           79 :       const draft = draftStore.getDraft(path)
     490          113 :       if (!draft?.isTemporary) return
     491           99 :       try {
     492           78 :         const workflowData = JSON.parse(draft.data)
     493           78 :         const restored = workflowStore.createTemporary(draft.name, workflowData)
     494           78 :         stampWithDraftTime(restored, path, workflowData, draft.updatedAt)
     495              :       } catch (err) {
     496            0 :         console.warn(
     497              :           'Failed to parse workflow draft, creating with default',
     498              :           err
     499              :         )
     500            0 :         draftStore.removeDraft(path)
     501            0 :         workflowStore.createTemporary(draft.name)
     502              :       }
     503              :     })
     504              : 
     505           55 :     workflowStore.openWorkflowsInBackground({
     506              :       left: storedWorkflows.slice(0, storedActiveIndex),
     507              :       right: storedWorkflows.slice(storedActiveIndex)
     508              :     })
     509              : 
     510           55 :     tabStateRestored = true
     511           55 :     if (openedLinkedWorkflow) return
     512              : 
     513           55 :     const activePath = storedWorkflows[storedActiveIndex]
     514         2355 :     const workflow = activePath
     515              :       ? workflowStore.getWorkflowByPath(activePath)
     516              :       : null
     517         2355 :     if (workflow) {
     518           54 :       await useWorkflowService().openWorkflow(workflow)
     519              :     }
     520              :   }
     521              : 
     522         2355 :   return {
     523              :     initializeWorkflow,
     524              :     loadSharedWorkflowFromUrlIfPresent,
     525              :     loadTemplateFromUrlIfPresent,
     526              :     restoreWorkflowTabsState
     527              :   }
     528              : }
        

Generated by: LCOV version 2.0-1