Function: selectCreateSite()

function selectCreateSite(state: {
    checkSiteNow: (siteIdentifier: string, monitorId: string) => Promise<void>;
    startSiteMonitoring: (siteIdentifier: string) => Promise<void>;
    startSiteMonitorMonitoring: (
        siteIdentifier: string,
        monitorId: string
    ) => Promise<void>;
    stopSiteMonitoring: (siteIdentifier: string) => Promise<void>;
    stopSiteMonitorMonitoring: (
        siteIdentifier: string,
        monitorId: string
    ) => Promise<void>;
    addMonitorToSite: (
        siteIdentifier: string,
        monitor: Monitor
    ) => Promise<void>;
    createSite: (siteData: {
        identifier: string;
        monitoring?: boolean;
        monitors?: Monitor[];
        name?: string;
    }) => Promise<void>;
    deleteSite: (identifier: string) => Promise<void>;
    downloadSqliteBackup: () => Promise<SerializedDatabaseBackupResult>;
    removeMonitorFromSite: (
        siteIdentifier: string,
        monitorId: string
    ) => Promise<void>;
    restoreSqliteBackup: (
        payload: SerializedDatabaseRestorePayload
    ) => Promise<SerializedDatabaseRestoreResult>;
    saveSqliteBackup: () => Promise<SerializedDatabaseBackupSaveResult>;
    updateMonitorRetryAttempts: (
        siteIdentifier: string,
        monitorId: string,
        retryAttempts: number | undefined
    ) => Promise<void>;
    updateMonitorTimeout: (
        siteIdentifier: string,
        monitorId: string,
        timeout: number | undefined
    ) => Promise<void>;
    updateSiteCheckInterval: (
        siteIdentifier: string,
        monitorId: string,
        interval: number
    ) => Promise<void>;
    addSite: (site: Site) => void;
    applySiteSnapshot: (site: Site) => void;
    getSelectedMonitorId: (siteIdentifier: string) => string | undefined;
    getSelectedSite: () => Site | undefined;
    removeSite: (identifier: string) => void;
    selectSite: (site: Site | undefined) => void;
    setSelectedMonitorId: (siteIdentifier: string, monitorId: string) => void;
    setSites: (sites: Site[]) => void;
    setStatusSubscriptionSummary: (
        summary: StatusUpdateSubscriptionSummary | undefined
    ) => void;
    retryStatusSubscription: (
        callback?: (update: StatusUpdate) => void
    ) => Promise<StatusUpdateSubscriptionSummary>;
    subscribeToStatusUpdates: (
        callback?: (update: StatusUpdate) => void
    ) => Promise<StatusUpdateSubscriptionSummary>;
    unsubscribeFromStatusUpdates: () => StatusUpdateUnsubscribeResult;
    fullResyncSites: () => Promise<void>;
    getSyncStatus: () => Promise<{
        lastSyncAt: number | null;
        siteCount: number;
        source:
            | "cache"
            | "database"
            | "frontend"
            | "import"
            | "monitor-update";
        synchronized: boolean;
    }>;
    subscribeToSyncEvents: () => () => void;
    syncSites: () => Promise<void>;
    initializeSites: () => Promise<{
        message: string;
        sitesLoaded: number;
        success: boolean;
    }>;
    modifySite: (identifier: string, updates: Partial<Site>) => Promise<void>;
    recordSiteSyncDelta: (delta: SiteSyncDelta | undefined) => void;
    setLastBackupMetadata: (
        metadata: SerializedDatabaseBackupMetadata | undefined
    ) => void;
    lastBackupMetadata: SerializedDatabaseBackupMetadata | undefined;
    lastSyncDelta: SiteSyncDelta | undefined;
    optimisticMonitoringLocks: Partial<
        Record<string, OptimisticMonitoringLock>
    >;
    selectedMonitorIds: Partial<Record<Site["identifier"], Monitor["id"]>>;
    selectedSiteIdentifier: string | undefined;
    sites: Site[];
    sitesRevision: number;
    statusSubscriptionSummary: StatusUpdateSubscriptionSummary | undefined;
}): (siteData: {
    identifier: string;
    monitoring?: boolean;
    monitors?: Monitor[];
    name?: string;
}) => Promise<void>;

Defined in: src/stores/sites/selectors.ts:8

Selects the action used to create a site.

Parameters

state

checkSiteNow

(siteIdentifier: string, monitorId: string) => Promise<void>

Check a site now

startSiteMonitoring

(siteIdentifier: string) => Promise<void>

Start monitoring for a site

startSiteMonitorMonitoring

(siteIdentifier: string, monitorId: string) => Promise<void>

Start monitoring for a specific site monitor

stopSiteMonitoring

(siteIdentifier: string) => Promise<void>

Stop monitoring for a site

stopSiteMonitorMonitoring

