windmill-components 1.89.1 → 1.103.0

package/package/gen/services/RawAppService.js

@@ -0,0 +1,106 @@
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class RawAppService {
+    /**
+     * list all available raw apps
+     * @returns ListableRawApp All available raw apps
+     * @throws ApiError
+     */
+    static listRawApps({ workspace, page, perPage, orderDesc, createdBy, pathStart, pathExact, starredOnly, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/raw_apps/list',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'page': page,
+                'per_page': perPage,
+                'order_desc': orderDesc,
+                'created_by': createdBy,
+                'path_start': pathStart,
+                'path_exact': pathExact,
+                'starred_only': starredOnly,
+            },
+        });
+    }
+    /**
+     * does an app exisst at path
+     * @returns boolean app exists
+     * @throws ApiError
+     */
+    static existsRawApp({ workspace, path, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/raw_apps/exists/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * get app by path
+     * @returns string app details
+     * @throws ApiError
+     */
+    static getRawAppData({ workspace, version, path, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/apps/get_data/{version}/{path}',
+            path: {
+                'workspace': workspace,
+                'version': version,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * create raw app
+     * @returns string raw app created
+     * @throws ApiError
+     */
+    static createRawApp({ workspace, requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/raw_apps/create',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * update app
+     * @returns string app updated
+     * @throws ApiError
+     */
+    static updateRawApp({ workspace, path, requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/raw_apps/update/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * delete raw app
+     * @returns string app deleted
+     * @throws ApiError
+     */
+    static deleteRawApp({ workspace, path, }) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/w/{workspace}/raw_apps/delete/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+}

package/package/gen/services/ScriptService.d.ts

@@ -1,4 +1,6 @@
 import type { MainArgSignature } from '../models/MainArgSignature';
+import type { NewScript } from '../models/NewScript';
+import type { NewScriptWithDraft } from '../models/NewScriptWithDraft';
 import type { Script } from '../models/Script';
 import type { CancelablePromise } from '../core/CancelablePromise';
 export declare class ScriptService {
@@ -140,19 +142,7 @@ export declare class ScriptService {
         /**
          * Partially filled script
          */
-        requestBody: {
-            path: string;
-            parent_hash?: string;
-            summary: string;
-            description: string;
-            content: string;
-            schema?: any;
-            is_template?: boolean;
-            lock?: Array<string>;
-            language: 'python3' | 'deno' | 'go' | 'bash';
-            kind?: 'script' | 'failure' | 'trigger' | 'command' | 'approval';
-            tag?: string;
-        };
+        requestBody: NewScript;
     }): CancelablePromise<string>;
     /**
      * inspect python code to infer jsonschema of arguments
@@ -243,6 +233,15 @@ export declare class ScriptService {
         workspace: string;
         path: string;
     }): CancelablePromise<Script>;
+    /**
+     * get script by path with draft
+     * @returns NewScriptWithDraft script details
+     * @throws ApiError
+     */
+    static getScriptByPathWithDraft({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<NewScriptWithDraft>;
     /**
      * raw script by path
      * @returns string script content

package/package/gen/services/ScriptService.js

@@ -226,6 +226,21 @@ export class ScriptService {
             },
         });
     }
+    /**
+     * get script by path with draft
+     * @returns NewScriptWithDraft script details
+     * @throws ApiError
+     */
+    static getScriptByPathWithDraft({ workspace, path, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/get/draft/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
     /**
      * raw script by path
      * @returns string script content

package/package/hub.d.ts

@@ -0,0 +1,21 @@
+import type { Schema } from './common';
+import { type Flow, type Script } from './gen';
+export declare function scriptToHubUrl(content: string, summary: string, description: string, kind: Script.kind, language: Script.language, schema: Schema | undefined, lock: string | undefined): URL;
+export declare function loadHubFlows(): Promise<{
+    id: number;
+    flow_id: number;
+    summary: string;
+    apps: string[];
+    approved: boolean;
+    votes: number;
+}[] | undefined>;
+export declare function loadHubApps(): Promise<{
+    id: number;
+    app_id: number;
+    summary: string;
+    apps: string[];
+    approved: boolean;
+    votes: number;
+}[] | undefined>;
+export declare function flowToHubUrl(flow: Flow): URL;
+export declare function appToHubUrl(staticApp: any): URL;

package/package/hub.js

@@ -0,0 +1,49 @@
+import { AppService, FlowService } from './gen';
+import { encodeState } from './utils';
+export function scriptToHubUrl(content, summary, description, kind, language, schema, lock) {
+    const url = new URL('https://hub.windmill.dev/scripts/add');
+    url.searchParams.append('content', content);
+    url.searchParams.append('summary', summary);
+    url.searchParams.append('description', description);
+    url.searchParams.append('kind', kind);
+    url.searchParams.append('language', language);
+    url.searchParams.append('schema', JSON.stringify(schema, null, 2));
+    lock && url.searchParams.append('lockfile', lock);
+    return url;
+}
+export async function loadHubFlows() {
+    try {
+        const flows = (await FlowService.listHubFlows()).flows ?? [];
+        const processed = flows.sort((a, b) => b.votes - a.votes);
+        return processed;
+    }
+    catch {
+        console.error('Hub is not available');
+    }
+}
+export async function loadHubApps() {
+    try {
+        const apps = (await AppService.listHubApps()).apps ?? [];
+        const processed = apps.sort((a, b) => b.votes - a.votes);
+        return processed;
+    }
+    catch {
+        console.error('Hub is not available');
+    }
+}
+export function flowToHubUrl(flow) {
+    const url = new URL('https://hub.windmill.dev/flows/add');
+    const openFlow = {
+        value: flow.value,
+        summary: flow.summary,
+        description: flow.description,
+        schema: flow.schema
+    };
+    url.searchParams.append('flow', encodeState(openFlow));
+    return url;
+}
+export function appToHubUrl(staticApp) {
+    const url = new URL('https://hub.windmill.dev/apps/add');
+    url.searchParams.append('app', encodeState(staticApp));
+    return url;
+}

package/package/infer.js

@@ -1,9 +1,10 @@
 import { ScriptService } from './gen';
 import { get, writable } from 'svelte/store';
 import { sortObject } from './utils.js';
+import { tick } from 'svelte';
 const loadSchemaLastRun = writable(undefined);
 export async function inferArgs(language, code, schema) {
-    let lastRun = get(loadSchemaLastRun);
+    const lastRun = get(loadSchemaLastRun);
     let inferedSchema;
     if (lastRun && code == lastRun[0] && lastRun[1]) {
         inferedSchema = lastRun[1];
@@ -41,7 +42,7 @@ export async function inferArgs(language, code, schema) {
         loadSchemaLastRun.set([code, inferedSchema]);
     }
     schema.required = [];
-    const oldProperties = Object.assign({}, schema.properties);
+    const oldProperties = JSON.parse(JSON.stringify(schema.properties));
     schema.properties = {};
     for (const arg of inferedSchema.args) {
         if (!(arg.name in oldProperties)) {
@@ -57,9 +58,10 @@ export async function inferArgs(language, code, schema) {
             schema.required.push(arg.name);
         }
     }
+    await tick();
 }
 function argSigToJsonSchemaType(t, oldS) {
-    const newS = { type: '', description: '' };
+    const newS = { type: '' };
     if (t === 'int') {
         newS.type = 'integer';
     }
@@ -135,9 +137,10 @@ function argSigToJsonSchemaType(t, oldS) {
             }
         }
     }
-    let oldDescription = oldS.description;
+    else if (oldS.format == 'date-time' && newS.format != 'date-time') {
+        delete oldS.format;
+    }
     Object.assign(oldS, newS);
-    oldS.description = oldDescription;
     if (oldS.format?.startsWith('resource-') && newS.type != 'object') {
         oldS.format = undefined;
     }

package/package/logout.js

@@ -1,10 +1,10 @@
 import { goto } from '$app/navigation';
 import { UserService } from './gen';
 import { clearStores } from './stores.js';
-import { sendUserToast } from './utils.js';
+import { sendUserToast } from './toast';
 export async function logoutWithRedirect(rd) {
     await clearUser();
-    if (rd && rd != "/" && rd?.split('?')[0] != '/user/login') {
+    if (rd && rd != '/' && rd?.split('?')[0] != '/user/login') {
         const error = document.cookie.includes('token')
             ? `error=${encodeURIComponent('You have been logged out because your session has expired.')}&`
             : '';
@@ -25,6 +25,5 @@ export async function clearUser() {
         clearStores();
         await UserService.logout();
     }
-    catch (error) {
-    }
+    catch (error) { }
 }

package/package/navigation.d.ts

@@ -0,0 +1 @@
+export declare function setQuery(url: URL, key: string, value: string): Promise<void>;

package/package/navigation.js

@@ -0,0 +1,5 @@
+import { goto } from '$app/navigation';
+export async function setQuery(url, key, value) {
+    url.searchParams.set(key, value);
+    await goto(`?${url.searchParams.toString()}`);
+}

package/package/schema.d.ts

@@ -0,0 +1,3 @@
+import type { Schema } from './common';
+export declare function schemaToTsType(schema: Schema): string;
+export declare function schemaToObject(schema: Schema, args: Record<string, any>): Object;

package/package/schema.js

@@ -0,0 +1,43 @@
+export function schemaToTsType(schema) {
+    if (!schema || !schema.properties) {
+        return 'any';
+    }
+    const propKeys = Object.keys(schema.properties);
+    const types = propKeys
+        .map((key) => {
+        const prop = schema.properties[key];
+        const isOptional = !schema.required.includes(key);
+        const prefix = `${key}${isOptional ? '?' : ''}`;
+        let type = 'any';
+        if (prop.type === 'string') {
+            type = 'string';
+        }
+        else if (prop.type === 'number' || prop.type === 'integer') {
+            type = 'number';
+        }
+        else if (prop.type === 'boolean') {
+            type = 'boolean';
+        }
+        else if (prop.type === 'array') {
+            let type = prop.items?.type ?? 'any';
+            if (type === 'integer') {
+                type = 'number';
+            }
+            type = `${type}[]`;
+        }
+        return `${prefix}: ${type}`;
+    })
+        .join(';');
+    return `{ ${types} }`;
+}
+export function schemaToObject(schema, args) {
+    const object = {};
+    if (!schema || !schema.properties) {
+        return object;
+    }
+    const propKeys = Object.keys(schema.properties);
+    propKeys.forEach((key) => {
+        object[key] = args[key] ?? null;
+    });
+    return object;
+}

package/package/script_helpers.d.ts

@@ -1,4 +1,4 @@
-import type { Script } from './gen';
+import { Script } from './gen';
 import PYTHON_INIT_CODE from './init_scripts/python_init_code';
 import PYTHON_INIT_CODE_CLEAR from './init_scripts/python_init_code_clear';
 import PYTHON_INIT_CODE_TRIGGER from './init_scripts/python_init_code_trigger';
@@ -12,9 +12,10 @@ export declare const DENO_FAILURE_MODULE_CODE = "// flow is considered recovered
 export declare const POSTGRES_INIT_CODE: string;
 export declare const MYSQL_INIT_CODE: string;
 export declare const FETCH_INIT_CODE = "export async function main(\n\turl: string | undefined,\n\tmethod: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' = 'GET',\n\tbody: Object = {},\n\theaders: Record<string, string> = {}\n): Promise<Response | null> {\n\tif (!url) {\n\t\tconsole.error('Error: URL is undefined')\n\t\treturn null\n\t}\n\n\tconst requestOptions: RequestInit = {\n\t\tmethod: method || 'GET',\n\t\theaders: headers || {}\n\t}\n\n\tif (requestOptions.method !== 'GET' && requestOptions.method !== 'HEAD' && body !== undefined) {\n\t\trequestOptions.body = JSON.stringify(body)\n\t\trequestOptions.headers = {\n\t\t\t'Content-Type': 'application/json',\n\t\t\t...requestOptions.headers\n\t\t}\n\t}\n\n\treturn await fetch(url, requestOptions)\n\t\t.then((res) => res.json())\n\t\t.catch(() => {\n\t\t\tthrow new Error('An error occured')\n\t\t})\n}";
-export declare const BASH_INIT_CODE = "# arguments of the form X=\"$I\" are parsed as parameters X of type string\nmsg=\"$1\"\ndflt=\"${2:-default value}\"\n\n# the last line of the stdout is the return value\necho \"Hello $msg\"\n";
+export declare const BASH_INIT_CODE = "# shellcheck shell=bash\n# arguments of the form X=\"$I\" are parsed as parameters X of type string\nmsg=\"$1\"\ndflt=\"${2:-default value}\"\n\n# the last line of the stdout is the return value\necho \"Hello $msg\"\n";
 export declare const DENO_INIT_CODE_TRIGGER: string;
 export declare const GO_INIT_CODE_TRIGGER = "package inner\n\nimport (\n\twmill \"github.com/windmill-labs/windmill-go-client\"\n)\n\nfunc main() (interface{}, error) {\n\n\t// A common trigger script would follow this pattern:\n\t// 1. Get the last saved state\n\tstate, _ := wmill.GetState()\n\t// 2. Get the actual state from the external service\n\t// newState := ...\n\t// 3. Compare the two states and update the internal state\n\twmill.SetState(4)\n\t// 4. Return the new rows\n\n\treturn state, nil\n\n\t// In subsequent scripts, you may refer to each row/value returned by the trigger script using\n\t// 'flow_input.iter.value'\n}\n";
-export declare const DENO_INIT_CODE_APPROVAL = "import * as wmill from \"https://deno.land/x/windmill@v1.41.0/mod.ts\"\n\nexport async function main(approver?: string) {\n  return wmill.getResumeEndpoints(approver)\n}";
+export declare const DENO_INIT_CODE_APPROVAL = "import * as wmill from \"https://deno.land/x/windmill@v1.99.0/mod.ts\"\n\nexport async function main(approver?: string) {\n  return wmill.getResumeEndpoints(approver)\n}";
+export declare const DOCKER_INIT_CODE = "# shellcheck shell=bash\n# Bash script that calls docker as a client to the host daemon\n# See documentation: https://docs.windmill.dev/docs/advanced/docker\nmsg=\"${1:-world}\"\n\ndocker run --rm alpine /bin/echo \"Hello $msg\"\n";
 export declare function isInitialCode(content: string): boolean;
-export declare function initialCode(language: 'deno' | 'python3' | 'go' | 'bash', kind: Script.kind, subkind: 'pgsql' | 'mysql' | 'flow' | 'script' | 'fetch' | undefined): string;
+export declare function initialCode(language: 'deno' | 'python3' | 'go' | 'bash', kind: Script.kind | undefined, subkind: 'pgsql' | 'mysql' | 'flow' | 'script' | 'fetch' | 'docker' | undefined): string;

package/package/script_helpers.js

@@ -1,9 +1,10 @@
+import { Script } from './gen';
 import PYTHON_INIT_CODE from './init_scripts/python_init_code';
 import PYTHON_INIT_CODE_CLEAR from './init_scripts/python_init_code_clear';
 import PYTHON_INIT_CODE_TRIGGER from './init_scripts/python_init_code_trigger';
 import PYTHON_FAILURE_MODULE_CODE from './init_scripts/python_failure_module';
 export { PYTHON_INIT_CODE, PYTHON_INIT_CODE_CLEAR, PYTHON_INIT_CODE_TRIGGER, PYTHON_FAILURE_MODULE_CODE };
-export const DENO_INIT_CODE = `// Ctrl/CMD+. to cache dependencies on imports hover, Ctrl/CMD+S to format.
+export const DENO_INIT_CODE = `// Ctrl/CMD+. to cache dependencies on imports hover.
 
 // import { toWords } from "npm:number-to-words@1"
 // import * as wmill from "https://deno.land/x/windmill@v${__pkg__.version}/mod.ts"
@@ -151,7 +152,8 @@ export const FETCH_INIT_CODE = `export async function main(
 			throw new Error('An error occured')
 		})
 }`;
-export const BASH_INIT_CODE = `# arguments of the form X="$I" are parsed as parameters X of type string
+export const BASH_INIT_CODE = `# shellcheck shell=bash
+# arguments of the form X="$I" are parsed as parameters X of type string
 msg="$1"
 dflt="\${2:-default value}"
 
@@ -201,11 +203,18 @@ func main() (interface{}, error) {
 	// 'flow_input.iter.value'
 }
 `;
-export const DENO_INIT_CODE_APPROVAL = `import * as wmill from "https://deno.land/x/windmill@v1.41.0/mod.ts"
+export const DENO_INIT_CODE_APPROVAL = `import * as wmill from "https://deno.land/x/windmill@v1.99.0/mod.ts"
 
 export async function main(approver?: string) {
   return wmill.getResumeEndpoints(approver)
 }`;
+export const DOCKER_INIT_CODE = `# shellcheck shell=bash
+# Bash script that calls docker as a client to the host daemon
+# See documentation: https://docs.windmill.dev/docs/advanced/docker
+msg="\${1:-world}"
+
+docker run --rm alpine /bin/echo "Hello $msg"
+`;
 const ALL_INITIAL_CODE = [
     PYTHON_INIT_CODE,
     PYTHON_INIT_CODE_TRIGGER,
@@ -226,6 +235,9 @@ export function isInitialCode(content) {
     return false;
 }
 export function initialCode(language, kind, subkind) {
+    if (!kind) {
+        kind = Script.kind.SCRIPT;
+    }
     if (language === 'deno') {
         if (kind === 'trigger') {
             return DENO_INIT_CODE_TRIGGER;
@@ -272,7 +284,12 @@ export function initialCode(language, kind, subkind) {
         }
     }
     else if (language == 'bash') {
-        return BASH_INIT_CODE;
+        if (subkind === 'docker') {
+            return DOCKER_INIT_CODE;
+        }
+        else {
+            return BASH_INIT_CODE;
+        }
     }
     else {
         if (kind === 'failure') {

package/package/scripts.d.ts

@@ -1,3 +1,15 @@
-import type { Schema } from './common';
+import type { Schema, SupportedLanguage } from './common';
+import { Script } from './gen';
+export declare function scriptLangToEditorLang(lang: Script.language): Script.language.GO | "typescript" | "python" | "shell";
 export declare function loadSchema(path: string, hash?: string): Promise<Schema>;
 export declare function loadSchemaFlow(path: string): Promise<Schema>;
+export declare function scriptPathToHref(path: string): string;
+export declare function getScriptByPath(path: string): Promise<{
+    content: string;
+    language: SupportedLanguage;
+    schema: any;
+    description: string;
+    tag: string | undefined;
+}>;
+export declare function getLatestHashForScript(path: string): Promise<string>;
+export declare function loadHubScripts(): Promise<void>;

package/package/scripts.js

@@ -1,8 +1,22 @@
 import { get } from 'svelte/store';
-import { FlowService, ScriptService } from './gen';
+import { FlowService, Script, ScriptService } from './gen';
 import { inferArgs } from './infer';
-import { workspaceStore } from './stores';
+import { workspaceStore, hubScripts } from './stores';
 import { emptySchema } from './utils';
+export function scriptLangToEditorLang(lang) {
+    if (lang == 'deno') {
+        return 'typescript';
+    }
+    else if (lang == 'python3') {
+        return 'python';
+    }
+    else if (lang == 'bash') {
+        return 'shell';
+    }
+    else {
+        return lang;
+    }
+}
 export async function loadSchema(path, hash) {
     if (path.startsWith('hub/')) {
         const { content, language, schema } = await ScriptService.getHubScriptByPath({ path });
@@ -37,3 +51,64 @@ export async function loadSchemaFlow(path) {
     });
     return flow.schema;
 }
+export function scriptPathToHref(path) {
+    if (path.startsWith('hub/')) {
+        return 'https://hub.windmill.dev/from_version/' + path.substring(4);
+    }
+    else {
+        return `/scripts/get/${path}?workspace=${get(workspaceStore)}`;
+    }
+}
+export async function getScriptByPath(path) {
+    if (path.startsWith('hub/')) {
+        const { content, language, schema } = await ScriptService.getHubScriptByPath({ path });
+        return {
+            content,
+            language: language,
+            schema,
+            description: '',
+            tag: undefined
+        };
+    }
+    else {
+        const script = await ScriptService.getScriptByPath({
+            workspace: get(workspaceStore),
+            path: path ?? ''
+        });
+        return {
+            content: script.content,
+            language: script.language,
+            schema: script.schema,
+            description: script.description,
+            tag: script.tag
+        };
+    }
+}
+export async function getLatestHashForScript(path) {
+    const script = await ScriptService.getScriptByPath({
+        workspace: get(workspaceStore),
+        path: path ?? ''
+    });
+    return script.hash;
+}
+export async function loadHubScripts() {
+    try {
+        const scripts = (await ScriptService.listHubScripts()).asks ?? [];
+        const processed = scripts
+            .map((x) => ({
+            path: `hub/${x.id}/${x.app}/${x.summary.toLowerCase().replaceAll(/\s+/g, '_')}`,
+            summary: `${x.summary} (${x.app})`,
+            approved: x.approved,
+            kind: x.kind,
+            app: x.app,
+            views: x.views,
+            votes: x.votes,
+            ask_id: x.ask_id
+        }))
+            .sort((a, b) => b.views - a.views);
+        hubScripts.set(processed);
+    }
+    catch {
+        console.error('Hub is not available');
+    }
+}

package/package/stores.d.ts

@@ -1,6 +1,6 @@
 import { type Readable } from 'svelte/store';
 import type { UserWorkspaceList } from './gen/models/UserWorkspaceList.js';
-import { type TokenResponse } from './gen';
+import type { TokenResponse } from './gen';
 export interface UserExt {
     email: string;
     username: string;

package/package/stores.js

@@ -1,9 +1,6 @@
-import { browser } from '$app/environment';
-import { derived, writable, get } from 'svelte/store';
-import { getUserExt } from './user';
-import { WorkspaceService } from './gen';
-import { isCloudHosted } from './utils';
-let persistedWorkspace = browser && localStorage.getItem('workspace');
+import { BROWSER } from 'esm-env';
+import { derived, writable } from 'svelte/store';
+let persistedWorkspace = BROWSER && localStorage.getItem('workspace');
 export const workerTags = writable(undefined);
 export const usageStore = writable(0);
 export const runFormStore = writable();
@@ -31,39 +28,6 @@ export const userWorkspaces = derived([usersWorkspaceStore, superadmin], ([store
     }
 });
 export const hubScripts = writable(undefined);
-if (browser) {
-    workspaceStore.subscribe(async (workspace) => {
-        if (workspace) {
-            try {
-                localStorage.setItem('workspace', String(workspace));
-            }
-            catch (e) {
-                console.error('Could not persist workspace to local storage', e);
-            }
-            const user = await getUserExt(workspace);
-            userStore.set(user);
-            if (isCloudHosted() && user?.is_admin) {
-                premiumStore.set(await WorkspaceService.getPremiumInfo({ workspace }));
-            }
-        }
-        else {
-            userStore.set(undefined);
-        }
-    });
-    setInterval(async () => {
-        try {
-            const workspace = get(workspaceStore);
-            const user = get(userStore);
-            if (workspace && user && !user.is_super_admin && !user.is_admin) {
-                userStore.set(await getUserExt(workspace));
-                console.log('refreshed user');
-            }
-        }
-        catch (e) {
-            console.error('Could not refresh user', e);
-        }
-    }, 30000);
-}
 export function switchWorkspace(workspace) {
     localStorage.removeItem('flow');
     localStorage.removeItem('app');

package/package/toast.d.ts

@@ -0,0 +1,5 @@
+export type ToastAction = {
+    label: string;
+    callback: () => void;
+};
+export declare function sendUserToast(message: string, error?: boolean, actions?: ToastAction[], errorMessage?: string | undefined): void;

package/package/toast.js

@@ -0,0 +1,22 @@
+import Toast from './components/Toast.svelte';
+import { toast } from '@zerodevx/svelte-toast';
+export function sendUserToast(message, error = false, actions = [], errorMessage = undefined) {
+    toast.push({
+        component: {
+            src: Toast,
+            props: {
+                message,
+                error,
+                actions,
+                errorMessage
+            },
+            sendIdTo: 'toastId'
+        },
+        dismissable: false,
+        initial: 0,
+        theme: {
+            '--toastPadding': '0',
+            '--toastMsgPadding': '0'
+        }
+    });
+}