windmill-components 1.473.0 → 1.493.2

package/package/components/DefaultScriptsInner.svelte

@@ -1,4 +1,4 @@
-<script>import { WorkspaceService } from '../gen';
+<script lang="ts">import { WorkspaceService } from '../gen';
 import { defaultScripts, workspaceStore } from '../stores';
 import { flip } from 'svelte/animate';
 import Toggle from './Toggle.svelte';

package/package/components/DefaultScriptsInner.svelte.d.ts

@@ -1,16 +1,20 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        small?: boolean | undefined;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type DefaultScriptsInnerProps = typeof __propDef.props;
-export type DefaultScriptsInnerEvents = typeof __propDef.events;
-export type DefaultScriptsInnerSlots = typeof __propDef.slots;
-export default class DefaultScriptsInner extends SvelteComponent<DefaultScriptsInnerProps, DefaultScriptsInnerEvents, DefaultScriptsInnerSlots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+declare const DefaultScriptsInner: $$__sveltets_2_IsomorphicComponent<{
+    small?: boolean;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type DefaultScriptsInner = InstanceType<typeof DefaultScriptsInner>;
+export default DefaultScriptsInner;

package/package/components/DefaultTags.svelte

@@ -1,4 +1,4 @@
-<script>import { Button } from './common';
+<script lang="ts">import { Button } from './common';
 import { Pen } from 'lucide-svelte';
 import Tooltip from './Tooltip.svelte';
 import Popover from './meltComponents/Popover.svelte';

package/package/components/DefaultTags.svelte.d.ts

@@ -1,17 +1,21 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        defaultTagPerWorkspace?: boolean | undefined;
-        defaultTagWorkspaces?: string[] | undefined;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type DefaultTagsProps = typeof __propDef.props;
-export type DefaultTagsEvents = typeof __propDef.events;
-export type DefaultTagsSlots = typeof __propDef.slots;
-export default class DefaultTags extends SvelteComponent<DefaultTagsProps, DefaultTagsEvents, DefaultTagsSlots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+declare const DefaultTags: $$__sveltets_2_IsomorphicComponent<{
+    defaultTagPerWorkspace?: boolean | undefined;
+    defaultTagWorkspaces?: string[] | undefined;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type DefaultTags = InstanceType<typeof DefaultTags>;
+export default DefaultTags;

package/package/components/DefaultTagsInner.svelte

@@ -1,4 +1,4 @@
-<script>import { Button } from './common';
+<script lang="ts">import { Button } from './common';
 import { AlertTriangle, Loader2 } from 'lucide-svelte';
 import { SettingService, WorkerService, WorkspaceService } from '../gen';
 import Tooltip from './Tooltip.svelte';
@@ -58,7 +58,7 @@ loadWorkspaces();
 				</div>
 			{/each}
 		</div>
-		<div class="py-4 flex flex-col gap-2">
+		<div id="default-tags-settings" class="py-4 flex flex-col gap-2">
 			<Toggle
 				bind:checked={defaultTagPerWorkspace}
 				options={{ right: 'workspace specific default tags' }}
@@ -66,7 +66,11 @@ loadWorkspaces();
 			{#if defaultTagPerWorkspace}
 				<Toggle bind:checked={limitToWorkspaces} options={{ right: 'only for some workspaces' }} />
 				{#if limitToWorkspaces}
-					<MultiSelectWrapper items={workspaces} bind:value={defaultTagWorkspaces} />
+					<MultiSelectWrapper
+						target="#default-tags-settings"
+						items={workspaces}
+						bind:value={defaultTagWorkspaces}
+					/>
 				{/if}
 			{/if}
 		</div>
@@ -95,7 +99,9 @@ loadWorkspaces();
 			}}
 			disabled={!$enterpriseLicense || !$superadmin}
 		>
-			Save {#if !$superadmin} <span class="text-2xs text-tertiary">superadmin only</span> {/if}
+			Save {#if !$superadmin}
+				<span class="text-2xs text-tertiary">superadmin only</span>
+			{/if}
 		</Button>
 
 		<span class="text-2xs text-tertiary"

package/package/components/DefaultTagsInner.svelte.d.ts

@@ -1,17 +1,21 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        defaultTagPerWorkspace?: boolean | undefined;
-        defaultTagWorkspaces?: string[] | undefined;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type DefaultTagsInnerProps = typeof __propDef.props;
-export type DefaultTagsInnerEvents = typeof __propDef.events;
-export type DefaultTagsInnerSlots = typeof __propDef.slots;
-export default class DefaultTagsInner extends SvelteComponent<DefaultTagsInnerProps, DefaultTagsInnerEvents, DefaultTagsInnerSlots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+declare const DefaultTagsInner: $$__sveltets_2_IsomorphicComponent<{
+    defaultTagPerWorkspace?: boolean | undefined;
+    defaultTagWorkspaces?: string[] | undefined;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type DefaultTagsInner = InstanceType<typeof DefaultTagsInner>;
+export default DefaultTagsInner;

package/package/components/DeployButton.svelte

@@ -0,0 +1,63 @@
+<script lang="ts">import { Button } from './common';
+import { Save, CornerDownLeft } from 'lucide-svelte';
+import { createEventDispatcher } from 'svelte';
+const { loading = false, loadingSave = false, newFlow = false, dropdownItems = [] } = $props();
+const dispatch = createEventDispatcher();
+let msgInput = $state(undefined);
+let hideDropdown = $state(false);
+let deploymentMsg = $state('');
+let dropdownOpen = $state(false);
+</script>
+
+<Button
+	disabled={loading}
+	loading={loadingSave}
+	size="xs"
+	startIcon={{ icon: Save }}
+	on:click={() => dispatch('save')}
+	dropdownItems={!newFlow ? dropdownItems : undefined}
+	tooltipPopover={{
+		placement: 'bottom-end',
+		openDelay: dropdownOpen ? 200 : 0,
+		closeDelay: 0,
+		portal: 'body'
+	}}
+	on:tooltipOpen={async ({ detail }) => {
+		if (detail) {
+			// Use setTimeout to ensure DOM is updated
+			setTimeout(() => {
+				msgInput?.focus()
+			}, 0)
+			hideDropdown = true
+		} else {
+			hideDropdown = false
+		}
+	}}
+	{hideDropdown}
+	on:dropdownOpen={({ detail }) => (dropdownOpen = detail)}
+>
+	Deploy
+	<svelte:fragment slot="tooltip">
+		<div class="flex flex-row gap-2 w-80 p-4 bg-surface rounded-lg shadow-lg border z-[5001]">
+			<input
+				type="text"
+				placeholder="Deployment message"
+				bind:value={deploymentMsg}
+				onkeydown={async (e) => {
+					if (e.key === 'Enter') {
+						dispatch('save', deploymentMsg)
+					}
+				}}
+				bind:this={msgInput}
+			/>
+			<Button
+				size="xs"
+				on:click={async () => dispatch('save', deploymentMsg)}
+				endIcon={{ icon: CornerDownLeft }}
+				loading={loadingSave}
+			>
+				Deploy
+			</Button>
+		</div>
+	</svelte:fragment>
+</Button>

package/package/components/DeployButton.svelte.d.ts

@@ -0,0 +1,29 @@
+type $$ComponentProps = {
+    loading?: boolean;
+    loadingSave?: boolean;
+    newFlow?: boolean;
+    dropdownItems?: Array<{
+        label: string;
+        onClick: () => void;
+    }>;
+};
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const DeployButton: $$__sveltets_2_IsomorphicComponent<$$ComponentProps, {
+    save: CustomEvent<any>;
+} & {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, "">;
+type DeployButton = InstanceType<typeof DeployButton>;
+export default DeployButton;

package/package/components/DeployToSetting.svelte

@@ -1,4 +1,4 @@
-<script>import { WorkspaceService } from '../gen';
+<script lang="ts">import { WorkspaceService } from '../gen';
 import { enterpriseLicense, usersWorkspaceStore, workspaceStore } from '../stores';
 import { sendUserToast } from '../toast';
 import { fade } from 'svelte/transition';
@@ -16,7 +16,8 @@ const all_ok = {
     apps: true,
     resources: true,
     variables: true,
-    secrets: true
+    secrets: true,
+    triggers: true
 };
 export let workspaceToDeployTo;
 export let deployUiSettings = {
@@ -43,6 +44,9 @@ function deployUITypeMapToArray(typesMap, expectedValue) {
     if (typesMap.secrets == expectedValue) {
         result.push('secret');
     }
+    if (typesMap.triggers == expectedValue) {
+        result.push('trigger');
+    }
     return result;
 }
 async function editWindmillDeploymentUISettings() {
@@ -141,18 +145,9 @@ async function editWindmillDeploymentUISettings() {
 			</Tooltip></h4
 		>
 		<div class="flex flex-col gap-2 mt-1">
-			<Toggle
-				bind:checked={deployUiSettings.include_type.scripts}
-				options={{ right: 'Scripts' }}
-			/>
-			<Toggle
-				bind:checked={deployUiSettings.include_type.flows}
-				options={{ right: 'Flows' }}
-			/>
-			<Toggle
-				bind:checked={deployUiSettings.include_type.apps}
-				options={{ right: 'Apps' }}
-			/>
+			<Toggle bind:checked={deployUiSettings.include_type.scripts} options={{ right: 'Scripts' }} />
+			<Toggle bind:checked={deployUiSettings.include_type.flows} options={{ right: 'Flows' }} />
+			<Toggle bind:checked={deployUiSettings.include_type.apps} options={{ right: 'Apps' }} />
 			<Toggle
 				bind:checked={deployUiSettings.include_type.resources}
 				options={{ right: 'Resources' }}
@@ -174,6 +169,10 @@ async function editWindmillDeploymentUISettings() {
 					options={{ left: 'Include secrets' }}
 				/>
 			</div>
+			<Toggle
+				bind:checked={deployUiSettings.include_type.triggers}
+				options={{ right: 'Trigger' }}
+			/>
 		</div>
 	</div>
 </div>

package/package/components/DeployToSetting.svelte.d.ts

@@ -1,27 +1,32 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        workspaceToDeployTo: string | undefined;
-        deployUiSettings?: {
-            include_path: string[];
-            include_type: {
-                scripts: boolean;
-                flows: boolean;
-                apps: boolean;
-                resources: boolean;
-                variables: boolean;
-                secrets: boolean;
-            };
-        } | undefined;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type DeployToSettingProps = typeof __propDef.props;
-export type DeployToSettingEvents = typeof __propDef.events;
-export type DeployToSettingSlots = typeof __propDef.slots;
-export default class DeployToSetting extends SvelteComponent<DeployToSettingProps, DeployToSettingEvents, DeployToSettingSlots> {
+    z_$$bindings?: Bindings;
 }
-export {};
+declare const DeployToSetting: $$__sveltets_2_IsomorphicComponent<{
+    workspaceToDeployTo: string | undefined;
+    deployUiSettings?: {
+        include_path: string[];
+        include_type: {
+            scripts: boolean;
+            flows: boolean;
+            apps: boolean;
+            resources: boolean;
+            variables: boolean;
+            secrets: boolean;
+            triggers: boolean;
+        };
+    };
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type DeployToSetting = InstanceType<typeof DeployToSetting>;
+export default DeployToSetting;

package/package/components/DeployWorkspace.svelte

@@ -1,4 +1,4 @@
-<script>import { createEventDispatcher } from 'svelte';
+<script lang="ts">import { createEventDispatcher } from 'svelte';
 import { base } from '../base';
 import { enterpriseLicense, superadmin, workspaceStore } from '../stores';
 import { AppService, FlowService, FolderService, RawAppService, ResourceService, ScheduleService, ScriptService, UserService, VariableService, WorkspaceService } from '../gen';
@@ -10,9 +10,11 @@ import Toggle from './Toggle.svelte';
 import { Loader2 } from 'lucide-svelte';
 import Badge from './common/badge/Badge.svelte';
 import DiffDrawer from './DiffDrawer.svelte';
+import { existsTrigger, getTriggerDependency, getTriggersDeployData, getTriggerValue } from '../utils_deployable';
 const dispatch = createEventDispatcher();
 export let kind;
 export let initialPath = '';
+export let additionalInformation = undefined;
 export let workspaceToDeployTo = undefined;
 export let hideButton = false;
 let seeTarget = undefined;
@@ -116,6 +118,12 @@ async function getDependencies(kind, path) {
             }
             return [...recObj(res.value), { kind: 'resource_type', path: res.resource_type }];
         }
+        else if (kind == 'trigger') {
+            if (additionalInformation?.triggers) {
+                return getTriggerDependency(additionalInformation.triggers.kind, path, $workspaceStore);
+            }
+            throw new Error('Missing trigger information');
+        }
         return [];
     }
     let toProcess = [{ kind, path }];
@@ -137,70 +145,85 @@ async function getDependencies(kind, path) {
     return processed;
 }
 async function checkAlreadyExists(kind, path) {
+    let exists;
     if (kind == 'flow') {
-        return await FlowService.existsFlowByPath({
+        exists = await FlowService.existsFlowByPath({
             workspace: workspaceToDeployTo,
             path: path
         });
     }
     else if (kind == 'script') {
-        return await ScriptService.existsScriptByPath({
+        exists = await ScriptService.existsScriptByPath({
             workspace: workspaceToDeployTo,
             path: path
         });
     }
     else if (kind == 'app') {
-        return await AppService.existsApp({
+        exists = await AppService.existsApp({
             workspace: workspaceToDeployTo,
             path: path
         });
     }
     else if (kind == 'raw_app') {
-        return await RawAppService.existsRawApp({
+        exists = await RawAppService.existsRawApp({
             workspace: workspaceToDeployTo,
             path: path
         });
     }
     else if (kind == 'variable') {
-        return await VariableService.existsVariable({
+        exists = await VariableService.existsVariable({
             workspace: workspaceToDeployTo,
             path: path
         });
     }
     else if (kind == 'resource') {
-        return await ResourceService.existsResource({
+        exists = await ResourceService.existsResource({
             workspace: workspaceToDeployTo,
             path: path
         });
     }
     else if (kind == 'schedule') {
-        return await ScheduleService.existsSchedule({
+        exists = await ScheduleService.existsSchedule({
             workspace: workspaceToDeployTo,
             path: path
         });
     }
     else if (kind == 'resource_type') {
-        return await ResourceService.existsResourceType({
+        exists = await ResourceService.existsResourceType({
             workspace: workspaceToDeployTo,
             path: path
         });
     }
     else if (kind == 'folder') {
-        let exists = true;
-        try {
-            await FolderService.getFolder({
-                workspace: workspaceToDeployTo,
-                name: path
-            });
+        exists = await FolderService.existsFolder({
+            workspace: workspaceToDeployTo,
+            name: path
+        });
+    }
+    else if (kind === 'trigger') {
+        const triggersKind = [
+            'kafka',
+            'mqtt',
+            'nats',
+            'postgres',
+            'routes',
+            'schedules',
+            'sqs',
+            'websockets',
+            'gcp'
+        ];
+        if (additionalInformation?.triggers &&
+            triggersKind.includes(additionalInformation.triggers.kind)) {
+            exists = await existsTrigger({ workspace: workspaceToDeployTo, path }, additionalInformation.triggers.kind);
         }
-        catch (e) {
-            exists = false;
+        else {
+            throw new Error(`Unexpected triggers kind, expected one of: '${triggersKind.join(', ')}' got: ${additionalInformation?.triggers?.kind}`);
         }
-        return exists;
     }
     else {
         throw new Error(`Unknown kind ${kind}`);
     }
+    return exists;
 }
 const deploymentStatus = {};
 async function deploy(kind, path) {
@@ -387,6 +410,27 @@ async function deploy(kind, path) {
                 }
             });
         }
+        else if (kind === 'trigger') {
+            if (additionalInformation?.triggers) {
+                const { data, createFn, updateFn } = await getTriggersDeployData(additionalInformation.triggers.kind, path, $workspaceStore);
+                if (alreadyExists) {
+                    await updateFn({
+                        path,
+                        workspace: workspaceToDeployTo,
+                        requestBody: data
+                    });
+                }
+                else {
+                    await createFn({
+                        workspace: workspaceToDeployTo,
+                        requestBody: data
+                    });
+                }
+            }
+            else {
+                throw new Error('Missing triggers kind');
+            }
+        }
         else {
             throw new Error(`Unknown kind ${kind}`);
         }
@@ -489,6 +533,14 @@ async function getValue(kind, path, workspace) {
                 name: folder.name
             };
         }
+        else if (kind == 'trigger') {
+            if (additionalInformation?.triggers) {
+                return await getTriggerValue(additionalInformation.triggers.kind, path, workspace);
+            }
+            else {
+                throw new Error(`Missing trigger information`);
+            }
+        }
         else {
             throw new Error(`Unknown kind ${kind}`);
         }
@@ -512,7 +564,7 @@ async function showDiff(kind, path) {
 }
 </script>
 
-<div class="mt-6" />
+<div class="mt-6"></div>
 
 {#if !$enterpriseLicense}
 	<Alert type="error" title="Enterprise license required"
@@ -536,7 +588,7 @@ async function showDiff(kind, path) {
 	<input class="max-w-xs" type="text" disabled value={workspaceToDeployTo} />
 
 	{#if seeTarget == undefined}
-		<div class="mt-6" />
+		<div class="mt-6"></div>
 		<Loader2 class="animate-spin" />
 	{:else if seeTarget == true}
 		<h3 class="mb-6 mt-16">All related deployable items</h3>
@@ -606,7 +658,7 @@ async function showDiff(kind, path) {
 			>
 		{/if}
 	{:else}
-		<div class="my-2" />
+		<div class="my-2"></div>
 		<Alert type="error" title="User not allowed to deploy to this workspace"
 			>Ask a permissioned user to deploy this item using the shareable link or get the proper
 			permissions on the target workspace</Alert

package/package/components/DeployWorkspace.svelte.d.ts

@@ -1,23 +1,30 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        kind: "script" | "flow" | "resource" | "resource_type" | "schedule" | "app" | "folder" | "variable" | "raw_app";
-        initialPath?: string | undefined;
-        workspaceToDeployTo?: string | undefined;
-        hideButton?: boolean | undefined;
-        deployAll?: (() => void) | undefined;
+import { type AdditionalInformation, type Kind } from '../utils_deployable';
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
     };
-    events: {
-        update: CustomEvent<any>;
-    } & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type DeployWorkspaceProps = typeof __propDef.props;
-export type DeployWorkspaceEvents = typeof __propDef.events;
-export type DeployWorkspaceSlots = typeof __propDef.slots;
-export default class DeployWorkspace extends SvelteComponent<DeployWorkspaceProps, DeployWorkspaceEvents, DeployWorkspaceSlots> {
-    get deployAll(): () => void;
+    z_$$bindings?: Bindings;
 }
-export {};
+declare const DeployWorkspace: $$__sveltets_2_IsomorphicComponent<{
+    kind: Kind;
+    initialPath?: string;
+    additionalInformation?: AdditionalInformation | undefined;
+    workspaceToDeployTo?: string | undefined;
+    hideButton?: boolean;
+    deployAll?: () => void;
+}, {
+    update: CustomEvent<any>;
+} & {
+    [evt: string]: CustomEvent<any>;
+}, {}, {
+    deployAll: () => void;
+}, string>;
+type DeployWorkspace = InstanceType<typeof DeployWorkspace>;
+export default DeployWorkspace;

package/package/components/DeployWorkspaceDrawer.svelte

@@ -1,12 +1,15 @@
-<script>import { Button, Drawer } from './common';
+<script lang="ts">import { Button, Drawer } from './common';
 import DrawerContent from './common/drawer/DrawerContent.svelte';
 import DeployWorkspace from './DeployWorkspace.svelte';
+import {} from '../utils_deployable';
 let initialPath = undefined;
 let kind = undefined;
 let drawer = undefined;
 let workspaceToDeployTo = undefined;
 let deployWorkspace = undefined;
-export async function openDrawer(initialPath_l, kind_l) {
+let additionalInformation = undefined;
+export async function openDrawer(initialPath_l, kind_l, additionalInformation_l) {
+    additionalInformation = additionalInformation_l;
     initialPath = initialPath_l;
     kind = kind_l;
     drawer?.openDrawer();
@@ -15,11 +18,12 @@ export async function openDrawer(initialPath_l, kind_l) {
 
 <Drawer bind:this={drawer} size="900px">
 	<DrawerContent title="Deploy {initialPath}" on:close={drawer.closeDrawer}>
-		{#if kind != undefined && initialPath != undefined}
+		{#if (kind != 'trigger' && kind != undefined && initialPath != undefined) || (kind === 'trigger' && initialPath != undefined && additionalInformation?.triggers != undefined)}
 			<DeployWorkspace
 				hideButton
 				{initialPath}
 				{kind}
+				{additionalInformation}
 				bind:workspaceToDeployTo
 				bind:this={deployWorkspace}
 			/>