(siteIdentifier: string, monitorId: string) => Promise<void>

Stop monitoring for a specific site monitor

addMonitorToSite

(siteIdentifier: string, monitor: Monitor) => Promise<void>

Add a monitor to an existing site

createSite

(siteData: { identifier: string; monitoring?: boolean; monitors?: Monitor[]; name?: string; }) => Promise<void>

Create a new site

deleteSite

(identifier: string) => Promise<void>

Delete a site

downloadSqliteBackup

() => Promise<SerializedDatabaseBackupResult>

Download SQLite backup

removeMonitorFromSite

(siteIdentifier: string, monitorId: string) => Promise<void>

Remove a monitor from a site

restoreSqliteBackup

(payload: SerializedDatabaseRestorePayload) => Promise<SerializedDatabaseRestoreResult>

Restore SQLite backup

saveSqliteBackup

() => Promise<SerializedDatabaseBackupSaveResult>

Save SQLite backup via main process

updateMonitorRetryAttempts

(siteIdentifier: string, monitorId: string, retryAttempts: number | undefined) => Promise<void>

Update monitor retry attempts

updateMonitorTimeout

(siteIdentifier: string, monitorId: string, timeout: number | undefined) => Promise<void>

Update monitor timeout

updateSiteCheckInterval

(siteIdentifier: string, monitorId: string, interval: number) => Promise<void>

Update site check interval

addSite

(site: Site) => void

Add a site to the store

applySiteSnapshot

(site: Site) => void

Apply a backend-provided (or otherwise authoritative) site snapshot to local state.

Remarks

This is a pure state mutation helper (replace-by-identifier). It is intentionally named to avoid confusion with the IPC-backed SiteService.updateSite(...) / sites.update-site mutation.

getSelectedMonitorId

(siteIdentifier: string) => string | undefined

Get selected monitor ID for a site

getSelectedSite

() => Site | undefined

Get the currently selected site

removeSite

(identifier: string) => void

Remove a site from the store

selectSite

(site: Site | undefined) => void

Select site

setSelectedMonitorId

(siteIdentifier: string, monitorId: string) => void

Set selected monitor ID for a site

setSites

(sites: Site[]) => void

Set all sites

setStatusSubscriptionSummary

(summary: | StatusUpdateSubscriptionSummary | undefined) => void

Persist subscription diagnostics

retryStatusSubscription

(callback?: (update: StatusUpdate) => void) => Promise<StatusUpdateSubscriptionSummary>

Retry status update subscription using the last known callback

subscribeToStatusUpdates

(callback?: (update: StatusUpdate) => void) => Promise<StatusUpdateSubscriptionSummary>

Subscribe to status updates

unsubscribeFromStatusUpdates

() => StatusUpdateUnsubscribeResult

Unsubscribe from status updates

fullResyncSites

() => Promise<void>

Full resync from backend

getSyncStatus

() => Promise<{ lastSyncAt: number | null; siteCount: number; source: "cache" | "database" | "frontend" | "import" | "monitor-update"; synchronized: boolean; }>

Get sync status

subscribeToSyncEvents

() => () => void

Subscribe to sync events

syncSites

() => Promise<void>

Sync sites from backend

initializeSites

() => Promise<{ message: string; sitesLoaded: number; success: boolean; }>

Initialize sites data from backend

modifySite

(identifier: string, updates: Partial<Site>) => Promise<void>

Modify an existing site

recordSiteSyncDelta

(delta: | SiteSyncDelta | undefined) => void

Record latest site synchronization delta information

setLastBackupMetadata

(metadata: | SerializedDatabaseBackupMetadata | undefined) => void

Persist latest backup metadata for UI diagnostics

lastBackupMetadata

| SerializedDatabaseBackupMetadata | undefined

Latest database backup metadata for UI display and diagnostics.

lastSyncDelta

| SiteSyncDelta | undefined

Most recent synchronization delta captured from state sync events.

optimisticMonitoringLocks

Partial<Record<string, OptimisticMonitoringLock>>

Active optimistic monitoring locks for monitors keyed by site and monitor id.

selectedMonitorIds

Partial<Record<Site["identifier"], Monitor["id"]>>

Selected monitor IDs per site (UI state, not persisted)

selectedSiteIdentifier

string | undefined

Currently selected site identifier

sites

Site[]

Array of monitored sites

sitesRevision

number

Monotonic counter incremented whenever the sites collection changes.

Remarks

Used to detect and prevent stale full-sync responses from overwriting newer local mutations (e.g., user creates a site while an initial sync is still in-flight).

statusSubscriptionSummary

| StatusUpdateSubscriptionSummary | undefined

Latest status update subscription diagnostics.

Returns

(siteData: { identifier: string; monitoring?: boolean; monitors?: Monitor[]; name?: string; }) => Promise<void>